@sisense/sdk-data 1.33.0 → 2.0.0

package/dist/dimensional-model/filters/utils/condition-filter-util.js

@@ -1,9 +1,8 @@
-import { ConditionFilterType } from './types.js';
-import { withComposeCode } from './filter-code-util.js';
-import * as filterFactory from '../factory.js';
-import { createMeasureFromRankingFilterJaql } from './attribute-measure-util.js';
 import { TranslatableError } from '../../../translation/translatable-error.js';
+import * as filterFactory from '../factory.js';
 import { simplifyFilterConfig } from '../filter-config-utils.js';
+import { createMeasureFromRankingFilterJaql } from './attribute-measure-util.js';
+import { ConditionFilterType } from './types.js';
 const isTopCondition = (filter) => filter.top !== undefined;
 const isBottomCondition = (filter) => filter.bottom !== undefined;
 const isExcludeCondition = (filter) => { var _a; return !!((_a = filter.exclude) === null || _a === void 0 ? void 0 : _a.members); };
@@ -88,48 +87,48 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
     switch (conditionType) {
         case ConditionFilterType.BOTTOM:
             if (conditionFilterJaql.by) {
-                return withComposeCode(filterFactory.bottomRanking, 'bottomRanking')(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[ConditionFilterType.BOTTOM], { guid });
+                return filterFactory.bottomRanking(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[ConditionFilterType.BOTTOM], { guid });
             }
             break;
         case ConditionFilterType.EQUALS:
-            return withComposeCode(filterFactory.equals, 'equals')(attribute, conditionFilterJaql[ConditionFilterType.EQUALS], { guid });
+            return filterFactory.equals(attribute, conditionFilterJaql[ConditionFilterType.EQUALS], { guid });
         case ConditionFilterType.DOESNT_EQUAL:
-            return withComposeCode(filterFactory.doesntEqual, 'doesntEqual')(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_EQUAL], { guid });
+            return filterFactory.doesntEqual(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_EQUAL], { guid });
         case ConditionFilterType.GREATER_THAN:
-            return withComposeCode(filterFactory.greaterThan, 'greaterThan')(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN], { guid });
+            return filterFactory.greaterThan(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN], { guid });
         case ConditionFilterType.GREATER_THAN_OR_EQUAL:
-            return withComposeCode(filterFactory.greaterThanOrEqual, 'greaterThanOrEqual')(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL], { guid });
+            return filterFactory.greaterThanOrEqual(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL], { guid });
         case ConditionFilterType.TOP:
             if (conditionFilterJaql.by) {
-                return withComposeCode(filterFactory.topRanking, 'topRanking')(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[ConditionFilterType.TOP], { guid });
+                return filterFactory.topRanking(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[ConditionFilterType.TOP], { guid });
             }
             break;
         case ConditionFilterType.STARTS_WITH:
-            return withComposeCode(filterFactory.startsWith, 'startsWith')(attribute, conditionFilterJaql[ConditionFilterType.STARTS_WITH], { guid });
+            return filterFactory.startsWith(attribute, conditionFilterJaql[ConditionFilterType.STARTS_WITH], { guid });
         case ConditionFilterType.DOESNT_START_WITH:
-            return withComposeCode(filterFactory.doesntStartWith, 'doesntStartWith')(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_START_WITH], { guid });
+            return filterFactory.doesntStartWith(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_START_WITH], { guid });
         case ConditionFilterType.ENDS_WITH:
-            return withComposeCode(filterFactory.endsWith, 'endsWith')(attribute, conditionFilterJaql[ConditionFilterType.ENDS_WITH], { guid });
+            return filterFactory.endsWith(attribute, conditionFilterJaql[ConditionFilterType.ENDS_WITH], { guid });
         case ConditionFilterType.DOESNT_END_WITH:
-            return withComposeCode(filterFactory.doesntEndWith, 'doesntEndWith')(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_END_WITH], { guid });
+            return filterFactory.doesntEndWith(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_END_WITH], { guid });
         case ConditionFilterType.CONTAINS:
