@sisense/sdk-data 1.24.0 → 1.26.0

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

@@ -1,13 +1,17 @@
 /**
- * Stringifies the argument
+ * Stringifies the argument, with an option to exclude specific properties.
  *
- * @param arg - argument to stringify
- * @returns stringified argument
+ * @param arg - The argument to stringify.
+ * @param excludeProps - Optional array of property names to exclude when stringifying objects.
+ * @returns The stringified representation of the argument.
  */
-export declare function stringifyHelper(arg: any): string;
+export declare function stringifyHelper(arg: any, excludeProps?: string[]): string;
 /**
  * High order function to construct compose code for filter factory functions
  *
  * @param func - filter factory function
+ * @param funcName - name of the filter factory function. Needed if the function name is minified.
+ * @param ignoreIndexes - Indexes of parameters to ignore in the generated composeCode
+ * @returns filter factory function with composeCode property added to the filter
  */
-export declare function withComposeCode(func: (...args: any[]) => any): (...args: any[]) => any;
+export declare function withComposeCode<T extends (...args: any[]) => any>(func: T, funcName?: string, ignoreIndexes?: number[]): T;

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

@@ -1,10 +1,11 @@
 /**
- * Stringifies the argument
+ * Stringifies the argument, with an option to exclude specific properties.
  *
- * @param arg - argument to stringify
- * @returns stringified argument
+ * @param arg - The argument to stringify.
+ * @param excludeProps - Optional array of property names to exclude when stringifying objects.
+ * @returns The stringified representation of the argument.
  */
