@gooddata/sdk-ui-dashboard 11.54.0-alpha.6 → 11.54.0-alpha.7

package/esm/presentation/automations/alerting/state/useAlertFormState.d.ts

@@ -1,6 +1,7 @@
-import { type DateAttributeGranularity, type FilterContextItem, type IAlertAnomalyDetectionGranularity, type IAlertAnomalyDetectionSensitivity, type IAlertComparisonOperator, type IAlertRelativeArithmeticOperator, type IAlertRelativeOperator, type IAlertTriggerInterval, type IAlertTriggerMode, type IAutomationMetadataObject, type IAutomationMetadataObjectDefinition, type IAutomationRecipient, type IAutomationVisibleFilter, type IInsight, type INotificationChannelIdentifier, type INotificationChannelMetadataObject, type IWidget } from "@gooddata/sdk-model";
+import { type FilterContextItem, type IAutomationMetadataObject, type IAutomationVisibleFilter, type IInsight, type INotificationChannelIdentifier, type INotificationChannelMetadataObject, type IWidget } from "@gooddata/sdk-model";
 import { type IMeasureFormatMap } from "../DefaultAlertingDialog/utils/getters.js";
-import { type AlertAttribute, type AlertMetric, type AlertMetricComparatorType } from "../types.js";
+import { type AlertAttribute, type AlertMetric } from "../types.js";
+import { type IAlertFormState } from "./types.js";
 /**
  * Props for {@link useAlertFormState}.
  * @internal
@@ -28,36 +29,5 @@ export interface IUseAlertFormStateProps {
  *
  * @internal
  */
-export declare function useAlertFormState({ alertToEdit, insight, widget, notificationChannels, editedAutomationFilters, availableFiltersAsVisibleFilters, externalRecipientOverride, supportedMeasures, supportedAttributes, measureFormatMap }: IUseAlertFormStateProps): {
-    editedAutomation: IAutomationMetadataObjectDefinition | undefined;
-    setEditedAutomation: import("react").Dispatch<import("react").SetStateAction<IAutomationMetadataObjectDefinition | undefined>>;
-    originalAutomation: IAutomationMetadataObjectDefinition | undefined;
-    defaultUser: IAutomationRecipient;
-    defaultRecipient: IAutomationRecipient;
-    automationParameters: import("../../shared/automationFilters/automationParameters.js").IAutomationParameter[];
-    availableParameters: import("../../shared/automationFilters/automationParameters.js").IAutomationParameter[];
-    onParameterChange: (ref: import("@gooddata/sdk-model").IdentifierRef, value: string | number) => void;
-    onParameterDelete: (ref: import("@gooddata/sdk-model").IdentifierRef) => void;
-    onParameterAdd: (ref: import("@gooddata/sdk-model").IdentifierRef) => void;
-    dropStaleParameters: () => void;
-    onTitleChange: (value: string) => void;
-    onMeasureChange: (measure: AlertMetric) => void;
-    onAttributeChange: (attribute: AlertAttribute | undefined, value: {
-        title: string;
-        value: string;
-        name: string;
-    } | undefined) => void;
-    onComparisonOperatorChange: (measure: AlertMetric, comparisonOperator: IAlertComparisonOperator) => void;
-    onRelativeOperatorChange: (measure: AlertMetric, relativeOperator: IAlertRelativeOperator, arithmeticOperator: IAlertRelativeArithmeticOperator) => void;
-    onAnomalyDetectionChange: (measure: AlertMetric) => void;
-    onComparisonTypeChange: (measure: AlertMetric | undefined, relativeOperator: [IAlertRelativeOperator, IAlertRelativeArithmeticOperator] | undefined, comparisonType: AlertMetricComparatorType, granularity?: DateAttributeGranularity | undefined) => void;
-    onSensitivityChange: (sensitivity: IAlertAnomalyDetectionSensitivity) => void;
-    onTriggerIntervalChange: (triggerInterval: IAlertTriggerInterval, dirty?: boolean) => void;
-    onGranularityChange: (measure: AlertMetric | undefined, granularity: IAlertAnomalyDetectionGranularity) => void;
-    onDestinationChange: (destinationId: string) => void;
-    onTriggerModeChange: (triggerMode: IAlertTriggerMode) => void;
-    onRecipientsChange: (updatedRecipients: IAutomationRecipient[]) => void;
-    warningMessage: string | undefined;
-    isTitleValid: boolean;
-};
+export declare function useAlertFormState({ alertToEdit, insight, widget, notificationChannels, editedAutomationFilters, availableFiltersAsVisibleFilters, externalRecipientOverride, supportedMeasures, supportedAttributes, measureFormatMap }: IUseAlertFormStateProps): IAlertFormState;
 //# sourceMappingURL=useAlertFormState.d.ts.map

