@sisense/sdk-data 1.22.0 → 1.23.0

package/dist/cjs/utils.js

@@ -3,10 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getColumnNameFromAttribute = exports.getTableNameFromAttribute = exports.createFilterFromJaql = exports.convertSort = exports.convertJaqlDataSource = exports.convertDataSource = exports.isDataSourceInfo = exports.getDataSourceName = exports.getFilterListAndRelations = exports.guidFast = void 0;
+exports.getSortType = exports.getColumnNameFromAttribute = exports.getTableNameFromAttribute = exports.createFilterFromJaql = exports.convertSort = exports.convertJaqlDataSource = exports.convertDataSource = exports.isDataSourceInfo = exports.getDataSourceName = exports.getFilterListAndRelations = exports.guidFast = void 0;
 const cloneDeep_js_1 = __importDefault(require("lodash-es/cloneDeep.js"));
-const index_js_1 = require("./index.js");
 const filter_from_jaql_util_js_1 = require("./dimensional-model/filters/utils/filter-from-jaql-util.js");
+const types_js_1 = require("./dimensional-model/types.js");
 /**
  * A more performant, but slightly bulkier, RFC4122v4 implementation. Performance is improved by minimizing calls to random()
  *
@@ -127,10 +127,10 @@ exports.convertJaqlDataSource = convertJaqlDataSource;
  */
 function convertSort(sort) {
     if (sort) {
-        return sort === 'asc' ? index_js_1.Sort.Ascending : index_js_1.Sort.Descending;
+        return sort === 'asc' ? types_js_1.Sort.Ascending : types_js_1.Sort.Descending;
     }
     else {
-        return index_js_1.Sort.None;
+        return types_js_1.Sort.None;
     }
 }
 exports.convertSort = convertSort;
@@ -162,7 +162,12 @@ function parseExpression(expression) {
     const [table, column] = expression.slice(1, -1).split('.');
     return {
         table,
-        column,
+        column: column
+            ? column
+                // in case of Date we have to remove the (Calendar) part
+                .replace('(Calendar)', '')
+                .trim()
+            : '',
     };
 }
 /**
@@ -183,3 +188,21 @@ function getColumnNameFromAttribute(attribute) {
     return parseExpression(attribute.expression).column;
 }
 exports.getColumnNameFromAttribute = getColumnNameFromAttribute;
+/**
+ * Gets the sort type based on the jaql sort direction.
+ *
+ * @param jaqlSort - The jaql sort direction.
+ * @returns  The sort direction.
+ * @internal
+ */
+function getSortType(jaqlSort) {
+    switch (jaqlSort) {
+        case types_js_1.JaqlSortDirection.ASC:
+            return 'sortAsc';
+        case types_js_1.JaqlSortDirection.DESC:
+            return 'sortDesc';
+        default:
+            return 'sortNone';
+    }
+}
+exports.getSortType = getSortType;

package/dist/dimensional-model/filters/factory.d.ts