-export function stringifyHelper(arg) {
+export function stringifyHelper(arg, excludeProps = []) {
     try {
         if (arg === null || arg === undefined) {
             return JSON.stringify(arg);
@@ -16,7 +17,7 @@ export function stringifyHelper(arg) {
             return ('[' +
                 arg
                     .map((e) => {
-                    return stringifyHelper(e);
+                    return stringifyHelper(e, excludeProps);
                 })
                     .join(', ') +
                 ']');
@@ -27,6 +28,19 @@ export function stringifyHelper(arg) {
         if (typeof arg === 'number' || !isNaN(arg)) {
             return arg;
         }
+        if (typeof arg === 'object') {
+            const filteredObject = Object.keys(arg)
+                .filter((key) => !excludeProps.includes(key))
+                .reduce((acc, key) => {
+                acc[key] = arg[key];
+                return acc;
+            }, {});
+            // Check if the filtered object is empty
+            if (Object.keys(filteredObject).length === 0) {
+                return '';
+            }
+            return JSON.stringify(filteredObject);
+        }
     }
     catch (e) {
         console.error(e);
@@ -37,16 +51,26 @@ export function stringifyHelper(arg) {
  * High order function to construct compose code for filter factory functions
  *
  * @param func - filter factory function
+ * @param funcName - name of the filter factory function. Needed if the function name is minified.
+ * @param ignoreIndexes - Indexes of parameters to ignore in the generated composeCode
+ * @returns filter factory function with composeCode property added to the filter
  */
-export function withComposeCode(func) {
+export function withComposeCode(func, funcName, ignoreIndexes = []) {
     return function (...args) {
         const argValues = args
-            .map(stringifyHelper)
+            .map((arg, index) => {
+            if (ignoreIndexes.includes(index)) {
+                return ''; // Placeholder for ignored parameters
+            }
+            return stringifyHelper(arg, ['guid']);
+        })
             .join(', ')
             // remove any number of trailing commas
             .replace(/(,\s*)+$/, '');
-        const signature = `filterFactory.${func.name}(${argValues})`;
+        const signature = `filterFactory.${funcName !== null && funcName !== void 0 ? funcName : func.name}(${argValues})`;
+        // Call the original function and get the filter
         const filter = func(...args);
+        // Add the composeCode property
         filter.composeCode = signature;
         return filter;
     };

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

@@ -1,5 +1,5 @@
-import { BaseFilterJaql, ConditionFilterJaql, FilterJaqlInternal, PeriodFilterJaql, RangeFilterJaql, SpecificItemsFilterJaql } from './types.js';
-import { Attribute, BaseMeasure, Filter, LevelAttribute } from '../../interfaces.js';
+import { BaseFilterJaql, FilterJaqlInternal, PeriodFilterJaql, RangeFilterJaql, SpecificItemsFilterJaql } from './types.js';
+import { Attribute, Filter, LevelAttribute } from '../../interfaces.js';
 import { FilterJaql } from '../../types.js';
 /**
  * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
@@ -8,75 +8,65 @@ import { FilterJaql } from '../../types.js';
  * @param guid - Optional GUID for the filter
  * @returns A generic Filter object.
  */
-export declare const createGenericFilter: (jaql: FilterJaql | FilterJaqlInternal, guid?: string) => Filter;
+export declare const createGenericFilter: (jaql: FilterJaql | FilterJaqlInternal, guid: string) => Filter;
 /**
  * Creates a filter that includes all members of the attribute.
  *
  * @param attribute - The attribute.
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns The created Filter object.
  */
-export declare const createFilterIncludeAll: (attribute: Attribute, guid?: string) => Filter;
+export declare const createFilterIncludeAll: (attribute: Attribute, guid: string) => Filter;
 /**
  * Creates a filter from a specific items filter JAQL object.
  *
  * @param attribute - attribute
  * @param specificItemsFilterJaql - Specific Items Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromSpecificItemsFilterJaql: (attribute: Attribute, specificItemsFilterJaql: SpecificItemsFilterJaql, guid?: string, multiSelection?: boolean) => Filter;
+export declare const createFilterFromSpecificItemsFilterJaql: (attribute: Attribute, specificItemsFilterJaql: SpecificItemsFilterJaql, guid: string, multiSelection?: boolean) => Filter;
 /**
  * Creates a filter from a date range filter JAQL object.
  *
  * @param attribute - attribute
  * @param rangeFilterJaql - Range Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromDateRangeFilterJaql: (attribute: LevelAttribute, rangeFilterJaql: RangeFilterJaql, guid?: string) => Filter;
+export declare const createFilterFromDateRangeFilterJaql: (attribute: LevelAttribute, rangeFilterJaql: RangeFilterJaql, guid: string) => Filter;
 /**
  * Creates a filter from a numeric range filter JAQL object.
  *
  * @param attribute - attribute
  * @param rangeFilterJaql - Range Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromNumericRangeJaql: (attribute: Attribute, rangeFilterJaql: RangeFilterJaql, guid?: string) => Filter;
+export declare const createFilterFromNumericRangeJaql: (attribute: Attribute, rangeFilterJaql: RangeFilterJaql, guid: string) => Filter;
 /**
  * Creates a filter from a period filter JAQL object.
  *
  * @param attribute - attribute
  * @param periodFilterJaql - Period Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromPeriodFilterJaql: (attribute: LevelAttribute, periodFilterJaql: PeriodFilterJaql, guid?: string) => Filter;
-/**
- * Creates a filter from a condition filter JAQL object.
- *
- * @param attribute - attribute
- * @param conditionFilterJaql - Condition Filter Jaql
- * @param measure - measure
- * @param guid - Optional GUID for the filter
- * @returns Filter object
- */
-export declare const createFilterFromConditionFilterJaql: (attribute: Attribute, conditionFilterJaql: ConditionFilterJaql, measure?: BaseMeasure, guid?: string) => Filter;
+export declare const createFilterFromPeriodFilterJaql: (attribute: LevelAttribute, periodFilterJaql: PeriodFilterJaql, guid: string) => Filter;
 /**
  * Creates a filter from a custom filter JAQL object.
  *
  * @param attribute - attribute
  * @param customFilterJaql - Custom Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
-export declare const createFilterFromCustomFilterJaql: (attribute: Attribute, customFilterJaql: BaseFilterJaql, guid?: string) => Filter;
+export declare const createFilterFromCustomFilterJaql: (attribute: Attribute, customFilterJaql: BaseFilterJaql, guid: string) => Filter;
 /**
  * Creates a filter from a filter JAQL object.
  *
  * @param jaql - The filter JAQL object.
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object.
  */
-export declare const createFilterFromJaqlInternal: (jaql: FilterJaqlInternal, guid?: string) => Filter;
+export declare const createFilterFromJaqlInternal: (jaql: FilterJaqlInternal, guid: string) => Filter;

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

@@ -4,8 +4,8 @@ import { createAttributeFilterFromConditionFilterJaql, createMeasureFilterFromCo
 import { extractFilterTypeFromFilterJaql } from './filter-types-util.js';
 import { withComposeCode } from './filter-code-util.js';
 import { createAttributeFromFilterJaql, createMeasureFromFilterJaql, } from './attribute-measure-util.js';
-import { guidFast } from '../../../utils.js';
 import { TranslatableError } from '../../../translation/translatable-error.js';
+import { getDefaultBaseFilterConfig, simplifyFilterConfig } from '../filter-config-utils.js';
 /**
  * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
  *
@@ -15,7 +15,7 @@ import { TranslatableError } from '../../../translation/translatable-error.js';
  */
 export const createGenericFilter = (jaql, guid) => {
     return {
-        guid: guid || guidFast(13),
+        config: Object.assign(Object.assign({}, getDefaultBaseFilterConfig()), { guid, originalFilterJaql: jaql }),
         jaql: (nested) => {
             if (nested) {
                 return jaql;
@@ -41,31 +41,40 @@ export const createGenericFilter = (jaql, guid) => {
  * Creates a filter that includes all members of the attribute.
  *
  * @param attribute - The attribute.
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns The created Filter object.
  */
 export const createFilterIncludeAll = (attribute, guid) => {
     // including all members is equivalent to excluding none
     // so we can simply create a filter with no members and excludeMembers set to true
-    return withComposeCode(filterFactory.members)(attribute, [], true, guid);
+    const config = {
+        guid,
+        excludeMembers: true,
+    };
+    return withComposeCode(filterFactory.members, 'members')(attribute, [], config);
 };
 /**
  * Creates a filter from a specific items filter JAQL object.
  *
  * @param attribute - attribute
  * @param specificItemsFilterJaql - Specific Items Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
 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, undefined, multiSelection);
+    const config = simplifyFilterConfig({
+        guid,
+        excludeMembers: false,
+        enableMultiSelection: multiSelection !== null && multiSelection !== void 0 ? multiSelection : true,
+        deactivatedMembers,
+    });
+    return withComposeCode(filterFactory.members, 'members')(attribute, activeMembers, config);
 };
 function getDeactivatedMembersFromFilterJaql(filterJaql) {
-    var _a, _b, _c;
-    return ((_a = filterJaql.filter) === null || _a === void 0 ? void 0 : _a.turnedOff) ? (_c = (_b = filterJaql.filter) === null || _b === void 0 ? void 0 : _b.exclude) === null || _c === void 0 ? void 0 : _c.members : undefined;
+    var _a, _b, _c, _d;
+    return ((_a = filterJaql.filter) === null || _a === void 0 ? void 0 : _a.turnedOff) ? (_d = (_c = (_b = filterJaql.filter) === null || _b === void 0 ? void 0 : _b.exclude) === null || _c === void 0 ? void 0 : _c.members) !== null && _d !== void 0 ? _d : [] : [];
 }
 function getActiveMembersFromFilterJaql(filterJaql, deactivatedMembers) {
     const allMembers = filterJaql.members;
@@ -78,54 +87,37 @@ function getActiveMembersFromFilterJaql(filterJaql, deactivatedMembers) {
  *
  * @param attribute - attribute
  * @param rangeFilterJaql - Range Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
 export const createFilterFromDateRangeFilterJaql = (attribute, rangeFilterJaql, guid) => {
-    return withComposeCode(filterFactory.dateRange)(attribute, rangeFilterJaql.from, rangeFilterJaql.to, guid);
+    return withComposeCode(filterFactory.dateRange, 'dateRange')(attribute, rangeFilterJaql.from, rangeFilterJaql.to, { guid });
 };
 /**
  * Creates a filter from a numeric range filter JAQL object.
  *
  * @param attribute - attribute
  * @param rangeFilterJaql - Range Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
 export const createFilterFromNumericRangeJaql = (attribute, rangeFilterJaql, guid) => {
-    return withComposeCode(filterFactory.between)(attribute, rangeFilterJaql.from, rangeFilterJaql.to, guid);
+    return withComposeCode(filterFactory.between, 'between')(attribute, rangeFilterJaql.from, rangeFilterJaql.to, { guid });
 };
 /**
  * Creates a filter from a period filter JAQL object.
  *
  * @param attribute - attribute
  * @param periodFilterJaql - Period Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
 export const createFilterFromPeriodFilterJaql = (attribute, periodFilterJaql, guid) => {
     if (periodFilterJaql.last) {
-        return withComposeCode(filterFactory.dateRelativeTo)(attribute, periodFilterJaql.last.offset, periodFilterJaql.last.count, periodFilterJaql.last.anchor, guid);
-    }
-    else {
-        return withComposeCode(filterFactory.dateRelativeFrom)(attribute, periodFilterJaql.next.offset, periodFilterJaql.next.count, periodFilterJaql.next.anchor, guid);
-    }
-};
-/**
- * Creates a filter from a condition filter JAQL object.
- *
- * @param attribute - attribute
- * @param conditionFilterJaql - Condition Filter Jaql
- * @param measure - measure
- * @param guid - Optional GUID for the filter
- * @returns Filter object
- */
-export const createFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, measure, guid) => {
-    if (measure) {
-        return createMeasureFilterFromConditionFilterJaql(measure, conditionFilterJaql, guid);
+        return withComposeCode(filterFactory.dateRelativeTo, 'dateRelativeTo')(attribute, periodFilterJaql.last.offset, periodFilterJaql.last.count, periodFilterJaql.last.anchor, { guid });
     }
     else {
-        return createAttributeFilterFromConditionFilterJaql(attribute, conditionFilterJaql, guid);
+        return withComposeCode(filterFactory.dateRelativeFrom, 'dateRelativeFrom')(attribute, periodFilterJaql.next.offset, periodFilterJaql.next.count, periodFilterJaql.next.anchor, { guid });
     }
 };
 /**
@@ -133,17 +125,19 @@ export const createFilterFromConditionFilterJaql = (attribute, conditionFilterJa
  *
  * @param attribute - attribute
  * @param customFilterJaql - Custom Filter Jaql
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object
  */
 export const createFilterFromCustomFilterJaql = (attribute, customFilterJaql, guid) => {
-    return withComposeCode(filterFactory.customFilter)(attribute, customFilterJaql, guid);
+    return withComposeCode(filterFactory.customFilter, 'customFilter')(attribute, customFilterJaql, {
+        guid,
+    });
 };
 /**
  * Creates a filter from a filter JAQL object.
  *
  * @param jaql - The filter JAQL object.
- * @param guid - Optional GUID for the filter
+ * @param guid - GUID for the filter
  * @returns Filter object.
  */
 export const createFilterFromJaqlInternal = (jaql, guid) => {
@@ -165,7 +159,12 @@ export const createFilterFromJaqlInternal = (jaql, guid) => {
             case FILTER_TYPES.SPECIFIC_ITEMS:
                 return createFilterFromSpecificItemsFilterJaql(attribute, filterJaqlWithType, guid, filterJaqlWithType.multiSelection);
             case FILTER_TYPES.CONDITION:
-                return createFilterFromConditionFilterJaql(attribute, filterJaqlWithType, measure, guid);
+                if (measure) {
+                    return createMeasureFilterFromConditionFilterJaql(measure, filterJaqlWithType, guid);
+                }
+                else {
+                    return createAttributeFilterFromConditionFilterJaql(attribute, filterJaqlWithType, guid);
+                }
             case FILTER_TYPES.DATE_RANGE:
                 return createFilterFromDateRangeFilterJaql(attribute, filterJaqlWithType, guid);
             case FILTER_TYPES.PERIOD:

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

@@ -1,5 +1,5 @@
 import { DataSource } from '../interfaces.js';
-import { JaqlDataSource, Sort } from './types.js';
+import { FilterJaql, JaqlDataSource, Sort } from './types.js';
 /**
  * @internal
  */
@@ -339,15 +339,106 @@ export interface LevelAttribute extends Attribute {
     };
 }
 /**
- * Base interface for filter. See {@link filterFactory} for how to create filters.
+ * Base filter configuration
  */
-export interface Filter extends Element {
+export interface BaseFilterConfig {
+    /**
+     * Optional filter identifier
+     *
+     * If not provided, a unique identifier will be generated.
+     *
+     * @category Base Configurations
+     */
+    readonly guid?: string;
+    /**
+     * Original filter JAQL
+     *
+     * @category Base Configurations
+     * @internal
+     */
+    originalFilterJaql?: FilterJaql;
+    /**
+     * Boolean flag whether the filter is disabled
+     *
+     * If not specified, the default value is `false`.
+     *
+     * @category Base Configurations
+     */
+    disabled?: boolean;
+    /**
+     * Boolean flag whether the filter is locked
+     *
+     * If not specified, the default value is `false`.
+     *
+     * @category Base Configurations
+     */
+    locked?: boolean;
+}
+/**
+ * Complete configuration for base filter
+ *
+ * All properties are required except for originalFilterJaql
+ *
+ * @internal
+ */
+export declare type CompleteBaseFilterConfig = Required<Omit<BaseFilterConfig, 'originalFilterJaql'>> & {
+    originalFilterJaql?: FilterJaql;
+};
+/**
+ * Configurations for members filter
+ */
+export interface MembersFilterConfig extends BaseFilterConfig {
+    /**
+     * Boolean flag whether selected members are excluded or included in the filter
+     *
+     * If not specified, the default value is false.
+     *
+     * @category Extended Configurations
+     */
+    excludeMembers?: boolean;
+    /**
+     * Boolean flag whether selection of multiple members is enabled
+     *
+     * If not specified, the default value is `true`.
+     *
+     * @category Extended Configurations
+     */
+    enableMultiSelection?: boolean;
     /**
-     * Global filter identifier
+     * Optional list of members to be shown as deactivated in the `MemberFilterTile` component.
+     *
+     * This list should not contain members that are already included in the filter.
+     *
+     * @category Extended Configurations
      */
-    readonly guid: string;
+    deactivatedMembers?: string[];
+    /**
+     * Optional filter to be applied in the background
+     */
+    backgroundFilter?: Filter;
+}
+/**
+ * Complete configuration for members filter
+ *
+ * All properties are required except for originalFilterJaql and backgroundFilter
+ *
+ * @internal
+ */
+export declare type CompleteMembersFilterConfig = Required<Omit<MembersFilterConfig, 'originalFilterJaql' | 'backgroundFilter'>> & {
+    originalFilterJaql?: FilterJaql;
+    backgroundFilter?: Filter;
+};
+/**
+ * @internal
+ */
+export declare type FilterConfig = CompleteBaseFilterConfig | CompleteMembersFilterConfig;
+/**
+ * Base interface for filter. See {@link filterFactory} for how to create filters.
+ */
+export interface Filter extends Element {
     /**
      * Attribute this filter instance is filtering
+     * @internal
      */
     readonly attribute: Attribute;
     /**
@@ -356,20 +447,15 @@ export interface Filter extends Element {
     readonly filterType: string;
     /**
      * Boolean flag whether the filter is a scope filter
-     */
-    isScope: boolean;
-    /**
-     * Boolean flag whether the filter is disabled
-     *
      * @internal
      */
-    disabled: boolean;
+    isScope: boolean;
     /**
-     * Boolean flag whether the filter is locked
+     * Filter config
      *
      * @internal
      */
-    locked: boolean;
+    config: FilterConfig;
     /**
      * Gets JAQL representing this Filter instance
      *
@@ -436,7 +522,7 @@ export declare type FilterRelationsNode = Filter | Filter[] | FilterRelations;
  *
  * @internal
  */
-export declare type FilterRelationsModelNode = FilterRelationsModelIdNode | FilterRelationsModelBracketNode | FilterRelationsModel;
+export declare type FilterRelationsModelNode = FilterRelationsModelIdNode | FilterRelationsModelCascadeNode | FilterRelationsModelBracketNode | FilterRelationsModel;
 /**
  * A node or a subtree of a {@link FilterRelationsJaql} tree
  *
@@ -456,11 +542,12 @@ export interface FilterRelations {
     operator: 'AND' | 'OR';
 }
 /**
- * Incoming filter logical relations (AND/OR) when fetched from the instance
+ * Model of filter logical relations (AND/OR) from Fusion dashboard
  *
  * @internal
  */
 export interface FilterRelationsModel {
+    type: 'LogicalExpression';
     left: FilterRelationsModelNode;
     right: FilterRelationsModelNode;
     operator: 'AND' | 'OR';
@@ -489,6 +576,7 @@ export declare type FilterRelationsJaqlIdNode = {
  * @internal
  */
 export declare type FilterRelationsModelIdNode = {
+    type: 'Identifier';
     instanceId: string;
 };
 /**
@@ -497,8 +585,18 @@ export declare type FilterRelationsModelIdNode = {
  * @internal
  */
 export declare type FilterRelationsModelBracketNode = {
+    type: 'ParenthesizedLogicalExpression';
     value: FilterRelationsModelNode;
 };
+/**
+ * A node of a {@link FilterRelationsModel} tree that represents a cascading filter
+ *
+ * @internal
+ */
+export declare type FilterRelationsModelCascadeNode = {
+    type: 'CascadingIdentifier';
+    levels: FilterRelationsModelIdNode[];
+};
 /** Sorting direction, either in Ascending order, Descending order, or None */
 export declare type SortDirection = 'sortAsc' | 'sortDesc' | 'sortNone';
 /**

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

@@ -211,40 +211,40 @@ export declare type FormulaJaql = {
     context?: Record<FormulaID, FormulaContext>;
 };
 /** @internal */
-export declare type BaseFilter = IncludeAllFilter | IncludeMembersFilter | ExcludeMembersFilter | JaqlNumericFilter | ConditionFilterJaql | AndFilter<JaqlNumericFilter | ConditionFilterJaql> | OrFilter<JaqlNumericFilter | ConditionFilterJaql>;
+export declare type BaseFilterJaql = IncludeAllFilterJaql | IncludeMembersFilterJaql | ExcludeMembersFilterJaql | NumericFilterJaql | ConditionFilterJaql | AndFilterJaql<NumericFilterJaql | ConditionFilterJaql> | OrFilterJaql<NumericFilterJaql | ConditionFilterJaql>;
 /** @internal */
-export declare type BackgroundFilter = BaseFilter & {
+export declare type BackgroundFilterJaql = BaseFilterJaql & {
     level?: 'string';
 };
 /** @internal */
-export declare type IncludeAllFilter = {
+export declare type IncludeAllFilterJaql = {
     all: true;
 };
 /** @internal */
-export declare type IncludeMembersFilter = {
+export declare type IncludeMembersFilterJaql = {
     members: string[];
     multiSelection?: boolean;
 };
 /** @internal */
-export declare type ExcludeMembersFilter = {
+export declare type ExcludeMembersFilterJaql = {
     exclude: {
         members: string[];
     };
     multiSelection?: boolean;
 };
 /** @internal */
-export declare type TurnOffMembersFilter = ExcludeMembersFilter & {
+export declare type TurnOffMembersFilterJaql = ExcludeMembersFilterJaql & {
     turnedOff: boolean;
 };
 /** @internal */
 export declare type FilterJaql = BaseJaql & {
-    filter: BaseFilter & {
-        filter?: BackgroundFilter | TurnOffMembersFilter;
+    filter: BaseFilterJaql & {
+        filter?: BackgroundFilterJaql | TurnOffMembersFilterJaql;
     };
 };
 declare type NumericFilterValue = number | FormulaJaql;
 /** @internal */
-export declare type JaqlNumericFilter = {
+export declare type NumericFilterJaql = {
     equals?: NumericFilterValue;
     doesntEqual?: NumericFilterValue;
     toNotEqual?: NumericFilterValue;
@@ -257,11 +257,11 @@ export declare type JaqlNumericFilter = {
     '>='?: NumericFilterValue;
     '<='?: NumericFilterValue;
 };
-declare type AndFilter<FilterItem> = {
+declare type AndFilterJaql<FilterItem> = {
     and: FilterItem[];
 };
 /** @internal */
-export declare type OrFilter<FilterItem> = {
+export declare type OrFilterJaql<FilterItem> = {
     or: FilterItem[];
 };
 /**

package/dist/index.d.ts

@@ -16,6 +16,7 @@ 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 * from './dimensional-model/filters/filter-config-utils.js';
 export { createFilterMatcher } from './dimensional-model/filters/utils/filter-matcher-utils.js';
 /**
  * Functions to create date, text, or numeric filters on specified data.
@@ -85,6 +86,7 @@ export * from './dimensional-model/measures/measures.js';
  */
 export * as measureFactory from './dimensional-model/measures/factory.js';
 export * from './dimensional-model/simple-column-types.js';
+export * from './dimensional-model/filter-relations.js';
 /**
  * Functions to create elements for advanced analytics – for example, attributes and measures for constructing a custom Boxplot chart
  *

package/dist/index.js

@@ -16,6 +16,7 @@ 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 * from './dimensional-model/filters/filter-config-utils.js';
 export { createFilterMatcher } from './dimensional-model/filters/utils/filter-matcher-utils.js';
 /**
  * Functions to create date, text, or numeric filters on specified data.
@@ -85,6 +86,7 @@ export * from './dimensional-model/measures/measures.js';
  */
 export * as measureFactory from './dimensional-model/measures/factory.js';
 export * from './dimensional-model/simple-column-types.js';
+export * from './dimensional-model/filter-relations.js';
 /**
  * Functions to create elements for advanced analytics – for example, attributes and measures for constructing a custom Boxplot chart
  *