import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
// (C) 2019-2026 GoodData Corporation
import { useEffect, useMemo, useRef, useState } from "react";
import cx from "classnames";
import { FormattedMessage, defineMessage, useIntl } from "react-intl";
import { ValidationContextStore, convertError, createInvalidDatapoint, createInvalidNode, useValidationContextValue, } from "@gooddata/sdk-ui";
import { Button, ConfirmDialogBase, ContentDivider, Hyperlink, Message, Overlay, OverlayController, OverlayControllerProvider, ScrollablePanel, UiIcon, UiIconButton, UiTooltip, useId, } from "@gooddata/sdk-ui-kit";
import { useDashboardSelector } from "../../../model/react/DashboardStoreProvider.js";
import { useEnableAlertingAutomationFilterContext } from "../../../model/react/useDashboardAlerting/useEnableAutomationFilterContext.js";
import { selectEnableAlertOncePerInterval, selectEnableAnomalyDetectionAlert, selectEnableAutomationManagement, selectExternalRecipient, selectIsWhiteLabeled, selectLocale, } from "../../../model/store/config/configSelectors.js";
import { selectMaxAutomationRecipients } from "../../../model/store/entitlements/entitlementsSelectors.js";
import { selectCanUseAiAssistant } from "../../../model/store/permissions/permissionsSelectors.js";
import { selectIsAutomationDialogSecondaryTitleVisible } from "../../../model/store/topBar/topBarSelectors.js";
import { selectExecutionTimestamp } from "../../../model/store/ui/uiSelectors.js";
import { getWidgetTitle } from "../../../model/utils/dashboardItemUtils.js";
import { ApplyCurrentFiltersConfirmDialog } from "../../automationFilters/components/ApplyLatestFiltersConfirmDialog.js";
import { AutomationFiltersSelect } from "../../automationFilters/components/AutomationFiltersSelect.js";
import { useValidateExistingAutomationFilters } from "../../automationFilters/hooks/useValidateExistingAutomationFilters.js";
import { useAutomationFiltersSelect } from "../../automationFilters/useAutomationFiltersSelect.js";
import { DASHBOARD_DIALOG_OVERS_Z_INDEX } from "../../constants/zIndex.js";
import { IntlWrapper } from "../../localization/IntlWrapper.js";
import { RecipientsSelect } from "../../scheduledEmail/DefaultScheduledEmailDialog/components/RecipientsSelect/RecipientsSelect.js";
import { DeleteAlertConfirmDialog } from "../DefaultAlertingManagementDialog/components/DeleteAlertConfirmDialog.js";
import { AlertingDialogHeader } from "./AlertingDialogHeader.js";
import { AlertAttributeSelect } from "./components/AlertAttributeSelect.js";
import { AlertComparisonOperatorSelect } from "./components/AlertComparisonOperatorSelect.js";
//
//
import { AlertComparisonPeriodSelect } from "./components/AlertComparisonPeriodSelect.js";
import { AlertDestinationSelect } from "./components/AlertDestinationSelect.js";
import { AlertGranularitySelect } from "./components/AlertGranularitySelect.js";
import { AlertMeasureSelect } from "./components/AlertMeasureSelect.js";
import { AlertSensitivitySelect } from "./components/AlertSensitivitySelect.js";
import { AlertThresholdInput } from "./components/AlertThresholdInput.js";
import { AlertTriggerIntervalSelect } from "./components/AlertTriggerIntervalSelect.js";
import { AlertTriggerModeSelect } from "./components/AlertTriggerModeSelect.js";
import { ALERTING_DIALOG_ID } from "./constants.js";
import { DefaultLoadingAlertingDialog } from "./DefaultLoadingAlertingDialog.js";
import { useEditAlert } from "./hooks/useEditAlert.js";
import { useSaveAlertToBackend } from "./hooks/useSaveAlertToBackend.js";
import { getDescription, getValueSuffix } from "./utils/getters.js";
import { isAnomalyDetection, isChangeOrDifferenceOperator } from "./utils/guards.js";
import { isMobileView } from "./utils/responsive.js";
const OVERLAY_POSITION_TYPE = "sameAsTarget";
const CLOSE_ON_PARENT_SCROLL = true;
const overlayController = OverlayController.getInstance(DASHBOARD_DIALOG_OVERS_Z_INDEX);
export function AlertingDialogRenderer({ alertToEdit, users, usersError, notificationChannels, insight, widget, onCancel, onDeleteSuccess, onDeleteError, onError, onSuccess, onSaveError, onSaveSuccess, }) {
    const intl = useIntl();
    const dialogTitleRef = useRef(null);
    const isWhiteLabeled = useDashboardSelector(selectIsWhiteLabeled);
    const externalRecipientOverride = useDashboardSelector(selectExternalRecipient);
    const isSecondaryTitleVisible = useDashboardSelector(selectIsAutomationDialogSecondaryTitleVisible);
    const enableAutomationManagement = useDashboardSelector(selectEnableAutomationManagement);
    const enableAnomalyDetectionAlert = useDashboardSelector(selectEnableAnomalyDetectionAlert);
    const enableAiAssistant = useDashboardSelector(selectCanUseAiAssistant);
    const enableAlertOncePerInterval = useDashboardSelector(selectEnableAlertOncePerInterval);
    const [alertToDelete, setAlertToDelete] = useState(null);
    const handleAlertDeleteSuccess = (alert) => {
        onDeleteSuccess?.(alert);
        setAlertToDelete(null);
    };
    const { maxAutomationsRecipients, isExecutionTimestampMode, enableAutomationFilterContext } = useDefaultAlertingDialogData();
    const { editedAutomationFilters, setEditedAutomationFilters, availableFilters, availableFiltersAsVisibleFilters, filtersForNewAutomation, } = useAutomationFiltersSelect({
        automationToEdit: alertToEdit,
        widget,
    });
    const { onTitleChange, onRecipientsChange, onFiltersChange, onApplyCurrentFilters, onMeasureChange, getAttributeValues, onAttributeChange, onComparisonOperatorChange, onRelativeOperatorChange, onAnomalyDetectionChange, onChange, onBlur, onComparisonTypeChange, onDestinationChange, onTriggerModeChange, onTriggerIntervalChange, selectedMeasure, supportedMeasures, canManageAttributes, selectedAttribute, selectedValue, supportedAttributes, catalogAttributes, catalogDateDatasets, isResultLoading, selectedComparisonOperator, selectedRelativeOperator, selectedAiOperator, value, selectedComparator, selectedSensitivity, onSensitivityChange, selectedGranularity, onGranularityChange, canManageComparison, separators, defaultUser, originalAutomation, editedAutomation, allowOnlyLoggedUserRecipients, allowExternalRecipients, warningMessage, validationErrorMessage, isSubmitDisabled, isParentValid, thresholdErrorMessage, allowHourlyRecurrence, } = useEditAlert({
        insight,
        widget,
        alertToEdit,
        editedAutomationFilters,
        maxAutomationsRecipients,
        availableFiltersAsVisibleFilters,
        setEditedAutomationFilters,
        notificationChannels,
        filtersForNewAutomation,
        externalRecipientOverride,
    });
    const { isValid } = useValidateExistingAutomationFilters({
        automationToEdit: alertToEdit,
        widget,
        insight,
        enableAutomationFilterContext,
    });
    const [isApplyCurrentFiltersDialogOpen, setIsApplyCurrentFiltersDialogOpen] = useState(!isValid);
    const { isSavingAlert, handleCreateAlert, handleUpdateAlert } = useSaveAlertToBackend({
        onCreateSuccess: (alert) => {
            onSuccess?.(alert);
        },
        onCreateError: (err) => {
            onError?.(convertError(err));
        },
        onUpdateSuccess: (alert) => {
            onSaveSuccess?.(alert);
        },
        onUpdateError: (err) => {
            onSaveError?.(convertError(err));
        },
    });
    const handleSaveAlert = () => {
        if (!editedAutomation) {
            return;
        }
        const title = getDescription(intl, supportedMeasures, editedAutomation, separators);
        const sanitizedAutomation = editedAutomation.title
            ? editedAutomation
            : {
                ...editedAutomation,
                title,
            };
        if (alertToEdit) {
            handleUpdateAlert(sanitizedAutomation);
        }
        else {
            handleCreateAlert(sanitizedAutomation);
        }
    };
    const validationContextValue = useValidationContextValue(createInvalidNode({ id: "AlertingDialog" }));
    const { setInvalidDatapoints, getInvalidDatapoints } = validationContextValue;
    const invalidDatapoints = getInvalidDatapoints();
    useEffect(() => {
        setInvalidDatapoints(() => [
            !!validationErrorMessage && createInvalidDatapoint({ message: validationErrorMessage }),
            !!thresholdErrorMessage && createInvalidDatapoint({ message: thresholdErrorMessage }),
        ]);
    }, [validationErrorMessage, thresholdErrorMessage, setInvalidDatapoints]);
    const helpTextId = isMobileView()
        ? defineMessage({ id: "dialogs.alerting.footer.title.short" }).id
        : defineMessage({ id: "dialogs.alerting.footer.title" }).id;
    const titleElementId = useId();
    const { secondaryTitle, secondaryTitleIcon } = useMemo(() => {
        return {
            secondaryTitle: getWidgetTitle(widget),
            secondaryTitleIcon: (_jsx(UiIcon, { type: "visualization", size: 16, color: "complementary-6", accessibilityConfig: {
                    ariaLabel: intl.formatMessage({
                        id: "dialogs.automation.icon.ariaLabel.sourceVisualization",
                    }),
                } })),
        };
    }, [widget, intl]);
    if (isApplyCurrentFiltersDialogOpen && enableAutomationFilterContext) {
        return (_jsx(ApplyCurrentFiltersConfirmDialog, { automationType: "alert", onCancel: () => onCancel?.(), onEdit: () => {
                onApplyCurrentFilters();
                setIsApplyCurrentFiltersDialogOpen(false);
            } }));
    }
    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: cx("gd-notifications-channels-dialog s-gd-notifications-channels-dialog", {
                                "gd-dialog--wide gd-notifications-channels-dialog--wide": enableAutomationManagement,
                            }), isPositive: true, cancelButtonText: intl.formatMessage({ id: "cancel" }), submitButtonText: alertToEdit
                                ? intl.formatMessage({ id: `save` })
                                : intl.formatMessage({ id: `create` }), accessibilityConfig: {
                                closeButton: {
                                    ariaLabel: intl.formatMessage({ id: "dialogs.alert.closeLabel" }),
                                },
                                titleElementId,
                                dialogId: ALERTING_DIALOG_ID,
                            }, showProgressIndicator: isSavingAlert, returnFocusAfterClose: !enableAutomationManagement, footerLeftRenderer: () => (_jsx(AlertingDialogFooter, { isWhiteLabeled: isWhiteLabeled, helpTextId: helpTextId, alertToEdit: alertToEdit, isSavingAlert: isSavingAlert, onDeleteClick: () => setAlertToDelete(alertToEdit) })), isSubmitDisabled: isSubmitDisabled || isSavingAlert || isExecutionTimestampMode, submitButtonTooltipText: isExecutionTimestampMode
                                ? intl.formatMessage({
                                    id: "dialogs.alert.save.executionTimestampMode",
                                })
                                : undefined, initialFocus: dialogTitleRef, submitOnEnterKey: false, onCancel: onCancel, onSubmit: handleSaveAlert, headline: undefined, headerLeftButtonRenderer: () => (_jsx(AlertingDialogHeader, { title: editedAutomation?.title ?? "", onChange: onTitleChange, onCancel: onCancel, placeholder: intl.formatMessage({
                                    id: "dialogs.alert.title.placeholder",
                                }), ref: dialogTitleRef, secondaryTitle: secondaryTitle, secondaryTitleIcon: secondaryTitleIcon, isSecondaryTitleVisible: isSecondaryTitleVisible ? isParentValid : undefined })), children: [
                                _jsx("h2", { className: "sr-only", id: titleElementId, children: intl.formatMessage({ id: "dialogs.alert.accessibility.label.title" }) }), _jsxs(ScrollablePanel, { className: cx("gd-notifications-channel-dialog-content-wrapper", {
                                        "gd-notification-channel-dialog-with-automation-filters": enableAutomationFilterContext,
                                    }), children: [
                                        _jsx("div", { className: "gd-divider-with-margin" }), enableAutomationFilterContext ? (_jsxs(_Fragment, { children: [
                                                _jsx(AutomationFiltersSelect, { availableFilters: availableFilters, selectedFilters: editedAutomationFilters, onFiltersChange: onFiltersChange, storeFilters: true, onStoreFiltersChange: () => { }, isDashboardAutomation: false, overlayPositionType: OVERLAY_POSITION_TYPE, disableDateFilters: isAnomalyDetection(editedAutomation?.alert) }), _jsx(ContentDivider, { className: "gd-divider-with-margin" })
                                            ] })) : null, _jsxs(FormFieldGroup, { label: _jsx(FormattedMessage, { id: "insightAlert.config.when" }), children: [
                                                _jsx(FormField, { label: intl.formatMessage({ id: "insightAlert.config.metric" }), htmlFor: "alert.measure", children: _jsx(AlertMeasureSelect, { selectedMeasure: selectedMeasure, onMeasureChange: onMeasureChange, measures: supportedMeasures, overlayPositionType: OVERLAY_POSITION_TYPE, id: "alert.measure", closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) }), Boolean(canManageAttributes) &&
                                                    supportedAttributes.filter((a) => a.type === "attribute").length >
                                                        0 && (_jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.for" }), htmlFor: "alert.attribute", children: _jsx(AlertAttributeSelect, { id: "alert.attribute", selectedAttribute: selectedAttribute, selectedValue: selectedValue, onAttributeChange: onAttributeChange, attributes: supportedAttributes, catalogAttributes: catalogAttributes, catalogDateDatasets: catalogDateDatasets, getAttributeValues: getAttributeValues, isResultLoading: isResultLoading, showLabel: false, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) })), _jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.condition" }), htmlFor: "alert.condition", children: _jsx(AlertComparisonOperatorSelect, { id: "alert.condition", measure: selectedMeasure, enableAnomalyDetectionAlert: enableAnomalyDetectionAlert ? enableAiAssistant : false, selectedComparisonOperator: selectedComparisonOperator, selectedRelativeOperator: selectedRelativeOperator, selectedAiOperator: selectedAiOperator, onAnomalyDetectionChange: onAnomalyDetectionChange, onComparisonOperatorChange: onComparisonOperatorChange, onRelativeOperatorChange: onRelativeOperatorChange, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) }), !isAnomalyDetection(editedAutomation?.alert) && (_jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.threshold" }), htmlFor: "alert.value", children: _jsx(AlertThresholdInput, { id: "alert.value", value: value, onChange: onChange, onBlur: onBlur, suffix: getValueSuffix(editedAutomation?.alert), errorMessage: thresholdErrorMessage }) })), isChangeOrDifferenceOperator(editedAutomation?.alert) && (_jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.comparison" }), htmlFor: "alert.comparison", children: _jsx(AlertComparisonPeriodSelect, { id: "alert.comparison", measure: selectedMeasure, alert: editedAutomation, selectedComparison: selectedComparator?.comparator, onComparisonChange: (comparisonType) => {
                                                            onComparisonTypeChange(selectedMeasure, selectedRelativeOperator, comparisonType);
                                                        }, overlayPositionType: OVERLAY_POSITION_TYPE, canManageComparison: canManageComparison, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) })), isAnomalyDetection(editedAutomation?.alert) && (_jsxs(_Fragment, { children: [
                                                        _jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.sensitivity" }), htmlFor: "alert.sensitivity", children: _jsx(AlertSensitivitySelect, { id: "alert.sensitivity", selectedSensitivity: selectedSensitivity, onSensitivityChange: onSensitivityChange, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) }), _jsx(FormField, { label: _jsxs("div", { className: "gd-dashboard-alerting-dialog-form-field__content-container-tooltip", children: [
                                                                    _jsx(FormattedMessage, { id: "insightAlert.config.granularity" }), _jsx(UiTooltip, { anchor: _jsx(UiIconButton, { icon: "question", variant: "tertiary", size: "xsmall", accessibilityConfig: {
                                                                                ariaLabel: intl.formatMessage({
                                                                                    id: "insightAlert.config.granularity",
                                                                                }),
                                                                            } }), content: _jsx(FormattedMessage, { id: "insightAlert.config.granularity.tooltip" }), arrowPlacement: "left", optimalPlacement: true, offset: 10, width: 280, triggerBy: ["hover", "click"] })
                                                                ] }), htmlFor: "alert.granularity", children: _jsx(AlertGranularitySelect, { id: "alert.granularity", allowHourlyRecurrence: allowHourlyRecurrence, selectedGranularity: selectedGranularity, onGranularityChange: (granularity) => {
                                                                    onGranularityChange(selectedMeasure, granularity);
                                                                }, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) })
                                                    ] }))] }), _jsx(ContentDivider, { className: "gd-divider-with-margin" }), _jsxs(FormFieldGroup, { label: _jsx(FormattedMessage, { id: "insightAlert.config.do" }), children: [notificationChannels.length > 1 && (_jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.action" }), htmlFor: "alert.destination", children: _jsx(AlertDestinationSelect, { id: "alert.destination", selectedDestination: editedAutomation?.notificationChannel, onDestinationChange: onDestinationChange, destinations: notificationChannels, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) })), _jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.trigger" }), htmlFor: "alert.trigger", children: _jsx(AlertTriggerModeSelect, { id: "alert.trigger", selectedTriggerMode: editedAutomation?.alert?.trigger.mode ?? "ALWAYS", onTriggerModeChange: onTriggerModeChange, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL, enableAlertOncePerInterval: enableAlertOncePerInterval }) }), editedAutomation?.alert?.trigger.mode === "ONCE_PER_INTERVAL" ? (_jsx(FormField, { label: _jsxs("div", { className: "gd-dashboard-alerting-dialog-form-field__content-container-tooltip", children: [
                                                            _jsx(FormattedMessage, { id: "insightAlert.config.interval" }), _jsx(UiTooltip, { anchor: _jsx(UiIconButton, { icon: "question", variant: "tertiary", size: "xsmall", accessibilityConfig: {
                                                                        ariaLabel: intl.formatMessage({
                                                                            id: "insightAlert.config.interval",
                                                                        }),
                                                                    } }), content: _jsx(FormattedMessage, { id: "insightAlert.config.interval.tooltip" }), arrowPlacement: "left", optimalPlacement: true, offset: 10, width: 280, triggerBy: ["hover", "click"] })
                                                        ] }), htmlFor: "alert.interval", children: _jsx(AlertTriggerIntervalSelect, { id: "alert.interval", selectedTriggerInterval: editedAutomation?.alert?.trigger.interval ?? "DAY", onTriggerIntervalChange: onTriggerIntervalChange, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) })) : null, _jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.recipients" }), htmlFor: "alert.recipients", fullWidth: true, children: _jsx(RecipientsSelect, { id: "alert.recipients", loggedUser: defaultUser, users: users, usersError: usersError, value: editedAutomation?.recipients ?? [], originalValue: originalAutomation?.recipients || [], onChange: onRecipientsChange, allowEmptySelection: true, allowOnlyLoggedUserRecipients: allowOnlyLoggedUserRecipients, allowExternalRecipients: allowExternalRecipients, maxRecipients: maxAutomationsRecipients, notificationChannels: notificationChannels, notificationChannelId: editedAutomation?.notificationChannel, showLabel: false, externalRecipientOverride: externalRecipientOverride }) })
                                            ] }), warningMessage ? (_jsx(Message, { type: "warning", className: "gd-notifications-channels-dialog-error", children: warningMessage })) : null, invalidDatapoints.map((datapoint) => (_jsx(Message, { type: "error", id: datapoint.id, className: "gd-notifications-channels-dialog-error gd-notifications-channels-dialog-error-scrollable", children: datapoint.message }, datapoint.id)))] })
                            ] }) }) }) }), alertToDelete ? (_jsx(DeleteAlertConfirmDialog, { alert: alertToDelete, onCancel: () => setAlertToDelete(null), onSuccess: handleAlertDeleteSuccess, onError: onDeleteError })) : null] }));
}
/**
 * @alpha
 */
