Functions

addCalculatedMeasure(
  mdx,
  {
    calculatedMeasureName,
    expression,
    measureIndex,
    properties,
  },
  cube,
);

addLevel(mdx, {
  cube,
  dimensionName,
  hierarchyName,
  levelName,
  axisName,
  indexOnAxis,
  shouldCreateNonEmptyAxis,
  doesIncludeCalculatedMembers,
});

addMeasure(mdx, {
  cube,
  measureName,
  measureIndex,
  shouldCreateNonEmptyAxis,
  axisName,
});

addPage(dashboardState, options);

addWidget({
  dashboardState,
  initialWidgetState,
  layoutPath,
  pageKey,
  side,
});

areHierarchiesEqual(hierarchyCoordinatesA, hierarchyCoordinatesB);

areLevelsEqual(levelCoordinatesA, levelCoordinatesB);

areTuplesEqual(tupleCoordinatesA, tupleCoordinatesB);

collapse(mdx, {
  cube,
  tupleCoordinates,
});

createAtotiClient(constructorArgs);

createContentClient(constructorArguments);

createFilter(mdx, {
  cube,
  nonVisualTotals,
});

createLevelCompoundIdentifier({
  dimensionName,
  hierarchyName,
  levelName,
});

createMdxForFilter(filter, cube, options);

deserializeDashboardState(dashboardState);

deserializeFilter(filter);

deserializeWidgetState(widgetState);

expand(mdx, {
  cube,
  tupleCoordinates,
  toLevel,
  doesIncludeCalculatedMembers,
});

fetchTranslations(locale);

findContentRecords(tree, ids, pathOrOptions);

findMappingFieldForHierarchy(mapping, {
  dimensionName,
  hierarchyName,
});

getActiveToolKey(state);

getAntdTheme(atotiTheme);

getCalculatedMeasures(mdx);

getContentNodes(structure, options);

getContentRecordAtPath({
  tree,
  path,
});

getCube(dataModel, cubeName);

getCubeName(mdx);

getDashboardState(state);

getDimension(dimensionName, cube);

getDrillthroughColumns(mdx);

getExpandedFolderPathsInHomePage(state);

getExpandedTuples(mdx, cube);

getFilters(mdx, {
  cube,
});

getHasUnsavedChanges(state);

getHierarchy(hierarchyCoordinates, cube);

getIndexedDataModel(dataModel);

getIsDeferred(state);

getIsOpenDashboardPopupVisible(state);

getIsPresenting(state);

getIsSettingsPopupVisible(state);

getIsWidgetsPanelVisible(state);

getLayoutPath(layout, leafKey);

getLevel(levelCoordinates, cube);

getLevels(mdx, {
  cube,
});

getMeasure(measureName, cube);

getMeasureNames(mdx);

getMetaData(node, id);

getMetaDataRecord(node, id);

getNode(tree, path);

getOwnersAndReaders(permissions, currentUserName);

getOwnersAndReadersForNewFile({
  currentUserName,
  canShare,
  parentFolderOwners,
  parentFolderReaders,
  isParentFolderRoot,
  doesInheritParentFolderPermissions,
});

getPage(dashboardState, pageKey);

getParentPaths(paths);

getPluginsTranslations(plugins, locale);

getPrefixedLocalStorageKey(key);

getResourcesPanelKey(state);

getSelectedLeafKey(state, activePageKey);

import { useSelector } from "react-redux";
import { getWidget } from "@activeviam/atoti-ui-sdk"

const dashboardState = useSelector(getDashboardState);
const activePageKey = useActivePageKeyFromUrl();
const selectedLeafKey = useSelector((state) =>
 getSelectedLeafKey(state, activePageKey),
);
const selectedWidgetState = getWidget(dashboardState, activePageKey, selectedLeafKey);

getSelectionWithinWidgets(state);

getSort(mdx, {
  cube,
});

getStatusNotifications(state);

getTargetCube({
  dataModels,
  serverKey,
  cubeName,
  lastUsedCube,
});

getToolsTranslations(tools, locale);

getUserFromJwt(jwt);

getUserRoles(token);

getWidget(dashboardState, pageKey, leafKey);

getWidgetQuery(widgetState, {
  dashboardState,
  pageKey,
  queryRanges,
  userFilters,
  userQueryContext,
  dataModels,
  lastUsedCube,
  filtersFromFoldersBySection,
  atotiServerVersion,
  nonEmptyEvaluationMeasureSetting,
});

isActionInDashboard(props);

isBodyCell(props);

isHeaderCell(props);

isLevelNode(node, hierarchyCoordinates);

isStaticHeaderCell(props);

isTotal(hierarchy, member);

isWidgetInDashboard(props);

isWidgetWithQueryState(widgetState);

moveAllMeasures(mdx, {
  axisName,
  cube,
  indexOnAxis,
  shouldCreateNonEmptyAxis,
});

moveLevel(mdx, {
  cube,
  dimensionName,
  hierarchyName,
  levelName,
  axisName,
  indexOnAxis,
  shouldCreateNonEmptyAxis,
});

moveMeasure(mdx, {
  measureName,
  measureIndex,
});

moveWidget({
  dashboardState,
  originLayoutPath,
  pageKey,
  originPageKey: _originPageKey,
  targetPageKey: _targetPageKey,
  side,
  targetLayoutPath,
  emptyPageState,
});

opacitize(color, opacity);

parse(mdxString);

ping(serverUrl, serviceVersion, options);

quote(path);

quote("a", "b"); // === '[a].[b]'

removeAllMeasures(mdx, {
  cube,
  shouldRemoveCalculatedMeasureExpression,
});

removeLevel(mdx, {
  cube,
  dimensionName,
  hierarchyName,
  levelName,
});

removeMeasure(mdx, {
  cube,
  measureName,
  shouldRemoveCalculatedMeasureExpression,
});

removePage(dashboardState, pageKey);

removeSort(mdx);

removeWidget({
  dashboardState,
  layoutPath,
  pageKey,
  leafKey,
  emptyPageState,
});

search(list, searchValue, options);

serializeDashboardState(dashboardState);

serializeFilter(filter);

serializeWidgetState(widgetState, options);

setCubeName(mdx, {
  cubeName,
});

setDrillthroughColumns(mdx, {
  drillthroughColumnUniqueNames,
});

setFilters(mdx, {
  filters,
  cube,
});

setSort(mdx, {
  cube,
  levelCoordinates,
  orderMode,
  tupleCoordinates,
  serverVersion,
});

sortTree(tree, comparator);

stringify(mdx, options, indenter);

traverseMdx(mdx, callback, path);

unquote(str);

unquote("[a].[b]"); // === ['a', 'b']

updatePage(dashboardState, pageKey, updater);

updateWidget(
  dashboardState,
  {
    pageKey,
    leafKey,
  },
  updater,
);

withDefaultCellStyle(CellComponent);

withLazyLoadedQueryResult(WrappedComponent);

withQueryResult(WrappedComponent);

withWidgetLoadingBar(WrappedComponent);