@gooddata/sdk-ui-dashboard 11.55.0-alpha.0 → 11.55.0-alpha.2

package/esm/presentation/automations/alerting/blocks/AlertingDialogSensitivity.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormattedMessage } from "react-intl";
+import { AutomationDialogFormField } from "../../shared/slots/AutomationDialogFormField.js";
+import { DefaultAlertingDialogSensitivity } from "../DefaultAlertingDialog/DefaultAlertingDialogSensitivity.js";
+import { useAlertDraft } from "../state/AlertDraftContext.js";
+import { useAlertingDialogSensitivityProps } from "../state/useAlertingDialogFieldProps.js";
+import { isAnomalyDetection } from "../utils/guards.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's sensitivity field (the "Sensitivity" of anomaly detection), connected to
+ * the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogSensitivity} inside {@link AutomationDialogFormField} with
+ * the props of {@link useAlertingDialogSensitivityProps}; every prop passed here replaces the
+ * hook's value for that prop wholesale. Renders nothing unless the draft uses anomaly detection,
+ * and nothing while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export function AlertingDialogSensitivity(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogSensitivity, { ...overrides }) }));
+}
+function ConnectedAlertingDialogSensitivity(overrides) {
+    const props = { ...useAlertingDialogSensitivityProps(), ...overrides };
+    const { editedAutomation } = useAlertDraft();
+    if (!isAnomalyDetection(editedAutomation?.alert)) {
+        return null;
+    }
+    return (_jsx(AutomationDialogFormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.sensitivity" }), htmlFor: props.id, children: _jsx(DefaultAlertingDialogSensitivity, { ...props }) }));
+}

package/esm/presentation/automations/alerting/blocks/AlertingDialogThreshold.d.ts

@@ -0,0 +1,21 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogThresholdProps } from "../types.js";
+/**
+ * The alerting dialog's threshold field (the value a fixed-threshold, change or difference
+ * condition is compared against), connected to the dialog's state and rendered as a labelled form
+ * row.
+ *
+ * Renders {@link DefaultAlertingDialogThreshold} inside {@link AutomationDialogFormField} with the
+ * props of {@link useAlertingDialogThresholdProps}; every prop passed here replaces the hook's
+ * value for that prop wholesale. **The one `useAlertThreshold` mount**:
+ * {@link useAlertingDialogThresholdProps} owns the field's state and writes the draft
+ * (auto-computing a new alert's threshold), so place this block once per dialog and do not also
+ * call the hook. Renders nothing while the draft uses anomaly detection (that condition has no
+ * threshold); the hook stays mounted behind the gate, so the field's touched state survives a
+ * switch to anomaly detection and back. Renders nothing while
+ * `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogThreshold(overrides: Partial<IAlertingDialogThresholdProps>): ReactElement;
+//# sourceMappingURL=AlertingDialogThreshold.d.ts.map

package/esm/presentation/automations/alerting/blocks/AlertingDialogThreshold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogThreshold.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogThreshold.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAQ1C,OAAO,EAAE,KAAK,6BAA6B,EAAE,MAAM,aAAa,CAAC;AAKjE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,OAAO,CAAC,6BAA6B,CAAC,GAAG,YAAY,CAMvG"}

package/esm/presentation/automations/alerting/blocks/AlertingDialogThreshold.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormattedMessage } from "react-intl";
+import { AutomationDialogFormField } from "../../shared/slots/AutomationDialogFormField.js";
+import { DefaultAlertingDialogThreshold } from "../DefaultAlertingDialog/DefaultAlertingDialogThreshold.js";
+import { useAlertDraft } from "../state/AlertDraftContext.js";
+import { useAlertingDialogThresholdProps } from "../state/useAlertingDialogFieldProps.js";
+import { isAnomalyDetection } from "../utils/guards.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's threshold field (the value a fixed-threshold, change or difference
+ * condition is compared against), connected to the dialog's state and rendered as a labelled form
+ * row.
+ *
+ * Renders {@link DefaultAlertingDialogThreshold} inside {@link AutomationDialogFormField} with the
+ * props of {@link useAlertingDialogThresholdProps}; every prop passed here replaces the hook's
+ * value for that prop wholesale. **The one `useAlertThreshold` mount**:
+ * {@link useAlertingDialogThresholdProps} owns the field's state and writes the draft
+ * (auto-computing a new alert's threshold), so place this block once per dialog and do not also
+ * call the hook. Renders nothing while the draft uses anomaly detection (that condition has no
+ * threshold); the hook stays mounted behind the gate, so the field's touched state survives a
+ * switch to anomaly detection and back. Renders nothing while
+ * `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export function AlertingDialogThreshold(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogThreshold, { ...overrides }) }));
+}
+function ConnectedAlertingDialogThreshold(overrides) {
+    const props = { ...useAlertingDialogThresholdProps(), ...overrides };
+    const { editedAutomation } = useAlertDraft();
+    if (isAnomalyDetection(editedAutomation?.alert)) {
+        return null;
+    }
+    return (_jsx(AutomationDialogFormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.threshold" }), htmlFor: props.id, children: _jsx(DefaultAlertingDialogThreshold, { ...props }) }));
+}

package/esm/presentation/automations/alerting/blocks/AlertingDialogTriggerInterval.d.ts

@@ -0,0 +1,15 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogTriggerIntervalProps } from "../types.js";
+/**
+ * The alerting dialog's trigger-interval field (the interval a once-per-interval trigger notifies
+ * on), connected to the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogTriggerInterval} inside {@link AutomationDialogFormField}
+ * with the props of {@link useAlertingDialogTriggerIntervalProps}; every prop passed here replaces
+ * the hook's value for that prop wholesale. Renders nothing unless the draft's trigger mode is
+ * `ONCE_PER_INTERVAL`, and nothing while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogTriggerInterval(overrides: Partial<IAlertingDialogTriggerIntervalProps>): ReactElement;
+//# sourceMappingURL=AlertingDialogTriggerInterval.d.ts.map

package/esm/presentation/automations/alerting/blocks/AlertingDialogTriggerInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogTriggerInterval.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogTriggerInterval.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAQ1C,OAAO,EAAE,KAAK,mCAAmC,EAAE,MAAM,aAAa,CAAC;AAQvE;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CACzC,SAAS,EAAE,OAAO,CAAC,mCAAmC,CAAC,GACxD,YAAY,CAMd"}

package/esm/presentation/automations/alerting/blocks/AlertingDialogTriggerInterval.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { defineMessage } from "react-intl";
+import { AutomationDialogFormField } from "../../shared/slots/AutomationDialogFormField.js";
+import { DefaultAlertingDialogTriggerInterval } from "../DefaultAlertingDialog/DefaultAlertingDialogTriggerInterval.js";
+import { useAlertDraft } from "../state/AlertDraftContext.js";
+import { useAlertingDialogTriggerIntervalProps } from "../state/useAlertingDialogFieldProps.js";
+import { AlertingDialogFieldLabelWithTooltip } from "./AlertingDialogFieldLabelWithTooltip.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+const INTERVAL_LABEL = defineMessage({ id: "insightAlert.config.interval" });
+const INTERVAL_TOOLTIP = defineMessage({ id: "insightAlert.config.interval.tooltip" });
+/**
+ * The alerting dialog's trigger-interval field (the interval a once-per-interval trigger notifies
+ * on), connected to the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogTriggerInterval} inside {@link AutomationDialogFormField}
+ * with the props of {@link useAlertingDialogTriggerIntervalProps}; every prop passed here replaces
+ * the hook's value for that prop wholesale. Renders nothing unless the draft's trigger mode is
+ * `ONCE_PER_INTERVAL`, and nothing while `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export function AlertingDialogTriggerInterval(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogTriggerInterval, { ...overrides }) }));
+}
+function ConnectedAlertingDialogTriggerInterval(overrides) {
+    const props = { ...useAlertingDialogTriggerIntervalProps(), ...overrides };
+    const { editedAutomation } = useAlertDraft();
+    if (editedAutomation?.alert?.trigger.mode !== "ONCE_PER_INTERVAL") {
+        return null;
+    }
+    return (_jsx(AutomationDialogFormField, { label: _jsx(AlertingDialogFieldLabelWithTooltip, { label: INTERVAL_LABEL, tooltip: INTERVAL_TOOLTIP }), htmlFor: props.id, children: _jsx(DefaultAlertingDialogTriggerInterval, { ...props }) }));
+}

package/esm/presentation/automations/alerting/blocks/AlertingDialogTriggerMode.d.ts

@@ -0,0 +1,15 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogTriggerModeProps } from "../types.js";
+/**
+ * The alerting dialog's trigger-mode field ("Trigger": how often a met condition notifies),
+ * connected to the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogTriggerMode} inside {@link AutomationDialogFormField} with
+ * the props of {@link useAlertingDialogTriggerModeProps}; every prop passed here replaces the
+ * hook's value for that prop wholesale. Renders nothing while
+ * `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogTriggerMode(overrides: Partial<IAlertingDialogTriggerModeProps>): ReactElement;
+//# sourceMappingURL=AlertingDialogTriggerMode.d.ts.map

package/esm/presentation/automations/alerting/blocks/AlertingDialogTriggerMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogTriggerMode.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogTriggerMode.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAO1C,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,aAAa,CAAC;AAInE;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,OAAO,CAAC,+BAA+B,CAAC,GAAG,YAAY,CAM3G"}

package/esm/presentation/automations/alerting/blocks/AlertingDialogTriggerMode.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormattedMessage } from "react-intl";
+import { AutomationDialogFormField } from "../../shared/slots/AutomationDialogFormField.js";
+import { DefaultAlertingDialogTriggerMode } from "../DefaultAlertingDialog/DefaultAlertingDialogTriggerMode.js";
+import { useAlertingDialogTriggerModeProps } from "../state/useAlertingDialogFieldProps.js";
+import { WhenAlertingDialogLoaded } from "./WhenAlertingDialogLoaded.js";
+/**
+ * The alerting dialog's trigger-mode field ("Trigger": how often a met condition notifies),
+ * connected to the dialog's state and rendered as a labelled form row.
+ *
+ * Renders {@link DefaultAlertingDialogTriggerMode} inside {@link AutomationDialogFormField} with
+ * the props of {@link useAlertingDialogTriggerModeProps}; every prop passed here replaces the
+ * hook's value for that prop wholesale. Renders nothing while
+ * `useAlertingDialogContext().isLoading` is true.
+ *
+ * @alpha
+ */
+export function AlertingDialogTriggerMode(overrides) {
+    return (_jsx(WhenAlertingDialogLoaded, { children: _jsx(ConnectedAlertingDialogTriggerMode, { ...overrides }) }));
+}
+function ConnectedAlertingDialogTriggerMode(overrides) {
+    const props = { ...useAlertingDialogTriggerModeProps(), ...overrides };
+    return (_jsx(AutomationDialogFormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.trigger" }), htmlFor: props.id, children: _jsx(DefaultAlertingDialogTriggerMode, { ...props }) }));
+}

package/esm/presentation/automations/alerting/blocks/WhenAlertingDialogLoaded.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from "react";
+/**
+ * Renders its children only once the alerting dialog's data has loaded — the state accessors throw
+ * while `useAlertingDialogContext().isLoading` is true, because the state providers mount only then.
+ * Every connected alerting block goes through it.
+ *
+ * @internal
+ */
+export declare function WhenAlertingDialogLoaded({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=WhenAlertingDialogLoaded.d.ts.map

package/esm/presentation/automations/alerting/blocks/WhenAlertingDialogLoaded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WhenAlertingDialogLoaded.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/WhenAlertingDialogLoaded.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,kDAG7E"}

package/esm/presentation/automations/alerting/blocks/WhenAlertingDialogLoaded.js

@@ -0,0 +1,13 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useAlertingDialogContext } from "../../contexts/AlertingDialogContext.js";
+/**
+ * Renders its children only once the alerting dialog's data has loaded — the state accessors throw
+ * while `useAlertingDialogContext().isLoading` is true, because the state providers mount only then.
+ * Every connected alerting block goes through it.
+ *
+ * @internal
+ */
+export function WhenAlertingDialogLoaded({ children }) {
+    const { isLoading } = useAlertingDialogContext();
+    return isLoading ? null : _jsx(_Fragment, { children: children });
+}

package/esm/presentation/automations/alerting/{DefaultAlertingDialog/hooks → hooks}/useAlertThreshold.d.ts

@@ -1,6 +1,6 @@
 import { type Dispatch, type SetStateAction } from "react";
 import { type IAlertRelativeArithmeticOperator, type IAlertRelativeOperator, type IAttribute, type IAutomationMetadataObjectDefinition, type IMeasure } from "@gooddata/sdk-model";
-import { type AlertAttribute, type AlertMetric } from "../../types.js";
+import { type AlertAttribute, type AlertMetric } from "../types.js";
 export interface IUseAlertThresholdProps {
     setEditedAutomation: Dispatch<SetStateAction<IAutomationMetadataObjectDefinition | undefined>>;
     editedAutomation: IAutomationMetadataObjectDefinition | undefined;

package/esm/presentation/automations/alerting/hooks/useAlertThreshold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAlertThreshold.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/hooks/useAlertThreshold.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAe,MAAM,OAAO,CAAC;AAExE,OAAO,EACH,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC3B,KAAK,UAAU,EAEf,KAAK,mCAAmC,EACxC,KAAK,QAAQ,EAChB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAKpE,MAAM,WAAW,uBAAuB;IACpC,mBAAmB,EAAE,QAAQ,CAAC,cAAc,CAAC,mCAAmC,GAAG,SAAS,CAAC,CAAC,CAAC;IAC/F,gBAAgB,EAAE,mCAAmC,GAAG,SAAS,CAAC;IAClE,cAAc,EAAE,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,GAAG,SAAS,CAAC;IACrG,UAAU,EAAE,OAAO,CAAC;IACpB,wBAAwB,EAAE,CAAC,sBAAsB,EAAE,gCAAgC,CAAC,GAAG,SAAS,CAAC;IACjG,eAAe,EAAE,WAAW,GAAG,SAAS,CAAC;IACzC,iBAAiB,EAAE,cAAc,GAAG,SAAS,CAAC;IAC9C,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAC5C;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,EAC9B,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,EACd,UAAU,EACV,wBAAwB,EACxB,eAAe,EACf,iBAAiB,EACjB,aAAa,EAChB,EAAE,uBAAuB;;;;;EAgCzB"}

package/esm/presentation/automations/alerting/hooks/useAlertValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAlertValidation.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/hooks/useAlertValidation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAK7G,MAAM,MAAM,qBAAqB,GAAG,eAAe,GAAG,eAAe,CAAC;AAEtE,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,yBAAyB,GAAG,SAAS,EAC5C,MAAM,EAAE,OAAO,GAAG,SAAS,EAC3B,OAAO,EAAE,QAAQ,GAAG,SAAS,EAC7B,mBAAmB,EAAE,mBAAmB,EAAE,EAC1C,UAAU,CAAC,EAAE,OAAO,GACrB;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,gBAAgB,EAAE,qBAAqB,GAAG,SAAS,CAAA;CAAE,CAc3E"}

package/esm/presentation/automations/alerting/{DefaultAlertingDialog/hooks → hooks}/useAttributeValuesFromExecResults.d.ts

@@ -4,11 +4,31 @@ type IExecutionResultEnvelope = {
     isLoading?: boolean;
     executionResult?: IExecutionResult;
 };
+/**
+ * One distinct value of an attribute in the widget's execution result, as offered by the alert's
+ * attribute-value picker.
+ *
+ * @alpha
+ */
 export type AttributeValue = {
+    /**
+     * Display title: the formatted element name when the result has one, the raw name otherwise.
+     */
     title: string;
+    /**
+     * The element URI; this is what the alert stores.
+     */
     value: string;
+    /**
+     * The raw element name.
+     */
     name: string;
 };
+/**
+ * Reads the widget's execution result and exposes the attribute values and measure values in it.
+ *
+ * @internal
+ */
 export declare function useAttributeValuesFromExecResults(execResult: IExecutionResultEnvelope | undefined): {
     isResultLoading: boolean;
     getAttributeValues: (attr: IAttributeMetadataObject) => AttributeValue[];

package/esm/presentation/automations/alerting/hooks/useAttributeValuesFromExecResults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAttributeValuesFromExecResults.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/hooks/useAttributeValuesFromExecResults.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EACH,KAAK,UAAU,EAEf,KAAK,wBAAwB,EAC7B,KAAK,QAAQ,EAGhB,MAAM,qBAAqB,CAAC;AAG7B,KAAK,wBAAwB,GAAG;IAAE,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,eAAe,CAAC,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAE5F;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG;IACzB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,iCAAiC,CAAC,UAAU,EAAE,wBAAwB,GAAG,SAAS;;;;EAyEjG"}

package/esm/presentation/automations/alerting/{DefaultAlertingDialog/hooks → hooks}/useAttributeValuesFromExecResults.js

@@ -2,6 +2,11 @@
 import { useCallback, useEffect, useState } from "react";
 import { areObjRefsEqual, isResultAttributeHeader, } from "@gooddata/sdk-model";
 import { DataViewFacade } from "@gooddata/sdk-ui";
+/**
+ * Reads the widget's execution result and exposes the attribute values and measure values in it.
+ *
+ * @internal
+ */
 export function useAttributeValuesFromExecResults(execResult) {
     // Derive loading from the envelope's own isLoading flag, not from the
     // presence of executionResult: an errored execution has no executionResult

package/esm/presentation/automations/alerting/hooks/useGetSupportedMeasures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useGetSupportedMeasures.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/hooks/useGetSupportedMeasures.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAKpD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,kDAYnC,CAAC"}
+{"version":3,"file":"useGetSupportedMeasures.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/hooks/useGetSupportedMeasures.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAIpD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,kDAYnC,CAAC"}

package/esm/presentation/automations/alerting/hooks/useGetSupportedMeasures.js

@@ -2,7 +2,7 @@
 import { useEffect, useMemo, useState } from "react";
 import { fillMissingTitles } from "@gooddata/sdk-ui";
 import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
-import { getSupportedInsightMeasuresByInsight } from "../DefaultAlertingDialog/utils/items.js";
+import { getSupportedInsightMeasuresByInsight } from "../utils/items.js";
 /**
  * Hook that calculates supported alertable measures for an insight.
  *

package/esm/presentation/automations/alerting/{DefaultAlertingDialog/hooks → hooks}/useThresholdValue.d.ts

@@ -1,6 +1,6 @@
 import { type ChangeEvent, type FocusEvent } from "react";
 import { type IAlertRelativeArithmeticOperator, type IAlertRelativeOperator, type IAttribute, type IAutomationAlert, type IMeasure } from "@gooddata/sdk-model";
-import { type AlertAttribute, type AlertMetric } from "../../types.js";
+import { type AlertAttribute, type AlertMetric } from "../types.js";
 export declare function useThresholdValue(changeValue: (value: number) => void, getMetricValue: (measure?: IMeasure, attr?: IAttribute, value?: string | null) => number | undefined, isNewAlert?: boolean, alert?: IAutomationAlert, selectedRelativeOperator?: [
     IAlertRelativeOperator | undefined,
     IAlertRelativeArithmeticOperator | undefined

package/esm/presentation/automations/alerting/hooks/useThresholdValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useThresholdValue.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/hooks/useThresholdValue.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAoC,MAAM,OAAO,CAAC;AAI5F,OAAO,EACH,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC3B,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,QAAQ,EAChB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAgCpE,wBAAgB,iBAAiB,CAC7B,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EACpC,cAAc,EAAE,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,GAAG,SAAS,EACpG,UAAU,CAAC,EAAE,OAAO,EACpB,KAAK,CAAC,EAAE,gBAAgB,EACxB,wBAAwB,GAAE;IACtB,sBAAsB,GAAG,SAAS;IAClC,gCAAgC,GAAG,SAAS;CACtB,EAC1B,eAAe,CAAC,EAAE,WAAW,EAC7B,iBAAiB,CAAC,EAAE,cAAc,EAClC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI;;;;;EAkFhC"}

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

@@ -8,7 +8,7 @@ export declare const AlertActionsContextProvider: import("react").Provider<IAler
  * must check that flag before calling this. On the alerting side that state is reached only by an
  * automations refresh while the dialog is open, so it will not appear in manual testing.
  *
- * @internal
+ * @alpha
  */
 export declare function useAlertActions(): IAlertActionsContextValue;
 //# sourceMappingURL=AlertActionsContext.d.ts.map

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

@@ -12,7 +12,7 @@ export const AlertActionsContextProvider = AlertActionsContext.Provider;
  * must check that flag before calling this. On the alerting side that state is reached only by an
  * automations refresh while the dialog is open, so it will not appear in manual testing.
  *
- * @internal
+ * @alpha
  */
 export function useAlertActions() {
     return useContext(AlertActionsContext) ?? missingAlertStateProvider("useAlertActions");

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

@@ -8,7 +8,7 @@ export declare const AlertDataContextProvider: import("react").Provider<IAlertDa
  * must check that flag before calling this. On the alerting side that state is reached only by an
  * automations refresh while the dialog is open, so it will not appear in manual testing.
  *
- * @internal
+ * @alpha
  */
 export declare function useAlertData(): IAlertDataContextValue;
 //# sourceMappingURL=AlertDataContext.d.ts.map

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

@@ -12,7 +12,7 @@ export const AlertDataContextProvider = AlertDataContext.Provider;
  * must check that flag before calling this. On the alerting side that state is reached only by an
  * automations refresh while the dialog is open, so it will not appear in manual testing.
  *
- * @internal
+ * @alpha
  */
 export function useAlertData() {
     return useContext(AlertDataContext) ?? missingAlertStateProvider("useAlertData");

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

@@ -8,7 +8,7 @@ export declare const AlertDraftContextProvider: import("react").Provider<IAlertD
  * must check that flag before calling this. On the alerting side that state is reached only by an
  * automations refresh while the dialog is open, so it will not appear in manual testing.
  *
- * @internal
+ * @alpha
  */
 export declare function useAlertDraft(): IAlertDraftContextValue;
 //# sourceMappingURL=AlertDraftContext.d.ts.map

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

@@ -12,7 +12,7 @@ export const AlertDraftContextProvider = AlertDraftContext.Provider;
  * must check that flag before calling this. On the alerting side that state is reached only by an
  * automations refresh while the dialog is open, so it will not appear in manual testing.
  *
- * @internal
+ * @alpha
  */
 export function useAlertDraft() {
     return useContext(AlertDraftContext) ?? missingAlertStateProvider("useAlertDraft");

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

@@ -8,7 +8,7 @@ export declare const AlertFiltersContextProvider: import("react").Provider<IAler
  * must check that flag before calling this. On the alerting side that state is reached only by an
  * automations refresh while the dialog is open, so it will not appear in manual testing.
  *
- * @internal
+ * @alpha
  */
 export declare function useAlertFilters(): IAlertFiltersContextValue;
 //# sourceMappingURL=AlertFiltersContext.d.ts.map

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

@@ -12,7 +12,7 @@ export const AlertFiltersContextProvider = AlertFiltersContext.Provider;
  * must check that flag before calling this. On the alerting side that state is reached only by an
  * automations refresh while the dialog is open, so it will not appear in manual testing.
  *
- * @internal
+ * @alpha
  */
 export function useAlertFilters() {
     return useContext(AlertFiltersContext) ?? missingAlertStateProvider("useAlertFilters");