package/esm/presentation/automations/alerting/state/useAlertFormState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAlertFormState.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/useAlertFormState.ts"],"names":[],"mappings":"AAMA,OAAO,EACH,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,KAAK,iCAAiC,EACtC,KAAK,iCAAiC,EACtC,KAAK,wBAAwB,EAC7B,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAC9B,KAAK,mCAAmC,EACxC,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,QAAQ,EAEb,KAAK,8BAA8B,EACnC,KAAK,kCAAkC,EACvC,KAAK,OAAO,EACf,MAAM,qBAAqB,CAAC;AAiB7B,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,2CAA2C,CAAC;AAWnF,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAEpG;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACpC,WAAW,CAAC,EAAE,yBAAyB,CAAC;IACxC,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,oBAAoB,EAAE,8BAA8B,EAAE,GAAG,kCAAkC,EAAE,CAAC;IAC9F,uBAAuB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAC9C,gCAAgC,CAAC,EAAE,wBAAwB,EAAE,GAAG,SAAS,CAAC;IAC1E,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,iBAAiB,EAAE,WAAW,EAAE,CAAC;IACjC,mBAAmB,EAAE,cAAc,EAAE,CAAC;IACtC,gBAAgB,EAAE,iBAAiB,CAAC;CACvC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,EAC9B,WAAW,EACX,OAAO,EACP,MAAM,EACN,oBAAoB,EACpB,uBAAuB,EACvB,gCAAgC,EAChC,yBAAyB,EACzB,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EACnB,EAAE,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6ZzB"}
+{"version":3,"file":"useAlertFormState.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/useAlertFormState.ts"],"names":[],"mappings":"AAMA,OAAO,EAEH,KAAK,iBAAiB,EAQtB,KAAK,yBAAyB,EAG9B,KAAK,wBAAwB,EAC7B,KAAK,QAAQ,EAEb,KAAK,8BAA8B,EACnC,KAAK,kCAAkC,EACvC,KAAK,OAAO,EACf,MAAM,qBAAqB,CAAC;AAiB7B,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,2CAA2C,CAAC;AAWnF,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAkC,MAAM,aAAa,CAAC;AAEpG,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACpC,WAAW,CAAC,EAAE,yBAAyB,CAAC;IACxC,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,oBAAoB,EAAE,8BAA8B,EAAE,GAAG,kCAAkC,EAAE,CAAC;IAC9F,uBAAuB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAC9C,gCAAgC,CAAC,EAAE,wBAAwB,EAAE,GAAG,SAAS,CAAC;IAC1E,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,iBAAiB,EAAE,WAAW,EAAE,CAAC;IACjC,mBAAmB,EAAE,cAAc,EAAE,CAAC;IACtC,gBAAgB,EAAE,iBAAiB,CAAC;CACvC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,EAC9B,WAAW,EACX,OAAO,EACP,MAAM,EACN,oBAAoB,EACpB,uBAAuB,EACvB,gCAAgC,EAChC,yBAAyB,EACzB,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EACnB,EAAE,uBAAuB,GAAG,eAAe,CA6Z3C"}

package/esm/presentation/automations/alerting/state/useAlertSupportedMetrics.d.ts

@@ -1,7 +1,5 @@
 import { type IAutomationMetadataObject, type IInsight, type IWidget } from "@gooddata/sdk-model";