-            return withComposeCode(filterFactory.contains, 'contains')(attribute, conditionFilterJaql[ConditionFilterType.CONTAINS], { guid });
+            return filterFactory.contains(attribute, conditionFilterJaql[ConditionFilterType.CONTAINS], { guid });
         case ConditionFilterType.DOESNT_CONTAIN:
-            return withComposeCode(filterFactory.doesntContain, 'doesntContain')(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_CONTAIN], { guid });
+            return filterFactory.doesntContain(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_CONTAIN], { guid });
         case ConditionFilterType.LESS_THAN:
-            return withComposeCode(filterFactory.lessThan, 'lessThan')(attribute, conditionFilterJaql[ConditionFilterType.LESS_THAN], { guid });
+            return filterFactory.lessThan(attribute, conditionFilterJaql[ConditionFilterType.LESS_THAN], { guid });
         case ConditionFilterType.LESS_THAN_OR_EQUAL:
-            return withComposeCode(filterFactory.lessThanOrEqual, 'lessThanOrEqual')(attribute, conditionFilterJaql[ConditionFilterType.LESS_THAN_OR_EQUAL], { guid });
+            return filterFactory.lessThanOrEqual(attribute, conditionFilterJaql[ConditionFilterType.LESS_THAN_OR_EQUAL], { guid });
         case ConditionFilterType.BETWEEN:
-            return withComposeCode(filterFactory.between, 'between')(attribute, conditionFilterJaql.from, conditionFilterJaql.to, { guid });
+            return filterFactory.between(attribute, conditionFilterJaql.from, conditionFilterJaql.to, { guid });
         case ConditionFilterType.IS_NOT_BETWEEN:
-            return withComposeCode(filterFactory.exclude, 'exclude')(withComposeCode(filterFactory.between, 'between')(attribute, (_a = conditionFilterJaql.exclude) === null || _a === void 0 ? void 0 : _a.from, (_b = conditionFilterJaql.exclude) === null || _b === void 0 ? void 0 : _b.to, { guid }), undefined, { guid });
+            return filterFactory.exclude(filterFactory.between(attribute, (_a = conditionFilterJaql.exclude) === null || _a === void 0 ? void 0 : _a.from, (_b = conditionFilterJaql.exclude) === null || _b === void 0 ? void 0 : _b.to, { guid }), undefined, { guid });
         case ConditionFilterType.MULTIPLE_CONDITION:
             if (conditionFilterJaql.and) {
-                return withComposeCode(filterFactory.intersection, 'intersection')(conditionFilterJaql.and.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c, guid)), { guid });
+                return filterFactory.intersection(conditionFilterJaql.and.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c, guid)), { guid });
             }
             if (conditionFilterJaql.or) {
-                return withComposeCode(filterFactory.union, 'union')(conditionFilterJaql.or.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c, guid)), { guid });
+                return filterFactory.union(conditionFilterJaql.or.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c, guid)), { guid });
             }
             break;
         case ConditionFilterType.IS_NOT: {
@@ -143,7 +142,7 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
                 enableMultiSelection: (_g = conditionFilterJaql.multiSelection) !== null && _g !== void 0 ? _g : true,
                 deactivatedMembers,
             });
-            return withComposeCode(filterFactory.members, 'members')(attribute, selectedMembers, config);
+            return filterFactory.members(attribute, selectedMembers, config);
         }
         case ConditionFilterType.AFTER:
         case ConditionFilterType.BEFORE:
@@ -165,20 +164,23 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
  * @returns measure filter
  */
 export const createMeasureFilterFromConditionFilterJaql = (measure, conditionFilterJaql, guid) => {
+    var _a, _b;
     const conditionType = getSelectedConditionOption(conditionFilterJaql);
     switch (conditionType) {
         case ConditionFilterType.EQUALS:
-            return withComposeCode(filterFactory.measureEquals, 'measureEquals')(measure, conditionFilterJaql[ConditionFilterType.EQUALS], { guid });
+            return filterFactory.measureEquals(measure, conditionFilterJaql[ConditionFilterType.EQUALS], { guid });
         case ConditionFilterType.GREATER_THAN:
-            return withComposeCode(filterFactory.measureGreaterThan, 'measureGreaterThan')(measure, conditionFilterJaql[ConditionFilterType.GREATER_THAN], { guid });
+            return filterFactory.measureGreaterThan(measure, conditionFilterJaql[ConditionFilterType.GREATER_THAN], { guid });
         case ConditionFilterType.GREATER_THAN_OR_EQUAL:
-            return withComposeCode(filterFactory.measureGreaterThanOrEqual, 'measureGreaterThanOrEqual')(measure, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL], { guid });
+            return filterFactory.measureGreaterThanOrEqual(measure, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL], { guid });
         case ConditionFilterType.LESS_THAN:
