@sisense/sdk-data 1.28.0 → 1.29.0

package/dist/cjs/utils.d.ts

@@ -1,7 +1,7 @@
 import { JaqlDataSource } from './dimensional-model/filters/utils/types.js';
-import { Attribute, Filter, FilterRelations, FilterRelationsJaql, SortDirection } from './dimensional-model/interfaces.js';
+import { Attribute, BaseMeasure, CalculatedMeasure, Filter, FilterRelations, FilterRelationsJaql, LevelAttribute, SortDirection } from './dimensional-model/interfaces.js';
 import { DataSource, DataSourceInfo } from './interfaces.js';
-import { FilterJaql, JaqlSortDirection, Sort } from './dimensional-model/types.js';
+import { FilterJaql, FormulaJaql, Jaql, JaqlSortDirection, Sort } from './dimensional-model/types.js';
 /**
  * A more performant, but slightly bulkier, RFC4122v4 implementation. Performance is improved by minimizing calls to random()
  *
@@ -80,3 +80,75 @@ export declare function getColumnNameFromAttribute(attribute: Attribute): string
  * @internal
  */
 export declare function getSortType(jaqlSort: `${JaqlSortDirection}` | undefined): SortDirection;
+/**
+ * Creates an attribute or level attribute from the provided parameters
+ * @returns attribute or level attribute
+ *
+ * @internal
+ */
+export declare const createAttributeHelper: ({ dim, table, column, dataType, level, format, sort, title, dataSource, }: {
+    /** Dimension expression */
+    dim: string;
+    /** Table name */
+    table: string | undefined;
+    /** Column name */
+    column: string | undefined;
+    /** Data type */
+    dataType: string;
+    /** Date level */
+    level: string | undefined;
+    /** Format */
+    format: string | undefined;
+    /** Sort */
+    sort: string | undefined;
+    /** Attribute title */
+    title?: string | undefined;
+    /** Jaql data source */
+    dataSource?: JaqlDataSource | undefined;
+}) => Attribute | LevelAttribute;
+/**
+ * Creates a measure from the provided parameters
+ *
+ * @returns measure
+ *
+ * @internal
+ */
+export declare const createMeasureHelper: ({ dim, table, column, dataType, agg, level, format, sort, title, dataSource, }: {
+    /** Dimension expression */
+    dim: string;
+    /** Table name */
+    table: string | undefined;
+    /** Column name */
+    column: string;
+    /** Data type */
+    dataType: string;
+    /** Aggregation function */
+    agg: string;
+    /** Date level */
+    level: string | undefined;
+    /** Format */
+    format: string | undefined;
+    /** Sort */
+    sort: string | undefined;
+    /** Measure title */
+    title?: string | undefined;
+    /** Jaql data source */
+    dataSource?: JaqlDataSource | undefined;
+}) => BaseMeasure;
+/**
+ * Creates a measure from the provided parameters
+ *
+ * @returns calculated measure
+ *
+ * @internal
+ */
+export declare const createCalculatedMeasureHelper: (jaql: FormulaJaql) => CalculatedMeasure;
+/**
+ * Creates a dimensional element from a JAQL object.
+ * @param jaql - The JAQL object.
+ * @param datetimeFormat - The datetime format.
+ * @returns The created dimensional element.
+ *
+ * @internal
+ */
+export declare function createDimensionalElementFromJaql(jaql: Jaql, datetimeFormat?: string): Attribute | BaseMeasure | CalculatedMeasure | Filter;

package/dist/cjs/utils.js