@@ -377,10 +377,11 @@ export declare function numeric(attribute: Attribute, operatorA?: string, valueA
  * @param guid - Optional GUID for the filter
  * @param deactivatedMembers - Array of deactivated member values
  * @param backgroundFilter - Optional background filter
+ * @param multiSelection - Optional flag to disable multi-selection
  * @returns A filter instance
  * @shortDescription Creates filter on attribute to match certain string values
  */
-export declare function members(attribute: Attribute, members: string[], excludeMembers?: boolean, guid?: string, deactivatedMembers?: string[], backgroundFilter?: Filter): Filter;
+export declare function members(attribute: Attribute, members: string[], excludeMembers?: boolean, guid?: string, deactivatedMembers?: string[], backgroundFilter?: Filter, multiSelection?: boolean): Filter;
 /**
  * Creates a filter to isolate date values starting from and including the given date and level.
  *

package/dist/dimensional-model/filters/factory.js

@@ -427,11 +427,12 @@ export function numeric(attribute, operatorA, valueA, operatorB, valueB, guid) {
  * @param guid - Optional GUID for the filter
  * @param deactivatedMembers - Array of deactivated member values
  * @param backgroundFilter - Optional background filter
+ * @param multiSelection - Optional flag to disable multi-selection
  * @returns A filter instance
  * @shortDescription Creates filter on attribute to match certain string values
  */
-export function members(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter) {
-    return new MembersFilter(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter);
+export function members(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter, multiSelection) {
+    return new MembersFilter(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter, multiSelection);
 }
 // DATE FILTERS
 /**

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

@@ -166,10 +166,12 @@ export declare class MembersFilter extends AbstractFilter {
     /** @internal */
     excludeMembers: boolean;
     /** @internal */
+    multiSelection: boolean;
+    /** @internal */
     deactivatedMembers: any[];
     /** @internal */
     backgroundFilter?: Filter;
-    constructor(attribute: Attribute, members?: any[], excludeMembers?: boolean, guid?: string, deactivatedMembers?: any[], backgroundFilter?: Filter);
+    constructor(attribute: Attribute, members?: any[], excludeMembers?: boolean, guid?: string, deactivatedMembers?: any[], backgroundFilter?: Filter, multiSelection?: boolean);
     /**
      * gets the element's ID
      */

package/dist/dimensional-model/filters/filters.js

@@ -220,10 +220,11 @@ export class LogicalAttributeFilter extends AbstractFilter {
  * @internal
  */
 export class MembersFilter extends AbstractFilter {
-    constructor(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter) {
+    constructor(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter, multiSelection = true) {
         super(attribute, FilterTypes.members, guid);
         this.members = members !== null && members !== void 0 ? members : [];
         this.excludeMembers = excludeMembers !== null && excludeMembers !== void 0 ? excludeMembers : false;
+        this.multiSelection = multiSelection;
         this.deactivatedMembers = deactivatedMembers !== null && deactivatedMembers !== void 0 ? deactivatedMembers : [];
         this.backgroundFilter = backgroundFilter;
         if (this.members.filter((m) => m === null || m === undefined).length > 0) {
@@ -256,10 +257,7 @@ export class MembersFilter extends AbstractFilter {
         const membersFilterJaql = {
             members: this.members.map((m) => m.toString()),
         };
-        // if there's no members to exclude, do not add the exclude property
-        const filterJaql = this.excludeMembers && this.members.length
-            ? { exclude: membersFilterJaql }
-            : membersFilterJaql;
+        const filterJaql = this.excludeMembers ? { exclude: membersFilterJaql } : membersFilterJaql;
         if (this.backgroundFilter) {
             return {
                 and: [filterJaql, this.backgroundFilter.filterJaql()],

package/dist/dimensional-model/filters/utils/attribute-measure-util.d.ts

@@ -55,4 +55,4 @@ export declare const createMeasureFromFilterJaql: (jaql: FilterJaqlInternal) =>
  * @param jaql - Ranking filter Jaql object
  * @returns Measure
  */
-export declare const createMeasureFromRankingFilterJaql: (jaql: RankingFilterJaql | CustomFormulaJaql) => BaseMeasure | CalculatedMeasure;
+export declare const createMeasureFromRankingFilterJaql: (jaql: RankingFilterJaql | CustomFormulaJaql, rankingMessage?: string) => BaseMeasure | CalculatedMeasure;

package/dist/dimensional-model/filters/utils/attribute-measure-util.js

@@ -3,6 +3,7 @@ import { isNumber } from '../../simple-column-types.js';
 import { MetadataTypes } from '../../types.js';
 import * as measureFactory from '../../measures/factory.js';
 import { transformCustomFormulaJaql } from '../../measures/factory.js';
+import { DimensionalBaseMeasure } from '../../measures/measures.js';
 const DATA_MODEL_MODULE_NAME = 'DM';
 /**
  * Creates an attribute or level attribute from the provided parameters
@@ -58,7 +59,7 @@ export const createAttributeFromFilterJaql = (jaql) => {
  */
 export const createMeasureHelper = (dim, table, column, level, dataType, agg, title, dataSource) => {
     const attribute = createAttributeHelper(dim, table, column, level, dataType, title, dataSource);
-    const measure = measureFactory.aggregate(attribute, agg);
+    const measure = measureFactory.aggregate(attribute, agg, title);
     measure.composeCode = `measureFactory.${agg}(${attribute.composeCode})`;
     return measure;
 };
@@ -85,7 +86,7 @@ export const createMeasureFromFilterJaql = (jaql) => {
     const { dim, table, column, title, level, datatype: dataType, agg, datasource: dataSource, } = jaql;
     if (!agg)
         return undefined;
-    return createMeasureHelper(dim, table, column, level, dataType, agg, title, dataSource);
+    return createMeasureHelper(dim, table, column, level, dataType, DimensionalBaseMeasure.aggregationFromJAQL(agg), title, dataSource);
 };
 /**
  * Creates a measure from the provided ranking filter JAQL object
@@ -93,9 +94,9 @@ export const createMeasureFromFilterJaql = (jaql) => {
  * @param jaql - Ranking filter Jaql object
  * @returns Measure
  */
-export const createMeasureFromRankingFilterJaql = (jaql) => {
+export const createMeasureFromRankingFilterJaql = (jaql, rankingMessage) => {
     if ('formula' in jaql)
         return createCalculatedMeasureFromJaql(jaql);
     const { dim, table, column, level, datatype: dataType, agg } = jaql;
-    return createMeasureHelper(dim, table, column, level, dataType, agg);
+    return createMeasureHelper(dim, table, column, level, dataType, DimensionalBaseMeasure.aggregationFromJAQL(agg), rankingMessage);
 };

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

@@ -82,12 +82,12 @@ export const getSelectedConditionOption = (filter) => {
  * @returns attribute filter
  */
 export const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, guid) => {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f;
     const conditionType = getSelectedConditionOption(conditionFilterJaql);
     switch (conditionType) {
         case ConditionFilterType.BOTTOM:
             if (conditionFilterJaql.by) {
-                return withComposeCode(filterFactory.bottomRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by), conditionFilterJaql[ConditionFilterType.BOTTOM], guid);
+                return withComposeCode(filterFactory.bottomRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[ConditionFilterType.BOTTOM], guid);
             }
             break;
         case ConditionFilterType.EQUALS:
@@ -100,7 +100,7 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
             return withComposeCode(filterFactory.greaterThanOrEqual)(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL], guid);
         case ConditionFilterType.TOP:
             if (conditionFilterJaql.by) {
-                return withComposeCode(filterFactory.topRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by), conditionFilterJaql[ConditionFilterType.TOP], guid);
+                return withComposeCode(filterFactory.topRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[ConditionFilterType.TOP], guid);
             }
             break;
         case ConditionFilterType.STARTS_WITH:
@@ -131,10 +131,13 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
                 return withComposeCode(filterFactory.union)(conditionFilterJaql.or.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c, guid)), guid);
             }
             break;
-        case ConditionFilterType.IS_NOT:
+        case ConditionFilterType.IS_NOT: {
+            const deactivatedMembers = (((_c = conditionFilterJaql.filter) === null || _c === void 0 ? void 0 : _c.turnedOff) && ((_d = conditionFilterJaql.filter.exclude) === null || _d === void 0 ? void 0 : _d.members)) ||
+                [];
+            const selectedMembers = ((_f = (_e = conditionFilterJaql.exclude) === null || _e === void 0 ? void 0 : _e.members) === null || _f === void 0 ? void 0 : _f.filter((member) => !deactivatedMembers.includes(member))) || [];
             // use members filter with exclude instead of exclude filter
-            return withComposeCode(filterFactory.members)(attribute, ((_c = conditionFilterJaql.exclude) === null || _c === void 0 ? void 0 : _c.members) || [], true, guid, (((_d = conditionFilterJaql.filter) === null || _d === void 0 ? void 0 : _d.turnedOff) && ((_e = conditionFilterJaql.filter.exclude) === null || _e === void 0 ? void 0 : _e.members)) ||
-                []);
+            return withComposeCode(filterFactory.members)(attribute, selectedMembers, true, guid, deactivatedMembers, undefined, conditionFilterJaql.multiSelection);
+        }
         case ConditionFilterType.AFTER:
         case ConditionFilterType.BEFORE:
         case ConditionFilterType.IS_EMPTY:

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

@@ -25,7 +25,7 @@ export declare const createFilterIncludeAll: (attribute: Attribute, guid?: strin
  * @param guid - Optional GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromSpecificItemsFilterJaql: (attribute: Attribute, specificItemsFilterJaql: SpecificItemsFilterJaql, guid?: string) => Filter;
+export declare const createFilterFromSpecificItemsFilterJaql: (attribute: Attribute, specificItemsFilterJaql: SpecificItemsFilterJaql, guid?: string, multiSelection?: boolean) => Filter;
 /**
  * Creates a filter from a date range filter JAQL object.
  *

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

@@ -57,11 +57,11 @@ export const createFilterIncludeAll = (attribute, guid) => {
  * @param guid - Optional GUID for the filter
  * @returns Filter object
  */
-export const createFilterFromSpecificItemsFilterJaql = (attribute, specificItemsFilterJaql, guid) => {
+export const createFilterFromSpecificItemsFilterJaql = (attribute, specificItemsFilterJaql, guid, multiSelection) => {
     const deactivatedMembers = getDeactivatedMembersFromFilterJaql(specificItemsFilterJaql);
     const activeMembers = getActiveMembersFromFilterJaql(specificItemsFilterJaql, deactivatedMembers);
     return withComposeCode(filterFactory.members)(attribute, activeMembers, undefined, // use undefined instead of false to avoid including the property in composeCode
-    guid, deactivatedMembers);
+    guid, deactivatedMembers, undefined, multiSelection);
 };
 function getDeactivatedMembersFromFilterJaql(filterJaql) {
     var _a, _b, _c;
@@ -163,7 +163,7 @@ export const createFilterFromJaqlInternal = (jaql, guid) => {
             case FILTER_TYPES.INCLUDE_ALL:
                 return createFilterIncludeAll(attribute, guid);
             case FILTER_TYPES.SPECIFIC_ITEMS:
-                return createFilterFromSpecificItemsFilterJaql(attribute, filterJaqlWithType, guid);
+                return createFilterFromSpecificItemsFilterJaql(attribute, filterJaqlWithType, guid, filterJaqlWithType.multiSelection);
             case FILTER_TYPES.CONDITION:
                 return createFilterFromConditionFilterJaql(attribute, filterJaqlWithType, measure, guid);
             case FILTER_TYPES.DATE_RANGE:

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

@@ -0,0 +1,36 @@
+import { DimensionalElement } from './base.js';
+import { SortDirection } from './interfaces.js';
+import { MetadataItem } 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
+ * the JAQL as it is designed to be "passed through" to the query execution
+ * step.
+ *
+ * This will typically be used for JAQL metadata that is coming from a Sisense
+ * instance and is assumed to be correct (e.g. dashboard widget, NLQ
+ * suggestion).
+ *
+ * @param item - the metadata item in a JAQL query
+ * @param type - the data type of the dimension
+ * @internal
+ */
+export declare class JaqlElement extends DimensionalElement {
+    private readonly metadataItem;
+    expression: string;
+    skipValidation: boolean;
+    aggregation?: string;
+    formula?: string;
+    sortType?: SortDirection;
+    constructor(item: MetadataItem, type: string);
+    get id(): string;
+    jaql(): MetadataItem;
+}
+/**
+ * Create a JaqlElement from a MetadataItem
+ *
+ * @param item - the metadata item in a JAQL query
+ * @returns a JaqlElement
+ * @internal
+ */
+export declare function createJaqlElement(item: MetadataItem): JaqlElement;

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

@@ -0,0 +1,68 @@
+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
+ * for a dimension, measure, or filter. We do little to no interpretation of
+ * the JAQL as it is designed to be "passed through" to the query execution
+ * step.
+ *
+ * This will typically be used for JAQL metadata that is coming from a Sisense
+ * instance and is assumed to be correct (e.g. dashboard widget, NLQ
+ * suggestion).
+ *
+ * @param item - the metadata item in a JAQL query
+ * @param type - the data type of the dimension
+ * @internal
+ */
+export class JaqlElement extends DimensionalElement {
+    constructor(item, type) {
+        var _a;
+        super((_a = item.jaql.title) !== null && _a !== void 0 ? _a : '', type);
+        this.expression = (item.jaql.dim || item.jaql.formula);
+        this.metadataItem = item;
+        if (item.jaql.agg) {
+            this.aggregation = item.jaql.agg;
+        }
+        else {
+            delete this.aggregation;
+        }
+        if (item.jaql.formula) {
+            this.formula = item.jaql.formula;
+        }
+        else {
+            delete this.formula;
+        }
+        if (item.jaql.sort) {
+            this.sortType = getSortType(item.jaql.sort);
+        }
+        else {
+            delete this.sortType;
+        }
+        this.skipValidation = true;
+    }
+    get id() {
+        return this.expression;
+    }
+    jaql() {
+        return this.metadataItem;
+    }
+}
+const toMetadataType = {
+    text: MetadataTypes.TextAttribute,
+    numeric: MetadataTypes.NumericAttribute,
+    datetime: MetadataTypes.DateLevel,
+};
+/**
+ * Create a JaqlElement from a MetadataItem
+ *
+ * @param item - the metadata item in a JAQL query
+ * @returns a JaqlElement
+ * @internal
+ */
+export function createJaqlElement(item) {
+    var _a;
+    // TODO: measures with a "formula" may not have a datatype. force this to be numeric because aggregations
+    // 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');
+}

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

@@ -223,12 +223,14 @@ export declare type IncludeAllFilter = {
 /** @internal */
 export declare type IncludeMembersFilter = {
     members: string[];
+    multiSelection?: boolean;
 };
 /** @internal */
 export declare type ExcludeMembersFilter = {
     exclude: {
         members: string[];
     };
+    multiSelection?: boolean;
 };
 /** @internal */
 export declare type TurnOffMembersFilter = ExcludeMembersFilter & {
@@ -266,3 +268,149 @@ export declare type OrFilter<FilterItem> = {
  * Abstract object with any unknown values
  */
 export declare type AnyObject = Record<string, any>;
+/**
+ * @internal
+ */
+interface DecimalAbbreviations {
+    k: boolean;
+    m: boolean;
+    b: boolean;
+    t: boolean;
+}
+/**
+ * @internal
+ */
+export declare enum CurrencyPosition {
+    PRE = "pre",
+    POST = "post"
+}
+/**
+ * @internal
+ */
+export declare type NumericMask = {
+    isdefault?: boolean;
+    abbreviations?: DecimalAbbreviations;
+    decimals?: 'auto' | number | string;
+    currency?: {
+        symbol: string;
+        position: CurrencyPosition;
+    };
+    percent?: boolean;
+    number?: {
+        separated: boolean;
+    };
+    separated?: boolean;
+    type?: string;
+};
+/**
+ * @internal
+ */
+export declare type DatetimeMask = {
+    isdefault?: boolean;
+    years: string;
+    quarters: string;
+    months: string;
+    weeks: string;
+    minutes: string;
+    days: string;
+    type: string;
+    dateAndTime?: string;
+};
+/**
+ * @internal
+ */
+export declare type MetadataItem = {
+    instanceid?: string;
+    measure?: MetadataItemJaql;
+    jaql: MetadataItemJaql;
+    panel?: string;
+    isScope?: boolean;
+    format?: {
+        mask?: Partial<DatetimeMask> | Partial<NumericMask>;
+        number?: string;
+        subtotal?: boolean;
+        width?: number;
+        databars?: boolean;
+        color?: {
+            type: string;
+            color?: string;
+            conditions?: Array<{
+                color: string;
+                operator: string;
+                expression: string | Record<string, any>;
+            }>;
+        };
+    };
+    field?: {
+        id?: string;
+        index?: number;
+    };
+    filter?: MetadataItem;
+    exclude?: MetadataItem;
+    by?: MetadataItemJaql;
+    level?: string;
+    anchor?: string;
+    from?: string;
+    to?: string;
+};
+/**
+ * @internal
+ */
+export declare type MetadataItemJaql = {
+    dim?: string;
+    agg?: string;
+    datatype?: string;
+    table?: string;
+    column?: string;
+    level?: string;
+    dateTimeLevel?: string;
+    bucket?: string;
+    sort?: string;
+    in?: {
+        selected: {
+            jaql: MetadataItemJaql;
+        };
+    };
+    title?: string;
+    type?: string;
+    formula?: string;
+    context?: {
+        [itemId: string]: MetadataItemJaql;
+    };
+    filter?: MetadataItem;
+    sortDetails?: {
+        dir: string;
+        field?: number;
+        measurePath?: Record<number, string | number>;
+        sortingLastDimension?: boolean;
+        initialized?: boolean;
+    };
+};
+/**
+ * @internal
+ */
+export declare type DataSourceField = {
+    column: string;
+    dimtype: string;
+    id: string;
+    indexed: boolean;
+    merged: boolean;
+    table: string;
+    title: string;
+    type: string;
+};
+/**
+ * @internal
+ */
+export declare type DataSourceSchema = {
+    title: string;
+    type: 'extract' | 'live';
+} & AnyObject;
+/**
+ * @internal
+ */
+export declare type DataSourceMetadata = {
+    title: string;
+    fullname: string;
+    live: boolean;
+};

package/dist/dimensional-model/types.js

@@ -104,7 +104,8 @@ export const MetadataTypes = {
             const type = o;
             return type.toLowerCase() === MetadataTypes.BaseMeasure;
         }
-        return (o.agg || o.aggregation) && o.attribute && !this.isMeasureTemplate(o);
+        // JaqlElement doesn't have property attribute. Check for jaql instead
+        return (o.agg || o.aggregation) && (o.attribute || o.jaql) && !this.isMeasureTemplate(o);
     },
     /**
      * Checks whether the given object or type is a measure - of any type
@@ -297,3 +298,11 @@ export var JaqlSortDirection;
     JaqlSortDirection["ASC"] = "asc";
     JaqlSortDirection["DESC"] = "desc";
 })(JaqlSortDirection = JaqlSortDirection || (JaqlSortDirection = {}));
+/**
+ * @internal
+ */
+export var CurrencyPosition;
+(function (CurrencyPosition) {
+    CurrencyPosition["PRE"] = "pre";
+    CurrencyPosition["POST"] = "post";
+})(CurrencyPosition = CurrencyPosition || (CurrencyPosition = {}));

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export * from './dimensional-model/data-model.js';
 export * from './dimensional-model/attributes.js';
 export * from './dimensional-model/dimensions.js';
 export * from './dimensional-model/factory.js';
+export * from './dimensional-model/jaql-element.js';
 export * from './dimensional-model/filters/filters.js';
 export { createFilterMatcher } from './dimensional-model/filters/utils/filter-matcher-utils.js';
 /**
@@ -91,3 +92,4 @@ export * from './dimensional-model/simple-column-types.js';
  */
 export * as analyticsFactory from './dimensional-model/analytics/factory.js';
 export * from './utils.js';
+export { type TranslationDictionary, PACKAGE_NAMESPACE as translationNamespace, } from './translation/resources/index.js';

package/dist/index.js

@@ -14,6 +14,7 @@ export * from './dimensional-model/data-model.js';
 export * from './dimensional-model/attributes.js';
 export * from './dimensional-model/dimensions.js';
 export * from './dimensional-model/factory.js';
+export * from './dimensional-model/jaql-element.js';
 export * from './dimensional-model/filters/filters.js';
 export { createFilterMatcher } from './dimensional-model/filters/utils/filter-matcher-utils.js';
 /**
@@ -91,3 +92,4 @@ export * from './dimensional-model/simple-column-types.js';
  */
 export * as analyticsFactory from './dimensional-model/analytics/factory.js';
 export * from './utils.js';
+export { PACKAGE_NAMESPACE as translationNamespace, } from './translation/resources/index.js';

package/dist/translation/resources/en.d.ts

@@ -28,4 +28,18 @@ export declare const translation: {
         unsupportedDimensionalElement: string;
     };
 };
+/**
+ * A reference type containing all currently used translation keys.
+ * This type serves as a complete resource for creating custom translations,
+ * ensuring that all required keys are present and included.
+ * It can also be used as Partial to make sure custom translation does not contain any typos.
+ *
+ * @example
+ * ```typescript
+ * import { TranslationDictionary } from '@sisense/sdk-data';
+ *
+ * const customTranslationResources: Partial<TranslationDictionary> = {
+ * ```
+ * @internal
+ */
 export declare type TranslationDictionary = typeof translation;

package/dist/translation/resources/index.d.ts

@@ -1,5 +1,11 @@
 import { TranslationDictionary } from './en.js';
 export type { TranslationDictionary };
+/**
+ * A reference to the namespace of the translation resources.
+ * This namespace is used to access the translation resources in the i18next instance.
+ *
+ * @internal
+ */
 export declare const PACKAGE_NAMESPACE: "sdkData";
 export declare const resources: {
     en: {

package/dist/translation/resources/index.js

@@ -1,5 +1,11 @@
 import { translation as enDictionary } from './en.js';
 import { translation as ukDictionary } from './uk.js';
+/**
+ * A reference to the namespace of the translation resources.
+ * This namespace is used to access the translation resources in the i18next instance.
+ *
+ * @internal
+ */
 export const PACKAGE_NAMESPACE = 'sdkData';
 export const resources = {
     en: enDictionary,