@sisense/sdk-data 1.12.0 → 1.14.0

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

@@ -31,6 +31,8 @@ const filterFactory = __importStar(require("../factory.js"));
 const types_js_1 = require("./types.js");
 const attribute_measure_util_js_1 = require("./attribute-measure-util.js");
 const condition_filter_util_js_1 = require("./condition-filter-util.js");
+const filter_from_jaql_util_js_2 = require("./filter-from-jaql-util.js");
+const filter_code_util_js_1 = require("./filter-code-util.js");
 (0, vitest_1.describe)('filter-from-jaql-util', () => {
     (0, vitest_1.describe)('createFilterFromJaqlInternal', () => {
         const guid = 'instanceid';
@@ -56,7 +58,7 @@ const condition_filter_util_js_1 = require("./condition-filter-util.js");
                 };
                 const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
                 const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const expectedFilter = filterFactory.members(attribute, [], guid);
+                const expectedFilter = filterFactory.members(attribute, [], [], guid);
                 expectEqualFilters(filter, expectedFilter);
             });
             it('should handle members text', () => {
@@ -74,7 +76,7 @@ const condition_filter_util_js_1 = require("./condition-filter-util.js");
                 };
                 const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
                 const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const expectedFilter = filterFactory.members(attribute, jaql.filter.members, guid);
+                const expectedFilter = filterFactory.members(attribute, jaql.filter.members, [], guid);
                 expectEqualFilters(filter, expectedFilter);
             });
             test('should handle members datetime', () => {
@@ -116,7 +118,7 @@ const condition_filter_util_js_1 = require("./condition-filter-util.js");
                 ].forEach((jaql) => {
                     const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
                     const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                    const expectedFilter = filterFactory.members(attribute, jaql.filter.members, guid);
+                    const expectedFilter = filterFactory.members(attribute, jaql.filter.members, [], guid);
                     expectEqualFilters(filter, expectedFilter);
                 });
             });
@@ -134,7 +136,39 @@ const condition_filter_util_js_1 = require("./condition-filter-util.js");
                 };
                 const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
                 const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
-                const expectedFilter = filterFactory.members(attribute, jaql.filter.members, guid);
+                const expectedFilter = filterFactory.members(attribute, jaql.filter.members, [], guid);
+                expectEqualFilters(filter, expectedFilter);
+            });
+            it('should handle deactivated members', () => {
+                const jaql = {
+                    datasource: {
+                        title: 'Sample ECommerce',
+                        fullname: 'LocalHost/Sample ECommerce',
+                        id: 'localhost_aSampleIAAaECommerce',
+                        address: 'LocalHost',
+                        database: 'aSampleIAAaECommerce',
+                    },
+                    column: 'Country',
+                    dim: '[country.Country]',
+                    datatype: 'text',
+                    title: 'COUNTRY',
+                    collapsed: true,
+                    isDashboardFilter: true,
+                    filter: {
+                        explicit: true,
+                        multiSelection: true,
+                        members: ['Albania', 'Algeria', 'Angola'],
+                        filter: {
+                            turnedOff: true,
+                            exclude: {
+                                members: ['Angola'],
+                            },
+                        },
+                    },
+                };
+                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                const expectedFilter = filterFactory.members(attribute, ['Albania', 'Algeria'], ['Angola'], guid);
                 expectEqualFilters(filter, expectedFilter);
             });
         });
@@ -475,19 +509,50 @@ const condition_filter_util_js_1 = require("./condition-filter-util.js");
                 });
             });
         });
