@gooddata/sdk-ui-metric-component 11.65.0-alpha.4 → 11.65.0-alpha.6

package/esm/sdk-ui-metric-component.d.ts

@@ -0,0 +1,1615 @@
+import { Context } from 'react';
+import { Css } from 'tss-react';
+import { CSSObject } from 'tss-react';
+import { Cx } from 'tss-react';
+import { ForwardRefExoticComponent } from 'react';
+import { IAuthenticationContext } from '@gooddata/sdk-backend-spi';
+import { ICatalogAttribute } from '@gooddata/sdk-model';
+import { IInsight } from '@gooddata/sdk-model';
+import { ILocale } from '@gooddata/sdk-ui';
+import { IMeasureExpressionToken } from '@gooddata/sdk-backend-spi';
+import { IMeasureMetadataObject } from '@gooddata/sdk-model';
+import { IMeasureMetadataObjectDefinition } from '@gooddata/sdk-model';
+import { IMeasureOverride } from '@gooddata/sdk-backend-spi';
+import { IMeasureReferencing } from '@gooddata/sdk-backend-spi';
+import { IMetadataObject } from '@gooddata/sdk-model';
+import { IObjectShareDraft } from '@gooddata/sdk-ui-ext';
+import { ISeparators } from '@gooddata/sdk-model';
+import { ITranslations } from '@gooddata/sdk-ui';
+import { IWorkspacePermissions } from '@gooddata/sdk-model';
+import { JSX } from 'react/jsx-runtime';
+import type * as monaco from 'monaco-editor/editor/editor.api.js';
+import { NotAuthenticated } from '@gooddata/sdk-backend-spi';
+import { ObjectVisibility } from '@gooddata/sdk-model';
+import { ObjRef } from '@gooddata/sdk-model';
+import { PropsWithChildren } from 'react';
+import { ReactElement } from 'react';
+import { ReactNode } from 'react';
+import { Ref } from 'react';
+import { RefAttributes } from 'react';
+import { UseCancelablePromiseState } from '@gooddata/sdk-ui';
+
+/**
+ * @internal
+ */
+export declare function Authentication({ children, Error, initOpenNotAuthenticatedOverlay, initOpenContractExpiredDialog, }: {
+    Error: (err: Error) => ReactElement;
+    initOpenNotAuthenticatedOverlay?: ((callback: (err: Error) => void) => void) | false;
+    initOpenContractExpiredDialog?: ((callback: (tier: string) => void) => void) | false;
+    children: ReactNode;
+}): JSX.Element;
+
+/**
+ * @internal
+ */
+export declare enum CancelMode {
+    Continue = "continue",
+    Cross = "cross",
+    Cancel = "cancel"
+}
+
+/**
+ * @internal
+ */
+export declare enum CloseAllStatus {
+    Close = "close",
+    Canceled = "canceled",
+    Complete = "complete",
+    Incomplete = "incomplete"
+}
+
+/**
+ * @internal
+ */
+export declare type CloseAllTabsResult = CloseAllTabsWithCancel | CloseAllTabsWithProceed;
+
+/**
+ * @internal
+ */
+export declare type CloseAllTabsWithCancel = {
+    status: CloseAllStatus.Canceled | CloseAllStatus.Close;
+};
+
+/**
+ * @internal
+ */
+export declare type CloseAllTabsWithProceed = {
+    status: CloseAllStatus.Incomplete | CloseAllStatus.Complete;
+    closedTabs: IMetricInfo[];
+    invalidTabs: IMetricInfo[];
+};
+
+/**
+ * @internal
+ */
+export declare type ConflictChecker = (identifiers: string[]) => Promise<IMeasureOverride[]>;
+
+/**
+ * @internal
+ */
+export declare function ConflictContextProvider({ children, checker }: IConflictContext): JSX.Element;
+
+/**
+ * @internal
+ */
+export declare const contactLink = "https://www.gooddata.com/contact/";
+
+/**
+ * @internal
+ */
+export declare function contractExpiredHandler(tier: string): void;
+
+/**
+ * @internal
+ */
+export declare function createDefaultTheme(): {
+    globals: {
+        font: string;
+        colors: {
+            font: string;
+            shadow: string;
+            errorLight: string;
+            errorFull: string;
+            border: string;
+        };
+    };
+    content: {
+        colors: {
+            line: string;
+            lineNumber: string;
+            activeLineNumber: string;
+            slider: string;
+            sliderHover: string;
+            bracketMatch: string;
+        };
+        borders: {
+            size: number;
+        };
+    };
+    suggestion: {
+        font: string;
+        colors: {
+            line: string;
+            active: string;
+            background: string;
+            selectedBackground: string;
+            highlightedBackground: string;
+        };
+        item: {
+            fontSize: number;
+        };
+        label: {
+            fontSize: number;
+        };
+        borders: {
+            default: string;
+        };
+        shadow: string;
+    };
+    detail: {
+        colors: {
+            border: string;
+            background: string;
+            header: string;
+        };
+        header: {
+            size: number;
+            fontSize: number;
+            lineHeight: number;
+            close: {
+                font: string;
+                size: number;
+            };
+        };
+        padding: number;
+        closeSize: string;
+    };
+    statusBar: {
+        colors: {
+            color: string;
+            background: string;
+        };
+        borders: {
+            size: number;
+            default: string;
+        };
+    };
+    errorsBar: {
+        font: string;
+        sizes: {
+            headerFontSize: number;
+            bodyFontSize: number;
+            lineHeight: number;
+        };
+        colors: {
+            font: string;
+            error: string;
+            headBackground: string;
+            bodyBackground: string;
+            body: string;
+        };
+        border: {
+            topWidth: number;
+        };
+        left: number;
+        paddingVertical: number;
+        paddingHorizontal: number;
+    };
+    tooltip: {
+        colors: {
+            background: string;
+            hover: string;
+            line: string;
+        };
+        borders: {
+            size: number;
+            default: string;
+        };
+        borderRadius: string;
+    };
+    hoverBar: {
+        font: string;
+        sizes: {
+            font: number;
+            borderRadius: number;
+            borderRadiusInner: number;
+        };
+        colors: {
+            background: string;
+            errorBackground: string;
+            errorText: string;
+        };
+        border: string;
+        boxShadow: string;
+        margin: number;
+        padding: string;
+    };
+    hoverMetric: {
+        lineHeight: number;
+        padding: number;
+        space: number;
+        tooltip: {
+            normal: {
+                minWidth: number;
+                maxWidth: number;
+                maxHeight: number;
+            };
+            expanded: {
+                minWidth: number;
+                maxWidth: number;
+                maxHeight: number;
+                maxHeightDescription: number;
+            };
+        };
+        title: {
+            bottomSpace: number;
+            fontSize: number;
+        };
+        description: {
+            fontSize: number;
+        };
+        readMore: {
+            paddingText: number;
+        };
+        colors: {
+            color: string;
+            hover: string;
+            border: string;
+            link: string;
+        };
+    };
+    decorator: {
+        paddingTop: string;
+        paddingBottom: string;
+        fontWeight: string;
+        borderRadius: string;
+    };
+    doc: {
+        font: string;
+        colors: {
+            main: string;
+        };
+        h1: {
+            fontSize: number;
+            lineHeight: number;
+        };
+        h1p: {
+            fontSize: number;
+            lineHeight: number;
+            color: string;
+        };
+        h2: {
+            fontSize: number;
+            lineHeight: number;
+        };
+        h3: {
+            fontSize: number;
+            lineHeight: number;
+            color: string;
+        };
+        p: {
+            fontSize: number;
+            lineHeight: number;
+            color: string;
+        };
+        code: {
+            font: string;
+            fontSize: number;
+            lineHeight: number;
+            color: string;
+        };
+        smallPadding: number;
+        bigPadding: number;
+    };
+};
+
+/**
+ * @internal
+ */
+export declare function createDefinitionByMetric(metric: IMeasureDef): IMeasureMetadataObjectDefinition;
+
+/**
+ * @internal
+ */
+export declare function createDraftEditMetricInfo(metric: IMeasureDef, saveMode?: SaveNameMode, focusedField?: FormField, generateNewId?: boolean): IMetricInfoDraft;
+
+/**
+ * @internal
+ */
+export declare function createDraftNewMetricInfo(): IMetricInfoDraft;
+
+/**
+ * @internal
+ */
+export declare function createEditMetricInfo(identifier: string, metric: IMeasureDef): IMetricInfo;
+
+/**
+ * @internal
+ */
+export declare function createNewMetricInfo(identifier: string, prescription?: IMeasureDef, metrics?: IMeasureMetadataObject[], prefix?: string, parents?: string[]): IMetricInfo;
+
+/**
+ * @internal
+ */
+export declare const DEFAULT_LANGUAGE: ILocale;
+
+/**
+ * @internal
+ */
+export declare const DEFAULT_MESSAGES: Record<string, ITranslations>;
+
+/**
+ * @internal
+ */
+export declare type DefaultTheme = ReturnType<typeof useTheme>;
+
+/**
+ * @internal
+ */
+export declare function DeleteMetric({ locale, metric, onDelete, onClose, onMetricsChange }: IDeleteMetricProps): JSX.Element;
+
+/**
+ * @internal
+ */
+export declare const EditMetric: ForwardRefExoticComponent<Omit<IEditMetricProps, "ref"> & RefAttributes<IEditMetricApi | undefined>>;
+
+/**
+ * @internal
+ */
+export declare type EmptyMetric = IMeasureMetadataObjectDefinition & Required<Pick<IMeasureMetadataObjectDefinition, "expression" | "type" | "description" | "format" | "title" | "tags">>;
+
+/**
+ * @internal
+ */
+export declare const emptyMetric: EmptyMetric;
+
+/**
+ * @internal
+ */
+export declare type EmptyMetricWidthId = EmptyMetric & {
+    id: string;
+};
+
+/**
+ * @internal
+ */
+export declare const emptyMetricWithId: EmptyMetricWidthId;
+
+/**
+ * @internal
+ */
+export declare function emptyOrganizationPermissions(): IOrganizationPermissions;
+
+/**
+ * @internal
+ */
+export declare function emptyWorkspacePermissions(): IWorkspacePermissions;
+
+/**
+ * @internal
+ */
+export declare enum EventCategories {
+    emptyMetricList = "emptyMetricList",
+    metricList = "metricList",
+    metricComponent = "metricComponent"
+}
+
+/**
+ * @internal
+ */
+export declare const EventContext: Context<IEventContextType>;
+
+/**
+ * @internal
+ */
+export declare function EventContextProvider({ children, listeners: initialListeners, }: {
+    listeners?: IEventListener[];
+    children: ReactNode;
+}): JSX.Element;
+
+/**
+ * @internal
+ */
+export declare enum Events {
+    pageView = "pageView",
+    performanceFirstContentfulPaint = "first-contentful-paint-in-ms",
+    performanceLargestContentfulPaint = "largest-contentful-paint-in-ms",
+    metricCreateClick = "metricCreateClick",
+    metricEditClick = "metricEditClick",
+    metricCopyClick = "metricCopyClick",
+    metricDeleteClick = "metricDeleteClick",
+    howToCreateClick = "howToCreateClick",
+    metricClick = "metricClick",
+    metricNameClick = "metricNameClick",
+    metricIdClick = "metricIdClick",
+    sortChanged = "sortChanged",
+    searchUsed = "searchUsed",
+    metricTooltipDisplayed = "metricTooltipDisplayed",
+    metricOpenFromTooltip = "metricOpenFromTooltip",
+    metricCopied = "metricCopied",
+    metricCopyFailed = "metricCopyFailed",
+    metricDeleted = "metricDeleted",
+    metricDeleteFailed = "metricDeleteFailed",
+    /***** metric component *****/
+    metricNameCreated = "metricNameCreated",
+    metricIdCreated = "metricIdCreated",
+    metricIdEdit = "metricIdEdit",
+    metricDefinitionCreated = "metricDefinitionCreated",
+    metricDescriptionAdded = "metricDescriptionAdded",
+    metricUsageClick = "metricUsageClick",
+    metricSaveFailed = "metricSaveFailed",
+    metricSavedAndClosed = "metricSavedAndClosed",
+    metricEditedAndClosed = "metricEditedAndClosed",
+    metricClosedWithoutSave = "metricClosedWithoutSave",
+    metricFormatChanged = "metricFormatChanged",
+    metricSavedAsNew = "metricSavedAsNew",
+    metricSaveAsNewFailed = "metricSaveAsNewFailed",
+    metricConflictedId = "metricConflictedId",
+    editorToggleSuggestionDetails = "editorToggleSuggestionDetails",
+    editorSuggestionDetailLinkClick = "editorSuggestionDetailLinkClick",
+    /***** data stats *****/
+    workspaceMetricStatsChanged = "workspaceMetricStatsChanged",
+    /******* Conversion Dialog ********/
+    upgradeButtonClicked = "upgradeButtonClicked",
+    inviteButtonClicked = "inviteButtonClicked",
+    conversionDialogOpened = "conversionDialogOpened",
+    contactSales = "contactSales",
+    inviteUser = "inviteUser"
+}
+
+/**
+ * @internal
+ */
+export declare function FeaturesAndSettingsContextProvider({ children, canShowResults, canShowSql, canMaximize, enableMetricPermissions, defaultMetricVisibility, }: PropsWithChildren<Partial<IFeaturesAndSettingsContext>>): JSX.Element;
+
+/**
+ * @internal
+ */
+export declare enum FormField {
+    id = "id",
+    title = "title",
+    description = "description",
+    expression = "expression",
+    format = "format",
+    metricType = "metricType",
+    prefix = "prefix",
+    tags = "tags"
+}
+
+/**
+ * @internal
+ */
+export declare function GlobalLoading(): JSX.Element;
+
+/**
+ * @internal
+ */
+export declare const howToCreateMetricLink = "https://www.gooddata.com/developers/cloud-native/doc/cloud/create-metrics";
+
+/**
+ * @internal
+ */
+export declare interface IConflictContext {
+    checker: ConflictChecker;
+    children?: ReactNode;
+}
+
+/**
+ * @internal
+ */
+export declare interface IDeleteMetricInfo {
+    references: IMeasureReferencing;
+}
+
+/**
+ * @internal
+ */
+export declare interface IDeleteMetricProps {
+    locale?: string;
+    metric: IMeasureDef;
+    onDelete?: (metric: IMeasureMetadataObject, info: IDeleteMetricInfo, err: Error | null) => void;
+    onClose?: () => void;
+    onMetricsChange?: (metric: IMeasureDef) => void;
+}
+
+/**
+ * @internal
+ */
+export declare type IDisposable = monaco.IDisposable;
+
+/**
+ * @internal
+ */
+export declare interface IEditMetricApi {
+    close: () => void;
+    save: () => Promise<void>;
+    saveForce: () => Promise<void>;
+}
+
+/**
+ * @internal
+ */
+export declare interface IEditMetricProps {
+    metric: IMeasureDef;
+    setting?: IMeasureSetting;
+    locale?: string;
+    prefixes?: IPrefixes;
+    initial?: IMeasureDef;
+    focusedField?: FormField;
+    generateNewId?: boolean;
+    saveMode?: SaveNameMode;
+    permissions?: IWorkspacePermissions;
+    showCloseButton?: boolean;
+    onDelete?: (metric: IMeasureMetadataObject) => void;
+    onCancel?: (cancelMode: CancelMode | undefined) => void;
+    onSave?: (metric: IMeasureMetadataObject, info: ISaveMetricInfo, err: Error | null) => Promise<void> | void;
+    onDirtyChanged?: (dirty: boolean) => void;
+    onMetricsChange?: (metric: IMeasureDef) => void;
+    onValueChange?: (metric: IMeasureDef, valid: boolean) => void;
+    onSettingChange?: (setting: Partial<IMeasureSetting>) => void;
+    activeInsight?: IInsight;
+    insightOpenType?: "external" | "internal";
+    onInsightClick?: (object: IInsight) => void;
+    metricOpenType?: "external" | "internal";
+    onMetricClick?: (object: IMetadataObject) => void;
+    ref?: Ref<IEditMetricApi | undefined>;
+    isWhiteLabeled?: boolean;
+    separators?: ISeparators;
+    useReferences?: boolean;
+    currencyFormatOverride?: string | null;
+    enableMetricFormatOverrides?: boolean;
+    /** Access drafted so far, kept by the tab. */
+    draftAccess?: IObjectShareDraft;
+    onDraftAccessChange?: (draftAccess: IObjectShareDraft | undefined) => void;
+}
+
+/**
+ * @internal
+ */
+export declare type IEditorContribution = monaco.editor.IEditorContribution;
+
+/**
+ * @internal
+ */
+export declare interface IEvent {
+    action: Events;
+    label?: string;
+    category?: string;
+    value?: number;
+    trackId?: string;
+    variables?: {
+        [key: string]: number;
+    };
+}
+
+/**
+ * @internal
+ */
+export declare interface IEventContextType {
+    emit: (event: IEvent) => void;
+    registerListener: (listener: IEventListener) => () => void;
+}
+
+/**
+ * @internal
+ */
+export declare interface IEventListener {
+    (event: IEvent): void;
+}
+
+/**
+ * @internal
+ */
+export declare type IEventsCallback<Type extends IEventsInterface> = {
+    [Property in keyof Type]: (...args: Parameters<Type[Property]>) => void;
+};
+
+/**
+ * @internal
+ */
+export declare interface IEventsInterface {
+    [type: string]: (...args: never[]) => IEvent | null;
+}
+
+/**
+ * @internal
+ */
+export declare interface IExpressionToken {
+    id?: string;
+    ref?: ObjRef;
+    title: string;
+    deleted?: boolean;
+    empty?: boolean;
+    category?: (typeof TypeMapping)[keyof typeof TypeMapping] | IMeasureExpressionToken["type"];
+}
+
+/**
+ * @internal
+ */
+export declare interface IFeaturesAndSettingsContext {
+    canShowResults: boolean;
+    canShowSql: boolean;
+    canMaximize: boolean;
+    /**
+     * When set, a metric's own object-level permissions decide who may edit or share it.
+     * Remove together with the enableMetricPermissions feature flag.
+     */
+    enableMetricPermissions: boolean;
+    /** Who can view a metric once it is created. */
+    defaultMetricVisibility: ObjectVisibility;
+}
+
+/**
+ * @internal
+ */
+export declare interface IIntlWrapperProps {
+    locale?: string;
+}
+
+/**
+ * @internal
+ */
+export declare interface ILanguageServiceProviderProps {
+    /**
+     * Resolved value of the enableComputedAttributes workspace setting. When false, the language
+     * service does not request computed attributes from the catalog (the backend refuses the
+     * listing when the setting is off). Leave undefined when the host does not know the setting.
+     */
+    enableComputedAttributes?: boolean;
+}
+
+/**
+ * @internal
+ */
+export declare interface IManageMetricApi {
+    save: () => Promise<void>;
+    saveForce: () => Promise<void>;
+    close: () => void;
+}
+
+/**
+ * @internal
+ */
+export declare interface IManageMetricProps {
+    locale?: string;
+    setting?: IMeasureSetting;
+    prefixes?: IPrefixes;
+    editingMetric?: IMeasureDef | false | null;
+    deletingMetric?: IMeasureDef | false | null;
+    onDelete?: (metric: IMeasureMetadataObject, info: IDeleteMetricInfo, err: Error | null) => void;
+    onSave?: (metric: IMeasureDef, info: ISaveMetricInfo, err: Error | null) => Promise<void> | void;
+    onDirtyChanged?: (dirty: boolean) => void;
+    onDeleteCancel?: () => void;
+    onEditCancel?: () => void;
+    onMetricsChange?: (metric: IMeasureDef) => void;
+    insightOpenType?: "external" | "internal";
+    onInsightClick?: (object: IInsight) => void;
+    metricOpenType?: "external" | "internal";
+    onMetricClick?: (object: IMetadataObject) => void;
+    permissions?: IWorkspacePermissions;
+    ref?: Ref<IManageMetricApi | undefined>;
+    isWhiteLabeled?: boolean;
+    separators?: ISeparators;
+    onSettingChange?: (setting: Partial<IMeasureSetting>) => void;
+    useReferences?: boolean;
+    currencyFormatOverride?: string | null;
+    enableMetricFormatOverrides?: boolean;
+}
+
+/**
+ * @internal
+ */
+export declare interface IManageMetricsApi {
+    saveAndCloseAll: () => Promise<CloseAllTabsResult>;
+}
+
+/**
+ * @internal
+ */
+export declare interface IManageMetricsProps {
+    ref?: Ref<IManageMetricsApi | undefined>;
+    locale?: string;
+    prefixes?: IPrefixes;
+    permissions?: IWorkspacePermissions;
+    isWhiteLabeled?: boolean;
+    separators?: ISeparators;
+    maximized?: boolean;
+    setMinimized: (minimized: boolean) => void;
+    setMaximized: (maximized: boolean) => void;
+    useReferences?: boolean;
+    currencyFormatOverride?: string | null;
+    enableMetricFormatOverrides?: boolean;
+}
+
+/**
+ * @internal
+ */
+export declare interface IMaqlEditorApi {
+    autoformat: () => void;
+    getValue: () => string;
+    getValid: () => boolean;
+}
+
+/**
+ * @internal
+ */
+export declare interface IMaqlEditorIcon {
+    base64: string;
+    width?: number;
+    height?: number;
+}
+
+/**
+ * @internal
+ */
+export declare interface IMaqlEditorIcons {
+    fact?: IMaqlEditorIcon;
+    metric?: IMaqlEditorIcon;
+    dataset?: IMaqlEditorIcon;
+    label?: IMaqlEditorIcon;
+    attribute?: IMaqlEditorIcon;
+    keyword?: IMaqlEditorIcon;
+    function?: IMaqlEditorIcon;
+    detail?: IMaqlEditorIcon;
+    next?: IMaqlEditorIcon;
+    prev?: IMaqlEditorIcon;
+    close?: IMaqlEditorIcon;
+}
+
+/**
+ * @internal
+ */
+export declare interface IMaqlEditorProps {
+    cssTheme?: MaqlEditorDefaultTheme;
+    autofocus?: boolean;
+    autohint?: boolean;
+    decorators?: boolean;
+    defaultValue?: string;
+    readonly?: boolean;
+    inline?: boolean;
+    icons?: IMaqlEditorIcons;
+    onFocus?: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    onBlur?: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    onEditorMount?: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    onEditorUpdate?: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    onChange?: (editor: IStandaloneCodeEditor, monaco: Monaco, value: string) => void;
+    onValid?: (editor: IStandaloneCodeEditor, monaco: Monaco, valid: boolean) => void;
+    onMetricOpen?: (editor: IStandaloneCodeEditor, object: IMetadataObject) => void;
+    ref?: Ref<IMaqlEditorApi | null>;
+}
+
+/**
+ * @internal
+ */
+export declare interface IMaqlFragmentCommonProps {
+    links?: NonNullable<IExpressionToken["category"]>[];
+    onClick?: (token: IExpressionToken) => void;
+    getLink?: (token: IExpressionToken) => string;
+}
+
+/**
+ * @internal
+ */
+export declare type IMeasureDef = (IMeasureMetadataObjectDefinition | IMeasureMetadataObject) & {
+    prefix?: string;
+};
+
+/**
+ * @internal
+ */
+export declare type IMeasureSetting = {
+    sqlOpen: boolean;
+    computedFor: string | null;
+    attributes: ICatalogAttribute[];
+    display: {
+        limit: 10 | 100 | 1000 | 10000;
+        ranking: "top" | "bottom";
+    };
+};
+
+/**
+ * @internal
+ */
+export declare type IMetricInfo = IMeasureSetting & {
+    initial: IMeasureDef;
+    current: IMeasureDef;
+    identifier: string;
+    kind: MetricInfoKind;
+    saveMode?: SaveNameMode;
+    focusedField?: FormField;
+    generateNewId?: boolean;
+    /** Access drafted but not saved. Held by the tab because a switch unmounts the editor. */
+    draftAccess?: IObjectShareDraft;
+};
+
+/**
+ * @internal
+ */
+export declare type IMetricInfoDraft = Omit<IMetricInfo, "identifier">;
+
+/**
+ * @internal
+ */
+export declare interface IMetricListSort {
+    type: "title" | "id";
+    direction: "asc" | "desc";
+}
+
+/**
+ * @internal
+ */
+export declare interface IMetricServiceProps {
+    settings?: Partial<IFeaturesAndSettingsContext>;
+}
+
+/**
+ * @internal
+ */
+export declare interface IMetricTooltipContentProps {
+    metric: IMeasureMetadataObject;
+    previewOptions?: IMaqlFragmentCommonProps;
+    showEditButton?: boolean;
+    onEditClick?: () => void;
+    useReferences?: boolean;
+    separators?: ISeparators;
+}
+
+/**
+ * @internal
+ */
+export declare interface IMetricTooltipProps {
+    active?: boolean;
+    className?: string;
+    iconClassName?: string;
+    metric: IMeasureMetadataObject;
+    previewOptions?: IMetricTooltipContentProps["previewOptions"];
+    onTooltipOpen?: (open: boolean) => void;
+    useReferences?: boolean;
+    separators?: ISeparators;
+}
+
+/**
+ * @internal
+ */
+export declare interface IMinimizedMetricsProps {
+    ref?: Ref<HTMLElement | undefined>;
+    permissions?: IWorkspacePermissions;
+    locale?: string;
+    setMinimized: (state: boolean) => void;
+}
+
+/**
+ * @internal
+ */
+export declare interface IMultipleMetricsProps {
+    active: number;
+    metrics: IMetricInfo[];
+    ref?: Ref<IManageMetricsApi | undefined>;
+    permissions?: IWorkspacePermissions;
+    activeInsight?: IInsight;
+    insightOpenType?: "external" | "internal";
+    onInsightClick?: (object: IInsight) => void;
+    metricOpenType?: "external" | "internal";
+    onMetricClick?: (object: IMetadataObject) => void;
+    onDelete?: (metric: IMeasureMetadataObject, info: IDeleteMetricInfo, err: Error | null) => void;
+    onSave?: (metric: IMeasureMetadataObject, info: ISaveMetricInfo, err: Error | null) => Promise<void> | void;
+    onDirtyChanged?: (dirty: boolean) => void;
+    onMetricsChange?: (metric: IMeasureDef) => void;
+    onCancel: (metricInfo: IMetricInfo) => void;
+    onClose: (metricInfos: IMetricInfo[]) => void;
+    activateTab: (metricInfo: IMetricInfo) => void;
+    openTab: (metricInfo: IMetricInfoDraft) => void;
+    createTab: () => void;
+    children?: ReactNode;
+}
+
+/**
+ * @internal
+ */
+export declare function initOpenContractExpiredDialog(callback: (tier: string) => void): void;
+
+/**
+ * @internal
+ */
+export declare function initOpenNotAuthenticatedOverlay(callback: (err: NotAuthenticatedError) => void): void;
+
+/**
+ * @internal
+ */
+export declare function IntlWrapper({ locale, children }: PropsWithChildren<IIntlWrapperProps>): JSX.Element | null;
+
+/**
+ * @internal
+ */
+export declare interface IOrganizationPermissions {
+    hasOrgManagePermission: boolean;
+    hasBaseUiAccessPermission?: boolean;
+}
+
+/**
+ * @internal
+ */
+export declare interface IPrefixes {
+    current: string | undefined;
+    parents: string[];
+}
+
+/**
+ * @internal
+ */
+export declare interface ISaveMetricInfo {
+    references: IMeasureReferencing;
+    saveMode: SaveNameMode | undefined;
+    formField: FormField | undefined;
+    regenerateId: boolean | undefined;
+    previousMetric: IMeasureDef;
+}
+
+/**
+ * @internal
+ */
+export declare interface ISqlEditorApi {
+    copy: () => boolean;
+}
+
+/**
+ * @internal
+ */
+export declare interface ISqlEditorProps {
+    cssTheme?: MaqlEditorDefaultTheme;
+    autofocus?: boolean;
+    defaultValue?: string;
+    readonly?: boolean;
+    inline?: boolean;
+    onFocus?: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    onBlur?: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    onEditorMount?: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    onChange?: (editor: IStandaloneCodeEditor, monaco: Monaco, value: string) => void;
+    onValid?: (editor: IStandaloneCodeEditor, monaco: Monaco, valid: boolean) => void;
+    ref?: Ref<ISqlEditorApi | null>;
+}
+
+/**
+ * @internal
+ */
+export declare type IStandaloneCodeEditor = monaco.editor.IStandaloneCodeEditor;
+
+/**
+ * @internal
+ */
+export declare type IStandaloneEditorConstructionOptions = monaco.editor.IStandaloneEditorConstructionOptions;
+
+/**
+ * @internal
+ */
+export declare interface IUseMetricList {
+    items: IMeasureMetadataObject[];
+    search: string;
+    setSearch: (value: string) => void;
+    sort: IMetricListSort;
+    setSort: (sort: IMetricListSort) => void;
+    totalCount: number;
+}
+
+/**
+ * @internal
+ */
+export declare interface IUseMetricListDataOptions {
+    /**
+     * Ask the backend for each metric's object-level permissions.
+     */
+    loadPermissions?: boolean;
+}
+
+/**
+ * @internal
+ */
+export declare interface IUseMetricsOptions {
+    /**
+     * Ask the backend for each metric's object-level permissions. Defaults to the
+     * enableMetricPermissions feature flag when the caller sits inside the metric dialog.
+     */
+    loadPermissions?: boolean;
+}
+
+/**
+ * @internal
+ */
+export declare function LanguageServiceProvider({ children, enableComputedAttributes, }: PropsWithChildren<ILanguageServiceProviderProps>): JSX.Element;
+
+/**
+ * @internal
+ */
+export declare const licenseLink = "https://support.gooddata.com/hc/en-us/articles/1500005499441";
+
+/**
+ * @internal
+ */
+export declare const makeStyles: <Params = void, RuleNameSubsetReferencableInNestedSelectors extends string = never>(params?: {
+    name?: string | Record<string, unknown> | undefined;
+    uniqId?: string | undefined;
+} | undefined) => <RuleName extends string>(cssObjectByRuleNameOrGetCssObjectByRuleName: Record<RuleName, CSSObject> | ((theme: {
+    fonts: {
+        main: string;
+        placeholder: string;
+    };
+    globals: {
+        font: string;
+        colors: {
+            title: string;
+            subtitle: string;
+            description: string;
+            defaultWhite: string;
+            defaultText: string;
+            defaultGreyedText: string;
+            defaultStateBlank: string;
+            defaultBorder: string;
+            defaultBorderDarker: string;
+            dropdownButton: string;
+            dropdownButtonHover: string;
+            dropdownButtonMoreHover: string;
+            dropdownHeaderBackground: string;
+            editorBackground: string;
+            editableRowHover: string;
+            line: string;
+            placeholder: string;
+            white: string;
+            border: string;
+            link: string;
+            maqlKeyword: string;
+            metric: string;
+            fact: string;
+            attribute: string;
+            dataset: string;
+            parameter: string;
+            comment: string;
+            value: string;
+            active: string;
+            negative: string;
+            negativeBackground: string;
+            warning: string;
+        };
+        spinner: CSSObject;
+        normalItemStyle: {
+            fontWeight: number;
+            fontSize: number;
+            padding: string;
+            background: string;
+            borderRadius: number;
+            outline: number;
+            height: number;
+            lineHeight: string;
+            display: string;
+        };
+        smallItemStyle: {
+            fontSize: number;
+            fontWeight: number;
+            lineHeight: string;
+            height: string;
+        };
+        metricList: {
+            itemSize: number;
+            padding: number;
+        };
+        community: {
+            color: string;
+            background: string;
+        };
+    };
+    tabs: {
+        colors: {
+            border: string;
+            active: string;
+            divider: string;
+            dirty: string;
+            background: string;
+            negative: string;
+            separator: string;
+            normal: string;
+            create: string;
+            hover: string;
+            placeholder: string;
+            arrow: string;
+            disabled: string;
+        };
+        sizes: {
+            arrowButtonWidth: number;
+            controlsDividerWidth: number;
+            controlsDividerMargin: number;
+            buttonMargin: number;
+            flag: number;
+            space: number;
+            tabsPadding: number;
+            tabLastDivider: number;
+            tabBorderRadius: number;
+        };
+        lineHeight: {
+            close: number;
+            title: number;
+        };
+        fontSize: {
+            title: number;
+        };
+    };
+    preview: {
+        colors: {
+            text: string;
+            default: string;
+            create: string;
+            hover: string;
+        };
+    };
+    minimize: {
+        boxShadow: string;
+        colors: {
+            editing: string;
+            count: string;
+            border: string;
+            divider: string;
+            background: string;
+        };
+        sizes: {
+            borderRadius: number;
+            gap: number;
+            countsMinWidth: number;
+            button: number;
+        };
+        lineHeight: {
+            text: number;
+        };
+        fontSize: {
+            text: number;
+        };
+    };
+}, params: Params, classes: Record<RuleNameSubsetReferencableInNestedSelectors, string>) => Record<RuleName | RuleNameSubsetReferencableInNestedSelectors, CSSObject>)) => (params: Params, muiStyleOverridesParams?: {
+    props: Record<string, unknown>;
+    ownerState?: Record<string, unknown>;
+} | undefined) => {
+    classes: Record<RuleName, string>;
+    theme: {
+        fonts: {
+            main: string;
+            placeholder: string;
+        };
+        globals: {
+            font: string;
+            colors: {
+                title: string;
+                subtitle: string;
+                description: string;
+                defaultWhite: string;
+                defaultText: string;
+                defaultGreyedText: string;
+                defaultStateBlank: string;
+                defaultBorder: string;
+                defaultBorderDarker: string;
+                dropdownButton: string;
+                dropdownButtonHover: string;
+                dropdownButtonMoreHover: string;
+                dropdownHeaderBackground: string;
+                editorBackground: string;
+                editableRowHover: string;
+                line: string;
+                placeholder: string;
+                white: string;
+                border: string;
+                link: string;
+                maqlKeyword: string;
+                metric: string;
+                fact: string;
+                attribute: string;
+                dataset: string;
+                parameter: string;
+                comment: string;
+                value: string;
+                active: string;
+                negative: string;
+                negativeBackground: string;
+                warning: string;
+            };
+            spinner: CSSObject;
+            normalItemStyle: {
+                fontWeight: number;
+                fontSize: number;
+                padding: string;
+                background: string;
+                borderRadius: number;
+                outline: number;
+                height: number;
+                lineHeight: string;
+                display: string;
+            };
+            smallItemStyle: {
+                fontSize: number;
+                fontWeight: number;
+                lineHeight: string;
+                height: string;
+            };
+            metricList: {
+                itemSize: number;
+                padding: number;
+            };
+            community: {
+                color: string;
+                background: string;
+            };
+        };
+        tabs: {
+            colors: {
+                border: string;
+                active: string;
+                divider: string;
+                dirty: string;
+                background: string;
+                negative: string;
+                separator: string;
+                normal: string;
+                create: string;
+                hover: string;
+                placeholder: string;
+                arrow: string;
+                disabled: string;
+            };
+            sizes: {
+                arrowButtonWidth: number;
+                controlsDividerWidth: number;
+                controlsDividerMargin: number;
+                buttonMargin: number;
+                flag: number;
+                space: number;
+                tabsPadding: number;
+                tabLastDivider: number;
+                tabBorderRadius: number;
+            };
+            lineHeight: {
+                close: number;
+                title: number;
+            };
+            fontSize: {
+                title: number;
+            };
+        };
+        preview: {
+            colors: {
+                text: string;
+                default: string;
+                create: string;
+                hover: string;
+            };
+        };
+        minimize: {
+            boxShadow: string;
+            colors: {
+                editing: string;
+                count: string;
+                border: string;
+                divider: string;
+                background: string;
+            };
+            sizes: {
+                borderRadius: number;
+                gap: number;
+                countsMinWidth: number;
+                button: number;
+            };
+            lineHeight: {
+                text: number;
+            };
+            fontSize: {
+                text: number;
+            };
+        };
+    };
+    css: Css;
+    cx: Cx;
+};
+
+/**
+ * @internal
+ */
+export declare const ManageMetric: ForwardRefExoticComponent<Omit<IManageMetricProps, "ref"> & RefAttributes<IManageMetricApi | undefined>>;
+
+/**
+ * @internal
+ */
+export declare const ManageMetrics: ForwardRefExoticComponent<Omit<IManageMetricsProps, "ref"> & RefAttributes<IManageMetricsApi | undefined>>;
+
+/**
+ * @internal
+ */
+export declare const MaqlEditor: ForwardRefExoticComponent<Omit<IMaqlEditorProps, "ref"> & RefAttributes<IMaqlEditorApi>>;
+
+/**
+ * @internal
+ */
+export declare type MaqlEditorDefaultTheme = ReturnType<typeof createDefaultTheme>;
+
+/**
+ * @internal
+ */
+export declare const maqlStartingLink = "https://university.gooddata.com/getting-started-with-maql-in-gooddatacn";
+
+/**
+ * @internal
+ */
+export declare const maqlWritingLink = "https://university.gooddata.com/nested-aggregations";
+
+/**
+ * @internal
+ */
+export declare enum MetricInfoKind {
+    Create = "CREATE",
+    Edit = "EDIT"
+}
+
+/**
+ * @internal
+ */
+export declare function MetricService({ children, settings }: PropsWithChildren<IMetricServiceProps>): JSX.Element;
+
+/**
+ * @internal
+ */
+export declare function MetricsReloadContextProvider({ children }: PropsWithChildren): JSX.Element;
+
+/**
+ * @internal
+ */
+export declare function MetricTooltip({ metric, className, iconClassName, active, onTooltipOpen, previewOptions, useReferences, separators, }: IMetricTooltipProps): JSX.Element;
+
+/**
+ * @internal
+ */
+export declare const MinimizeMetrics: ForwardRefExoticComponent<Omit<IMinimizedMetricsProps, "ref"> & RefAttributes<HTMLElement | undefined>>;
+
+/**
+ * @internal
+ */
+export declare type Monaco = typeof monaco;
+
+/**
+ * @internal
+ */
+export declare function MultipleMetricsState({ children, active, metrics, permissions, createTab, activateTab, openTab, onSave, onDelete, onMetricsChange, metricOpenType, onMetricClick, activeInsight, insightOpenType, onInsightClick, onDirtyChanged, onClose, onCancel, }: IMultipleMetricsProps): JSX.Element;
+
+/**
+ * @internal
+ */
+export declare class NotAuthenticatedError extends NotAuthenticated {
+    readonly redirectLink: string;
+    readonly cause?: Error | undefined;
+    constructor(message: string, redirectLink: string, cause?: Error | undefined);
+}
+
+/**
+ * @internal
+ */
+export declare function notAuthenticatedHandler(ctx: IAuthenticationContext, err: NotAuthenticated): void;
+
+/**
+ * @internal
+ */
+export declare function prepareMetricForSaveAs(initialValueMetric: IMeasureDef, metricToSaveAs: IMeasureDef, metrics?: IMeasureMetadataObject[], prefix?: string, parents?: string[]): {
+    metric: IMeasureMetadataObjectDefinition;
+    updatedFields: {
+        id: boolean;
+        title: boolean;
+    };
+};
+
+/**
+ * @internal
+ */
+export declare const pricingLink = "https://www.gooddata.com/pricing/";
+
+/**
+ * @internal
+ */
+export declare const privacyPolicyLink = "https://www.gooddata.com/privacy-policy";
+
+/**
+ * Resolves translation messages for the given locale.
+ * Memoized to cache promises and prevent duplicate async imports.
+ *
+ * @internal
+ */
+export declare const resolveMessages: (locale: string) => Promise<ITranslations>;
+
+/**
+ * @internal
+ */
+export declare enum SaveNameMode {
+    save = "save",
+    saveAsNew = "save_as_new"
+}
+
+/**
+ * @internal
+ */
+export declare function shimMaqlEditor(): void;
+
+/**
+ * @internal
+ */
+export declare const SqlEditor: ForwardRefExoticComponent<Omit<ISqlEditorProps, "ref"> & RefAttributes<ISqlEditorApi>>;
+
+/**
+ * @internal
+ */
+export declare const supportLink = "https://support.gooddata.com/hc/en-us/articles/1500005149321";
+
+/**
+ * @internal
+ */
+export declare const TypeMapping: {
+    readonly measure: "metric";
+    readonly label: "attribute";
+};
+
+/**
+ * @internal
+ */
+export declare function useEvents<EventsInterface extends IEventsInterface>(value: EventsInterface): IEventsCallback<EventsInterface>;
+
+/**
+ * @internal
+ */
+export declare const useMetricListData: ({ loadPermissions, }?: IUseMetricListDataOptions) => IUseMetricList;
+
+/**
+ * Hook allowing to get metrics
+ *
+ * @internal
+ */
+export declare function useMetrics({ loadPermissions }?: IUseMetricsOptions): UseCancelablePromiseState<IMeasureMetadataObject[], unknown>;
+
+/**
+ * @internal
+ */
+export declare function useTheme(): {
+    fonts: {
+        main: string;
+        placeholder: string;
+    };
+    globals: {
+        font: string;
+        colors: {
+            title: string;
+            subtitle: string;
+            description: string;
+            defaultWhite: string;
+            defaultText: string;
+            defaultGreyedText: string;
+            defaultStateBlank: string;
+            defaultBorder: string;
+            defaultBorderDarker: string;
+            dropdownButton: string;
+            dropdownButtonHover: string;
+            dropdownButtonMoreHover: string;
+            dropdownHeaderBackground: string;
+            editorBackground: string;
+            editableRowHover: string;
+            line: string;
+            placeholder: string;
+            white: string;
+            border: string;
+            link: string;
+            maqlKeyword: string;
+            metric: string;
+            fact: string;
+            attribute: string;
+            dataset: string;
+            parameter: string;
+            comment: string;
+            value: string;
+            active: string;
+            negative: string;
+            negativeBackground: string;
+            warning: string;
+        };
+        spinner: CSSObject;
+        normalItemStyle: {
+            fontWeight: number;
+            fontSize: number;
+            padding: string;
+            background: string;
+            borderRadius: number;
+            outline: number;
+            height: number;
+            lineHeight: string;
+            display: string;
+        };
+        smallItemStyle: {
+            fontSize: number;
+            fontWeight: number;
+            lineHeight: string;
+            height: string;
+        };
+        metricList: {
+            itemSize: number;
+            padding: number;
+        };
+        community: {
+            color: string;
+            background: string;
+        };
+    };
+    tabs: {
+        colors: {
+            border: string;
+            active: string;
+            divider: string;
+            dirty: string;
+            background: string;
+            negative: string;
+            separator: string;
+            normal: string;
+            create: string;
+            hover: string;
+            placeholder: string;
+            arrow: string;
+            disabled: string;
+        };
+        sizes: {
+            arrowButtonWidth: number;
+            controlsDividerWidth: number;
+            controlsDividerMargin: number;
+            buttonMargin: number;
+            flag: number;
+            space: number;
+            tabsPadding: number;
+            tabLastDivider: number;
+            tabBorderRadius: number;
+        };
+        lineHeight: {
+            close: number;
+            title: number;
+        };
+        fontSize: {
+            title: number;
+        };
+    };
+    preview: {
+        colors: {
+            text: string;
+            default: string;
+            create: string;
+            hover: string;
+        };
+    };
+    minimize: {
+        boxShadow: string;
+        colors: {
+            editing: string;
+            count: string;
+            border: string;
+            divider: string;
+            background: string;
+        };
+        sizes: {
+            borderRadius: number;
+            gap: number;
+            countsMinWidth: number;
+            button: number;
+        };
+        lineHeight: {
+            text: number;
+        };
+        fontSize: {
+            text: number;
+        };
+    };
+};
+
+/**
+ * Validates if a locale has translations available in the messages map.
+ * Falls back to DEFAULT_LANGUAGE if the locale is not found.
+ *
+ * @param messages - Map of locale codes to translation records
+ * @param locale - The locale to validate
+ * @returns The validated locale or DEFAULT_LANGUAGE if not found
+ * @internal
+ */
+export declare function validateLocaleForMessagesMap(messages: Record<string, Record<string, string>>, locale: string): string;
+
+export { }