-            return withComposeCode(filterFactory.measureLessThan, 'measureLessThan')(measure, conditionFilterJaql[ConditionFilterType.LESS_THAN], { guid });
+            return filterFactory.measureLessThan(measure, conditionFilterJaql[ConditionFilterType.LESS_THAN], { guid });
         case ConditionFilterType.LESS_THAN_OR_EQUAL:
-            return withComposeCode(filterFactory.measureLessThanOrEqual, 'measureLessThanOrEqual')(measure, conditionFilterJaql[ConditionFilterType.LESS_THAN_OR_EQUAL], { guid });
+            return filterFactory.measureLessThanOrEqual(measure, conditionFilterJaql[ConditionFilterType.LESS_THAN_OR_EQUAL], { guid });
         case ConditionFilterType.BETWEEN:
-            return withComposeCode(filterFactory.measureBetween, 'measureBetween')(measure, conditionFilterJaql.from, conditionFilterJaql.to, { guid });
+            return filterFactory.measureBetween(measure, conditionFilterJaql.from, conditionFilterJaql.to, { guid });
+        case ConditionFilterType.IS_NOT_BETWEEN:
+            return filterFactory.exclude(filterFactory.measureBetween(measure, (_a = conditionFilterJaql.exclude) === null || _a === void 0 ? void 0 : _a.from, (_b = conditionFilterJaql.exclude) === null || _b === void 0 ? void 0 : _b.to, { guid }), undefined, { guid });
     }
     throw new TranslatableError('errors.filter.unsupportedConditionFilter', {
         filter: JSON.stringify(conditionFilterJaql),

package/dist/dimensional-model/filters/utils/filter-from-jaql-util.d.ts

@@ -1,6 +1,6 @@
-import { BaseFilterJaql, FilterJaqlInternal, PeriodFilterJaql, RangeFilterJaql, SpecificItemsFilterJaql } from './types.js';
 import { Attribute, Filter, LevelAttribute } from '../../interfaces.js';
 import { FilterJaql } from '../../types.js';
+import { BaseFilterJaql, FilterJaqlInternal, PeriodFilterJaql, RangeFilterJaql, SpecificItemsFilterJaql } from './types.js';
 /**
  * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
  *

package/dist/dimensional-model/filters/utils/filter-from-jaql-util.js

@@ -1,11 +1,10 @@
-import { FILTER_TYPES, } from './types.js';
+import { TranslatableError } from '../../../translation/translatable-error.js';
 import * as filterFactory from '../factory.js';
+import { getDefaultBaseFilterConfig, simplifyFilterConfig } from '../filter-config-utils.js';
+import { createAttributeFromFilterJaql, createMeasureFromFilterJaql, } from './attribute-measure-util.js';
 import { createAttributeFilterFromConditionFilterJaql, createMeasureFilterFromConditionFilterJaql, } from './condition-filter-util.js';
 import { extractFilterTypeFromFilterJaql } from './filter-types-util.js';
-import { withComposeCode } from './filter-code-util.js';
-import { createAttributeFromFilterJaql, createMeasureFromFilterJaql, } from './attribute-measure-util.js';
-import { TranslatableError } from '../../../translation/translatable-error.js';
-import { getDefaultBaseFilterConfig, simplifyFilterConfig } from '../filter-config-utils.js';
+import { FILTER_TYPES, } from './types.js';
 /**
  * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
  *
@@ -14,7 +13,7 @@ import { getDefaultBaseFilterConfig, simplifyFilterConfig } from '../filter-conf
  * @returns A generic Filter object.
  */
 export const createGenericFilter = (jaql, guid) => {
-    return {
+    const baseFilter = {
         config: Object.assign(Object.assign({}, getDefaultBaseFilterConfig()), { guid, originalFilterJaql: jaql }),
         jaql: (nested) => {
             if (nested) {
@@ -29,13 +28,8 @@ export const createGenericFilter = (jaql, guid) => {
             id: jaql.dim,
         },
         type: 'filter',
-        serializable() {
-            return Object.assign(Object.assign({}, this), { jaql: this.jaql() });
-        },
-        toJSON() {
-            return this.serializable();
-        },
     };
+    return Object.assign({}, baseFilter);
 };
 /**
  * Creates a filter that includes all members of the attribute.
@@ -51,7 +45,7 @@ export const createFilterIncludeAll = (attribute, guid) => {
         guid,
         excludeMembers: true,
     };
-    return withComposeCode(filterFactory.members, 'members')(attribute, [], config);
+    return filterFactory.members(attribute, [], config);
 };
 /**
  * Creates a filter from a specific items filter JAQL object.
@@ -70,7 +64,7 @@ export const createFilterFromSpecificItemsFilterJaql = (attribute, specificItems
         enableMultiSelection: multiSelection !== null && multiSelection !== void 0 ? multiSelection : true,
         deactivatedMembers,
     });
-    return withComposeCode(filterFactory.members, 'members')(attribute, activeMembers, config);
+    return filterFactory.members(attribute, activeMembers, config);
 };
 function getDeactivatedMembersFromFilterJaql(filterJaql) {
     var _a, _b, _c, _d;
@@ -91,7 +85,7 @@ function getActiveMembersFromFilterJaql(filterJaql, deactivatedMembers) {
  * @returns Filter object
  */
 export const createFilterFromDateRangeFilterJaql = (attribute, rangeFilterJaql, guid) => {
-    return withComposeCode(filterFactory.dateRange, 'dateRange')(attribute, rangeFilterJaql.from, rangeFilterJaql.to, { guid });
+    return filterFactory.dateRange(attribute, rangeFilterJaql.from, rangeFilterJaql.to, { guid });
 };
 /**
  * Creates a filter from a numeric range filter JAQL object.
@@ -102,7 +96,7 @@ export const createFilterFromDateRangeFilterJaql = (attribute, rangeFilterJaql,
  * @returns Filter object
  */
 export const createFilterFromNumericRangeJaql = (attribute, rangeFilterJaql, guid) => {
-    return withComposeCode(filterFactory.between, 'between')(attribute, rangeFilterJaql.from, rangeFilterJaql.to, { guid });
+    return filterFactory.between(attribute, rangeFilterJaql.from, rangeFilterJaql.to, { guid });
 };
 /**
  * Creates a filter from a period filter JAQL object.
@@ -114,10 +108,10 @@ export const createFilterFromNumericRangeJaql = (attribute, rangeFilterJaql, gui
  */
 export const createFilterFromPeriodFilterJaql = (attribute, periodFilterJaql, guid) => {
     if (periodFilterJaql.last) {
-        return withComposeCode(filterFactory.dateRelativeTo, 'dateRelativeTo')(attribute, periodFilterJaql.last.offset, periodFilterJaql.last.count, periodFilterJaql.last.anchor, { guid });
+        return filterFactory.dateRelativeTo(attribute, periodFilterJaql.last.offset, periodFilterJaql.last.count, periodFilterJaql.last.anchor, { guid });
     }
     else {
-        return withComposeCode(filterFactory.dateRelativeFrom, 'dateRelativeFrom')(attribute, periodFilterJaql.next.offset, periodFilterJaql.next.count, periodFilterJaql.next.anchor, { guid });
+        return filterFactory.dateRelativeFrom(attribute, periodFilterJaql.next.offset, periodFilterJaql.next.count, periodFilterJaql.next.anchor, { guid });
     }
 };
 /**
@@ -129,7 +123,7 @@ export const createFilterFromPeriodFilterJaql = (attribute, periodFilterJaql, gu
  * @returns Filter object
  */
 export const createFilterFromCustomFilterJaql = (attribute, customFilterJaql, guid) => {
-    return withComposeCode(filterFactory.customFilter, 'customFilter')(attribute, customFilterJaql, {
+    return filterFactory.customFilter(attribute, customFilterJaql, {
         guid,
     });
 };

package/dist/dimensional-model/filters/utils/filter-types-util.d.ts

@@ -1,4 +1,4 @@
-import { FilterModalType, AnyTypeFilterJaql, DatetimeLevel, FilterType, SpecificItemsFilterJaql, ConditionFilterJaql, FilterJaqlInternal, FilterJaqlWrapperWithType } from './types.js';
+import { AnyTypeFilterJaql, ConditionFilterJaql, DatetimeLevel, FilterJaqlInternal, FilterJaqlWrapperWithType, FilterModalType, FilterType, SpecificItemsFilterJaql } from './types.js';
 export declare const isSpecificItemsFilter: (filter: AnyTypeFilterJaql) => filter is SpecificItemsFilterJaql;
 export declare const isNumericRangeFilter: (filter: AnyTypeFilterJaql) => boolean;
 export declare const isConditionFilter: (filter: AnyTypeFilterJaql) => filter is ConditionFilterJaql;

package/dist/dimensional-model/filters/utils/filter-types-util.js

@@ -1,6 +1,6 @@
 import { getSelectedConditionOption } from './condition-filter-util.js';
-import { FilterModalType, DatetimeLevel, FILTER_TYPES, nonSupportedMinutesBuckets, ConditionFilterType, DEFAULT_FILTER_JAQL_WRAPPER, } from './types.js';
 import { getCorrectTimeLevel } from './date-time-filter-util.js';
+import { ConditionFilterType, DatetimeLevel, DEFAULT_FILTER_JAQL_WRAPPER, FILTER_TYPES, FilterModalType, nonSupportedMinutesBuckets, } from './types.js';
 const isIncludeAllFilter = (filter) => filter === null || filter === void 0 ? void 0 : filter.all;
 const getInnerPeriodFilter = (filter) => (filter.last ? filter.last : filter.next);
 const isPeriodFilter = (filter) => { var _a; return ((_a = getInnerPeriodFilter(filter)) === null || _a === void 0 ? void 0 : _a.offset) < 2; };

package/dist/dimensional-model/filters/utils/types.d.ts

@@ -19,6 +19,16 @@ export declare type JaqlDataSource = {
     lastBuildTime?: string;
     revisionId?: string;
 };
+/**
+ * Data source as specified in the jaql
+ * but with required filelds
+ *
+ * @internal
+ */
+export declare type JaqlDataSourceForDto = JaqlDataSource & {
+    id: string;
+    address?: string;
+};
 export declare enum GeneralFilterType {
     INCLUDE_ALL = "INCLUDE_ALL",
     ADVANCED = "ADVANCED",

package/dist/dimensional-model/interfaces.d.ts

@@ -1,5 +1,5 @@
 import { DataSource } from '../interfaces.js';
-import { FilterJaql, JaqlDataSource, Sort } from './types.js';
+import { DateLevel, FilterJaql, JaqlDataSource, JSONObject, Sort } from './types.js';
 /**
  * @internal
  */
@@ -46,13 +46,13 @@ export interface Element {
      *
      * @internal
      */
-    serializable(): any;
+    serialize(): JSONObject;
     /**
      * Overrides JSON.stringify() behavior.
      *
      * @internal
      */
-    toJSON(): any;
+    toJSON(): JSONObject;
     /**
      * Gets the JAQL representation of this instance.
      *
@@ -337,6 +337,14 @@ export interface LevelAttribute extends Attribute {
         dateTimeLevel?: string;
         bucket?: string;
     };
+    /**
+     * Gets a {@link LevelAttribute} with the given granularity
+     *
+     * @param granularity - Date granularity
+     * @returns New instance representing {@link LevelAttribute} with provided granularity
+     * @internal
+     */
+    setGranularity(granularity: DateLevel): LevelAttribute;
 }
 /**
  * Base filter configuration
@@ -514,10 +522,6 @@ export declare function isPivotMeasure(arg: Measure | PivotMeasure): arg is Pivo
  * Data options for grand totals of a pivot table
  */
 export declare type PivotGrandTotals = {
-    /**
-     * @deprecated
-     */
-    title?: string;
     rows?: boolean;
     columns?: boolean;
 };
@@ -550,6 +554,12 @@ export interface FilterRelations {
     left: FilterRelationsNode;
     right: FilterRelationsNode;
     operator: 'AND' | 'OR';
+    /**
+     * Compose code for the filter relations
+     *
+     * @internal
+     */
+    composeCode?: string;
 }
 /**
  * Model of filter logical relations (AND/OR) from Fusion dashboard

package/dist/dimensional-model/jaql-element.d.ts

@@ -1,6 +1,6 @@
 import { DimensionalElement } from './base.js';
 import { SortDirection } from './interfaces.js';
-import { MetadataItem, MetadataItemJaql } from './types.js';
+import { JSONObject, MetadataItem, MetadataItemJaql } from './types.js';
 /**
  * This implementation wraps metadata for a JAQL query. The metadata could be
  * for a dimension, measure, or filter. We do little to no interpretation of
@@ -26,6 +26,10 @@ export declare class JaqlElement extends DimensionalElement {
     get id(): string;
     jaql(nested?: true): MetadataItemJaql;
     jaql(nested?: false | undefined): MetadataItem;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serialize(): JSONObject;
 }
 /**
  * Create a JaqlElement from a MetadataItem
@@ -35,3 +39,11 @@ export declare class JaqlElement extends DimensionalElement {
  * @internal
  */
 export declare function createJaqlElement(item: MetadataItem): JaqlElement;
+/**
+ * Create a DimensionalElement from a MetadataItem
+ *
+ * @param item - the metadata item in a JAQL query
+ * @returns a DimensionalElement
+ * @internal
+ */
+export declare function createDimensionalElementFromMetadataItem(item: MetadataItem): import("./interfaces.js").Attribute | import("./interfaces.js").BaseMeasure | import("./interfaces.js").CalculatedMeasure | JaqlElement;

package/dist/dimensional-model/jaql-element.js

@@ -1,5 +1,5 @@
+import { createAttributeHelper, createCalculatedMeasureHelper, createMeasureHelper, getSortType, } from '../utils.js';
 import { DimensionalElement } from './base.js';
-import { getSortType } from '../utils.js';
 import { MetadataTypes, } from './types.js';
 /**
  * This implementation wraps metadata for a JAQL query. The metadata could be
@@ -47,6 +47,16 @@ export class JaqlElement extends DimensionalElement {
     jaql(nested) {
         return nested === true ? this.metadataItem.jaql : this.metadataItem;
     }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'JaqlElement';
+        result.metadataItem = this.metadataItem;
+        result.type = this.type;
+        return result;
+    }
 }
 const toMetadataType = {
     text: MetadataTypes.TextAttribute,
@@ -66,3 +76,44 @@ export function createJaqlElement(item) {
     // will always be of type number. check if there is a more correct way to do this
     return new JaqlElement(item, (_a = toMetadataType[item.jaql.datatype]) !== null && _a !== void 0 ? _a : 'numeric');
 }
+/**
+ * Create a DimensionalElement from a MetadataItem
+ *
+ * @param item - the metadata item in a JAQL query
+ * @returns a DimensionalElement
+ * @internal
+ */
+export function createDimensionalElementFromMetadataItem(item) {
+    const { jaql } = item;
+    // calculated measure
+    if (jaql.formula) {
+        return createCalculatedMeasureHelper(jaql);
+    }
+    // measure
+    if ('agg' in jaql && jaql.dim && jaql.datatype) {
+        return createMeasureHelper({
+            expression: jaql.dim,
+            dataType: jaql.datatype,
+            agg: jaql.agg || '',
+            granularity: jaql.level,
+            format: undefined,
+            sort: jaql.sort,
+            title: jaql.title,
+            dataSource: jaql.datasource,
+        });
+    }
+    // attribute
+    if (jaql.dim && jaql.datatype) {
+        return createAttributeHelper({
+            expression: jaql.dim,
+            dataType: jaql.datatype,
+            granularity: jaql.level,
+            sort: jaql.sort,
+            title: jaql.title,
+            panel: item.panel,
+            dataSource: jaql.datasource,
+        });
+    }
+    // fall back to createJaqlElement
+    return createJaqlElement(item);
+}