@sisense/sdk-data 0.14.0 → 0.16.0

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

@@ -1,4 +1,5 @@
 import { create } from './factory.js';
+import { TranslatableError } from '../translation/translatable-error.js';
 /**
  * @internal
  */
@@ -17,11 +18,11 @@ export class DimensionalDataModel {
         }
     }
     static fromConfig(config) {
-        if (!config && config.name) {
-            throw new Error('name must be specified');
+        if (config && !config.name) {
+            throw new TranslatableError('errors.dataModel.noName');
         }
-        if (!config && config.metadata) {
-            throw new Error('metadata must be specified');
+        if (config && !config.metadata) {
+            throw new TranslatableError('errors.dataModel.noMetadata');
         }
         const metadata = new Array();
         for (let i = 0; i < config.metadata.length; i++) {

package/dist/dimensional-model/factory.js

@@ -1,11 +1,11 @@
 /* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-throw-literal */
 import { MetadataTypes } from './types.js';
 import { createMeasure } from './measures/measures.js';
 import { createFilter } from './filters/filters.js';
 import { createDimension } from './dimensions.js';
 import { createAttribute } from './attributes.js';
+import { TranslatableError } from '../translation/translatable-error.js';
 /**
  * Generate an array of dimension model instances out of the given JSON array
  *
@@ -46,5 +46,5 @@ export function create(item) {
         item.dimtype) {
         return createDimension(item);
     }
-    throw 'unsupported';
+    throw new TranslatableError('errors.unsupportedDimesionalElement');
 }

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

@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/no-throw-literal */
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable max-lines */
 /* eslint-disable max-params */
@@ -14,6 +13,7 @@ import { DimensionalElement } from '../base.js';
 import { DateLevels, MetadataTypes } from '../types.js';
 import { create } from '../factory.js';
 import { DimensionalBaseMeasure } from '../measures/measures.js';
+import { TranslatableError } from '../../translation/translatable-error.js';
 /**
  * Different text operators that can be used with text filters
  *
@@ -140,7 +140,7 @@ class AbstractFilter extends DimensionalElement {
         if (granularity === DateLevels.Hours ||
             granularity === DateLevels.MinutesRoundTo30 ||
             granularity === DateLevels.MinutesRoundTo15) {
-            throw new Error('Filters do not support the next "datetime" levels: Hours, MinutesRoundTo30, MinutesRoundTo15');
+            throw new TranslatableError('errors.filter.unsupportedDatetimeLevel');
         }
     }
 }
@@ -185,7 +185,9 @@ export class MembersFilter extends AbstractFilter {
         super(attribute, FilterTypes.members);
         this.members = members !== null && members !== void 0 ? members : [];
         if (this.members.filter((m) => m === null || m === undefined).length > 0) {
-            throw `MembersFilter of ${attribute.id} - member cannot be null`;
+            throw new TranslatableError('errors.filter.membersFilterNullMember', {
+                attributeId: attribute.id,
+            });
         }
     }
     /**
@@ -399,9 +401,6 @@ export class RankingFilter extends AbstractFilter {
 export class NumericFilter extends DoubleOperatorFilter {
     constructor(att, operatorA, valueA, operatorB, valueB) {
         super(att, FilterTypes.numeric, operatorA, valueA, operatorB, valueB);
-        // if (att.dimension && !MetadataTypes.isTextDimension(att.dimension.type)) {
-        //     throw 'Dimension must be of Text type to be applied with Text filter';
-        // }
     }
 }
 /**
@@ -410,9 +409,6 @@ export class NumericFilter extends DoubleOperatorFilter {
 export class TextFilter extends DoubleOperatorFilter {
     constructor(att, operator, value) {
         super(att, FilterTypes.text, operator, value);
-        // if (att.dimension && !MetadataTypes.isTextDimension(att.dimension.type)) {
-        //     throw 'Dimension must be of Text type to be applied with Text filter';
-        // }
     }
 }
 /**
@@ -544,5 +540,7 @@ export function createFilter(json) {
             return new DateRangeFilter(create(json.attribute), json.valueA, json.valueB);
             break;
     }
-    throw 'unsupported filter type';
+    throw new TranslatableError('errors.filter.unsupportedType', {
+        filterType: json.filterType,
+    });
 }

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

@@ -339,3 +339,6 @@ export interface Filter extends Element {
      */
     filterJaql(): any;
 }
+export interface CustomFormulaContext {
+    [key: string]: Attribute | Measure;
+}

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

@@ -1,4 +1,4 @@
-import { Attribute, Measure, Filter, CalculatedMeasure, BaseMeasure } from '../interfaces.js';
+import { Attribute, Measure, Filter, CalculatedMeasure, BaseMeasure, CustomFormulaContext } from '../interfaces.js';
 import { ForecastFormulaOptions, TrendFormulaOptions } from '../../interfaces.js';
 /**
  * Defines the different numeric operators that can be used with numeric filters
@@ -32,6 +32,66 @@ export declare const RankingSortTypes: {
     Ascending: string;
     Descending: string;
 };
+/**
+ * Creates a calculated measure for a [valid custom formula](https://docs.sisense.com/main/SisenseLinux/dashboard-functions-reference.htm).
+ *
+ * Use square brackets within the `formula` to include dimensions or measures.
+ * Each unique dimension or measure included in the `formula` must be defined using a property:value pair in the `context` parameter.
+ *
+ * You can nest custom formulas by placing one inside the `formula` parameter of another
+ *
+ *
+ * Note: Shared formula must be fetched prior to use (see {@link @sisense/sdk-ui!useGetSharedFormula | useGetSharedFormula}).
+ *
+ * @example
+ * An example of constructing a `customFormula` using dimensions, measures, and nested custom formulas:
+ * ```tsx
+ *  const profitabilityRatio = measures.customFormula(
+ *   'Profitability Ratio',
+ *   '([totalRevenue] - SUM([cost])) / [totalRevenue]',
+ *   {
+ *     totalRevenue: measures.sum(DM.Commerce.Revenue),
+ *     cost: DM.Commerce.Cost,
+ *   },
+ * );
+ *
+ * const profitabilityRatioRank = measures.customFormula(
+ *   'Profitability Ratio Rank',
+ *   'RANK([profRatio], "ASC", "1224")',
+ *   {
+ *     profRatio: profitabilityRatio,
+ *   },
+ * );
+ *
+ * return (
+ *   <Chart
+ *     dataSet={DM.DataSource}
+ *     chartType="line"
+ *     dataOptions={{
+ *       category: [DM.Commerce.AgeRange],
+ *       value: [
+ *         profitabilityRatioRank,
+ *         {
+ *           column: measures.sum(DM.Commerce.Revenue, 'Total Revenue'),
+ *           showOnRightAxis: true,
+ *           chartType: 'column',
+ *         },
+ *         {
+ *           column: measures.sum(DM.Commerce.Cost, 'Total Cost'),
+ *           showOnRightAxis: true,
+ *           chartType: 'column',
+ *         },
+ *       ],
+ *     }}
+ *   />
+ * );
+ * ```
+ * @param title - Title of the measure to be displayed in legend
+ * @param formula - Formula to be used for the measure
+ * @param context - Formula context as a map of strings to measures or attributes
+ * @returns A calculated measure object that may be used in a chart or a query
+ */
+export declare function customFormula(title: string, formula: string, context: CustomFormulaContext): Attribute | Measure;
 /**
  * Creates a basic aggregated measure.
  * This is a base function to build other aggregation functions (e.g., `sum`, `average`, etc)

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

@@ -1,6 +1,9 @@
 import { DimensionalBaseMeasure, DimensionalCalculatedMeasure } from './measures.js';
-import { AggregationTypes, MetadataTypes } from '../types.js';
+import { AggregationTypes, MetadataTypes, Sort } from '../types.js';
 import { normalizeName } from '../base.js';
+import mapValues from 'lodash/mapValues.js';
+import { DimensionalAttribute, DimensionalLevelAttribute } from '../attributes.js';
+import { isDatetime, isNumber } from './../simple-column-types.js';
 /**
  * Defines the different numeric operators that can be used with numeric filters
  *
@@ -70,6 +73,96 @@ function measureFunction(measure, name, func, options) {
     builder.push(')');
     return new DimensionalCalculatedMeasure(name, builder.join(''), context);
 }
+function transformCustomFormulaJaql(jaql) {
+    var _a;
+    const isFormulaJaql = 'formula' in jaql;
+    let sort;
+    if (jaql.sort) {
+        sort = jaql.sort === 'asc' ? Sort.Ascending : Sort.Descending;
+    }
+    if (isFormulaJaql) {
+        const context = mapValues((_a = jaql.context) !== null && _a !== void 0 ? _a : {}, (jaqlContextValue) => jaqlContextValue ? transformCustomFormulaJaql(jaqlContextValue) : {});
+        return new DimensionalCalculatedMeasure(jaql.title, jaql.formula, context, undefined, undefined, sort);
+    }
+    const hasAggregation = !!jaql.agg;
+    const isDatatypeDatetime = isDatetime(jaql.datatype);
+    const attributeType = isNumber(jaql.datatype)
+        ? MetadataTypes.NumericAttribute
+        : MetadataTypes.TextAttribute;
+    const attribute = isDatatypeDatetime
+        ? new DimensionalLevelAttribute(jaql.title, jaql.dim, DimensionalLevelAttribute.translateJaqlToGranularity(jaql), undefined, undefined, sort)
+        : new DimensionalAttribute(jaql.title, jaql.dim, attributeType, undefined, sort);
+    if (hasAggregation) {
+        return new DimensionalBaseMeasure(jaql.title, attribute, DimensionalBaseMeasure.aggregationFromJAQL(jaql.agg || ''), undefined, undefined, sort);
+    }
+    return attribute;
+}
+/**
+ * Creates a calculated measure for a [valid custom formula](https://docs.sisense.com/main/SisenseLinux/dashboard-functions-reference.htm).
+ *
+ * Use square brackets within the `formula` to include dimensions or measures.
+ * Each unique dimension or measure included in the `formula` must be defined using a property:value pair in the `context` parameter.
+ *
+ * You can nest custom formulas by placing one inside the `formula` parameter of another
+ *
+ *
+ * Note: Shared formula must be fetched prior to use (see {@link @sisense/sdk-ui!useGetSharedFormula | useGetSharedFormula}).
+ *
+ * @example
+ * An example of constructing a `customFormula` using dimensions, measures, and nested custom formulas:
+ * ```tsx
+ *  const profitabilityRatio = measures.customFormula(
+ *   'Profitability Ratio',
+ *   '([totalRevenue] - SUM([cost])) / [totalRevenue]',
+ *   {
+ *     totalRevenue: measures.sum(DM.Commerce.Revenue),
+ *     cost: DM.Commerce.Cost,
+ *   },
+ * );
+ *
+ * const profitabilityRatioRank = measures.customFormula(
+ *   'Profitability Ratio Rank',
+ *   'RANK([profRatio], "ASC", "1224")',
+ *   {
+ *     profRatio: profitabilityRatio,
+ *   },
+ * );
+ *
+ * return (
+ *   <Chart
+ *     dataSet={DM.DataSource}
+ *     chartType="line"
+ *     dataOptions={{
+ *       category: [DM.Commerce.AgeRange],
+ *       value: [
+ *         profitabilityRatioRank,
+ *         {
+ *           column: measures.sum(DM.Commerce.Revenue, 'Total Revenue'),
+ *           showOnRightAxis: true,
+ *           chartType: 'column',
+ *         },
+ *         {
+ *           column: measures.sum(DM.Commerce.Cost, 'Total Cost'),
+ *           showOnRightAxis: true,
+ *           chartType: 'column',
+ *         },
+ *       ],
+ *     }}
+ *   />
+ * );
+ * ```
+ * @param title - Title of the measure to be displayed in legend
+ * @param formula - Formula to be used for the measure
+ * @param context - Formula context as a map of strings to measures or attributes
+ * @returns A calculated measure object that may be used in a chart or a query
+ */
+export function customFormula(title, formula, context) {
+    const newContext = Object.entries(context).reduce((acc, [key, val]) => {
+        acc[`[${key}]`] = val.jaql().jaql;
+        return acc;
+    }, {});
+    return transformCustomFormulaJaql({ title, formula, context: newContext });
+}
 function arithmetic(operand1, operator, operand2, name, withParentheses) {
     const builder = [];
     const context = {};
@@ -97,13 +190,6 @@ function arithmetic(operand1, operator, operand2, name, withParentheses) {
  * @returns A Measure instance
  */
 export function aggregate(attribute, aggregationType, name, format) {
-    // if (aggregationType == AggregationTypes.Average || aggregationType == AggregationTypes.Max ||
-    //     aggregationType == AggregationTypes.Min || aggregationType == AggregationTypes.Median ||
-    //     aggregationType == AggregationTypes.Sum) {
-    //         if (!MetadataTypes.isNumericDimension(attribute.type)) {
-    //             throw `${aggregationType} is supported for numeric attributes only, where ${attribute.name} is ${attribute.type}`;
-    //         }
-    //     }
     return new DimensionalBaseMeasure(name !== null && name !== void 0 ? name : `${aggregationType.toString()} ${attribute.name}`, attribute, aggregationType, format);
 }
 /**
@@ -541,9 +627,7 @@ export function contribution(measure, name) {
  */
 export function trend(measure, name, options) {
     let params;
-    const adjustValues = (value) => value
-        .replace('advancedSmoothing', 'Advanced Smoothing')
-        .replace('localEstimates', 'Local Estimates');
+    const adjustValues = (value) => value.replace('advancedSmoothing', 'smooth').replace('localEstimates', 'local');
     if (options) {
         // make a comma separated name=value string based on options
         params = Object.entries(options)
@@ -577,7 +661,7 @@ export function forecast(measure, name, options) {
     let params;
     if (options) {
         // create ISO string values for any Date objects
-        const adjustedOptions = Object.assign({}, options);
+        const adjustedOptions = Object.assign({ forecastHorizon: 3 }, options);
         if (adjustedOptions.startDate) {
             const startDate = new Date(adjustedOptions.startDate);
             adjustedOptions.startDate = startDate.toISOString().replace(/.\d+Z$/g, '');

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

@@ -8,12 +8,12 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable sonarjs/cognitive-complexity */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/no-throw-literal */
 import * as m from './factory.js';
 import { Sort, AggregationTypes, MetadataTypes } from '../types.js';
 import { DimensionalElement } from '../base.js';
 import { DimensionalAttribute, createAttribute } from '../attributes.js';
 import { create } from '../factory.js';
+import { TranslatableError } from '../../translation/translatable-error.js';
 /**
  * @internal
  */
@@ -360,7 +360,7 @@ export function createMeasure(json) {
     }
     if (MetadataTypes.isCalculatedMeasure(json)) {
         if (json.context === undefined) {
-            throw new Error(`DimensionalCalculatedMeasure must have context property`);
+            throw new TranslatableError('errors.measure.dimensionalCalculatedMeasure.noContext');
         }
         const context = {};
         Object.getOwnPropertyNames(json.context).forEach((pname) => {
@@ -370,19 +370,19 @@ export function createMeasure(json) {
     }
     else if (MetadataTypes.isMeasureTemplate(json)) {
         if (att === undefined) {
-            throw new Error(`DimensionalBaseMeasure must have attribute/dim/expression property`);
+            throw new TranslatableError('errors.measure.dimensionalBaseMeasure.noAttributeDimExpression');
         }
         return new DimensionalMeasureTemplate(name, att, format, desc);
     }
     else if (MetadataTypes.isBaseMeasure(json)) {
         if (att === undefined) {
-            throw new Error(`DimensionalBaseMeasure must have attribute/dim/expression property`);
+            throw new TranslatableError('errors.measure.dimensionalBaseMeasure.noAttributeDimExpression');
         }
         const agg = json.agg || json.aggregation;
         if (!agg) {
-            throw `DimensionalBaseMeasure must have agg or aggregation property`;
+            throw new TranslatableError('errors.measure.dimensionalBaseMeasure.noAggAggregation');
         }
         return new DimensionalBaseMeasure(name, att, agg, format, desc);
     }
-    throw 'unsupported measure type';
+    throw new TranslatableError('errors.measure.unsupportedType');
 }

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

@@ -150,3 +150,55 @@ export declare const DateLevels: {
     /** @internal */
     readonly all: string[];
 };
+export declare enum DataType {
+    TEXT = "text",
+    NUMERIC = "numeric",
+    DATETIME = "datetime"
+}
+export declare enum SortDirection {
+    ASC = "asc",
+    DESC = "desc"
+}
+export declare type Jaql = BaseJaql | FormulaJaql | FilterJaql;
+export declare type BaseJaql = {
+    agg?: string;
+    datatype: DataType;
+    dim: string;
+    table: string;
+    column: string;
+    title: string;
+    level?: 'years' | 'quarters' | 'months' | 'weeks' | 'minutes' | 'days';
+    sort?: SortDirection;
+};
+export declare type FormulaID = string;
+export declare type FormulaContext = BaseJaql | FormulaJaql | FilterJaql;
+export declare type FormulaJaql = {
+    type?: 'measure';
+    sort?: SortDirection;
+    title: string;
+    formula: string;
+    context?: Record<FormulaID, FormulaContext>;
+};
+export declare type BaseFilter = IncludeAllFilter | IncludeMembersFilter | ExcludeMembersFilter;
+export declare type BackgroundFilter = BaseFilter & {
+    level?: 'string';
+};
+export declare type IncludeAllFilter = {
+    all: true;
+};
+export declare type IncludeMembersFilter = {
+    members: string[];
+};
+export declare type ExcludeMembersFilter = {
+    exclude: {
+        members: string[];
+    };
+};
+export declare type TurnOffMembersFilter = ExcludeMembersFilter & {
+    turnedOff: boolean;
+};
+export declare type FilterJaql = BaseJaql & {
+    filter: BaseFilter & {
+        filter?: BackgroundFilter | TurnOffMembersFilter;
+    };
+};

package/dist/dimensional-model/types.js

@@ -282,3 +282,14 @@ export const DateLevels = {
         ];
     },
 };
+export var DataType;
+(function (DataType) {
+    DataType["TEXT"] = "text";
+    DataType["NUMERIC"] = "numeric";
+    DataType["DATETIME"] = "datetime";
+})(DataType = DataType || (DataType = {}));
+export var SortDirection;
+(function (SortDirection) {
+    SortDirection["ASC"] = "asc";
+    SortDirection["DESC"] = "desc";
+})(SortDirection = SortDirection || (SortDirection = {}));

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import './translation/initialize-i18n.js';
 /**
  * @packageDocumentation
  * @beta

package/dist/index.js

@@ -1,3 +1,4 @@
+import './translation/initialize-i18n.js';
 /**
  * @packageDocumentation
  * @beta

package/dist/interfaces.d.ts

@@ -184,7 +184,7 @@ export declare type ForecastFormulaOptions = {
      *
      * @defaultValue 3
      */
-    forecastHorizon: number;
+    forecastHorizon?: number;
     /**
      * Forecasting model type. The 'auto' option automatically
      * fits the best combination of models.

package/dist/translation/initialize-i18n.d.ts

@@ -0,0 +1,2 @@
+export declare function initializeI18n(): import("@sisense/sdk-common").I18NextInitResult;
+export declare const i18nextInstance: import("i18next").i18n;

package/dist/translation/initialize-i18n.js

@@ -0,0 +1,10 @@
+import { initI18next } from '@sisense/sdk-common';
+import { resources, PACKAGE_NAMESPACE } from './resources/index.js';
+export function initializeI18n() {
+    return initI18next({
+        resource: resources,
+        language: 'en',
+        namespace: PACKAGE_NAMESPACE,
+    });
+}
+export const { i18nextInstance } = initializeI18n();

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

@@ -0,0 +1,28 @@
+/**
+ * Translation dictionary for English language.
+ */
+export declare const translation: {
+    errors: {
+        measure: {
+            unsupportedType: string;
+            dimensionalCalculatedMeasure: {
+                noContext: string;
+            };
+            dimensionalBaseMeasure: {
+                noAttributeDimExpression: string;
+                noAggAggregation: string;
+            };
+        };
+        dataModelConfig: {
+            noName: string;
+            noMetadata: string;
+        };
+        filter: {
+            unsupportedType: string;
+            unsupportedDatetimeLevel: string;
+            membersFilterNullMember: string;
+        };
+        unsupportedDimesionalElement: string;
+    };
+};
+export declare type TranslationDictionary = typeof translation;

package/dist/translation/resources/en.js

@@ -0,0 +1,27 @@
+/**
+ * Translation dictionary for English language.
+ */
+export const translation = {
+    errors: {
+        measure: {
+            unsupportedType: 'Unsupported measure type',
+            dimensionalCalculatedMeasure: {
+                noContext: "DimensionalCalculatedMeasure must have 'context' property",
+            },
+            dimensionalBaseMeasure: {
+                noAttributeDimExpression: "DimensionalBaseMeasure must have 'attribute'/'dim'/'expression' property",
+                noAggAggregation: "DimensionalBaseMeasure must have 'agg' or 'aggregation' property",
+            },
+        },
+        dataModelConfig: {
+            noName: "'name' must be specified in config for DataModel",
+            noMetadata: "'metadata' must be specified in config for DataModel",
+        },
+        filter: {
+            unsupportedType: 'Unsupported filter type: {{filterType}}',
+            unsupportedDatetimeLevel: 'Filters do not support the next "datetime" levels: Hours, MinutesRoundTo30, MinutesRoundTo15',
+            membersFilterNullMember: 'MembersFilter of {{attributeId}} - member cannot be null',
+        },
+        unsupportedDimesionalElement: 'Unsupported dimensional element type',
+    },
+};

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

@@ -0,0 +1,53 @@
+import { TranslationDictionary } from './en.js';
+export type { TranslationDictionary };
+export declare const PACKAGE_NAMESPACE: "sdkData";
+export declare const resources: {
+    en: {
+        errors: {
+            measure: {
+                unsupportedType: string;
+                dimensionalCalculatedMeasure: {
+                    noContext: string;
+                };
+                dimensionalBaseMeasure: {
+                    noAttributeDimExpression: string;
+                    noAggAggregation: string;
+                };
+            };
+            dataModelConfig: {
+                noName: string;
+                noMetadata: string;
+            };
+            filter: {
+                unsupportedType: string;
+                unsupportedDatetimeLevel: string;
+                membersFilterNullMember: string;
+            };
+            unsupportedDimesionalElement: string;
+        };
+    };
+    uk: {
+        errors: {
+            measure: {
+                unsupportedType: string;
+                dimensionalCalculatedMeasure: {
+                    noContext: string;
+                };
+                dimensionalBaseMeasure: {
+                    noAttributeDimExpression: string;
+                    noAggAggregation: string;
+                };
+            };
+            dataModelConfig: {
+                noName: string;
+                noMetadata: string;
+            };
+            filter: {
+                unsupportedType: string;
+                unsupportedDatetimeLevel: string;
+                membersFilterNullMember: string;
+            };
+            unsupportedDimesionalElement: string;
+        };
+    };
+};

package/dist/translation/resources/index.js

@@ -0,0 +1,7 @@
+import { translation as enDictionary } from './en.js';
+import { translation as ukDictionary } from './uk.js';
+export const PACKAGE_NAMESPACE = 'sdkData';
+export const resources = {
+    en: enDictionary,
+    uk: ukDictionary,
+};

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

@@ -0,0 +1,5 @@
+import { TranslationDictionary } from './index.js';
+/**
+ * Translation dictionary for Ukrainian language.
+ */
+export declare const translation: TranslationDictionary;

package/dist/translation/resources/uk.js

@@ -0,0 +1,27 @@
+/**
+ * Translation dictionary for Ukrainian language.
+ */
+export const translation = {
+    errors: {
+        measure: {
+            unsupportedType: 'Непідтримуваний тип measure',
+            dimensionalCalculatedMeasure: {
+                noContext: "DimensionalCalculatedMeasure має мати властивість 'context'",
+            },
+            dimensionalBaseMeasure: {
+                noAttributeDimExpression: "DimensionalBaseMeasure має мати властивість 'attribute'/'dim'/'expression'",
+                noAggAggregation: "DimensionalBaseMeasure має мати властивість 'agg' або 'aggregation'",
+            },
+        },
+        dataModelConfig: {
+            noName: "'name' має бути вказано в конфігурації для DataModel",
+            noMetadata: "'metadata' має бути вказано в конфігурації для DataModel",
+        },
+        filter: {
+            unsupportedType: 'Непідтримуваний тип фільтра: {{filterType}}',
+            unsupportedDatetimeLevel: 'Фільтри не підтримують наступні рівні "datetime": Hours, MinutesRoundTo30, MinutesRoundTo15',
+            membersFilterNullMember: 'MembersFilter у {{attributeId}} - member не може бути нульовим',
+        },
+        unsupportedDimesionalElement: 'Непідтримуваний тип елемента',
+    },
+};

package/dist/translation/translatable-error.d.ts

@@ -0,0 +1,5 @@
+import { AbstractTranslatableError } from '@sisense/sdk-common';
+import { PACKAGE_NAMESPACE } from './resources/index.js';
+export declare class TranslatableError extends AbstractTranslatableError<typeof PACKAGE_NAMESPACE> {
+    constructor(translationKey: string, interpolationOptions?: Record<string, string>);
+}

package/dist/translation/translatable-error.js

@@ -0,0 +1,11 @@
+import { AbstractTranslatableError } from '@sisense/sdk-common';
+import { i18nextInstance } from './initialize-i18n.js';
+import { PACKAGE_NAMESPACE } from './resources/index.js';
+export class TranslatableError extends AbstractTranslatableError {
+    constructor(translationKey, interpolationOptions) {
+        super(PACKAGE_NAMESPACE, {
+            key: translationKey,
+            interpolationOptions: interpolationOptions,
+        }, i18nextInstance.t);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sisense/sdk-data",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
@@ -12,8 +12,10 @@
   "author": "Sisense ",
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@sisense/sdk-rest-client": "^0.14.0",
+    "@sisense/sdk-common": "^0.16.0",
+    "@sisense/sdk-rest-client": "^0.16.0",
     "guid-typescript": "^1.0.9",
+    "lodash": "^4.17.21",
     "numeral": "^2.0.6",
     "object-hash": "^3.0.0"
   },
@@ -37,6 +39,7 @@
   ],
   "devDependencies": {
     "@babel/preset-env": "^7.20.2",
+    "@types/lodash": "^4.14.201",
     "@types/numeral": "2.0.2",
     "@types/object-hash": "^3.0.5",
     "eslint": "^8.40.0",