export function DefaultAlertingDialogNew(props) {
    const { isLoading, onCancel, alertToEdit } = props;
    const locale = useDashboardSelector(selectLocale);
    if (isLoading) {
        return _jsx(DefaultLoadingAlertingDialog, { onCancel: onCancel, alertToEdit: alertToEdit });
    }
    return (_jsx(IntlWrapper, { locale: locale, children: _jsx(AlertingDialogRenderer, { ...props }) }));
}
function useDefaultAlertingDialogData() {
    const maxAutomationsRecipients = useDashboardSelector(selectMaxAutomationRecipients);
    const isExecutionTimestampMode = !!useDashboardSelector(selectExecutionTimestamp);
    const enableAutomationFilterContext = useEnableAlertingAutomationFilterContext();
    return {
        maxAutomationsRecipients,
        isExecutionTimestampMode,
        enableAutomationFilterContext,
    };
}
function AlertingDialogFooter({ isWhiteLabeled, helpTextId, alertToEdit, isSavingAlert, onDeleteClick, }) {
    const intl = useIntl();
    return (_jsxs("div", { className: "gd-notifications-channels-dialog-footer-link", children: [isWhiteLabeled ? null : (_jsx(Hyperlink, { text: intl.formatMessage({ id: helpTextId }), href: "https://www.gooddata.com/docs/cloud/create-dashboards/automation/alerts/", iconClass: "gd-icon-circle-question" })), alertToEdit ? (_jsx(Button, { className: "gd-button-link-dimmed", value: intl.formatMessage({ id: "delete" }), onClick: onDeleteClick, disabled: isSavingAlert })) : null] }));
}
function FormField({ label, children, htmlFor, fullWidth = false, }) {
    return (_jsxs("div", { className: "gd-input-component gd-input-component--no-last-child-margin gd-dashboard-alerting-dialog-form-field", children: [
            _jsx("div", { className: "gd-dashboard-alerting-dialog-form-field__label-container", children: _jsx("label", { className: "gd-label gd-dashboard-alerting-dialog-form-field__label", htmlFor: htmlFor, children: label }) }), _jsx("div", { className: fullWidth
                    ? "gd-dashboard-alerting-dialog-form-field__content-container-full-width"
                    : "gd-dashboard-alerting-dialog-form-field__content-container", children: children })
        ] }));
}
function FormFieldGroup({ label, children }) {
    return (_jsxs("div", { className: "gd-input-component gd-input-component--no-last-child-margin gd-dashboard-alerting-dialog-form-field-group", children: [
            _jsx("div", { className: "gd-dashboard-alerting-dialog-form-field-group__label-container", children: _jsx("label", { className: "gd-label gd-dashboard-alerting-dialog-form-field-group__label", children: label }) }), _jsx("div", { className: "gd-dashboard-alerting-dialog-form-field-group__content-container", children: children })
        ] }));
}
//# sourceMappingURL=DefaultAlertingDialogNew.js.map