@sisense/sdk-data 1.22.0 → 1.24.0

package/dist/cjs/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/cjs/dimensional-model/filters/factory.js

@@ -449,11 +449,12 @@ exports.numeric = numeric;
  * @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
  */
-function members(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter) {
-    return new filters_js_1.MembersFilter(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter);
+function members(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter, multiSelection) {
+    return new filters_js_1.MembersFilter(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter, multiSelection);
 }
 exports.members = members;
 // DATE FILTERS

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

@@ -34,11 +34,11 @@ export declare const NumericOperators: {
  * @internal
  */
 export declare const DateOperators: {
-    From: string;
-    To: string;
-    Last: string;
-    Next: string;
-    Anchor: string;
+    readonly From: "from";
+    readonly To: "to";
+    readonly Last: "last";
+    readonly Next: "next";
+    readonly Anchor: "Anchor";
 };
 /**
  * Different logical operators that can be used with logical filters
@@ -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
      */
@@ -317,9 +319,9 @@ export declare class DateRangeFilter extends DoubleOperatorFilter<Date | string>
 export declare class RelativeDateFilter extends AbstractFilter {
     readonly offset: number;
     readonly count: number;
-    readonly operator: string;
+    readonly operator: typeof DateOperators.Last | typeof DateOperators.Next;
     readonly anchor?: Date | string;
-    constructor(l: LevelAttribute, offset: number, count: number, operator?: string, anchor?: Date | string, guid?: string);
+    constructor(l: LevelAttribute, offset: number, count: number, operator?: typeof DateOperators.Last | typeof DateOperators.Next, anchor?: Date | string, guid?: string);
     get level(): LevelAttribute;
     /**
      * gets the element's ID

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

@@ -227,10 +227,11 @@ exports.LogicalAttributeFilter = LogicalAttributeFilter;
  * @internal
  */
 class MembersFilter extends AbstractFilter {
-    constructor(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter) {
+    constructor(attribute, members, excludeMembers, guid, deactivatedMembers, backgroundFilter, multiSelection = true) {
         super(attribute, exports.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) {
@@ -263,10 +264,7 @@ 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/cjs/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/cjs/dimensional-model/filters/utils/attribute-measure-util.js

@@ -29,6 +29,7 @@ const simple_column_types_js_1 = require("../../simple-column-types.js");
 const types_js_1 = require("../../types.js");
 const measureFactory = __importStar(require("../../measures/factory.js"));
 const factory_js_1 = require("../../measures/factory.js");
+const measures_js_1 = require("../../measures/measures.js");
 const DATA_MODEL_MODULE_NAME = 'DM';
 /**
  * Creates an attribute or level attribute from the provided parameters
@@ -86,7 +87,7 @@ exports.createAttributeFromFilterJaql = createAttributeFromFilterJaql;
  */
 const createMeasureHelper = (dim, table, column, level, dataType, agg, title, dataSource) => {
     const attribute = (0, exports.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;
 };
@@ -115,7 +116,7 @@ const createMeasureFromFilterJaql = (jaql) => {
     const { dim, table, column, title, level, datatype: dataType, agg, datasource: dataSource, } = jaql;
     if (!agg)
         return undefined;
-    return (0, exports.createMeasureHelper)(dim, table, column, level, dataType, agg, title, dataSource);
+    return (0, exports.createMeasureHelper)(dim, table, column, level, dataType, measures_js_1.DimensionalBaseMeasure.aggregationFromJAQL(agg), title, dataSource);
 };
 exports.createMeasureFromFilterJaql = createMeasureFromFilterJaql;
 /**
@@ -124,10 +125,10 @@ exports.createMeasureFromFilterJaql = createMeasureFromFilterJaql;
  * @param jaql - Ranking filter Jaql object
  * @returns Measure
  */
-const createMeasureFromRankingFilterJaql = (jaql) => {
+const createMeasureFromRankingFilterJaql = (jaql, rankingMessage) => {
     if ('formula' in jaql)
         return (0, exports.createCalculatedMeasureFromJaql)(jaql);
     const { dim, table, column, level, datatype: dataType, agg } = jaql;
-    return (0, exports.createMeasureHelper)(dim, table, column, level, dataType, agg);
+    return (0, exports.createMeasureHelper)(dim, table, column, level, dataType, measures_js_1.DimensionalBaseMeasure.aggregationFromJAQL(agg), rankingMessage);
 };
 exports.createMeasureFromRankingFilterJaql = createMeasureFromRankingFilterJaql;

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

@@ -109,12 +109,12 @@ exports.getSelectedConditionOption = getSelectedConditionOption;
  * @returns attribute filter
  */
 const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, guid) => {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f;
     const conditionType = (0, exports.getSelectedConditionOption)(conditionFilterJaql);
     switch (conditionType) {
         case types_js_1.ConditionFilterType.BOTTOM:
             if (conditionFilterJaql.by) {
-                return (0, filter_code_util_js_1.withComposeCode)(filterFactory.bottomRanking)(attribute, (0, attribute_measure_util_js_1.createMeasureFromRankingFilterJaql)(conditionFilterJaql.by), conditionFilterJaql[types_js_1.ConditionFilterType.BOTTOM], guid);
+                return (0, filter_code_util_js_1.withComposeCode)(filterFactory.bottomRanking)(attribute, (0, attribute_measure_util_js_1.createMeasureFromRankingFilterJaql)(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[types_js_1.ConditionFilterType.BOTTOM], guid);
             }
             break;
         case types_js_1.ConditionFilterType.EQUALS:
@@ -127,7 +127,7 @@ const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilter
             return (0, filter_code_util_js_1.withComposeCode)(filterFactory.greaterThanOrEqual)(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL], guid);
         case types_js_1.ConditionFilterType.TOP:
             if (conditionFilterJaql.by) {
-                return (0, filter_code_util_js_1.withComposeCode)(filterFactory.topRanking)(attribute, (0, attribute_measure_util_js_1.createMeasureFromRankingFilterJaql)(conditionFilterJaql.by), conditionFilterJaql[types_js_1.ConditionFilterType.TOP], guid);
+                return (0, filter_code_util_js_1.withComposeCode)(filterFactory.topRanking)(attribute, (0, attribute_measure_util_js_1.createMeasureFromRankingFilterJaql)(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[types_js_1.ConditionFilterType.TOP], guid);
             }
             break;
         case types_js_1.ConditionFilterType.STARTS_WITH:
@@ -158,10 +158,13 @@ const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilter
                 return (0, filter_code_util_js_1.withComposeCode)(filterFactory.union)(conditionFilterJaql.or.map((c) => (0, exports.createAttributeFilterFromConditionFilterJaql)(attribute, c, guid)), guid);
             }
             break;
-        case types_js_1.ConditionFilterType.IS_NOT:
+        case types_js_1.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 (0, filter_code_util_js_1.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 (0, filter_code_util_js_1.withComposeCode)(filterFactory.members)(attribute, selectedMembers, true, guid, deactivatedMembers, undefined, conditionFilterJaql.multiSelection);
+        }
         case types_js_1.ConditionFilterType.AFTER:
         case types_js_1.ConditionFilterType.BEFORE:
         case types_js_1.ConditionFilterType.IS_EMPTY:

package/dist/cjs/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/cjs/dimensional-model/filters/utils/filter-from-jaql-util.js

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

package/dist/cjs/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/cjs/dimensional-model/jaql-element.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJaqlElement = exports.JaqlElement = void 0;
+const base_js_1 = require("./base.js");
+const utils_js_1 = require("../utils.js");
+const types_js_1 = require("./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
+ */
+class JaqlElement extends base_js_1.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 = (0, utils_js_1.getSortType)(item.jaql.sort);
+        }
+        else {
+            delete this.sortType;
+        }
+        this.skipValidation = true;
+    }
+    get id() {
+        return this.expression;
+    }
+    jaql() {
+        return this.metadataItem;
+    }
+}
+exports.JaqlElement = JaqlElement;
+const toMetadataType = {
+    text: types_js_1.MetadataTypes.TextAttribute,
+    numeric: types_js_1.MetadataTypes.NumericAttribute,
+    datetime: types_js_1.MetadataTypes.DateLevel,
+};
+/**
+ * Create a JaqlElement from a MetadataItem
+ *
+ * @param item - the metadata item in a JAQL query
+ * @returns a JaqlElement
+ * @internal
+ */
+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');
+}
+exports.createJaqlElement = createJaqlElement;

package/dist/cjs/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,156 @@ 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;
+    members?: string[];
+    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 VagueMetadataItem = Omit<MetadataItem, 'json'> & {
+    json?: MetadataItem;
+};
+/**
+ * @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/cjs/dimensional-model/types.js

@@ -6,7 +6,7 @@
  * Types
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JaqlSortDirection = exports.DataType = exports.DateLevels = exports.MetadataTypes = exports.Sort = exports.AggregationTypes = void 0;
+exports.CurrencyPosition = exports.JaqlSortDirection = exports.DataType = exports.DateLevels = exports.MetadataTypes = exports.Sort = exports.AggregationTypes = void 0;
 /**
  * Different aggregation types
  */
@@ -107,7 +107,8 @@ exports.MetadataTypes = {
             const type = o;
             return type.toLowerCase() === exports.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
@@ -300,3 +301,11 @@ var JaqlSortDirection;
     JaqlSortDirection["ASC"] = "asc";
     JaqlSortDirection["DESC"] = "desc";
 })(JaqlSortDirection = exports.JaqlSortDirection || (exports.JaqlSortDirection = {}));
+/**
+ * @internal
+ */
+var CurrencyPosition;
+(function (CurrencyPosition) {
+    CurrencyPosition["PRE"] = "pre";
+    CurrencyPosition["POST"] = "post";
+})(CurrencyPosition = exports.CurrencyPosition || (exports.CurrencyPosition = {}));

package/dist/cjs/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/cjs/index.js

@@ -26,7 +26,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyticsFactory = exports.measureFactory = exports.filterFactory = exports.createFilterMatcher = void 0;
+exports.translationNamespace = exports.analyticsFactory = exports.measureFactory = exports.filterFactory = exports.createFilterMatcher = void 0;
 require("./translation/initialize-i18n.js");
 /**
  * @packageDocumentation
@@ -43,6 +43,7 @@ __exportStar(require("./dimensional-model/data-model.js"), exports);
 __exportStar(require("./dimensional-model/attributes.js"), exports);
 __exportStar(require("./dimensional-model/dimensions.js"), exports);
 __exportStar(require("./dimensional-model/factory.js"), exports);
+__exportStar(require("./dimensional-model/jaql-element.js"), exports);
 __exportStar(require("./dimensional-model/filters/filters.js"), exports);
 var filter_matcher_utils_js_1 = require("./dimensional-model/filters/utils/filter-matcher-utils.js");
 Object.defineProperty(exports, "createFilterMatcher", { enumerable: true, get: function () { return filter_matcher_utils_js_1.createFilterMatcher; } });
@@ -121,3 +122,5 @@ __exportStar(require("./dimensional-model/simple-column-types.js"), exports);
  */
 exports.analyticsFactory = __importStar(require("./dimensional-model/analytics/factory.js"));
 __exportStar(require("./utils.js"), exports);
+var index_js_1 = require("./translation/resources/index.js");
+Object.defineProperty(exports, "translationNamespace", { enumerable: true, get: function () { return index_js_1.PACKAGE_NAMESPACE; } });

package/dist/cjs/interfaces.d.ts

@@ -132,6 +132,14 @@ export interface CalculatedMeasureColumn {
  * Info of data source
  */
 export declare type DataSourceInfo = {
+    /**
+     * @internal
+     **/
+    id?: string;
+    /**
+     * @internal
+     **/
+    address?: string;
     title: string;
     type: 'live' | 'elasticube';
 };

package/dist/cjs/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/cjs/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/cjs/translation/resources/index.js

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resources = exports.PACKAGE_NAMESPACE = void 0;
 const en_js_1 = require("./en.js");
 const uk_js_1 = require("./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
+ */
 exports.PACKAGE_NAMESPACE = 'sdkData';
 exports.resources = {
     en: en_js_1.translation,

package/dist/cjs/utils.d.ts

@@ -1,5 +1,7 @@
-import { Filter, FilterRelations, FilterRelationsJaql, DataSource, DataSourceInfo, FilterJaql, Sort, Attribute } from './index.js';
 import { JaqlDataSource } from './dimensional-model/filters/utils/types.js';
+import { Attribute, Filter, FilterRelations, FilterRelationsJaql, SortDirection } from './dimensional-model/interfaces.js';
+import { DataSource, DataSourceInfo } from './interfaces.js';
+import { FilterJaql, JaqlSortDirection, Sort } from './dimensional-model/types.js';
 /**
  * A more performant, but slightly bulkier, RFC4122v4 implementation. Performance is improved by minimizing calls to random()
  *
@@ -68,3 +70,11 @@ export declare function getTableNameFromAttribute(attribute: Attribute): string;
  * @internal
  */
 export declare function getColumnNameFromAttribute(attribute: Attribute): string;
+/**
+ * Gets the sort type based on the jaql sort direction.
+ *
+ * @param jaqlSort - The jaql sort direction.
+ * @returns  The sort direction.
+ * @internal
+ */
+export declare function getSortType(jaqlSort: `${JaqlSortDirection}` | undefined): SortDirection;