@gooddata/sdk-ui-dashboard 11.45.0-alpha.1 → 11.45.0

package/esm/model/commandHandlers/scheduledEmail/refreshAutomationsHandlers.js

@@ -4,7 +4,7 @@ import { all, call, put, select } from "redux-saga/effects";
 import { convertError } from "@gooddata/sdk-ui";
 import { automationsRefreshed } from "../../events/scheduledEmail.js";
 import { automationsActions } from "../../store/automations/index.js";
-import { selectEnableAlerting, selectEnableScheduling, selectExternalRecipient, selectIsReadOnly, } from "../../store/config/configSelectors.js";
+import { selectExternalRecipient, selectIsReadOnly } from "../../store/config/configSelectors.js";
 import { selectDashboardId } from "../../store/meta/metaSelectors.js";
 import { selectCanManageWorkspace } from "../../store/permissions/permissionsSelectors.js";
 import { selectCurrentUser } from "../../store/user/userSelectors.js";
@@ -12,13 +12,10 @@ import { loadDashboardUserAutomations, loadWorkspaceAutomationsCount } from "./l
 export function* refreshAutomationsHandlers(ctx, cmd) {
     const dashboardId = yield select(selectDashboardId);
     const user = yield select(selectCurrentUser);
-    const enableScheduling = yield select(selectEnableScheduling);
-    const enableAlerting = yield select(selectEnableAlerting);
     const canManageAutomations = yield select(selectCanManageWorkspace);
     const isReadOnly = yield select(selectIsReadOnly);
-    const enableAutomations = enableScheduling || enableAlerting;
     const externalRecipient = yield select(selectExternalRecipient);
-    if (!dashboardId || !user || !enableAutomations || isReadOnly) {
+    if (!dashboardId || !user || isReadOnly) {
         return;
     }
     yield put(automationsActions.setAutomationsLoading(true));
@@ -34,11 +31,10 @@ export function* refreshAutomationsHandlers(ctx, cmd) {
         ]));
     }
     catch (e) {
-        yield put(automationsActions.setAutomationsLoading(false));
-        batchActions([
+        yield put(batchActions([
             automationsActions.setAutomationsLoading(false),
             automationsActions.setAutomationsError(convertError(e)),
-        ]);
+        ]));
     }
     return automationsRefreshed(ctx, cmd.correlationId);
 }