@@ -3,11 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSortType = exports.getColumnNameFromAttribute = exports.getTableNameFromAttribute = exports.createFilterFromJaql = exports.convertSort = exports.convertJaqlDataSource = exports.convertDataSource = exports.isDataSourceInfo = exports.getDataSourceName = exports.getFilterListAndRelationsJaql = exports.guidFast = void 0;
+exports.createDimensionalElementFromJaql = exports.createCalculatedMeasureHelper = exports.createMeasureHelper = exports.createAttributeHelper = exports.getSortType = exports.getColumnNameFromAttribute = exports.getTableNameFromAttribute = exports.createFilterFromJaql = exports.convertSort = exports.convertJaqlDataSource = exports.convertDataSource = exports.isDataSourceInfo = exports.getDataSourceName = exports.getFilterListAndRelationsJaql = exports.guidFast = void 0;
 const cloneDeep_js_1 = __importDefault(require("lodash-es/cloneDeep.js"));
-const index_js_1 = require("./index.js");
+const mapValues_js_1 = __importDefault(require("lodash-es/mapValues.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");
+const sdk_common_1 = require("@sisense/sdk-common");
+const measures_js_1 = require("./dimensional-model/measures/measures.js");
+const filters_js_1 = require("./dimensional-model/filters/filters.js");
+const attributes_js_1 = require("./dimensional-model/attributes.js");
+const simple_column_types_js_1 = require("./dimensional-model/simple-column-types.js");
 /**
  * A more performant, but slightly bulkier, RFC4122v4 implementation. Performance is improved by minimizing calls to random()
  *
@@ -63,7 +68,7 @@ const getFilterListAndRelationsJaql = (filterRelations) => {
         if (!node)
             return node;
         if (isFilter(node)) {
-            if ((0, index_js_1.isCascadingFilter)(node)) {
+            if ((0, filters_js_1.isCascadingFilter)(node)) {
                 return traverseCascade(node.filters);
             }
             filters.add(node);
@@ -232,3 +237,133 @@ function getSortType(jaqlSort) {
     }
 }
 exports.getSortType = getSortType;
+const DATA_MODEL_MODULE_NAME = 'DM';
+/**
+ * Creates an attribute or level attribute from the provided parameters
+ * @returns attribute or level attribute
+ *
+ * @internal
+ */
+const createAttributeHelper = ({ dim, table, column, dataType, level, format, sort, title, dataSource, }) => {
+    // if table is undefined, extract it from dim
+    const dimTable = table !== null && table !== void 0 ? table : parseExpression(dim).table;
+    // if column is undefined, extract it from dim
+    const dimColumn = column !== null && column !== void 0 ? column : parseExpression(dim).column;
+    const sortEnum = convertSort(sort);
+    const isDataTypeDatetime = dataType === types_js_1.DataType.DATETIME;
+    if (isDataTypeDatetime) {
+        const dateLevel = attributes_js_1.DimensionalLevelAttribute.translateJaqlToGranularity({ level });
+        const composeCode = (0, attributes_js_1.normalizeAttributeName)(dimTable, dimColumn, level, DATA_MODEL_MODULE_NAME);
+        const levelAttribute = new attributes_js_1.DimensionalLevelAttribute(title !== null && title !== void 0 ? title : dimColumn, dim, dateLevel, format || attributes_js_1.DimensionalLevelAttribute.getDefaultFormatForGranularity(dateLevel), undefined, sortEnum, dataSource, composeCode);
+        return levelAttribute;
+    }
+    const attributeType = !dataType || (0, simple_column_types_js_1.isNumber)(dataType) ? types_js_1.MetadataTypes.NumericAttribute : types_js_1.MetadataTypes.TextAttribute;
+    const composeCode = (0, attributes_js_1.normalizeAttributeName)(dimTable, dimColumn, undefined, DATA_MODEL_MODULE_NAME);
+    const attribute = new attributes_js_1.DimensionalAttribute(title !== null && title !== void 0 ? title : dimColumn, dim, attributeType, undefined, sortEnum, dataSource, composeCode);
+    return attribute;
+};
+exports.createAttributeHelper = createAttributeHelper;
+/**
+ * Creates a measure from the provided parameters
+ *
+ * @returns measure
+ *
+ * @internal
+ */
+const createMeasureHelper = ({ dim, table, column, dataType, agg, level, format, sort, title, dataSource, }) => {
+    const sortEnum = convertSort(sort);
+    const attribute = (0, exports.createAttributeHelper)({
+        dim,
+        table,
+        column,
+        dataType,
+        level,
+        format,
+        sort,
+        title,
+        dataSource,
+    });
+    const tranformedAgg = measures_js_1.DimensionalBaseMeasure.aggregationFromJAQL(agg);
+    const updatedTitle = title !== null && title !== void 0 ? title : `${tranformedAgg} ${column}`;
+    // currently, sort and format applied to attribute but not to measure
+    const composeCode = `measureFactory.${tranformedAgg}(${attribute.composeCode}, '${(0, sdk_common_1.escapeSingleQuotes)(updatedTitle)}')`;
+    const measure = new measures_js_1.DimensionalBaseMeasure(updatedTitle, attribute, tranformedAgg, undefined, undefined, sortEnum, composeCode);
+    return measure;
+};
+exports.createMeasureHelper = createMeasureHelper;
+const getContextComposeCode = (context) => {
+    return ('{' +
+        Object.entries(context).reduce((acc, [key, value]) => {
+            acc =
+                acc +
+                    `'${key.slice(1, -1)}': ${value && 'composeCode' in value ? value.composeCode : JSON.stringify(value)},`;
+            return acc;
+        }, '') +
+        '}');
+};
+/**
+ * Creates a measure from the provided parameters
+ *
+ * @returns calculated measure
+ *
+ * @internal
+ */
+const createCalculatedMeasureHelper = (jaql) => {
+    var _a;
+    const sortEnum = convertSort(jaql.sort);
+    const context = (0, mapValues_js_1.default)((_a = jaql.context) !== null && _a !== void 0 ? _a : {}, (jaqlContextValue) => {
+        if (typeof jaqlContextValue === 'string') {
+            return jaqlContextValue;
+        }
+        return jaqlContextValue && createDimensionalElementFromJaql(jaqlContextValue);
+    });
+    const composeCode = `measureFactory.customFormula('${(0, sdk_common_1.escapeSingleQuotes)(jaql.title)}', '${jaql.formula}', ${getContextComposeCode(context)})`;
+    return new measures_js_1.DimensionalCalculatedMeasure(jaql.title, jaql.formula, context, undefined, undefined, sortEnum, composeCode);
+};
+exports.createCalculatedMeasureHelper = createCalculatedMeasureHelper;
+/**
+ * Creates a dimensional element from a JAQL object.
+ * @param jaql - The JAQL object.
+ * @param datetimeFormat - The datetime format.
+ * @returns The created dimensional element.
+ *
+ * @internal
+ */
+function createDimensionalElementFromJaql(jaql, datetimeFormat) {
+    const isFilterJaql = 'filter' in jaql;
+    if (isFilterJaql) {
+        return (0, exports.createFilterFromJaql)(jaql);
+    }
+    const isFormulaJaql = 'formula' in jaql;
+    if (isFormulaJaql) {
+        return (0, exports.createCalculatedMeasureHelper)(jaql);
+    }
+    const dataSource = 'datasource' in jaql ? jaql.datasource : undefined;
+    const hasAggregation = !!jaql.agg;
+    if (hasAggregation) {
+        return (0, exports.createMeasureHelper)({
+            dim: jaql.dim,
+            table: jaql.table,
+            column: jaql.column,
+            dataType: jaql.datatype,
+            agg: jaql.agg || '',
+            level: jaql.level,
+            format: datetimeFormat,
+            sort: jaql.sort,
+            title: jaql.title,
+            dataSource,
+        });
+    }
+    return (0, exports.createAttributeHelper)({
+        dim: jaql.dim,
+        table: jaql.table,
+        column: jaql.column,
+        dataType: jaql.datatype,
+        level: jaql.level,
+        format: datetimeFormat,
+        sort: jaql.sort,
+        title: jaql.title,
+        dataSource,
+    });
+}
+exports.createDimensionalElementFromJaql = createDimensionalElementFromJaql;

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

@@ -11,7 +11,7 @@ export declare const jaqlSimpleColumnType: (datatype: string) => string;
 export declare class DimensionalAttribute extends DimensionalElement implements Attribute {
     readonly expression: string;
     protected _sort: Sort;
-    constructor(name: string, expression: string, type?: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource);
+    constructor(name: string, expression: string, type?: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource, composeCode?: string);
     /**
      * gets the element's ID
      */
@@ -46,7 +46,7 @@ export declare class DimensionalAttribute extends DimensionalElement implements
 export declare class DimensionalLevelAttribute extends DimensionalAttribute implements LevelAttribute {
     private _format;
     readonly granularity: string;
-    constructor(l: string, expression: string, granularity: string, format?: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource);
+    constructor(l: string, expression: string, granularity: string, format?: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource, composeCode?: string);
     /**
      * gets the element's ID
      */

package/dist/dimensional-model/attributes.js

@@ -9,8 +9,8 @@ export const jaqlSimpleColumnType = (datatype) => simpleColumnType(datatype).rep
  * @internal
  */
 export class DimensionalAttribute extends DimensionalElement {
-    constructor(name, expression, type, desc, sort, dataSource) {
-        super(name, type || MetadataTypes.Attribute, desc, dataSource);
+    constructor(name, expression, type, desc, sort, dataSource, composeCode) {
+        super(name, type || MetadataTypes.Attribute, desc, dataSource, composeCode);
         this._sort = Sort.None;
         this.expression = expression;
         this._sort = sort || Sort.None;
@@ -36,7 +36,7 @@ export class DimensionalAttribute extends DimensionalElement {
      * @returns An instance representing the sorted {@link Attribute} of this instance
      */
     sort(sort) {
-        return new DimensionalAttribute(this.name, this.expression, this.type, this.description, sort, this.dataSource);
+        return new DimensionalAttribute(this.name, this.expression, this.type, this.description, sort, this.dataSource, this.composeCode);
     }
     /**
      * Gets the JAQL representation of this instance
@@ -72,8 +72,8 @@ export class DimensionalAttribute extends DimensionalElement {
  * @internal
  */
 export class DimensionalLevelAttribute extends DimensionalAttribute {
-    constructor(l, expression, granularity, format, desc, sort, dataSource) {
-        super(l, expression, MetadataTypes.DateLevel, desc, sort, dataSource);
+    constructor(l, expression, granularity, format, desc, sort, dataSource, composeCode) {
+        super(l, expression, MetadataTypes.DateLevel, desc, sort, dataSource, composeCode);
         this._format = format;
         this.granularity = granularity;
     }
@@ -104,7 +104,7 @@ export class DimensionalLevelAttribute extends DimensionalAttribute {
      * @returns An instance representing the sorted {@link LevelAttribute} of this instance
      */
     sort(sort) {
-        return new DimensionalLevelAttribute(this.name, this.expression, this.granularity, this._format, this.description, sort, this.dataSource);
+        return new DimensionalLevelAttribute(this.name, this.expression, this.granularity, this._format, this.description, sort, this.dataSource, this.composeCode);
     }
     /**
      * The string formatting of this instance
@@ -121,7 +121,7 @@ export class DimensionalLevelAttribute extends DimensionalAttribute {
      * @returns An instance representing the formatted {@link LevelAttribute} of this instance
      */
     format(format) {
-        return new DimensionalLevelAttribute(this.name, this.expression, this.granularity, format, this.description, this._sort, this.dataSource);
+        return new DimensionalLevelAttribute(this.name, this.expression, this.granularity, format, this.description, this._sort, this.dataSource, this.composeCode);
     }
     /**
      * Gets a serializable representation of the element

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

@@ -21,7 +21,7 @@ export declare abstract class DimensionalElement implements Element {
      * Defines the element's data source
      */
     get dataSource(): JaqlDataSource;
-    constructor(name: string, type: string, desc?: string, dataSource?: JaqlDataSource);
+    constructor(name: string, type: string, desc?: string, dataSource?: JaqlDataSource, composeCode?: string);
     /**
      * gets the element's description
      */
@@ -34,6 +34,12 @@ export declare abstract class DimensionalElement implements Element {
      * gets the element's ID
      */
     abstract get id(): string;
+    /**
+     * Optional CSDK code to initialize this element
+     *
+     * @internal
+     */
+    composeCode?: string;
     /**
      * Gets a serializable representation of the element
      */

package/dist/dimensional-model/base.js

@@ -2,13 +2,14 @@
  * @internal
  */
 export class DimensionalElement {
-    constructor(name, type, desc, dataSource) {
+    constructor(name, type, desc, dataSource, composeCode) {
         this._name = name;
         this.type = type;
         this.description = desc || '';
         if (dataSource) {
             this._dataSource = dataSource;
         }
+        this.composeCode = composeCode;
     }
     /**
      * Defines the element's name

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

@@ -1,16 +1,19 @@
 import { BaseFilterConfig, CompleteBaseFilterConfig, CompleteMembersFilterConfig, MembersFilterConfig } from '../interfaces.js';
 /**
  * Returns a default configuration for a base filter.
+ *
  * @internal
  */
 export declare const getDefaultBaseFilterConfig: () => CompleteBaseFilterConfig;
 /**
  * Returns a default configuration for a members filter.
+ *
  * @internal
  */
 export declare const getDefaultMembersFilterConfig: () => CompleteMembersFilterConfig;
 /**
  * Checks whether the given configuration is a members filter configuration.
+ *
  * @param config - The filter configuration.
  * @returns Whether the configuration is a members filter configuration.
  * @internal
@@ -18,6 +21,7 @@ export declare const getDefaultMembersFilterConfig: () => CompleteMembersFilterC
 export declare function isMembersFilterConfig(config: BaseFilterConfig | MembersFilterConfig): config is MembersFilterConfig;
 /**
  * Simplifies the filter configuration by removing default values.
+ *
  * @param config - The filter configuration.
  * @returns The simplified filter configuration.
  * @internal

package/dist/dimensional-model/filters/filter-config-utils.js

@@ -2,6 +2,7 @@ import isEqual from 'lodash-es/isEqual.js';
 import { guidFast } from '../../utils.js';
 /**
  * Returns a default configuration for a base filter.
+ *
  * @internal
  */
 export const getDefaultBaseFilterConfig = () => ({
@@ -11,11 +12,13 @@ export const getDefaultBaseFilterConfig = () => ({
 });
 /**
  * Returns a default configuration for a members filter.
+ *
  * @internal
  */
 export const getDefaultMembersFilterConfig = () => (Object.assign(Object.assign({}, getDefaultBaseFilterConfig()), { excludeMembers: false, enableMultiSelection: true, deactivatedMembers: [] }));
 /**
  * Checks whether the given configuration is a members filter configuration.
+ *
  * @param config - The filter configuration.
  * @returns Whether the configuration is a members filter configuration.
  * @internal
@@ -25,6 +28,7 @@ export function isMembersFilterConfig(config) {
 }
 /**
  * Simplifies the filter configuration by removing default values.
+ *
  * @param config - The filter configuration.
  * @returns The simplified filter configuration.
  * @internal
@@ -34,6 +38,5 @@ export const simplifyFilterConfig = (config) => {
         ? getDefaultMembersFilterConfig()
         : getDefaultBaseFilterConfig();
     // Filter out properties that match their default values
-    const simplifiedConfig = Object.fromEntries(Object.entries(config).filter(([key, value]) => !isEqual(value, defaultConfig[key])));
-    return simplifiedConfig;
+    return Object.fromEntries(Object.entries(config).filter(([key, value]) => !isEqual(value, defaultConfig[key])));
 };

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

@@ -0,0 +1,187 @@
+import { Filter, FilterRelations, FilterRelationsJaql, FilterRelationsModel, FilterRelationsModelNode } from '../../index.js';
+/**
+ * Type guard for checking if the provided filters are FilterRelations.
+ *
+ * @param filters - The filters to check.
+ * @returns `true` if the filters are FilterRelations, `false` otherwise.
+ * @group Filter Utilities
+ */
+export declare function isFilterRelations(filters: Filter[] | FilterRelations | undefined): filters is FilterRelations;
+/**
+ * Rules of filter relations - logical operators of how filters are related to each other.
+ *
+ * @internal
+ *
+ */
+export declare type FilterRelationsRules = FilterRelationsRule | FilterRelationsRuleNode | null;
+/** @internal */
+export declare type FilterRelationsRule = {
+    left: FilterRelationsRuleNode;
+    right: FilterRelationsRuleNode;
+    operator: 'AND' | 'OR';
+};
+/** @internal */
+export declare type FilterRelationsRuleIdNode = {
+    instanceid: string;
+};
+/** @internal */
+export declare type FilterRelationsRuleNode = FilterRelationsRule | FilterRelationsRuleIdNode;
+/**
+ * Filter action types
+ *
+ * @internal
+ */
+export declare type FilterAction = {
+    type: 'add';
+    payload: Filter;
+} | {
+    type: 'remove';
+    payload: Filter;
+};
+/**
+ * Merges source filters with target filters and recalculates relations.
+ *
+ * @param sourceFilters - The source filters or filter relations to merge.
+ * @param targetFilters - The target filters or filter relations to merge with.
+ * @returns Updated source filters merged with target filters. If the source filters are FilterRelations, the relations are recalculated.
+ * @internal
+ */
+export declare function mergeFiltersOrFilterRelations(sourceFilters?: Filter[] | FilterRelations, targetFilters?: Filter[] | FilterRelations): Filter[] | FilterRelations;
+/**
+ * Splits filters or filter relations into filters and relations rules.
+ * @internal
+ */
+export declare function splitFiltersAndRelations(filtersOrFilterRelations: Filter[] | FilterRelations | undefined): {
+    filters: Filter[];
+    relations: FilterRelationsRules;
+};
+/**
+ * Returns pure filters array from the given filters or filter relations.
+ * @internal
+ */
+export declare function getFiltersArray(filtersOrFilterRelations: Filter[] | FilterRelations | undefined): Filter[];
+/**
+ * Combines filters and relations into a single FilterRelations object.
+ * If the relations are empty or relations are trivial (single node), the filters are returned as is.
+ * @internal
+ */
+export declare function combineFiltersAndRelations(filters: Filter[], relations: FilterRelationsRules): Filter[] | FilterRelations;
+/** Type guard for checking if a node is a single relations node (trivial case when relations are needless).
+ * @internal
+ */
+export declare function isTrivialSingleNodeRelations(relations: FilterRelationsRules): relations is FilterRelationsRuleIdNode;
+/**
+ * Calculates new relations based on the changes in filters.
+ * @internal
+ */
+export declare function calculateNewRelations(prevFilters: Filter[], prevRelations: FilterRelationsRules, newFilters: Filter[]): FilterRelationsRules;
+/**
+ * Replaces a filter in the relations tree with a new filter.
+ * @internal
+ */
+export declare function getRelationsWithReplacedFilter(relations: FilterRelationsRules, filterToReplace: Filter, newFilter: Filter): FilterRelationsRules;
+/**
+ * Converts filter relations model from Fusion to internal CSDK filter relations rules.
+ * @internal
+ */
+export declare function convertFilterRelationsModelToRelationRules(filterRelationsModel: FilterRelationsModel | FilterRelationsModelNode | undefined, filters: Filter[]): FilterRelationsRules;
+/**
+ * @internal
+ */
+export declare function isRelationsRuleIdNode(node: FilterRelationsRuleNode): node is FilterRelationsRuleIdNode;
+/**
+ * @internal
+ */
+export declare function isRelationsRule(node: FilterRelationsRuleNode): node is FilterRelationsRule;
+/**
+ * Converts internal CSDK filter relations rules to filter relations model for Fusion.
+ * @internal
+ */
+export declare function filterRelationRulesToFilterRelationsModel(filterRelationRules: FilterRelationsRules, filters: Filter[]): FilterRelationsModel | FilterRelationsModelNode | undefined;
+/**
+ * @internal
+ */
+export declare function findFilterByGuid(filters: Filter[], guid: string): Filter | undefined;
+/**
+ * Error thrown when an unknown node type is encountered in filter relations.
+ * @internal
+ */
+export declare class UnknownRelationsNodeError extends Error {
+    constructor();
+}
+/** @internal */
+export declare type FilterRelationsDescription = FilterRelationsDescriptionNode[];
+/** @internal */
+export declare type FilterRelationsDescriptionNode = OpenBracketDescriptionNode | CloseBracketDescriptionNode | AttributeDescriptionNode | OperatorDescriptionNode;
+/** @internal */
+export declare type OpenBracketDescriptionNode = {
+    nodeType: 'openBracket';
+};
+/**
+ * @internal
+ */
+export declare function isOpenBracketDescriptionNode(node: FilterRelationsDescriptionNode): node is OpenBracketDescriptionNode;
+/** @internal */
+export declare type CloseBracketDescriptionNode = {
+    nodeType: 'closeBracket';
+};
+/**
+ * @internal
+ */
+export declare function isCloseBracketDescriptionNode(node: FilterRelationsDescriptionNode): node is CloseBracketDescriptionNode;
+/** @internal */
+export declare type AttributeDescriptionNode = {
+    nodeType: 'attribute';
+    attribute: string;
+};
+/**
+ * @internal
+ */
+export declare function isAttributeDescriptionNode(node: FilterRelationsDescriptionNode): node is AttributeDescriptionNode;
+/** @internal */
+export declare type OperatorDescriptionNode = {
+    nodeType: 'operator';
+    operator: 'AND' | 'OR';
+};
+/**
+ * @internal
+ */
+export declare function isOperatorDescriptionNode(node: FilterRelationsDescriptionNode): node is OperatorDescriptionNode;
+/**
+ * Gets a unique identifier for a filter, combining its attribute expression and granularity if available.
+ *
+ * @param {Filter} filter - The filter object to generate the unique identifier for.
+ * @returns {string} - The unique identifier for the filter.
+ * @internal
+ */
+export declare function getFilterCompareId(filter: Filter): string;
+/**
+ * Merges two arrays of filter objects, prioritizing 'targetFilters' over 'sourceFilters',
+ * and removes duplicates based on filter compare id.
+ *
+ * Saves the 'sourceFilters' filters order, while adds new filters to the end of the array.
+ *
+ * @param {Filter[]} [sourceFilters=[]] - The source array of filter objects.
+ * @param {Filter[]} [targetFilters=[]] - The target array of filter objects.
+ * @returns {Filter[]} - The merged array of filter objects.
+ * @internal
+ */
+export declare function mergeFilters(sourceFilters?: Filter[], targetFilters?: Filter[]): Filter[];
+/**
+ * Replaces nodes of filter reations tree with fetched filters by instance id.
+ *
+ * @param filters - The filters.
+ * @param highlights - The highlights
+ * @param filterRelations - Fetched filter relations.
+ * @returns Filter relations with filters in nodes.
+ * @internal
+ */
+export declare function getFilterRelationsFromJaql(filters: Filter[], highlights: Filter[], filterRelations: FilterRelationsJaql | undefined): FilterRelations | Filter[];
+/**
+ * Converts filter relations model to filter relations jaql.
+ *
+ * @param filterRelations - Filter relations model.
+ * @returns Filter relations jaql.
+ * @internal
+ */
+export declare function convertFilterRelationsModelToJaql(filterRelations: FilterRelationsModel | FilterRelationsModelNode | undefined): FilterRelationsJaql | undefined;