+        (0, vitest_1.describe)('ExcludeFilter', () => {
+            it('should handle exclude members', () => {
+                const jaql = {
+                    table: 'Country',
+                    column: 'Country',
+                    datatype: 'text',
+                    title: 'exclude Turkey from Country',
+                    dim: '[Country.Country]',
+                    filter: {
+                        exclude: {
+                            members: ['Turkey'],
+                        },
+                    },
+                };
+                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                const expectedFilter = filterFactory.exclude((0, filter_code_util_js_1.withComposeCode)(filterFactory.members)(attribute, jaql.filter.exclude.members, undefined, guid), undefined, guid);
+                expectEqualFilters(filter, expectedFilter);
+            });
+        });
+        (0, vitest_1.describe)('Advanced filter (pass-through JAQL)', () => {
+            test('should handle', () => {
+                const jaql = {
+                    table: 'Commerce',
+                    column: 'Revenue',
+                    datatype: 'numeric',
+                    title: 'sum Revenue',
+                    filter: {
+                        custom: true,
+                        isAdvanced: true,
+                    },
+                };
+                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                const expectedFilter = filterFactory.customFilter(attribute, jaql.filter, guid);
+                expect(filter.jaql()).toEqual(expectedFilter.jaql());
+                expect(filter.jaql(true)).toEqual(expectedFilter.jaql(true));
+                expect(filter.serializable()).toBeDefined();
+                expect(filter.toJSON()).toBeDefined();
+            });
+        });
         (0, vitest_1.describe)('Generic filter (pass-through JAQL)', () => {
             test('should fall back to generic filter (pass-through JAQL)', () => {
                 [
-                    // ADVANCED FILTER TYPE
-                    {
-                        table: 'Commerce',
-                        column: 'Revenue',
-                        datatype: 'numeric',
-                        title: 'sum Revenue',
-                        filter: {
-                            isAdvanced: true,
-                        },
-                    },
                     // SIMULATE INVALID FILTER TYPE
                     {
                         table: 'Commerce',
@@ -546,7 +611,7 @@ const condition_filter_util_js_1 = require("./condition-filter-util.js");
                 ].forEach((item) => {
                     const jaql = item;
                     const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
-                    const expectedFilter = filterFactory.customFilter(jaql, guid);
+                    const expectedFilter = (0, filter_from_jaql_util_js_2.createGenericFilter)(jaql, guid);
                     expect(filter.jaql()).toEqual(expectedFilter.jaql());
                     expect(filter.jaql(true)).toEqual(expectedFilter.jaql(true));
                     expect(filter.serializable()).toBeDefined();

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

@@ -35,6 +35,8 @@ const isInvalidFilter = (filter) => filter.filterType === types_js_1.FILTER_TYPE
 const getFilterType = (filter, dataType = types_js_1.FilterModalType.DATE_TIME, timeData) => {
     if (timeData && isTimeLevelNotSupported(timeData))
         return types_js_1.FILTER_TYPES.ADVANCED;
+    if (isAdvancedFilter(filter))
+        return types_js_1.FILTER_TYPES.ADVANCED;
     if (isIncludeAllFilter(filter))
         return types_js_1.FILTER_TYPES.INCLUDE_ALL;
     if (isPeriodFilter(filter))
@@ -47,11 +49,9 @@ const getFilterType = (filter, dataType = types_js_1.FilterModalType.DATE_TIME,
         return types_js_1.FILTER_TYPES.NUMERIC_RANGE;
     if ((0, exports.isConditionFilter)(filter))
         return types_js_1.FILTER_TYPES.CONDITION;
-    if (isAdvancedFilter(filter))
-        return types_js_1.FILTER_TYPES.ADVANCED;
     if (isInvalidFilter(filter))
         return types_js_1.FILTER_TYPES.INVALID;
-    return types_js_1.FILTER_TYPES.ADVANCED;
+    return types_js_1.FILTER_TYPES.INVALID;
 };
 exports.getFilterType = getFilterType;
 /**

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

@@ -70,6 +70,12 @@ export declare type FilterMultiSelectJaql = {
     multiSelection: boolean;
     members: string[];
     isCondition?: boolean;
+    filter?: {
+        turnedOff?: boolean;
+        exclude?: {
+            members?: string[];
+        };
+    };
 };
 export declare type FilterMultipleConditionJaql = {
     or: ConditionFilterJaql[];

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

@@ -249,6 +249,14 @@ export interface DateDimension extends Dimension {
      * Minutes (round to 15) level (for Live Models)
      */
     readonly MinutesRoundTo15: LevelAttribute;
+    /**
+     * Minutes level (for Live Models)
+     */
+    readonly Minutes: LevelAttribute;
+    /**
+     * Seconds level (for Live Models)
+     */
+    readonly Seconds: LevelAttribute;
     /**
      * Aggregated Hours level (for Live Models)
      */
@@ -346,6 +354,12 @@ export interface Filter extends Element {
      * @internal
      */
     disabled: boolean;
+    /**
+     * Boolean flag whether the filter is locked
+     *
+     * @internal
+     */
+    locked: boolean;
     /**
      * Gets JAQL representing this Filter instance
      *

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

@@ -144,6 +144,8 @@ export declare const DateLevels: {
     Hours: string;
     MinutesRoundTo30: string;
     MinutesRoundTo15: string;
+    Minutes: string;
+    Seconds: string;
     AggHours: string;
     AggMinutesRoundTo30: string;
     AggMinutesRoundTo15: string;

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

@@ -261,6 +261,8 @@ exports.DateLevels = {
     Hours: 'Hours',
     MinutesRoundTo30: 'MinutesRoundTo30',
     MinutesRoundTo15: 'MinutesRoundTo15',
+    Minutes: 'Minutes',
+    Seconds: 'Seconds',
     AggHours: 'AggHours',
     AggMinutesRoundTo30: 'AggMinutesRoundTo30',
     AggMinutesRoundTo15: 'AggMinutesRoundTo15',
@@ -276,6 +278,8 @@ exports.DateLevels = {
             exports.DateLevels.Hours,
             exports.DateLevels.MinutesRoundTo30,
             exports.DateLevels.MinutesRoundTo15,
+            exports.DateLevels.Minutes,
+            exports.DateLevels.Seconds,
             exports.DateLevels.AggHours,
             exports.DateLevels.AggMinutesRoundTo30,
             exports.DateLevels.AggMinutesRoundTo15,

package/dist/cjs/interfaces.d.ts

@@ -288,7 +288,7 @@ export declare const EMPTY_PIVOT_QUERY_RESULT_DATA: PivotQueryResultData;
  * @param arg
  * @internal
  */
-export declare function isDataSource(arg: DataSource | Data | undefined): arg is DataSource;
+export declare function isDataSource(arg: DataSource | Data | undefined): arg is DataSource | undefined;
 /**
  * Trend formula options.
  */

package/dist/cjs/translation/resources/en.js

@@ -22,7 +22,7 @@ exports.translation = {
         },
         filter: {
             unsupportedType: 'Unsupported filter type: {{filterType}}',
-            unsupportedDatetimeLevel: 'Filters do not support the next "datetime" levels: Hours, MinutesRoundTo30, MinutesRoundTo15',
+            unsupportedDatetimeLevel: 'Filters do not support the next "datetime" levels: Hours, MinutesRoundTo30, MinutesRoundTo15, Minutes, Seconds',
             membersFilterNullMember: 'MembersFilter of {{attributeId}} - member cannot be null',
         },
         unsupportedDimensionalElement: 'Unsupported dimensional element type',

package/dist/cjs/translation/resources/uk.js

@@ -22,7 +22,7 @@ exports.translation = {
         },
         filter: {
             unsupportedType: 'Непідтримуваний тип фільтра: {{filterType}}',
-            unsupportedDatetimeLevel: 'Фільтри не підтримують наступні рівні "datetime": Hours, MinutesRoundTo30, MinutesRoundTo15',
+            unsupportedDatetimeLevel: 'Фільтри не підтримують наступні рівні "datetime": Hours, MinutesRoundTo30, MinutesRoundTo15, Minutes, Seconds',
             membersFilterNullMember: 'MembersFilter у {{attributeId}} - member не може бути нульовим',
         },
         unsupportedDimensionalElement: 'Непідтримуваний тип елемента',

package/dist/cjs/utils.js

@@ -99,7 +99,11 @@ exports.isDataSourceInfo = isDataSourceInfo;
 const createFilterFromJaql = (jaql, instanceid) => {
     // translation logic is based on FilterJaqlInternal type (from internal modern-analytics-filters)
     // TODO reconcile FilterJaql and FilterJaqlInternal
-    const jaqlInternal = jaql;
-    return (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaqlInternal, instanceid);
+    const hasBackgroundFilter = jaql.filter.filter && !('turnedOff' in jaql.filter.filter);
+    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, instanceid);
+    if (hasBackgroundFilter) {
+        filter.backgroundFilter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(Object.assign(Object.assign({}, jaql), { filter: jaql.filter.filter }), `${instanceid}-bg`);
+    }
+    return filter;
 };
 exports.createFilterFromJaql = createFilterFromJaql;

package/dist/cjs/utils.test.js

@@ -154,5 +154,29 @@ const nestedFilterRelationsResult = {
             const expectedFilter = filterFactory.members(attribute, jaql.filter.members);
             expect(filter.jaql().jaql).toEqual(expectedFilter.jaql().jaql);
         });
+        test('should creact MembersFilter with inner background filter', () => {
+            const jaql = {
+                table: 'Category',
+                column: 'Category',
+                dim: '[Category.Category]',
+                datatype: 'text',
+                filter: {
+                    explicit: true,
+                    multiSelection: true,
+                    members: ['Cell Phones'],
+                    filter: {
+                        members: ['Cell Phones', 'GPS Devices'],
+                    },
+                },
+                title: 'Category',
+            };
+            const filter = (0, index_js_1.createFilterFromJaql)(jaql, instanceid);
+            const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+            const backgroundFilter = filterFactory.members(attribute, jaql.filter.filter.members);
+            const expectedFilter = filterFactory.members(attribute, jaql.filter.members, undefined, undefined, backgroundFilter);
+            expect(filter.jaql().jaql).toEqual(expectedFilter.jaql().jaql);
+            expect(filter.backgroundFilter).toBeDefined();
+            expect(expectedFilter.backgroundFilter).toBeDefined();
+        });
     });
 });

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

@@ -96,8 +96,8 @@ export const boxWhiskerIqrOutliers = (target) => {
         Attr: target,
     });
     outliersAttrWithInnerFilter.name = `${outliersAttrWithInnerFilter.name} (Outliers)`;
-    outliersAttrWithInnerFilter.jaql = () => {
-        return Object.assign(Object.assign({}, target.jaql(true)), { filter: {
+    outliersAttrWithInnerFilter.jaql = (nested) => {
+        const jaql = Object.assign(Object.assign({}, target.jaql(true)), { filter: {
                 or: [
                     {
                         fromNotEqual: outliersMax.jaql(true),
@@ -107,6 +107,7 @@ export const boxWhiskerIqrOutliers = (target) => {
                     },
                 ],
             } });
+        return nested ? jaql : { jaql };
     };
     return outliersAttrWithInnerFilter;
 };
@@ -124,8 +125,8 @@ export const boxWhiskerStdDevOutliers = (target) => {
     const outliersMin = customFormula(BOX_WHISKER.OUTLIER_MIN_VALUE_NAME, '(LOWERWHISKERMAX_STDEVP([Attr]), all([Attr]))', {
         Attr: target,
     });
-    outliersAttrWithInnerFilter.jaql = () => {
-        return Object.assign(Object.assign({}, target.jaql(true)), { filter: {
+    outliersAttrWithInnerFilter.jaql = (nested) => {
+        const jaql = Object.assign(Object.assign({}, target.jaql(true)), { filter: {
                 or: [
                     {
                         fromNotEqual: outliersMax.jaql(true),
@@ -135,6 +136,7 @@ export const boxWhiskerStdDevOutliers = (target) => {
                     },
                 ],
             } });
+        return nested ? jaql : { jaql };
     };
     return outliersAttrWithInnerFilter;
 };

package/dist/dimensional-model/attributes.js

@@ -158,6 +158,7 @@ export class DimensionalLevelAttribute extends DimensionalAttribute {
      */
     translateGranularityToJaql() {
         const MINUTES_LEVEL = 'minutes';
+        const SECONDS_LEVEL = 'seconds';
         switch (this.granularity) {
             case DateLevels.Years:
             case DateLevels.Quarters:
@@ -180,6 +181,16 @@ export class DimensionalLevelAttribute extends DimensionalAttribute {
                     dateTimeLevel: MINUTES_LEVEL,
                     bucket: '15',
                 };
+            case DateLevels.Minutes:
+                return {
+                    dateTimeLevel: MINUTES_LEVEL,
+                    bucket: '1',
+                };
+            case DateLevels.Seconds:
+                return {
+                    dateTimeLevel: SECONDS_LEVEL,
+                    bucket: '0',
+                };
             case DateLevels.AggHours:
                 return {
                     level: MINUTES_LEVEL,
@@ -211,7 +222,7 @@ export class DimensionalLevelAttribute extends DimensionalAttribute {
             return lvl;
         };
         if (json.dateTimeLevel) {
-            if (json.dateTimeLevel !== 'minutes') {
+            if (json.dateTimeLevel !== 'minutes' && json.dateTimeLevel !== 'seconds') {
                 return returnUnsupported(json.dateTimeLevel);
             }
             switch (json.bucket) {
@@ -221,6 +232,10 @@ export class DimensionalLevelAttribute extends DimensionalAttribute {
                     return DateLevels.MinutesRoundTo30;
                 case '15':
                     return DateLevels.MinutesRoundTo15;
+                case '1':
+                    return DateLevels.Minutes;
+                case '0':
+                    return DateLevels.Seconds;
                 default:
                     return returnUnsupported(json.dateTimeLevel);
             }
@@ -272,6 +287,10 @@ export class DimensionalLevelAttribute extends DimensionalAttribute {
                 return 'yyyy-MM-dd HH:mm';
             case DateLevels.MinutesRoundTo15:
                 return 'yyyy-MM-dd HH:mm';
+            case DateLevels.Minutes:
+                return 'yyyy-MM-dd HH:mm';
+            case DateLevels.Seconds:
+                return 'yyyy-MM-dd HH:mm:ss';
             case DateLevels.AggHours:
                 return 'HH:mm';
             case DateLevels.AggMinutesRoundTo30:

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

@@ -94,6 +94,14 @@ export declare class DimensionalDateDimension extends DimensionalDimension imple
      * Minutes (round to 15) level
      */
     readonly MinutesRoundTo15: LevelAttribute;
+    /**
+     * Minutes level (for Live Models)
+     */
+    readonly Minutes: LevelAttribute;
+    /**
+     * Seconds level (for Live Models)
+     */
+    readonly Seconds: LevelAttribute;
     /**
      * Aggregated Hours  level
      */

package/dist/dimensional-model/dimensions.js

@@ -160,6 +160,8 @@ export class DimensionalDateDimension extends DimensionalDimension {
         this.Hours = new DimensionalLevelAttribute(DateLevels.Hours, expression, DateLevels.Hours, 'yyyy-MM-dd HH:mm');
         this.MinutesRoundTo30 = new DimensionalLevelAttribute(DateLevels.MinutesRoundTo30, expression, DateLevels.MinutesRoundTo30, 'yyyy-MM-dd HH:mm');
         this.MinutesRoundTo15 = new DimensionalLevelAttribute(DateLevels.MinutesRoundTo15, expression, DateLevels.MinutesRoundTo15, 'yyyy-MM-dd HH:mm');
+        this.Minutes = new DimensionalLevelAttribute(DateLevels.Minutes, expression, DateLevels.Minutes, 'yyyy-MM-dd HH:mm');
+        this.Seconds = new DimensionalLevelAttribute(DateLevels.Seconds, expression, DateLevels.Seconds, 'yyyy-MM-dd HH:mm:ss');
         this.AggHours = new DimensionalLevelAttribute(DateLevels.AggHours, expression, DateLevels.AggHours, 'HH:mm');
         this.AggMinutesRoundTo30 = new DimensionalLevelAttribute(DateLevels.AggMinutesRoundTo30, expression, DateLevels.AggMinutesRoundTo30, 'HH:mm');
         this.AggMinutesRoundTo15 = new DimensionalLevelAttribute(DateLevels.AggMinutesRoundTo15, expression, DateLevels.AggMinutesRoundTo15, 'HH:mm');
@@ -173,6 +175,8 @@ export class DimensionalDateDimension extends DimensionalDimension {
             this.Hours,
             this.MinutesRoundTo30,
             this.MinutesRoundTo15,
+            this.Minutes,
+            this.Seconds,
             this.AggHours,
             this.AggMinutesRoundTo30,
             this.AggMinutesRoundTo15,

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

@@ -373,10 +373,11 @@ export declare function numeric(attribute: Attribute, operatorA?: string, valueA
  * ```
  * @param attribute - Attribute to filter on
  * @param members - Array of member values to filter by
+ * @param _deactivatedMembers - [internal] Array of deactivated member values
  * @param guid - Optional GUID for the filter
  * @returns A filter instance
  */
-export declare function members(attribute: Attribute, members: string[], guid?: string): Filter;
+export declare function members(attribute: Attribute, members: string[], _deactivatedMembers?: string[], guid?: string, backgroundFilter?: Filter): Filter;
 /**
  * Creates a filter to isolate date values starting from and including the given date and level.
  *
@@ -793,4 +794,4 @@ export declare namespace logic {
  * @returns A filter instance
  * @internal
  */
-export declare function customFilter(jaql: any, guid?: string): Filter;
+export declare function customFilter(attribute: Attribute, jaql: any, guid?: string): Filter;

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

@@ -1,5 +1,4 @@
-import { TextOperators, NumericOperators, DateOperators, LogicalOperators, RankingOperators, LogicalAttributeFilter, MembersFilter, ExcludeFilter, NumericFilter, MeasureFilter, RankingFilter, TextFilter, DateRangeFilter, RelativeDateFilter, } from './filters.js';
-import { createGenericFilter } from './utils/filter-from-jaql-util.js';
+import { TextOperators, NumericOperators, DateOperators, LogicalOperators, RankingOperators, LogicalAttributeFilter, MembersFilter, ExcludeFilter, NumericFilter, MeasureFilter, RankingFilter, TextFilter, DateRangeFilter, RelativeDateFilter, CustomFilter, } from './filters.js';
 // LOGICAL FILTERS
 /**
  * Creates a filter representing the union of multiple filters on the same attribute. The resulting
@@ -424,11 +423,12 @@ export function numeric(attribute, operatorA, valueA, operatorB, valueB, guid) {
  * ```
  * @param attribute - Attribute to filter on
  * @param members - Array of member values to filter by
+ * @param _deactivatedMembers - [internal] Array of deactivated member values
  * @param guid - Optional GUID for the filter
  * @returns A filter instance
  */
-export function members(attribute, members, guid) {
-    return new MembersFilter(attribute, members, guid);
+export function members(attribute, members, _deactivatedMembers, guid, backgroundFilter) {
+    return new MembersFilter(attribute, members, _deactivatedMembers, guid, backgroundFilter);
 }
 // DATE FILTERS
 /**
@@ -913,6 +913,6 @@ export var logic;
  * @returns A filter instance
  * @internal
  */
-export function customFilter(jaql, guid) {
-    return createGenericFilter(jaql, guid);
+export function customFilter(attribute, jaql, guid) {
+    return new CustomFilter(attribute, jaql, guid);
 }

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

@@ -74,6 +74,7 @@ export declare const FilterTypes: {
     date: string;
     relativeDate: string;
     cascading: string;
+    advanced: string;
 };
 /**
  * base implementation for filter classes
@@ -93,12 +94,22 @@ declare abstract class AbstractFilter extends DimensionalElement implements Filt
      * Global filter identifier
      */
     readonly guid: string;
+    private _disabled;
+    private _locked;
     /**
      * Boolean flag whether the filter is disabled
      *
      * @internal
      */
-    disabled: boolean;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /**
+     * Boolean flag whether the filter is locked
+     *
+     * @internal
+     */
+    get locked(): boolean;
+    set locked(value: boolean);
     constructor(att: Attribute, filterType: string, guid?: string);
     get name(): string;
     /**
@@ -151,7 +162,11 @@ export declare class LogicalAttributeFilter extends AbstractFilter {
  */
 export declare class MembersFilter extends AbstractFilter {
     readonly members: any[];
-    constructor(attribute: Attribute, members?: any[], guid?: string);
+    /** @internal */
+    _deactivatedMembers: any[];
+    /** @internal */
+    backgroundFilter?: Filter;
+    constructor(attribute: Attribute, members?: any[], _deactivatedMembers?: any[], guid?: string, backgroundFilter?: Filter);
     /**
      * gets the element's ID
      */
@@ -175,6 +190,10 @@ export declare class CascadingFilter extends AbstractFilter {
      * gets the element's ID
      */
     get id(): string;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get locked(): boolean;
+    set locked(value: boolean);
     /**
      * Gets a serializable representation of the element
      */
@@ -313,6 +332,22 @@ export declare class RelativeDateFilter extends AbstractFilter {
      */
     filterJaql(): any;
 }
+/**
+ * @internal
+ */
+export declare class CustomFilter extends AbstractFilter {
+    readonly jaqlExpression: any;
+    constructor(att: Attribute, jaql: any, guid?: string);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets JAQL representing this Filter instance
+     *
+     */
+    filterJaql(): any;
+}
 /**
  * @param json - Filter JSON representation
  * @internal