-import { useAttributeValuesFromExecResults } from "../DefaultAlertingDialog/hooks/useAttributeValuesFromExecResults.js";
-import { type IMeasureFormatMap } from "../DefaultAlertingDialog/utils/getters.js";
-import { type AlertAttribute, type AlertMetric } from "../types.js";
+import { type IAlertSupportedMetrics } from "./types.js";
 export interface IUseAlertSupportedMetricsProps {
     insight?: IInsight;
     widget?: IWidget;
@@ -17,12 +15,5 @@ export interface IUseAlertSupportedMetricsProps {
  *
  * @internal
  */
-export declare function useAlertSupportedMetrics({ insight, widget, alertToEdit }: IUseAlertSupportedMetricsProps): {
-    measureFormatMap: IMeasureFormatMap;
-    supportedMeasures: AlertMetric[];
-    supportedAttributes: AlertAttribute[];
-    isResultLoading: boolean;
-    getAttributeValues: ReturnType<typeof useAttributeValuesFromExecResults>["getAttributeValues"];
-    getMetricValue: ReturnType<typeof useAttributeValuesFromExecResults>["getMetricValue"];
-};
+export declare function useAlertSupportedMetrics({ insight, widget, alertToEdit }: IUseAlertSupportedMetricsProps): IAlertSupportedMetrics;
 //# sourceMappingURL=useAlertSupportedMetrics.d.ts.map

package/esm/presentation/automations/alerting/state/useAlertSupportedMetrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAlertSupportedMetrics.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/useAlertSupportedMetrics.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,yBAAyB,EAAE,KAAK,QAAQ,EAAE,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAKlG,OAAO,EAAE,iCAAiC,EAAE,MAAM,qEAAqE,CAAC;AACxH,OAAO,EACH,KAAK,iBAAiB,EAEzB,MAAM,2CAA2C,CAAC;AAKnD,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAEpE,MAAM,WAAW,8BAA8B;IAC3C,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,yBAAyB,CAAC;CAC3C;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,8BAA8B,GAAG;IACxG,gBAAgB,EAAE,iBAAiB,CAAC;IACpC,iBAAiB,EAAE,WAAW,EAAE,CAAC;IACjC,mBAAmB,EAAE,cAAc,EAAE,CAAC;IACtC,eAAe,EAAE,OAAO,CAAC;IACzB,kBAAkB,EAAE,UAAU,CAAC,OAAO,iCAAiC,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC/F,cAAc,EAAE,UAAU,CAAC,OAAO,iCAAiC,CAAC,CAAC,gBAAgB,CAAC,CAAC;CAC1F,CA8CA"}
+{"version":3,"file":"useAlertSupportedMetrics.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/useAlertSupportedMetrics.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,yBAAyB,EAAE,KAAK,QAAQ,EAAE,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAYlG,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD,MAAM,WAAW,8BAA8B;IAC3C,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,yBAAyB,CAAC;CAC3C;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,EACrC,OAAO,EACP,MAAM,EACN,WAAW,EACd,EAAE,8BAA8B,GAAG,sBAAsB,CA8CzD"}

package/esm/presentation/automations/alerting/state/useAlertSupportedMetrics.js

@@ -4,7 +4,7 @@ import { fillMissingTitles } from "@gooddata/sdk-ui";
 import { useAlertingDialogContext } from "../../contexts/AlertingDialogContext.js";
 import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
 import { useAttributeValuesFromExecResults } from "../DefaultAlertingDialog/hooks/useAttributeValuesFromExecResults.js";
-import { getMeasureFormatsFromExecution, } from "../DefaultAlertingDialog/utils/getters.js";
+import { getMeasureFormatsFromExecution } from "../DefaultAlertingDialog/utils/getters.js";
 import { getSupportedInsightAttributesByInsight, getSupportedInsightMeasuresByInsight, } from "../DefaultAlertingDialog/utils/items.js";
 /**
  * Derives which measures and attributes the alerting dialog may offer for the current widget: it
@@ -16,7 +16,7 @@ import { getSupportedInsightAttributesByInsight, getSupportedInsightMeasuresByIn
  *
  * @internal
  */
-export function useAlertSupportedMetrics({ insight, widget, alertToEdit }) {
+export function useAlertSupportedMetrics({ insight, widget, alertToEdit, }) {
     const { locale, catalogDateDatasets, catalogAttributes } = useAutomationsContext();
     const { executionResultByRef } = useAlertingDialogContext();
     const execResult = executionResultByRef(widget?.ref);

package/esm/presentation/automations/alerting/state/useAlertingDialogRegionProps.d.ts

@@ -0,0 +1,82 @@
+import { type Ref } from "react";
+import { type IAutomationDialogActionBarProps, type IAutomationDialogDestinationProps, type IAutomationDialogRecipientsProps } from "../../shared/slots/types.js";
+import { type AlertingDialogHeaderDefaultProps, type IAlertingDialogFiltersProps } from "../types.js";
+/**
+ * Inputs of {@link useAlertingDialogHeaderProps} that come from the dialog rather than its state.
+ *
+ * @internal
+ */
+export interface IUseAlertingDialogHeaderPropsInput {
+    /**
+     * Closes the dialog; the header's back/close button calls it.
+     */
+    onCancel?: () => void;
+    /**
+     * The dialog's initial-focus ref, attached to the title input.
+     */
+    ref?: Ref<HTMLInputElement>;
+}
+/**
+ * The exact props the default alerting dialog renders its header region with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @internal
+ */
+export declare function useAlertingDialogHeaderProps({ onCancel, ref }: IUseAlertingDialogHeaderPropsInput): AlertingDialogHeaderDefaultProps;
+/**
+ * The exact props the default alerting dialog renders its filters region with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @internal
+ */
+export declare function useAlertingDialogFiltersProps(): IAlertingDialogFiltersProps;
+/**
+ * The exact props the default alerting dialog renders its destination region with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @internal
+ */
+export declare function useAlertingDialogDestinationProps(): IAutomationDialogDestinationProps;
+/**
+ * The exact props the default alerting dialog renders its recipients region with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @internal
+ */
+export declare function useAlertingDialogRecipientsProps(): IAutomationDialogRecipientsProps;
+/**
+ * Inputs of {@link useAlertingDialogActionBarProps} that come from the dialog rather than its state.
+ *
+ * @internal
+ */
+export interface IUseAlertingDialogActionBarPropsInput {
+    /**
+     * Closes the dialog without saving.
+     */
+    onCancel?: () => void;
+    /**
+     * Submits the automation; the dialog's single submit path (see `useAlertSubmit`).
+     */
+    onSubmit: () => void;
+    /**
+     * Whether a save is in flight.
+     */
+    isSaving: boolean;
+    /**
+     * Opens the delete confirmation. Rendered only when an existing alert is being edited.
+     */
+    onDelete?: () => void;
+}
+/**
+ * The exact props the default alerting dialog renders its action bar with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @internal
+ */
+export declare function useAlertingDialogActionBarProps({ onCancel, onSubmit, isSaving, onDelete }: IUseAlertingDialogActionBarPropsInput): IAutomationDialogActionBarProps;
+//# sourceMappingURL=useAlertingDialogRegionProps.d.ts.map

package/esm/presentation/automations/alerting/state/useAlertingDialogRegionProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAlertingDialogRegionProps.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/state/useAlertingDialogRegionProps.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,GAAG,EAAW,MAAM,OAAO,CAAC;AAQ1C,OAAO,EACH,KAAK,+BAA+B,EACpC,KAAK,iCAAiC,EACtC,KAAK,gCAAgC,EACxC,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,KAAK,gCAAgC,EAAE,KAAK,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAStG;;;;GAIG;AACH,MAAM,WAAW,kCAAkC;IAC/C;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IAEtB;;OAEG;IACH,GAAG,CAAC,EAAE,GAAG,CAAC,gBAAgB,CAAC,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,EACzC,QAAQ,EACR,GAAG,EACN,EAAE,kCAAkC,GAAG,gCAAgC,CAkCvE;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,IAAI,2BAA2B,CAwB3E;AAED;;;;;;GAMG;AACH,wBAAgB,iCAAiC,IAAI,iCAAiC,CAUrF;AAED;;;;;;GAMG;AACH,wBAAgB,gCAAgC,IAAI,gCAAgC,CAqBnF;AAED;;;;GAIG;AACH,MAAM,WAAW,qCAAqC;IAClD;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IAEtB;;OAEG;IACH,QAAQ,EAAE,MAAM,IAAI,CAAC;IAErB;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,+BAA+B,CAAC,EAC5C,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,EACX,EAAE,qCAAqC,GAAG,+BAA+B,CAmCzE"}

package/esm/presentation/automations/alerting/state/useAlertingDialogRegionProps.js

@@ -0,0 +1,152 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useMemo } from "react";
+import { defineMessage, useIntl } from "react-intl";
+import { UiIcon } from "@gooddata/sdk-ui-kit";
+import { useAlertingDialogContext } from "../../contexts/AlertingDialogContext.js";
+import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
+import { isAnomalyDetection } from "../DefaultAlertingDialog/utils/guards.js";
+import { isMobileView } from "../DefaultAlertingDialog/utils/responsive.js";
+import { useAlertActions } from "./AlertActionsContext.js";
+import { useAlertData } from "./AlertDataContext.js";
+import { useAlertDraft } from "./AlertDraftContext.js";
+import { useAlertFilters } from "./AlertFiltersContext.js";
+import { useAlertDialogValidity } from "./useAlertDialogValidity.js";
+import { useAlertSelectedValues } from "./useAlertSelectedValues.js";
+/**
+ * The exact props the default alerting dialog renders its header region with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @internal
+ */
+export function useAlertingDialogHeaderProps({ onCancel, ref, }) {
+    const intl = useIntl();
+    const { isSecondaryTitleVisible } = useAutomationsContext();
+    const { widgetTitle } = useAlertingDialogContext();
+    const { editedAutomation } = useAlertDraft();
+    const { onTitleChange } = useAlertActions();
+    const { isParentValid } = useAlertDialogValidity();
+    const secondaryTitleIcon = useMemo(() => (_jsx(UiIcon, { type: "visualization", size: 16, color: "complementary-6", accessibilityConfig: {
+            ariaLabel: intl.formatMessage({
+                id: "dialogs.automation.icon.ariaLabel.sourceVisualization",
+            }),
+        } })), [intl]);
+    return {
+        title: editedAutomation?.title ?? "",
+        onChange: onTitleChange,
+        onCancel,
+        placeholder: intl.formatMessage({ id: "dialogs.alert.title.placeholder" }),
+        ref,
+        secondaryTitle: widgetTitle,
+        secondaryTitleIcon,
+        isSecondaryTitleVisible: isSecondaryTitleVisible ? isParentValid : undefined,
+    };
+}
+/**
+ * The exact props the default alerting dialog renders its filters region with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @internal
+ */
+export function useAlertingDialogFiltersProps() {
+    const { editedAutomation } = useAlertDraft();
+    const { availableFilters, selectedFilters, onFiltersChange, automationParameters, availableParameters, onParameterAdd, onParameterChange, onParameterDelete, } = useAlertFilters();
+    return {
+        availableFilters,
+        selectedFilters,
+        onFiltersChange,
+        disableDateFilters: isAnomalyDetection(editedAutomation?.alert),
+        parameters: automationParameters,
+        availableParameters,
+        onParameterAdd,
+        onParameterChange,
+        onParameterDelete,
+    };
+}
+/**
+ * The exact props the default alerting dialog renders its destination region with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @internal
+ */
+export function useAlertingDialogDestinationProps() {
+    const { notificationChannels } = useAlertingDialogContext();
+    const { editedAutomation } = useAlertDraft();
+    const { onDestinationChange } = useAlertActions();
+    return {
+        notificationChannels,
+        selectedNotificationChannelId: editedAutomation?.notificationChannel,
+        onChange: onDestinationChange,
+    };
+}
+/**
+ * The exact props the default alerting dialog renders its recipients region with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @internal
+ */
+export function useAlertingDialogRecipientsProps() {
+    const { maxAutomationsRecipients, externalRecipient: externalRecipientOverride } = useAutomationsContext();
+    const { notificationChannels } = useAlertingDialogContext();
+    const { editedAutomation } = useAlertDraft();
+    const { onRecipientsChange } = useAlertActions();
+    const { defaultUser } = useAlertData();
+    const { allowExternalRecipients, allowOnlyLoggedUserRecipients } = useAlertSelectedValues();
+    return {
+        loggedUser: defaultUser,
+        value: editedAutomation?.recipients ?? [],
+        onChange: onRecipientsChange,
+        allowEmptySelection: true,
+        allowOnlyLoggedUserRecipients,
+        allowExternalRecipients,
+        maxRecipients: maxAutomationsRecipients,
+        notificationChannels,
+        notificationChannelId: editedAutomation?.notificationChannel,
+        externalRecipientOverride,
+    };
+}
+/**
+ * The exact props the default alerting dialog renders its action bar with.
+ *
+ * Throws outside the alerting dialog's state providers.
+ *
+ * @internal
+ */
+export function useAlertingDialogActionBarProps({ onCancel, onSubmit, isSaving, onDelete, }) {
+    const intl = useIntl();
+    const { isWhiteLabeled, isExecutionTimestampMode } = useAutomationsContext();
+    const { alertToEdit } = useAlertingDialogContext();
+    const { isSubmitDisabled } = useAlertDialogValidity();
+    const helpTextId = isMobileView()
+        ? defineMessage({ id: "dialogs.alerting.footer.title.short" }).id
+        : defineMessage({ id: "dialogs.alerting.footer.title" }).id;
+    return {
+        cancelButtonText: intl.formatMessage({ id: "cancel" }),
+        submitButtonText: alertToEdit
+            ? intl.formatMessage({ id: "save" })
+            : intl.formatMessage({ id: "create" }),
+        onCancel: () => onCancel?.(),
+        onSubmit,
+        isSubmitDisabled: isSubmitDisabled || isSaving || isExecutionTimestampMode,
+        isSaving,
+        submitButtonTooltipText: isExecutionTimestampMode
+            ? intl.formatMessage({ id: "dialogs.alert.save.executionTimestampMode" })
+            : undefined,
+        ...(isWhiteLabeled
+            ? {}
+            : {
+                helpLinkText: intl.formatMessage({ id: helpTextId }),
+                helpLinkHref: "https://www.gooddata.com/docs/cloud/create-dashboards/automation/alerts/",
+            }),
+        ...(alertToEdit && onDelete
+            ? {
+                deleteButtonText: intl.formatMessage({ id: "delete" }),
+                onDelete,
+            }
+            : {}),
+    };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"DefaultScheduledEmailDialog.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/DefaultScheduledEmailDialog.tsx"],"names":[],"mappings":"AAoDA,OAAO,EACH,KAAK,iCAAiC,EAKzC,MAAM,aAAa,CAAC;AAwBrB,wBAAgB,2BAA2B,CAAC,EACxC,MAAM,EACN,QAAQ,EACR,eAAe,EACf,aAAa,EACb,OAAO,EACP,MAAM,EACN,WAAW,EACX,aAAa,EACb,QAAQ,EACR,SAAS,EACT,KAAK,EACL,UAAU,EACV,aAAa,EAChB,EAAE,iCAAiC,2CA4nBnC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,iCAAiC,2CAYnF"}
+{"version":3,"file":"DefaultScheduledEmailDialog.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/DefaultScheduledEmailDialog.tsx"],"names":[],"mappings":"AAsDA,OAAO,EAAE,KAAK,iCAAiC,EAAE,MAAM,aAAa,CAAC;AAuBrE,wBAAgB,2BAA2B,CAAC,EACxC,MAAM,EACN,QAAQ,EACR,eAAe,EACf,aAAa,EACb,OAAO,EACP,MAAM,EACN,WAAW,EACX,aAAa,EACb,QAAQ,EACR,SAAS,EACT,KAAK,EACL,UAAU,EACV,aAAa,EAChB,EAAE,iCAAiC,2CA4cnC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,iCAAiC,2CAYnF"}

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

@@ -2,9 +2,9 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 // (C) 2019-2026 GoodData Corporation
 import { useCallback, useMemo, useRef, useState } from "react";
 import cx from "classnames";
-import { defineMessage, useIntl } from "react-intl";
+import { useIntl } from "react-intl";
 import { ValidationContextStore, createInvalidNode, useValidationContextValue } from "@gooddata/sdk-ui";
-import { ConfirmDialogBase, ContentDivider, Message, Overlay, OverlayController, OverlayControllerProvider, RecurrenceForm, ScrollablePanel, UiIcon, UiTabs, getTimezoneDisplayLabel, isEnterKey, useIdPrefixed, } from "@gooddata/sdk-ui-kit";
+import { ConfirmDialogBase, ContentDivider, Message, Overlay, OverlayController, OverlayControllerProvider, RecurrenceForm, ScrollablePanel, 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";
@@ -14,13 +14,12 @@ import { AutomationDialogActionBar, AutomationDialogFooterLeft, } from "../../sh
 import { DeleteScheduleConfirmDialog } from "../DefaultScheduledEmailManagementDialog/components/DeleteScheduleConfirmDialog.js";
 import { useScheduleEmailDialogAccessibility } from "../hooks/useScheduleEmailDialogAccessibility.js";
 import { useScheduledExportActions } from "../state/ScheduledExportActionsContext.js";
-import { useScheduledExportData } from "../state/ScheduledExportDataContext.js";
 import { useScheduledExportDraft } from "../state/ScheduledExportDraftContext.js";
 import { useScheduledExportFilters } from "../state/ScheduledExportFiltersContext.js";
+import { useScheduledEmailDialogActionBarProps, useScheduledEmailDialogDestinationProps, useScheduledEmailDialogFiltersProps, useScheduledEmailDialogHeaderProps, useScheduledEmailDialogRecipientsProps, useScheduledEmailDialogTimezoneProps, } from "../state/useScheduledEmailDialogRegionProps.js";
 import { useScheduledExportAttachments } from "../state/useScheduledExportAttachments.js";
 import { useScheduledExportDialogValidity } from "../state/useScheduledExportDialogValidity.js";
 import { getDefaultCronExpression } from "../utils/cron.js";
-import { isMobileView } from "../utils/responsive.js";
 import { TIMEZONE_DEFAULT } from "../utils/timezone.js";
 import { DashboardAttachments } from "./components/Attachments/DashboardAttachments.js";
 import { WidgetAttachments } from "./components/Attachments/WidgetAttachments.js";
@@ -51,73 +50,51 @@ export function ScheduledMailDialogRenderer({ onBack, onCancel, onDeleteSuccess,
     const filtersTabContentRef = useRef(null);
     const [scheduledEmailToDelete, setScheduledEmailToDelete] = useState(null);
     const [selectedTabId, setSelectedTabId] = useState("general");
-    const { isWhiteLabeled, externalRecipient: externalRecipientOverride, isSecondaryTitleVisible, tabIds, } = useAutomationsContext();
-    const { exportTemplates, widgetTitle, scheduledExportToEdit, widget, dashboardFilters, notificationChannels, } = useScheduledEmailDialogContext();
+    const { isWhiteLabeled, tabIds } = useAutomationsContext();
+    const { exportTemplates, widget, dashboardFilters, notificationChannels } = useScheduledEmailDialogContext();
     const handleScheduleDeleteSuccess = () => {
         onDeleteSuccess?.();
         setScheduledEmailToDelete(null);
     };
-    const { locale, dashboardTitle, dateFormat, weekStart, maxAutomationsRecipients, allowHourlyRecurrence, isCrossFiltering, isExecutionTimestampMode, isSlidesExportEnabled, isAccessibilityModeEnabled, enableAutomationEvaluationMode, } = useDefaultScheduledEmailDialogData();
-    const { editedAutomation, 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 { locale, dashboardTitle, dateFormat, weekStart, allowHourlyRecurrence, isCrossFiltering, isSlidesExportEnabled, isAccessibilityModeEnabled, enableAutomationEvaluationMode, } = useDefaultScheduledEmailDialogData();
+    const { editedAutomation, startDate, isTimezoneFeatureEnabled, canSelectScheduleTimezone, scheduleTimezoneIsStale, } = useScheduledExportDraft();
+    const { onRecurrenceChange, onEvaluationModeChange, onSubjectChange, onMessageChange, onDashboardAttachmentsChange, onWidgetAttachmentsChange, onXlsxSettingsChange, onPdfSettingsChange, onCsvSettingsChange, onCsvRawSettingsChange, onSlidesTemplateIdChange, applyCurrentScheduleTimezone, } = useScheduledExportActions();
+    const { onApplyCurrentFilters, automationIsValid, applyLatest: applyLatestParameters, } = useScheduledExportFilters();
     const { selectedAttachments, xlsxSettings, pdfSettings, csvSettings, csvRawSettings, slidesTemplateIds } = useScheduledExportAttachments();
-    const { isSubmitDisabled, validationErrorMessage, isParentValid, allowExternalRecipients, allowOnlyLoggedUserRecipients, } = useScheduledExportDialogValidity();
+    const { isSubmitDisabled, validationErrorMessage } = useScheduledExportDialogValidity();
     // 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,
-        onSubmit,
-        onSaveSuccess,
-        onSaveError,
-        onSave,
-    });
+    const { handleSaveScheduledEmail, isSavingScheduledEmail, savingErrorMessage } = useSaveScheduledEmailToBackend({ onSuccess, onError, onSubmit, onSaveSuccess, onSaveError, onSave });
     const { returnFocusTo } = useScheduleEmailDialogAccessibility();
     const missingAttachmentsErrorMessage = selectedAttachments.length === 0 &&
         intl.formatMessage({ id: "scheduledEmail.attachments.error.noAttachmentsSelected" });
     const validationContextValue = useValidationContextValue(createInvalidNode({ id: "ScheduledEmailDialog" }));
     const { getInvalidDatapoints } = validationContextValue;
     const errorMessage = savingErrorMessage ?? validationErrorMessage ?? missingAttachmentsErrorMessage;
-    const helpTextId = isMobileView()
-        ? defineMessage({ id: "dialogs.schedule.email.footer.title.short" }).id
-        : defineMessage({ id: "dialogs.schedule.email.footer.title" }).id;
     const titleElementId = useIdPrefixed("title");
-    const submitDisabled = isSubmitDisabled || isSavingScheduledEmail || isExecutionTimestampMode;
+    const actionBarDefaultProps = useScheduledEmailDialogActionBarProps({
+        onCancel,
+        onSubmit: handleSaveScheduledEmail,
+        isSaving: isSavingScheduledEmail,
+        onDelete: () => setScheduledEmailToDelete(editedAutomation),
+    });
+    const submitDisabled = actionBarDefaultProps.isSubmitDisabled;
     const handleSubmitForm = useCallback((e) => {
         if (isEnterKey(e) && !submitDisabled) {
             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 {
-                secondaryTitle: widgetTitle,
-                secondaryTitleIcon: (_jsx(UiIcon, { type: "visualization", size: 16, color: "complementary-6", accessibilityConfig: {
-                        ariaLabel: intl.formatMessage({
-                            id: "dialogs.automation.icon.ariaLabel.sourceVisualization",
-                        }),
-                    } })),
-            };
-        }
-        return {
-            secondaryTitle: dashboardTitle,
-            secondaryTitleIcon: (_jsx(UiIcon, { type: "dashboard", size: 16, color: "complementary-6", accessibilityConfig: {
-                    ariaLabel: intl.formatMessage({
-                        id: "dialogs.automation.icon.ariaLabel.sourceDashboard",
-                    }),
-                } })),
-        };
-    }, [widget, widgetTitle, dashboardTitle, intl]);
+    const headerDefaultProps = useScheduledEmailDialogHeaderProps({
+        onBack,
+        onTitleKeyDown: handleSubmitForm,
+        ref: dialogTitleRef,
+    });
+    const filtersDefaultProps = useScheduledEmailDialogFiltersProps();
+    const destinationDefaultProps = useScheduledEmailDialogDestinationProps();
+    const recipientsDefaultProps = useScheduledEmailDialogRecipientsProps({
+        onKeyDownSubmit: handleSubmitForm,
+    });
+    const timezoneDefaultProps = useScheduledEmailDialogTimezoneProps();
     const tabs = useMemo(() => [
         {
             id: "general",
@@ -151,75 +128,8 @@ export function ScheduledMailDialogRenderer({ onBack, onCancel, onDeleteSuccess,
     }
     const selectedChannel = notificationChannels.find((channel) => channel.id === editedAutomation.notificationChannel);
     const isInPlatformChannel = selectedChannel?.destinationType === "inPlatform";
-    const filtersDefaultProps = {
-        availableFilters,
-        selectedFilters,
-        onFiltersChange,
-        storeFilters,
-        onStoreFiltersChange,
-        isDashboardAutomation: !widget,
-        filtersByTab,
-        editedFiltersByTab,
-        onFiltersByTabChange,
-        parameters: flatTabId ? visibleParametersByTab[flatTabId] : undefined,
-        availableParameters: flatTabId ? availableParametersByTab[flatTabId] : undefined,
-        onParameterAdd,
-        onParameterChange,
-        onParameterDelete,
-        parametersByTab: visibleParametersByTab,
-        availableParametersByTab,
-        onParameterAddByTab,
-        onParameterChangeByTab,
-        onParameterDeleteByTab,
-        parametersEnabled,
-    };
-    const destinationDefaultProps = {
-        notificationChannels,
-        selectedNotificationChannelId: editedAutomation.notificationChannel,
-        onChange: onDestinationChange,
-    };
-    const recipientsDefaultProps = {
-        loggedUser: defaultUser,
-        value: editedAutomation.recipients ?? [],
-        onChange: onRecipientsChange,
-        allowEmptySelection: true,
-        allowOnlyLoggedUserRecipients,
-        allowExternalRecipients,
-        maxRecipients: maxAutomationsRecipients,
-        notificationChannels,
-        notificationChannelId: editedAutomation.notificationChannel,
-        onKeyDownSubmit: handleSubmitForm,
-        externalRecipientOverride,
-    };
-    const actionBarDefaultProps = {
-        cancelButtonText: intl.formatMessage({ id: "cancel" }),
-        submitButtonText: scheduledExportToEdit
-            ? intl.formatMessage({ id: "dialogs.schedule.email.save" })
-            : intl.formatMessage({ id: "dialogs.schedule.email.create" }),
-        onCancel: () => onCancel?.(),
-        onSubmit: handleSaveScheduledEmail,
-        isSubmitDisabled: submitDisabled,
-        isSaving: isSavingScheduledEmail,
-        submitButtonTooltipText: isExecutionTimestampMode
-            ? intl.formatMessage({ id: "dialogs.schedule.email.save.executionTimestampMode" })
-            : undefined,
-        ...(isWhiteLabeled
-            ? {}
-            : {
-                helpLinkText: intl.formatMessage({ id: helpTextId }),
-                helpLinkHref: "https://www.gooddata.com/docs/cloud/create-dashboards/automation/scheduled-exports/#ScheduleExportsinDashboards-ScheduleExport",
-            }),
-        ...(scheduledExportToEdit
-            ? {
-                deleteButtonText: intl.formatMessage({ id: "delete" }),
-                onDelete: () => setScheduledEmailToDelete(editedAutomation),
-            }
-            : {}),
-    };
     return (_jsxs(_Fragment, { children: [
-            _jsx(Overlay, { className: "gd-notifications-channels-dialog-overlay", isModal: true, positionType: "fixed", ensureVisibility: true, children: _jsx(OverlayControllerProvider, { overlayController: overlayController, children: _jsx(ValidationContextStore, { value: validationContextValue, children: _jsxs(ConfirmDialogBase, { className: "gd-notifications-channels-dialog s-gd-notifications-channels-dialog gd-dialog--wide gd-notifications-channels-dialog--wide", isPositive: true, cancelButtonText: intl.formatMessage({ id: "cancel" }), submitButtonText: scheduledExportToEdit
-                                ? intl.formatMessage({ id: `dialogs.schedule.email.save` })
-                                : intl.formatMessage({ id: `dialogs.schedule.email.create` }), accessibilityConfig: {
+            _jsx(Overlay, { className: "gd-notifications-channels-dialog-overlay", isModal: true, positionType: "fixed", ensureVisibility: true, children: _jsx(OverlayControllerProvider, { overlayController: overlayController, children: _jsx(ValidationContextStore, { value: validationContextValue, children: _jsxs(ConfirmDialogBase, { className: "gd-notifications-channels-dialog s-gd-notifications-channels-dialog gd-dialog--wide gd-notifications-channels-dialog--wide", isPositive: true, cancelButtonText: actionBarDefaultProps.cancelButtonText, submitButtonText: actionBarDefaultProps.submitButtonText, accessibilityConfig: {
                                 closeButton: {
                                     ariaLabel: intl.formatMessage({
                                         id: "dialogs.schedule.email.closeLabel",
@@ -227,30 +137,11 @@ export function ScheduledMailDialogRenderer({ onBack, onCancel, onDeleteSuccess,
                                 },
                                 titleElementId,
                                 dialogId: SCHEDULED_EMAIL_DIALOG_ID,
-                            }, showProgressIndicator: isSavingScheduledEmail, returnFocusTo: returnFocusTo, returnFocusAfterClose: false, footerLeftRenderer: ActionBarSlot
+                            }, 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: isSavingScheduledEmail })), footerRenderer: ActionBarSlot
+                                : () => (_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 }))
-                                : undefined, isSubmitDisabled: submitDisabled, submitButtonTooltipText: isExecutionTimestampMode
-                                ? intl.formatMessage({
-                                    id: "dialogs.schedule.email.save.executionTimestampMode",
-                                })
-                                : undefined, initialFocus: dialogTitleRef, submitOnEnterKey: false, onCancel: onCancel, onSubmit: handleSaveScheduledEmail, headline: undefined, headerLeftButtonRenderer: () => {
-                                const headerDefaultProps = {
-                                    title: editedAutomation.title ?? "",
-                                    onChange: onTitleChange,
-                                    onBack,
-                                    placeholder: intl.formatMessage({
-                                        id: "dialogs.schedule.email.title.placeholder",
-                                    }),
-                                    ref: dialogTitleRef,
-                                    onTitleKeyDown: handleSubmitForm,
-                                    secondaryTitle,
-                                    secondaryTitleIcon,
-                                    isSecondaryTitleVisible: isSecondaryTitleVisible
-                                        ? isParentValid
-                                        : undefined,
-                                };
+                                : 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 }));
                             }, 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: {
@@ -323,17 +214,15 @@ function DefaultScheduledEmailDialogBody(props) {
     return (_jsx(IntlWrapper, { locale: locale, children: _jsx(ScheduledMailDialogRenderer, { ...props }) }));
 }
 function useDefaultScheduledEmailDialogData() {
-    const { locale, settings, weekStart, maxAutomationsRecipients, allowHourlyRecurrence, isExecutionTimestampMode, features: { enableSlideshowExports, enableAutomationEvaluationMode }, } = useAutomationsContext();
+    const { locale, settings, weekStart, allowHourlyRecurrence, features: { enableSlideshowExports, enableAutomationEvaluationMode }, } = useAutomationsContext();
     const { dashboardTitle, dateFormat, isCrossFiltering } = useScheduledEmailDialogContext();
     return {
         locale,
         dashboardTitle,
         dateFormat,
         weekStart,
-        maxAutomationsRecipients,
         allowHourlyRecurrence,
         isCrossFiltering,
-        isExecutionTimestampMode,
         isSlidesExportEnabled: enableSlideshowExports,
         isAccessibilityModeEnabled: settings?.enableAccessibilityMode === true,
         enableAutomationEvaluationMode,

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

@@ -1,6 +1,21 @@
-import { type IAutomationMetadataObject, type IAutomationMetadataObjectDefinition } from "@gooddata/sdk-model";
 import { type IScheduledEmailDialogProps } from "../../types.js";
-export declare function useSaveScheduledEmailToBackend(automation: IAutomationMetadataObject | IAutomationMetadataObjectDefinition, { onSuccess, onError, onSubmit, onSaveSuccess, onSaveError, onSave }: Pick<IScheduledEmailDialogProps, "onSuccess" | "onError" | "onSubmit" | "onSaveSuccess" | "onSaveError" | "onSave">): {
+/**
+ * Lifecycle callbacks of {@link useSaveScheduledEmailToBackend}: `onSubmit`/`onSuccess`/`onError`
+ * (create) and `onSave`/`onSaveSuccess`/`onSaveError` (edit).
+ *
+ * @internal
+ */
+export type IUseSaveScheduledEmailCallbacks = Pick<IScheduledEmailDialogProps, "onSuccess" | "onError" | "onSubmit" | "onSaveSuccess" | "onSaveError" | "onSave">;
+/**
+ * Saves the scheduled-export dialog's draft: creates a new schedule or updates the edited one after
+ * sanitizing it, keeps a 400 response's detail as an in-dialog error message, and routes everything
+ * else to the matching callback.
+ *
+ * Reads the draft from the scheduled-export state contexts, so it throws outside them.
+ *
+ * @internal
+ */
+export declare function useSaveScheduledEmailToBackend({ onSuccess, onError, onSubmit, onSaveSuccess, onSaveError, onSave }: IUseSaveScheduledEmailCallbacks): {
     handleSaveScheduledEmail: () => void;
     isSavingScheduledEmail: boolean;
     savingErrorMessage: string | undefined;