package/esm/model/queryServices/queryWidgetFilters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queryWidgetFilters.d.ts","sourceRoot":"","sources":["../../../src/model/queryServices/queryWidgetFilters.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,OAAO,EAGH,KAAK,OAAO,EACZ,KAAK,kBAAkB,EAqB1B,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAUjE,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,KAAK,yBAAyB,EAAsB,MAAM,yBAAyB,CAAC;AAE7F,eAAO,MAAM,yBAAyB,kGAAoE,CAAC;AAiM3G,wBAAiB,gBAAgB,CAC7B,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,yBAAyB,EACjC,OAAO,EAAE,kBAAkB,GAC5B,YAAY,CAAC,OAAO,EAAE,CAAC,CA6EzB"}
+{"version":3,"file":"queryWidgetFilters.d.ts","sourceRoot":"","sources":["../../../src/model/queryServices/queryWidgetFilters.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,OAAO,EAGH,KAAK,OAAO,EACZ,KAAK,kBAAkB,EAqB1B,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AASjE,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,KAAK,yBAAyB,EAAsB,MAAM,yBAAyB,CAAC;AAE7F,eAAO,MAAM,yBAAyB,kGAAoE,CAAC;AAiM3G,wBAAiB,gBAAgB,CAC7B,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,yBAAyB,EACjC,OAAO,EAAE,kBAAkB,GAC5B,YAAY,CAAC,OAAO,EAAE,CAAC,CAsEzB"}

package/esm/model/queryServices/queryWidgetFilters.js

@@ -5,7 +5,6 @@ import { areObjRefsEqual, filterLocalIdentifier, filterObjRef, insightFilters, i
 import { invalidQueryArguments } from "../events/general.js";
 import { createQueryService } from "../store/_infra/queryService.js";
 import { selectSupportsMultipleDateFilters } from "../store/backendCapabilities/backendCapabilitiesSelectors.js";
-import { selectEnableDateFilterIdentifiers } from "../store/config/configSelectors.js";
 import { selectInsightByRef } from "../store/insights/insightsSelectors.js";
 import { selectAttributeFilterConfigsDisplayAsLabelMap } from "../store/tabs/attributeFilterConfigs/attributeFilterConfigsSelectors.js";
 import { selectAllFiltersForWidgetByRef, selectFilterableWidgetByRef, } from "../store/tabs/layout/layoutSelectors.js";
@@ -110,14 +109,11 @@ export function* queryWithInsight(_ctx, widget, insight) {
     const widgetAwareDashboardFiltersSelector = selectAllFiltersForWidgetByRef(widget.ref);
     const [widgetAwareDashboardCommonDateFilters, widgetAwareDashboardOtherFilters] = yield select(widgetAwareDashboardFiltersSelector);
     const supportsMultipleDateFilters = yield select(selectSupportsMultipleDateFilters);
-    const enableDateFilterIdentifiers = yield select(selectEnableDateFilterIdentifiers);
     // add all time filter explicitly in case the date widgetAwareDashboardFilters are empty
     // this will cause the all time filter to be used instead of the insight date filter
     // if the dashboard date filter is not ignored by the widget
     if (!widgetAwareDashboardCommonDateFilters.length && widget.dateDataSet) {
-        widgetAwareDashboardCommonDateFilters.push(newAllTimeFilter(widget.dateDataSet, enableDateFilterIdentifiers
-            ? generateDateFilterLocalIdentifier(0, widget.dateDataSet)
-            : undefined));
+        widgetAwareDashboardCommonDateFilters.push(newAllTimeFilter(widget.dateDataSet, generateDateFilterLocalIdentifier(0, widget.dateDataSet)));
     }
     const effectiveInsightFilters = insightFilters(insight);
     const [dateFilters, attributeFilters] = yield all([

package/esm/model/react/useDasboardScheduledEmails/useDashboardScheduledEmails.d.ts

@@ -18,12 +18,12 @@ export declare const useDashboardScheduledEmails: () => {
     isScheduleEmailingDialogOpen: boolean;
     defaultOnScheduleEmailing: (widget?: import("@gooddata/sdk-model").IWidget | undefined) => void;
     onScheduleEmailingOpen: (widget?: import("@gooddata/sdk-model").IWidget | undefined) => void;
-    onScheduleEmailingCancel: (widget?: import("@gooddata/sdk-model").IWidget | undefined) => void;
-    onScheduleEmailingBack: (widget?: import("@gooddata/sdk-model").IWidget | undefined) => void;
+    onScheduleEmailingCancel: (_widget?: import("@gooddata/sdk-model").IWidget | undefined) => void;
+    onScheduleEmailingBack: (_widget?: import("@gooddata/sdk-model").IWidget | undefined) => void;
     onScheduleEmailingCreateError: () => void;
     onScheduleEmailingCreateSuccess: (scheduledEmail: import("@gooddata/sdk-model").IAutomationMetadataObject) => void;
     onScheduleEmailingSaveError: () => void;
-    onScheduleEmailingSaveSuccess: (widget?: import("@gooddata/sdk-model").IWidget | undefined) => void;
+    onScheduleEmailingSaveSuccess: (_widget?: import("@gooddata/sdk-model").IWidget | undefined) => void;
     isScheduledManagementEmailingVisible: boolean;
     isScheduleEmailingManagementDialogOpen: boolean;
     defaultOnScheduleEmailingManagement: (widget?: import("@gooddata/sdk-model").IWidget | undefined) => void;

package/esm/model/react/useDasboardScheduledEmails/useDashboardScheduledEmails.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDashboardScheduledEmails.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDasboardScheduledEmails/useDashboardScheduledEmails.ts"],"names":[],"mappings":"AASA;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuFvC,CAAC"}
+{"version":3,"file":"useDashboardScheduledEmails.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDasboardScheduledEmails/useDashboardScheduledEmails.ts"],"names":[],"mappings":"AASA;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoFvC,CAAC"}

package/esm/model/react/useDasboardScheduledEmails/useDashboardScheduledEmails.js

@@ -22,10 +22,8 @@ export const useDashboardScheduledEmails = () => {
     isScheduledEmailingVisible, isScheduleEmailingDialogOpen, 
     // List / Management Dialog
     isScheduledManagementEmailingVisible, isScheduleEmailingManagementDialogOpen, } = useDashboardScheduledEmailsData({ scheduledExportToEdit });
-    const { defaultOnScheduleEmailing, onScheduleEmailingCancel, onScheduleEmailingBack, onScheduleEmailingCreateError, onScheduleEmailingCreateSuccess, onScheduleEmailingOpen, onScheduleEmailingSaveError, onScheduleEmailingSaveSuccess, setShouldReturnToManagementDialog, } = useDashboardScheduledEmailsDialog();
-    const { defaultOnScheduleEmailingManagement, onScheduleEmailingManagementAdd, onScheduleEmailingManagementClose, onScheduleEmailingManagementDeleteError, onScheduleEmailingManagementDeleteSuccess, onScheduleEmailingManagementEdit, onScheduleEmailingManagementLoadingError, onScheduleEmailingManagementOpen, } = useDashboardScheduledEmailsManagementDialog({
-        setShouldReturnToManagementDialog,
-    });
+    const { defaultOnScheduleEmailing, onScheduleEmailingCancel, onScheduleEmailingBack, onScheduleEmailingCreateError, onScheduleEmailingCreateSuccess, onScheduleEmailingOpen, onScheduleEmailingSaveError, onScheduleEmailingSaveSuccess, } = useDashboardScheduledEmailsDialog();
+    const { defaultOnScheduleEmailingManagement, onScheduleEmailingManagementAdd, onScheduleEmailingManagementClose, onScheduleEmailingManagementDeleteError, onScheduleEmailingManagementDeleteSuccess, onScheduleEmailingManagementEdit, onScheduleEmailingManagementLoadingError, onScheduleEmailingManagementOpen, } = useDashboardScheduledEmailsManagementDialog();
     return {
         // Local state
         scheduledExportToEdit,

package/esm/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsCommands.d.ts

@@ -12,17 +12,17 @@ interface IOpenScheduleEmailingDialogOptions {
  */
 export declare const useDashboardScheduledEmailsCommands: () => {
     openScheduleEmailingDialog: (options?: IOpenScheduleEmailingDialogOptions) => void;
-    closeScheduleEmailingDialog: () => false | {
+    closeScheduleEmailingDialog: () => {
         payload: undefined;
         type: "uiSlice/closeScheduleEmailDialog";
     };
-    openScheduleEmailingManagementDialog: (widget?: IWidget | undefined, openedFrom?: string | undefined) => false | {
+    openScheduleEmailingManagementDialog: (widget?: IWidget | undefined, openedFrom?: string | undefined) => {
         payload: import("../../../types.js").IScheduleEmailContext & {
             openedFrom?: string | undefined;
         };
         type: "uiSlice/openScheduleEmailManagementDialog";
     };
-    closeScheduleEmailingManagementDialog: () => false | {
+    closeScheduleEmailingManagementDialog: () => {
         payload: undefined;
         type: "uiSlice/closeScheduleEmailManagementDialog";
     };

package/esm/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsCommands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDashboardScheduledEmailsCommands.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsCommands.tsx"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,yBAAyB,EAC9B,KAAK,OAAO,EAGf,MAAM,qBAAqB,CAAC;AAW7B;;GAEG;AACH,UAAU,kCAAkC;IACxC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,yBAAyB,CAAC;CACxC;AAED;;GAEG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;CAqE/C,CAAC"}
+{"version":3,"file":"useDashboardScheduledEmailsCommands.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsCommands.tsx"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,yBAAyB,EAC9B,KAAK,OAAO,EAGf,MAAM,qBAAqB,CAAC;AAU7B;;GAEG;AACH,UAAU,kCAAkC;IACxC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,yBAAyB,CAAC;CACxC;AAED;;GAEG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;CA+D/C,CAAC"}

package/esm/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsCommands.js

@@ -2,7 +2,6 @@
 import { useCallback } from "react";
 import { areObjRefsEqual, isInsightWidget, } from "@gooddata/sdk-model";
 import { switchDashboardTab } from "../../commands/tabs.js";
-import { selectEnableScheduling } from "../../store/config/configSelectors.js";
 import { selectInsights } from "../../store/insights/insightsSelectors.js";
 import { selectWidgets } from "../../store/tabs/layout/layoutSelectors.js";
 import { selectActiveTabLocalIdentifier } from "../../store/tabs/tabsSelectors.js";
@@ -18,37 +17,32 @@ export const useDashboardScheduledEmailsCommands = () => {
     const widgets = useDashboardSelector(selectWidgets);
     const insights = useDashboardSelector(selectInsights);
     const activeTabId = useDashboardSelector(selectActiveTabLocalIdentifier);
-    // Feature Flags
-    const isScheduledEmailingEnabled = useDashboardSelector(selectEnableScheduling);
     // Single Schedule Dialog
     const openScheduleEmailingDialog = useCallback((options = {}) => {
         const { widget, openedFrom, schedule } = options;
-        if (isScheduledEmailingEnabled) {
-            const targetTabIdentifier = schedule?.metadata?.targetTabIdentifier;
-            if (targetTabIdentifier && targetTabIdentifier !== activeTabId) {
-                dispatch(switchDashboardTab(targetTabIdentifier));
-            }
-            dispatch(uiActions.openScheduleEmailDialog({
-                ...(widget?.ref ? { widgetRef: widget.ref, openedFrom } : { openedFrom }),
-                ...(schedule ? { schedule } : {}),
-            }));
-            const selectedWidget = widgets.find((w) => w.localIdentifier === widget?.localIdentifier);
-            const insightRef = isInsightWidget(selectedWidget) ? selectedWidget.insight : undefined;
-            const insight = insights.find((i) => areObjRefsEqual(i.insight.ref, insightRef));
-            automationInteraction({
-                type: "scheduledExportInitialized",
-                automation_source: widget ? "widget" : "dashboard",
-                automation_visualization_type: insight?.insight.visualizationUrl,
-            });
+        const targetTabIdentifier = schedule?.metadata?.targetTabIdentifier;
+        if (targetTabIdentifier && targetTabIdentifier !== activeTabId) {
+            dispatch(switchDashboardTab(targetTabIdentifier));
         }
-    }, [activeTabId, automationInteraction, dispatch, insights, isScheduledEmailingEnabled, widgets]);
-    const closeScheduleEmailingDialog = useCallback(() => isScheduledEmailingEnabled && dispatch(uiActions.closeScheduleEmailDialog()), [dispatch, isScheduledEmailingEnabled]);
-    // List / Management Dialog
-    const openScheduleEmailingManagementDialog = useCallback((widget, openedFrom) => isScheduledEmailingEnabled &&
-        dispatch(uiActions.openScheduleEmailManagementDialog({
+        dispatch(uiActions.openScheduleEmailDialog({
             ...(widget?.ref ? { widgetRef: widget.ref, openedFrom } : { openedFrom }),
-        })), [dispatch, isScheduledEmailingEnabled]);
-    const closeScheduleEmailingManagementDialog = useCallback(() => isScheduledEmailingEnabled && dispatch(uiActions.closeScheduleEmailManagementDialog()), [dispatch, isScheduledEmailingEnabled]);
+            ...(schedule ? { schedule } : {}),
+        }));
+        const selectedWidget = widgets.find((w) => w.localIdentifier === widget?.localIdentifier);
+        const insightRef = isInsightWidget(selectedWidget) ? selectedWidget.insight : undefined;
+        const insight = insights.find((i) => areObjRefsEqual(i.insight.ref, insightRef));
+        automationInteraction({
+            type: "scheduledExportInitialized",
+            automation_source: widget ? "widget" : "dashboard",
+            automation_visualization_type: insight?.insight.visualizationUrl,
+        });
+    }, [activeTabId, automationInteraction, dispatch, insights, widgets]);
+    const closeScheduleEmailingDialog = useCallback(() => dispatch(uiActions.closeScheduleEmailDialog()), [dispatch]);
+    // List / Management Dialog
+    const openScheduleEmailingManagementDialog = useCallback((widget, openedFrom) => dispatch(uiActions.openScheduleEmailManagementDialog({
+        ...(widget?.ref ? { widgetRef: widget.ref, openedFrom } : { openedFrom }),
+    })), [dispatch]);
+    const closeScheduleEmailingManagementDialog = useCallback(() => dispatch(uiActions.closeScheduleEmailManagementDialog()), [dispatch]);
     return {
         openScheduleEmailingDialog,
         closeScheduleEmailingDialog,

package/esm/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDashboardScheduledEmailsData.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsData.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,yBAAyB,EAGjC,MAAM,qBAAqB,CAAC;AAwC7B,UAAU,qCAAqC;IAC3C,qBAAqB,CAAC,EAAE,yBAAyB,CAAC;CACrD;AAED;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;CAsG3C,CAAC"}
+{"version":3,"file":"useDashboardScheduledEmailsData.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsData.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,yBAAyB,EAGjC,MAAM,qBAAqB,CAAC;AAoC7B,UAAU,qCAAqC;IAC3C,qBAAqB,CAAC,EAAE,yBAAyB,CAAC;CACrD;AAED;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;CAkG3C,CAAC"}

package/esm/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsData.js

@@ -1,7 +1,7 @@
 // (C) 2022-2026 GoodData Corporation
 import { isExportDefinitionVisualizationObjectRequestPayload, } from "@gooddata/sdk-model";
 import { selectAllAutomationsCount, selectAutomationsError, selectAutomationsIsInitialized, selectAutomationsIsLoading, selectDashboardUserAutomationSchedulesInContext, } from "../../store/automations/automationsSelectors.js";
-import { selectEnableExportToDocumentStorage, selectEnableScheduling, selectIsReadOnly, } from "../../store/config/configSelectors.js";
+import { selectEnableExportToDocumentStorage, selectIsReadOnly } from "../../store/config/configSelectors.js";
 import { selectEntitlementMaxAutomations, selectEntitlementUnlimitedAutomations, } from "../../store/entitlements/entitlementsSelectors.js";
 import { selectInsightByWidgetRef } from "../../store/insights/insightsSelectors.js";
 import { selectNotificationChannels, selectNotificationChannelsCount, selectNotificationChannelsCountWithoutInPlatform, selectNotificationChannelsWithoutInPlatform, } from "../../store/notificationChannels/notificationChannelsSelectors.js";
@@ -25,8 +25,6 @@ export const useDashboardScheduledEmailsData = ({ scheduledExportToEdit, }) => {
     const isInViewMode = useDashboardSelector(selectIsInViewMode);
     // Visibility configuration
     const menuButtonItemsVisibility = useDashboardSelector(selectMenuButtonItemsVisibility);
-    // Feature flags
-    const isScheduledEmailingEnabled = useDashboardSelector(selectEnableScheduling);
     // Permissions
     const isWorkspaceManager = useDashboardSelector(selectCanManageWorkspace);
     const canCreateAutomation = useDashboardSelector(selectCanCreateAutomation);
@@ -52,7 +50,6 @@ export const useDashboardScheduledEmailsData = ({ scheduledExportToEdit, }) => {
     const showDueToNumberOfAvailableDestinations = numberOfAvailableDestinations > 0 || isWorkspaceManager;
     const isSchedulingAvailable = isInViewMode &&
         !isReadOnly &&
-        isScheduledEmailingEnabled &&
         showDueToNumberOfAvailableDestinations &&
         (menuButtonItemsVisibility.scheduleEmailButton ?? true);
     // Single Schedule Dialog

package/esm/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsDialog.d.ts

@@ -5,12 +5,11 @@ import { type IAutomationMetadataObject, type IWidget } from "@gooddata/sdk-mode
 export declare const useDashboardScheduledEmailsDialog: () => {
     defaultOnScheduleEmailing: (widget?: IWidget | undefined) => void;
     onScheduleEmailingOpen: (widget?: IWidget | undefined) => void;
-    onScheduleEmailingCancel: (widget?: IWidget | undefined) => void;
-    onScheduleEmailingBack: (widget?: IWidget | undefined) => void;
+    onScheduleEmailingCancel: (_widget?: IWidget | undefined) => void;
+    onScheduleEmailingBack: (_widget?: IWidget | undefined) => void;
     onScheduleEmailingCreateError: () => void;
     onScheduleEmailingCreateSuccess: (scheduledEmail: IAutomationMetadataObject) => void;
     onScheduleEmailingSaveError: () => void;
-    onScheduleEmailingSaveSuccess: (widget?: IWidget | undefined) => void;
-    setShouldReturnToManagementDialog: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    onScheduleEmailingSaveSuccess: (_widget?: IWidget | undefined) => void;
 };
 //# sourceMappingURL=useDashboardScheduledEmailsDialog.d.ts.map

package/esm/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsDialog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDashboardScheduledEmailsDialog.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsDialog.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,yBAAyB,EAE9B,KAAK,OAAO,EAKf,MAAM,qBAAqB,CAAC;AAe7B;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;CAuK7C,CAAC"}
+{"version":3,"file":"useDashboardScheduledEmailsDialog.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsDialog.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,yBAAyB,EAE9B,KAAK,OAAO,EAKf,MAAM,qBAAqB,CAAC;AAc7B;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;CAmI7C,CAAC"}

package/esm/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsDialog.js

@@ -1,9 +1,8 @@
 // (C) 2022-2026 GoodData Corporation
-import { useCallback, useState } from "react";
+import { useCallback } from "react";
 import { areObjRefsEqual, isExportDefinitionDashboardRequestPayload, isExportDefinitionVisualizationObjectRequestPayload, isInsightWidget, } from "@gooddata/sdk-model";
 import { useToastMessage } from "@gooddata/sdk-ui-kit";
 import { messages } from "../../../locales.js";
-import { selectEnableAutomationManagement } from "../../store/config/configSelectors.js";
 import { selectInsights } from "../../store/insights/insightsSelectors.js";
 import { selectDashboardRef } from "../../store/meta/metaSelectors.js";
 import { selectNotificationChannels } from "../../store/notificationChannels/notificationChannelsSelectors.js";
@@ -22,18 +21,11 @@ export const useDashboardScheduledEmailsDialog = () => {
     const destinations = useDashboardSelector(selectNotificationChannels);
     const allWidgets = useDashboardSelector(selectWidgets);
     const allInsights = useDashboardSelector(selectInsights);
-    const enableAutomationManagement = useDashboardSelector(selectEnableAutomationManagement);
-    const { closeScheduleEmailingDialog, openScheduleEmailingDialog, openScheduleEmailingManagementDialog } = useDashboardScheduledEmailsCommands();
-    const { refreshAutomations, refreshAutomationManagementItems } = useDashboardAutomations();
-    const [shouldReturnToManagementDialog, setShouldReturnToManagementDialog] = useState(false);
+    const { closeScheduleEmailingDialog, openScheduleEmailingDialog } = useDashboardScheduledEmailsCommands();
+    const { refreshAutomationManagementItems } = useDashboardAutomations();
     const handleRefreshAutomations = useCallback(() => {
-        if (enableAutomationManagement) {
-            refreshAutomationManagementItems();
-        }
-        else {
-            refreshAutomations();
-        }
-    }, [enableAutomationManagement, refreshAutomations, refreshAutomationManagementItems]);
+        refreshAutomationManagementItems();
+    }, [refreshAutomationManagementItems]);
     /*
      * exports and scheduling are not available when rendering a dashboard that is not persisted.
      * this can happen when a new dashboard is created and is being edited.
@@ -45,36 +37,20 @@ export const useDashboardScheduledEmailsDialog = () => {
             return;
         }
         openScheduleEmailingDialog({ widget, openedFrom: "dashboard" });
-        setShouldReturnToManagementDialog(false);
-    }, [dashboardRef, openScheduleEmailingDialog, setShouldReturnToManagementDialog]);
+    }, [dashboardRef, openScheduleEmailingDialog]);
     // Open / Close
     const onScheduleEmailingOpen = useCallback((widget) => {
         openScheduleEmailingDialog({ widget, openedFrom: "widget" });
-        setShouldReturnToManagementDialog(false);
-    }, [openScheduleEmailingDialog, setShouldReturnToManagementDialog]);
-    const onScheduleEmailingCancel = useCallback((widget) => {
+    }, [openScheduleEmailingDialog]);
+    const onScheduleEmailingCancel = useCallback((_widget) => {
         closeScheduleEmailingDialog();
-        if (!enableAutomationManagement && shouldReturnToManagementDialog) {
-            openScheduleEmailingManagementDialog(widget);
-        }
-    }, [
-        enableAutomationManagement,
-        shouldReturnToManagementDialog,
-        closeScheduleEmailingDialog,
-        openScheduleEmailingManagementDialog,
-    ]);
-    const onScheduleEmailingBack = useCallback((widget) => {
+    }, [closeScheduleEmailingDialog]);
+    const onScheduleEmailingBack = useCallback((_widget) => {
         closeScheduleEmailingDialog();
-        if (!enableAutomationManagement) {
-            openScheduleEmailingManagementDialog(widget);
-        }
-    }, [enableAutomationManagement, closeScheduleEmailingDialog, openScheduleEmailingManagementDialog]);
+    }, [closeScheduleEmailingDialog]);
     // Create
     const onScheduleEmailingCreateSuccess = useCallback((scheduledEmail) => {
         closeScheduleEmailingDialog();
-        if (!enableAutomationManagement) {
-            openScheduleEmailingManagementDialog();
-        }
         addSuccess(messages.scheduleEmailSubmitSuccess);
         handleRefreshAutomations();
         const widgetId = scheduledEmail.exportDefinitions?.find(({ requestPayload }) => isExportDefinitionVisualizationObjectRequestPayload(requestPayload))?.requestPayload?.content.widget;
@@ -95,9 +71,7 @@ export const useDashboardScheduledEmailsDialog = () => {
             ...(insight ? {} : { filter_context: dashboardFilters.length > 0 ? "edited" : "default" }),
         });
     }, [
-        enableAutomationManagement,
         closeScheduleEmailingDialog,
-        openScheduleEmailingManagementDialog,
         addSuccess,
         handleRefreshAutomations,
         allWidgets,
@@ -110,20 +84,11 @@ export const useDashboardScheduledEmailsDialog = () => {
         addError(messages.scheduleEmailSubmitError);
     }, [closeScheduleEmailingDialog, addError]);
     // Edit
-    const onScheduleEmailingSaveSuccess = useCallback((widget) => {
+    const onScheduleEmailingSaveSuccess = useCallback((_widget) => {
         closeScheduleEmailingDialog();
-        if (!enableAutomationManagement) {
-            openScheduleEmailingManagementDialog(widget);
-        }
         addSuccess(messages.scheduleEmailSaveSuccess);
         handleRefreshAutomations();
-    }, [
-        enableAutomationManagement,
-        closeScheduleEmailingDialog,
-        openScheduleEmailingManagementDialog,
-        addSuccess,
-        handleRefreshAutomations,
-    ]);
+    }, [closeScheduleEmailingDialog, addSuccess, handleRefreshAutomations]);
     const onScheduleEmailingSaveError = useCallback(() => {
         closeScheduleEmailingDialog();
         addError(messages.scheduleEmailSaveError);
@@ -137,6 +102,5 @@ export const useDashboardScheduledEmailsDialog = () => {
         onScheduleEmailingCreateSuccess,
         onScheduleEmailingSaveError,
         onScheduleEmailingSaveSuccess,
-        setShouldReturnToManagementDialog,
     };
 };

package/esm/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsManagementDialog.d.ts

@@ -2,13 +2,7 @@ import { type IAutomationMetadataObject, type IWidget } from "@gooddata/sdk-mode
 /**
  * @internal
  */
-export interface IUseDashboardScheduledEmailsManagementDialogProps {
-    setShouldReturnToManagementDialog: (value: boolean) => void;
-}
-/**
- * @internal
- */
-export declare const useDashboardScheduledEmailsManagementDialog: ({ setShouldReturnToManagementDialog, }: IUseDashboardScheduledEmailsManagementDialogProps) => {
+export declare const useDashboardScheduledEmailsManagementDialog: () => {
     defaultOnScheduleEmailingManagement: (widget?: IWidget | undefined) => void;
     onScheduleEmailingManagementOpen: (widget?: IWidget | undefined) => void;
     onScheduleEmailingManagementClose: () => void;

package/esm/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsManagementDialog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDashboardScheduledEmailsManagementDialog.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsManagementDialog.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,yBAAyB,EAAE,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAYnF;;GAEG;AACH,MAAM,WAAW,iDAAiD;IAC9D,iCAAiC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC/D;AAED;;GAEG;AACH,eAAO,MAAM,2CAA2C;;;;;;;;;CAiIvD,CAAC"}
+{"version":3,"file":"useDashboardScheduledEmailsManagementDialog.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsManagementDialog.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,yBAAyB,EAAE,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAWnF;;GAEG;AACH,eAAO,MAAM,2CAA2C;;;;;;;;;CAkGvD,CAAC"}

package/esm/model/react/useDasboardScheduledEmails/useDashboardScheduledEmailsManagementDialog.js

@@ -2,7 +2,6 @@
 import { useCallback } from "react";
 import { useToastMessage } from "@gooddata/sdk-ui-kit";
 import { messages } from "../../../locales.js";
-import { selectEnableAutomationManagement } from "../../store/config/configSelectors.js";
 import { selectDashboardRef } from "../../store/meta/metaSelectors.js";
 import { selectIsScheduleEmailManagementDialogContext } from "../../store/ui/uiSelectors.js";
 import { useDashboardSelector } from "../DashboardStoreProvider.js";
@@ -11,21 +10,15 @@ import { useDashboardScheduledEmailsCommands } from "./useDashboardScheduledEmai
 /**
  * @internal
  */
-export const useDashboardScheduledEmailsManagementDialog = ({ setShouldReturnToManagementDialog, }) => {
+export const useDashboardScheduledEmailsManagementDialog = () => {
     const { addSuccess, addError } = useToastMessage();
     const dashboardRef = useDashboardSelector(selectDashboardRef);
-    const enableAutomationManagement = useDashboardSelector(selectEnableAutomationManagement);
     const managementDialogContext = useDashboardSelector(selectIsScheduleEmailManagementDialogContext);
     const { closeScheduleEmailingDialog, closeScheduleEmailingManagementDialog, openScheduleEmailingDialog, openScheduleEmailingManagementDialog, } = useDashboardScheduledEmailsCommands();
-    const { refreshAutomations, refreshAutomationManagementItems } = useDashboardAutomations();
+    const { refreshAutomationManagementItems } = useDashboardAutomations();
     const handleRefreshAutomations = useCallback(() => {
-        if (enableAutomationManagement) {
-            refreshAutomationManagementItems();
-        }
-        else {
-            refreshAutomations();
-        }
-    }, [enableAutomationManagement, refreshAutomations, refreshAutomationManagementItems]);
+        refreshAutomationManagementItems();
+    }, [refreshAutomationManagementItems]);
     /*
      * exports and scheduling are not available when rendering a dashboard that is not persisted.
      * this can happen when a new dashboard is created and is being edited.
@@ -44,8 +37,7 @@ export const useDashboardScheduledEmailsManagementDialog = ({ setShouldReturnToM
     }, [openScheduleEmailingManagementDialog]);
     const onScheduleEmailingManagementClose = useCallback(() => {
         closeScheduleEmailingManagementDialog();
-        setShouldReturnToManagementDialog(false);
-    }, [closeScheduleEmailingManagementDialog, setShouldReturnToManagementDialog]);
+    }, [closeScheduleEmailingManagementDialog]);
     // Loading
     const onScheduleEmailingManagementLoadingError = useCallback(() => {
         closeScheduleEmailingManagementDialog();
@@ -57,37 +49,12 @@ export const useDashboardScheduledEmailsManagementDialog = ({ setShouldReturnToM
             ? { ref: managementDialogContext.widgetRef }
             : undefined;
         const widget = contextWidget ?? targetWidget;
-        if (enableAutomationManagement) {
-            openScheduleEmailingDialog({ widget });
-        }
-        else {
-            setShouldReturnToManagementDialog(true);
-            closeScheduleEmailingManagementDialog();
-            openScheduleEmailingDialog({ widget });
-        }
-    }, [
-        enableAutomationManagement,
-        managementDialogContext,
-        setShouldReturnToManagementDialog,
-        closeScheduleEmailingManagementDialog,
-        openScheduleEmailingDialog,
-    ]);
+        openScheduleEmailingDialog({ widget });
+    }, [managementDialogContext, openScheduleEmailingDialog]);
     // Edit
     const onScheduleEmailingManagementEdit = useCallback((schedule, widget) => {
-        if (enableAutomationManagement) {
-            openScheduleEmailingDialog({ widget, schedule });
-        }
-        else {
-            setShouldReturnToManagementDialog(true);
-            closeScheduleEmailingManagementDialog();
-            openScheduleEmailingDialog({ widget, schedule });
-        }
-    }, [
-        enableAutomationManagement,
-        closeScheduleEmailingManagementDialog,
-        openScheduleEmailingDialog,
-        setShouldReturnToManagementDialog,
-    ]);
+        openScheduleEmailingDialog({ widget, schedule });
+    }, [openScheduleEmailingDialog]);
     // Delete
     const onScheduleEmailingManagementDeleteSuccess = useCallback(() => {
         closeScheduleEmailingDialog();

package/esm/model/react/useDashboardAlerting/useDashboardAlertsCommands.d.ts

@@ -4,12 +4,12 @@ import { type IAutomationMetadataObject, type IWidget } from "@gooddata/sdk-mode
  */
 export declare const useDashboardAlertsCommands: () => {
     openAlertDialog: (widget?: IWidget | undefined, alert?: IAutomationMetadataObject | undefined) => void;
-    closeAlertDialog: () => false | {
+    closeAlertDialog: () => {
         payload: undefined;
         type: "uiSlice/closeAlertingDialog";
     };
     openAlertsManagementDialog: (widget?: IWidget | undefined, openedFrom?: string | undefined) => void;
-    closeAlertsManagementDialog: () => false | {
+    closeAlertsManagementDialog: () => {
         payload: undefined;
         type: "uiSlice/closeAlertingManagementDialog";
     };

package/esm/model/react/useDashboardAlerting/useDashboardAlertsCommands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDashboardAlertsCommands.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDashboardAlerting/useDashboardAlertsCommands.tsx"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,yBAAyB,EAC9B,KAAK,OAAO,EAGf,MAAM,qBAAqB,CAAC;AAW7B;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;CA+EtC,CAAC"}
+{"version":3,"file":"useDashboardAlertsCommands.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDashboardAlerting/useDashboardAlertsCommands.tsx"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,yBAAyB,EAC9B,KAAK,OAAO,EAGf,MAAM,qBAAqB,CAAC;AAU7B;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;CAmEtC,CAAC"}

package/esm/model/react/useDashboardAlerting/useDashboardAlertsCommands.js

@@ -2,7 +2,6 @@
 import { useCallback } from "react";
 import { areObjRefsEqual, isInsightWidget, } from "@gooddata/sdk-model";
 import { switchDashboardTab } from "../../commands/tabs.js";
-import { selectEnableAlerting } from "../../store/config/configSelectors.js";
 import { selectInsights } from "../../store/insights/insightsSelectors.js";
 import { selectWidgetLocalIdToTabIdMap, selectWidgets } from "../../store/tabs/layout/layoutSelectors.js";
 import { selectActiveTabLocalIdentifier } from "../../store/tabs/tabsSelectors.js";
@@ -19,37 +18,30 @@ export const useDashboardAlertsCommands = () => {
     const insights = useDashboardSelector(selectInsights);
     const widgetTabMap = useDashboardSelector(selectWidgetLocalIdToTabIdMap);
     const activeTabId = useDashboardSelector(selectActiveTabLocalIdentifier);
-    // Feature Flags
-    const isAlertingEnabled = useDashboardSelector(selectEnableAlerting);
     // Single Alert Dialog
     const openAlertDialog = useCallback((widget, alert) => {
-        if (isAlertingEnabled) {
-            const widgetLocalId = widget?.localIdentifier ?? alert?.metadata?.widget;
-            if (widgetLocalId) {
-                const targetTabId = widgetTabMap[widgetLocalId];
-                if (targetTabId && targetTabId !== activeTabId) {
-                    dispatch(switchDashboardTab(targetTabId));
-                }
+        const widgetLocalId = widget?.localIdentifier ?? alert?.metadata?.widget;
+        if (widgetLocalId) {
+            const targetTabId = widgetTabMap[widgetLocalId];
+            if (targetTabId && targetTabId !== activeTabId) {
+                dispatch(switchDashboardTab(targetTabId));
             }
-            dispatch(uiActions.openAlertingDialog({
-                ...(widget?.ref ? { widgetRef: widget.ref } : {}),
-                ...(alert ? { alert } : {}),
-            }));
-            const selectedWidget = widgets.find((w) => w.localIdentifier === widget?.localIdentifier);
-            const insightRef = isInsightWidget(selectedWidget) ? selectedWidget.insight : undefined;
-            const insight = insights.find((i) => areObjRefsEqual(i.insight.ref, insightRef));
-            automationInteraction({
-                type: "alertInitialized",
-                automation_visualization_type: insight?.insight.visualizationUrl,
-            });
         }
-    }, [activeTabId, automationInteraction, dispatch, insights, isAlertingEnabled, widgetTabMap, widgets]);
-    const closeAlertDialog = useCallback(() => isAlertingEnabled && dispatch(uiActions.closeAlertingDialog()), [dispatch, isAlertingEnabled]);
+        dispatch(uiActions.openAlertingDialog({
+            ...(widget?.ref ? { widgetRef: widget.ref } : {}),
+            ...(alert ? { alert } : {}),
+        }));
+        const selectedWidget = widgets.find((w) => w.localIdentifier === widgetLocalId);
+        const insightRef = isInsightWidget(selectedWidget) ? selectedWidget.insight : undefined;
+        const insight = insights.find((i) => areObjRefsEqual(i.insight.ref, insightRef));
+        automationInteraction({
+            type: "alertInitialized",
+            automation_visualization_type: insight?.insight.visualizationUrl,
+        });
+    }, [activeTabId, automationInteraction, dispatch, insights, widgetTabMap, widgets]);
+    const closeAlertDialog = useCallback(() => dispatch(uiActions.closeAlertingDialog()), [dispatch]);
     // List / Management Dialog
     const openAlertsManagementDialog = useCallback((widget, openedFrom) => {
-        if (!isAlertingEnabled) {
-            return;
-        }
         if (widget?.localIdentifier) {
             const targetTabId = widgetTabMap[widget.localIdentifier];
             if (targetTabId && targetTabId !== activeTabId) {
@@ -59,8 +51,8 @@ export const useDashboardAlertsCommands = () => {
         dispatch(uiActions.openAlertingManagementDialog({
             ...(widget?.ref ? { widgetRef: widget.ref, openedFrom } : { openedFrom }),
         }));
-    }, [activeTabId, dispatch, isAlertingEnabled, widgetTabMap]);
-    const closeAlertsManagementDialog = useCallback(() => isAlertingEnabled && dispatch(uiActions.closeAlertingManagementDialog()), [dispatch, isAlertingEnabled]);
+    }, [activeTabId, dispatch, widgetTabMap]);
+    const closeAlertsManagementDialog = useCallback(() => dispatch(uiActions.closeAlertingManagementDialog()), [dispatch]);
     return {
         openAlertDialog,
         closeAlertDialog,

package/esm/model/react/useDashboardAlerting/useDashboardAlertsData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDashboardAlertsData.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDashboardAlerting/useDashboardAlertsData.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAkCrE,UAAU,4BAA4B;IAClC,WAAW,CAAC,EAAE,yBAAyB,CAAC;CAC3C;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;CA+ElC,CAAC"}
+{"version":3,"file":"useDashboardAlertsData.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDashboardAlerting/useDashboardAlertsData.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAkCrE,UAAU,4BAA4B;IAClC,WAAW,CAAC,EAAE,yBAAyB,CAAC;CAC3C;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;CA2ElC,CAAC"}

package/esm/model/react/useDashboardAlerting/useDashboardAlertsData.js

@@ -1,6 +1,6 @@
 // (C) 2022-2026 GoodData Corporation
 import { selectAllAutomationsCount, selectAutomationsError, selectAutomationsIsInitialized, selectAutomationsIsLoading, selectDashboardUserAutomationAlertsInContext, } from "../../store/automations/automationsSelectors.js";
-import { selectEnableAlerting, selectIsReadOnly } from "../../store/config/configSelectors.js";
+import { selectIsReadOnly } from "../../store/config/configSelectors.js";
 import { selectEntitlementMaxAutomations, selectEntitlementUnlimitedAutomations, } from "../../store/entitlements/entitlementsSelectors.js";
 import { selectInsightByWidgetRef } from "../../store/insights/insightsSelectors.js";
 import { selectNotificationChannels, selectNotificationChannelsCount, } from "../../store/notificationChannels/notificationChannelsSelectors.js";
@@ -24,8 +24,6 @@ export const useDashboardAlertsData = ({ alertToEdit }) => {
     const isInViewMode = useDashboardSelector(selectIsInViewMode);
     // Visibility configuration
     const menuButtonItemsVisibility = useDashboardSelector(selectMenuButtonItemsVisibility);
-    // Feature flags
-    const isAlertingEnabled = useDashboardSelector(selectEnableAlerting);
     // Permissions
     const isWorkspaceManager = useDashboardSelector(selectCanManageWorkspace);
     const canCreateAutomation = useDashboardSelector(selectCanCreateAutomation);
@@ -42,7 +40,6 @@ export const useDashboardAlertsData = ({ alertToEdit }) => {
     const showDueToNumberOfAvailableDestinations = numberOfAvailableDestinations > 0 || isWorkspaceManager;
     const isAlertingAvailable = isInViewMode &&
         !isReadOnly &&
-        isAlertingEnabled &&
         showDueToNumberOfAvailableDestinations &&
         (menuButtonItemsVisibility.alertingButton ?? true);
     // Single Schedule Dialog

package/esm/model/react/useDashboardAlerting/useDashboardAlertsDialog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDashboardAlertsDialog.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDashboardAlerting/useDashboardAlertsDialog.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,yBAAyB,EAC9B,KAAK,OAAO,EAGf,MAAM,qBAAqB,CAAC;AAe7B;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;CAsIpC,CAAC"}
+{"version":3,"file":"useDashboardAlertsDialog.d.ts","sourceRoot":"","sources":["../../../../src/model/react/useDashboardAlerting/useDashboardAlertsDialog.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,yBAAyB,EAC9B,KAAK,OAAO,EAGf,MAAM,qBAAqB,CAAC;AAc7B;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;CAgIpC,CAAC"}