@sisense/sdk-data 1.10.1 → 1.12.0

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,366 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+const index_js_1 = require("../../index.js");
+const dimensions_js_1 = require("../dimensions.js");
+const filterFactory = __importStar(require("./factory.js"));
+const filters_js_1 = require("./filters.js");
+const TextDim = (0, dimensions_js_1.createDimension)({
+    name: 'text',
+    type: 'textdimension',
+    expression: '[Text]',
+});
+const NumDim = (0, dimensions_js_1.createDimension)({
+    name: 'num',
+    type: 'numericdimension',
+    expression: '[Num]',
+});
+const DateDim = (0, dimensions_js_1.createDateDimension)({
+    name: 'date',
+    expression: '[Date]',
+});
+const filter1 = new filters_js_1.MembersFilter(TextDim, []);
+const filter2 = new filters_js_1.MembersFilter(NumDim, []);
+describe('filterFactory', () => {
+    test('filterFactory.union()', () => {
+        const f = filterFactory.union([filter1, filter2]);
+        expect(f).toBeInstanceOf(filters_js_1.LogicalAttributeFilter);
+        expect(f).toHaveProperty('operator', filters_js_1.LogicalOperators.Union);
+        expect(f).toHaveProperty('filters', [filter1, filter2]);
+    });
+    test('filterFactory.intersection()', () => {
+        const f = filterFactory.intersection([filter1, filter2]);
+        expect(f).toBeInstanceOf(filters_js_1.LogicalAttributeFilter);
+        expect(f).toHaveProperty('operator', filters_js_1.LogicalOperators.Intersection);
+        expect(f).toHaveProperty('filters', [filter1, filter2]);
+    });
+    test('filterFactory.exclude()', () => {
+        const f = filterFactory.exclude(filter1);
+        expect(f).toBeInstanceOf(filters_js_1.ExcludeFilter);
+        expect(f).toHaveProperty('attribute', TextDim);
+        expect(f).toHaveProperty('filter', filter1);
+    });
+    test('filterFactory.doesntContain()', () => {
+        const f = filterFactory.doesntContain(TextDim, 'mem');
+        expect(f).toBeInstanceOf(filters_js_1.TextFilter);
+        expect(f).toHaveProperty('attribute', TextDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.TextOperators.DoesntContain);
+        expect(f).toHaveProperty('valueA', 'mem');
+    });
+    test('filterFactory.doesntEndWith()', () => {
+        const f = filterFactory.doesntEndWith(TextDim, 'mem');
+        expect(f).toBeInstanceOf(filters_js_1.TextFilter);
+        expect(f).toHaveProperty('attribute', TextDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.TextOperators.DoesntEndWith);
+        expect(f).toHaveProperty('valueA', 'mem');
+    });
+    test('filterFactory.doesntStartWith()', () => {
+        const f = filterFactory.doesntStartWith(TextDim, 'mem');
+        expect(f).toBeInstanceOf(filters_js_1.TextFilter);
+        expect(f).toHaveProperty('attribute', TextDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.TextOperators.DoesntStartWith);
+        expect(f).toHaveProperty('valueA', 'mem');
+    });
+    test('filterFactory.contains()', () => {
+        const f = filterFactory.contains(TextDim, 'mem');
+        expect(f).toBeInstanceOf(filters_js_1.TextFilter);
+        expect(f).toHaveProperty('attribute', TextDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.TextOperators.Contains);
+        expect(f).toHaveProperty('valueA', 'mem');
+    });
+    test('filterFactory.endsWith()', () => {
+        const f = filterFactory.endsWith(TextDim, 'mem');
+        expect(f).toBeInstanceOf(filters_js_1.TextFilter);
+        expect(f).toHaveProperty('attribute', TextDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.TextOperators.EndsWith);
+        expect(f).toHaveProperty('valueA', 'mem');
+    });
+    test('filterFactory.startsWith()', () => {
+        const f = filterFactory.startsWith(TextDim, 'mem');
+        expect(f).toBeInstanceOf(filters_js_1.TextFilter);
+        expect(f).toHaveProperty('attribute', TextDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.TextOperators.StartsWith);
+        expect(f).toHaveProperty('valueA', 'mem');
+    });
+    test('filterFactory.like()', () => {
+        const f = filterFactory.like(TextDim, '%mem%');
+        expect(f).toBeInstanceOf(filters_js_1.TextFilter);
+        expect(f).toHaveProperty('attribute', TextDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.TextOperators.Like);
+        expect(f).toHaveProperty('valueA', '%mem%');
+    });
+    test('filterFactory.doesntEqual() with string arg', () => {
+        const f = filterFactory.doesntEqual(TextDim, 'mem');
+        expect(f).toBeInstanceOf(filters_js_1.TextFilter);
+        expect(f).toHaveProperty('attribute', TextDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.TextOperators.DoesntEqual);
+        expect(f).toHaveProperty('valueA', 'mem');
+    });
+    test('filterFactory.doesntEqual() with numeric arg', () => {
+        const f = filterFactory.doesntEqual(NumDim, 5);
+        expect(f).toBeInstanceOf(filters_js_1.NumericFilter);
+        expect(f).toHaveProperty('attribute', NumDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.NumericOperators.DoesntEqual);
+        expect(f).toHaveProperty('valueA', 5);
+    });
+    test('filterFactory.equals() with string arg', () => {
+        const f = filterFactory.equals(TextDim, 'mem');
+        expect(f).toBeInstanceOf(filters_js_1.TextFilter);
+        expect(f).toHaveProperty('attribute', TextDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.TextOperators.Equals);
+        expect(f).toHaveProperty('valueA', 'mem');
+    });
+    test('filterFactory.equals() with numeric arg', () => {
+        const f = filterFactory.equals(NumDim, 5);
+        expect(f).toBeInstanceOf(filters_js_1.NumericFilter);
+        expect(f).toHaveProperty('attribute', NumDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.NumericOperators.Equals);
+        expect(f).toHaveProperty('valueA', 5);
+    });
+    test('filterFactory.greaterThan()', () => {
+        const f = filterFactory.greaterThan(NumDim, 5);
+        expect(f).toBeInstanceOf(filters_js_1.NumericFilter);
+        expect(f).toHaveProperty('attribute', NumDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.NumericOperators.FromNotEqual);
+        expect(f).toHaveProperty('valueA', 5);
+    });
+    test('filterFactory.greaterThanOrEqual()', () => {
+        const f = filterFactory.greaterThanOrEqual(NumDim, 5);
+        expect(f).toBeInstanceOf(filters_js_1.NumericFilter);
+        expect(f).toHaveProperty('attribute', NumDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.NumericOperators.From);
+        expect(f).toHaveProperty('valueA', 5);
+    });
+    test('filterFactory.lessThan()', () => {
+        const f = filterFactory.lessThan(NumDim, 5);
+        expect(f).toBeInstanceOf(filters_js_1.NumericFilter);
+        expect(f).toHaveProperty('attribute', NumDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.NumericOperators.ToNotEqual);
+        expect(f).toHaveProperty('valueA', 5);
+    });
+    test('filterFactory.lessThanOrEqual()', () => {
+        const f = filterFactory.lessThanOrEqual(NumDim, 5);
+        expect(f).toBeInstanceOf(filters_js_1.NumericFilter);
+        expect(f).toHaveProperty('attribute', NumDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.NumericOperators.To);
+        expect(f).toHaveProperty('valueA', 5);
+    });
+    test('filterFactory.between()', () => {
+        const f = filterFactory.between(NumDim, 3, 7);
+        expect(f).toBeInstanceOf(filters_js_1.NumericFilter);
+        expect(f).toHaveProperty('attribute', NumDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.NumericOperators.From);
+        expect(f).toHaveProperty('valueA', 3);
+        expect(f).toHaveProperty('operatorB', filters_js_1.NumericOperators.To);
+        expect(f).toHaveProperty('valueB', 7);
+    });
+    test('filterFactory.betweenNotEqual()', () => {
+        const f = filterFactory.betweenNotEqual(NumDim, 3, 7);
+        expect(f).toBeInstanceOf(filters_js_1.NumericFilter);
+        expect(f).toHaveProperty('attribute', NumDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.NumericOperators.FromNotEqual);
+        expect(f).toHaveProperty('valueA', 3);
+        expect(f).toHaveProperty('operatorB', filters_js_1.NumericOperators.ToNotEqual);
+        expect(f).toHaveProperty('valueB', 7);
+    });
+    test('filterFactory.numeric()', () => {
+        const f = filterFactory.numeric(NumDim, filters_js_1.NumericOperators.Equals, 5);
+        expect(f).toBeInstanceOf(filters_js_1.NumericFilter);
+        expect(f).toHaveProperty('attribute', NumDim);
+        expect(f).toHaveProperty('operatorA', filters_js_1.NumericOperators.Equals);
+        expect(f).toHaveProperty('valueA', 5);
+    });
+    test('filterFactory.member()', () => {
+        const f = filterFactory.members(TextDim, ['mem1', 'mem2']);
+        expect(f).toBeInstanceOf(filters_js_1.MembersFilter);
+        expect(f).toHaveProperty('attribute', TextDim);
+        expect(f).toHaveProperty('members', ['mem1', 'mem2']);
+    });
+    test('filterFactory.dateFrom()', () => {
+        const f = filterFactory.dateFrom(DateDim.Years, '2020-02-02T00:00:00Z');
+        expect(f).toBeInstanceOf(filters_js_1.DateRangeFilter);
+        expect(f).toHaveProperty('attribute', DateDim.Years);
+        expect(f).toHaveProperty('operatorA', filters_js_1.DateOperators.From);
+        expect(f).toHaveProperty('valueA', '2020-02-02T00:00:00Z');
+    });
+    test('filterFactory.dateTo()', () => {
+        const f = filterFactory.dateTo(DateDim.Years, '2020-02-02T00:00:00Z');
+        expect(f).toBeInstanceOf(filters_js_1.DateRangeFilter);
+        expect(f).toHaveProperty('attribute', DateDim.Years);
+        expect(f).toHaveProperty('operatorB', filters_js_1.DateOperators.To);
+        expect(f).toHaveProperty('valueB', '2020-02-02T00:00:00Z');
+    });
+    test('filterFactory.dateRange()', () => {
+        const f = filterFactory.dateRange(DateDim.Years, '2020-02-02T00:00:00Z', '2021-02-02T00:00:00Z');
+        expect(f).toBeInstanceOf(filters_js_1.DateRangeFilter);
+        expect(f).toHaveProperty('attribute', DateDim.Years);
+        expect(f).toHaveProperty('operatorA', filters_js_1.DateOperators.From);
+        expect(f).toHaveProperty('valueA', '2020-02-02T00:00:00Z');
+        expect(f).toHaveProperty('operatorB', filters_js_1.DateOperators.To);
+        expect(f).toHaveProperty('valueB', '2021-02-02T00:00:00Z');
+    });
+    test('filterFactory.dateRelative()', () => {
+        const f = filterFactory.dateRelative(DateDim.Years, 0, 1);
+        expect(f).toBeInstanceOf(filters_js_1.RelativeDateFilter);
+        expect(f).toHaveProperty('attribute', DateDim.Years);
+        expect(f).toHaveProperty('offset', 0);
+        expect(f).toHaveProperty('count', 1);
+        expect(f).toHaveProperty('operator', filters_js_1.DateOperators.Next);
+    });
+    test('filterFactory.dateRelativeFrom()', () => {
+        const f = filterFactory.dateRelativeFrom(DateDim.Years, 0, 1);
+        expect(f).toBeInstanceOf(filters_js_1.RelativeDateFilter);
+        expect(f).toHaveProperty('attribute', DateDim.Years);
+        expect(f).toHaveProperty('offset', 0);
+        expect(f).toHaveProperty('operator', filters_js_1.DateOperators.Next);
+    });
+    test('filterFactory.dateRelativeTo()', () => {
+        const f = filterFactory.dateRelativeTo(DateDim.Years, 0, 1);
+        expect(f).toBeInstanceOf(filters_js_1.RelativeDateFilter);
+        expect(f).toHaveProperty('attribute', DateDim.Years);
+        expect(f).toHaveProperty('offset', 0);
+        expect(f).toHaveProperty('count', 1);
+        expect(f).toHaveProperty('operator', filters_js_1.DateOperators.Last);
+    });
+    test('filterFactory.thisYear()', () => {
+        const f = filterFactory.thisYear(DateDim);
+        expect(f).toBeInstanceOf(filters_js_1.RelativeDateFilter);
+        expect(f).toHaveProperty('attribute', DateDim.Years);
+        expect(f).toHaveProperty('offset', 0);
+        expect(f).toHaveProperty('count', 1);
+        expect(f).toHaveProperty('operator', filters_js_1.DateOperators.Last);
+    });
+    test('filterFactory.thisMonth()', () => {
+        const f = filterFactory.thisMonth(DateDim);
+        expect(f).toBeInstanceOf(filters_js_1.RelativeDateFilter);
+        expect(f).toHaveProperty('attribute', DateDim.Months);
+        expect(f).toHaveProperty('offset', 0);
+        expect(f).toHaveProperty('count', 1);
+        expect(f).toHaveProperty('operator', filters_js_1.DateOperators.Last);
+    });
+    test('filterFactory.thisQuarter()', () => {
+        const f = filterFactory.thisQuarter(DateDim);
+        expect(f).toBeInstanceOf(filters_js_1.RelativeDateFilter);
+        expect(f).toHaveProperty('attribute', DateDim.Quarters);
+        expect(f).toHaveProperty('offset', 0);
+        expect(f).toHaveProperty('count', 1);
+        expect(f).toHaveProperty('operator', filters_js_1.DateOperators.Last);
+    });
+    test('filterFactory.today()', () => {
+        const f = filterFactory.today(DateDim);
+        expect(f).toBeInstanceOf(filters_js_1.RelativeDateFilter);
+        expect(f).toHaveProperty('attribute', DateDim.Days);
+        expect(f).toHaveProperty('offset', 0);
+        expect(f).toHaveProperty('count', 1);
+        expect(f).toHaveProperty('operator', filters_js_1.DateOperators.Last);
+    });
+    test('filterFactory.measureBase()', () => {
+        const f = filterFactory.measureBase(NumDim, index_js_1.measureFactory.sum(NumDim), filters_js_1.NumericOperators.From, 5);
+        expect(f).toBeInstanceOf(filters_js_1.MeasureFilter);
+        expect(f).toHaveProperty('attribute', NumDim);
+        expect(f).toHaveProperty('measure', index_js_1.measureFactory.sum(NumDim));
+        expect(f).toHaveProperty('operatorA', filters_js_1.NumericOperators.From);
+        expect(f).toHaveProperty('valueA', 5);
+    });
+    test('filterFactory.measureGreaterThanOrEqual()', () => {
+        const f = filterFactory.measureGreaterThanOrEqual(index_js_1.measureFactory.sum(NumDim), 5);
+        expect(f).toBeInstanceOf(filters_js_1.MeasureFilter);
+        expect(f).toHaveProperty('attribute', NumDim);
+        expect(f).toHaveProperty('measure', index_js_1.measureFactory.sum(NumDim));
+        expect(f).toHaveProperty('operatorA', filters_js_1.NumericOperators.From);
+        expect(f).toHaveProperty('valueA', 5);
+    });
+    test('filterFactory.measureLessThanOrEqual()', () => {
+        const f = filterFactory.measureLessThanOrEqual(index_js_1.measureFactory.sum(NumDim), 5);
+        expect(f).toBeInstanceOf(filters_js_1.MeasureFilter);
+        expect(f).toHaveProperty('attribute', NumDim);
+        expect(f).toHaveProperty('measure', index_js_1.measureFactory.sum(NumDim));
+        expect(f).toHaveProperty('operatorA', filters_js_1.NumericOperators.To);
+        expect(f).toHaveProperty('valueA', 5);
+    });
+    test('filterFactory.measureBetween()', () => {
+        const f = filterFactory.measureBetween(index_js_1.measureFactory.sum(NumDim), 3, 7);
+        expect(f).toBeInstanceOf(filters_js_1.MeasureFilter);
+        expect(f).toHaveProperty('attribute', NumDim);
+        expect(f).toHaveProperty('measure', index_js_1.measureFactory.sum(NumDim));
+        expect(f).toHaveProperty('operatorA', filters_js_1.NumericOperators.From);
+        expect(f).toHaveProperty('valueA', 3);
+        expect(f).toHaveProperty('operatorB', filters_js_1.NumericOperators.To);
+        expect(f).toHaveProperty('valueB', 7);
+    });
+    test('filterFactory.measureBetweenNotEqual()', () => {
+        const f = filterFactory.measureBetweenNotEqual(index_js_1.measureFactory.sum(NumDim), 3, 7);
+        expect(f).toBeInstanceOf(filters_js_1.MeasureFilter);
+        expect(f).toHaveProperty('attribute', NumDim);
+        expect(f).toHaveProperty('measure', index_js_1.measureFactory.sum(NumDim));
+        expect(f).toHaveProperty('operatorA', filters_js_1.NumericOperators.FromNotEqual);
+        expect(f).toHaveProperty('valueA', 3);
+        expect(f).toHaveProperty('operatorB', filters_js_1.NumericOperators.ToNotEqual);
+        expect(f).toHaveProperty('valueB', 7);
+    });
+    test('filterFactory.topRanking()', () => {
+        const f = filterFactory.topRanking(TextDim, index_js_1.measureFactory.sum(NumDim), 3);
+        expect(f).toBeInstanceOf(filters_js_1.RankingFilter);
+        expect(f).toHaveProperty('attribute', TextDim);
+        expect(f).toHaveProperty('measure', index_js_1.measureFactory.sum(NumDim));
+        expect(f).toHaveProperty('operator', filters_js_1.RankingOperators.Top);
+        expect(f).toHaveProperty('count', 3);
+    });
+    test('filterFactory.bottomRanking()', () => {
+        const f = filterFactory.bottomRanking(TextDim, index_js_1.measureFactory.sum(NumDim), 3);
+        expect(f).toBeInstanceOf(filters_js_1.RankingFilter);
+        expect(f).toHaveProperty('attribute', TextDim);
+        expect(f).toHaveProperty('measure', index_js_1.measureFactory.sum(NumDim));
+        expect(f).toHaveProperty('operator', filters_js_1.RankingOperators.Bottom);
+        expect(f).toHaveProperty('count', 3);
+    });
+    test('filterFactory.logic.and()', () => {
+        const f = filterFactory.logic.and(filter1, filter2);
+        expect(f).toHaveProperty('operator', 'AND');
+        expect(f).toHaveProperty('left', filter1);
+        expect(f).toHaveProperty('right', filter2);
+    });
+    test('filterFactory.logic.and() with array', () => {
+        const f = filterFactory.logic.and([filter1, filter2], filter2);
+        expect(f).toHaveProperty('operator', 'AND');
+        expect(f).toHaveProperty('left', { operator: 'AND', left: filter1, right: filter2 });
+        expect(f).toHaveProperty('right', filter2);
+    });
+    test('filterFactory.logic.or()', () => {
+        const f = filterFactory.logic.or(filter1, filter2);
+        expect(f).toHaveProperty('operator', 'OR');
+        expect(f).toHaveProperty('left', filter1);
+        expect(f).toHaveProperty('right', filter2);
+    });
+    test('filterFactory.logic.or() with array', () => {
+        const f = filterFactory.logic.or(filter1, [filter1, filter2]);
+        expect(f).toHaveProperty('operator', 'OR');
+        expect(f).toHaveProperty('left', filter1);
+        expect(f).toHaveProperty('right', { operator: 'AND', left: filter1, right: filter2 });
+    });
+});

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

@@ -0,0 +1,321 @@
+import { LevelAttribute, Attribute, Measure, Filter } from '../interfaces.js';
+import { DimensionalElement } from '../base.js';
+/**
+ * Different text operators that can be used with text filters
+ *
+ * @internal
+ */
+export declare const TextOperators: {
+    Contains: string;
+    StartsWith: string;
+    EndsWith: string;
+    Equals: string;
+    DoesntEqual: string;
+    DoesntStartWith: string;
+    DoesntContain: string;
+    DoesntEndWith: string;
+    Like: string;
+};
+/**
+ * Different numeric operators that can be used with numeric filters
+ */
+export declare const NumericOperators: {
+    Equals: string;
+    DoesntEqual: string;
+    From: string;
+    FromNotEqual: string;
+    To: string;
+    ToNotEqual: string;
+};
+/**
+ * Different date operators that can be used with date filters
+ *
+ * @internal
+ */
+export declare const DateOperators: {
+    From: string;
+    To: string;
+    Last: string;
+    Next: string;
+    Anchor: string;
+};
+/**
+ * Different logical operators that can be used with logical filters
+ *
+ * @internal
+ */
+export declare const LogicalOperators: {
+    Union: string;
+    Intersection: string;
+    Exclude: string;
+};
+/**
+ * Different ranking operators that can be used with ranking filter
+ *
+ * @internal
+ */
+export declare const RankingOperators: {
+    Top: string;
+    Bottom: string;
+};
+/**
+ * Different filter types
+ *
+ * @internal
+ */
+export declare const FilterTypes: {
+    logicalAttribute: string;
+    members: string;
+    exclude: string;
+    measure: string;
+    ranking: string;
+    text: string;
+    numeric: string;
+    date: string;
+    relativeDate: string;
+    cascading: string;
+};
+/**
+ * base implementation for filter classes
+ *
+ * @internal
+ */
+declare abstract class AbstractFilter extends DimensionalElement implements Filter {
+    /**
+     * Attribute this filter instance is filtering
+     */
+    readonly attribute: Attribute;
+    /**
+     * Filter type
+     */
+    readonly filterType: string;
+    /**
+     * Global filter identifier
+     */
+    readonly guid: string;
+    /**
+     * Boolean flag whether the filter is disabled
+     *
+     * @internal
+     */
+    disabled: boolean;
+    constructor(att: Attribute, filterType: string, guid?: string);
+    get name(): string;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    abstract filterJaql(): any;
+    /**
+     * gets the element's ID
+     */
+    abstract get id(): string;
+    /**
+     * Defines whether the filter is a scope filters
+     */
+    isScope: boolean;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets the JAQL representation of this instance
+     *
+     * @param nested - defines whether the JAQL is nested within parent JAQL statement or a root JAQL element
+     */
+    jaql(nested?: boolean): any;
+    static checkAttributeSupport(attribute: Attribute): void;
+    static disabledJaql(nested?: boolean): any;
+}
+/**
+ * @internal
+ */
+export declare class LogicalAttributeFilter extends AbstractFilter {
+    readonly filters: Filter[];
+    readonly operator: string;
+    constructor(filters: Filter[], operator: string, guid?: string);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+}
+/**
+ * @internal
+ */
+export declare class MembersFilter extends AbstractFilter {
+    readonly members: any[];
+    constructor(attribute: Attribute, members?: any[], guid?: string);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+}
+/**
+ * @internal
+ */
+export declare class CascadingFilter extends AbstractFilter {
+    readonly filters: Filter[];
+    constructor(filters: Filter[], guid?: string);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+    jaql(nested?: boolean): any;
+}
+/**
+ * @internal
+ */
+export declare class ExcludeFilter extends AbstractFilter {
+    readonly filter: Filter;
+    readonly input?: Filter;
+    constructor(filter: Filter, input?: Filter, guid?: string);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+}
+/**
+ * @internal
+ */
+export declare class DoubleOperatorFilter<Type> extends AbstractFilter {
+    operatorA?: string;
+    operatorB?: string;
+    valueA?: Type;
+    valueB?: Type;
+    constructor(att: Attribute, filterType: string, operatorA?: string, valueA?: Type, operatorB?: string, valueB?: Type, guid?: string);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+}
+/**
+ * @internal
+ */
+export declare class MeasureFilter extends DoubleOperatorFilter<number> {
+    measure: Measure;
+    constructor(att: Attribute, measure: Measure, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number, guid?: string);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    jaql(nested?: boolean | undefined): any;
+}
+/**
+ * @internal
+ */
+export declare class RankingFilter extends AbstractFilter {
+    count: number;
+    operator: string;
+    measure: Measure;
+    constructor(att: Attribute, measure: Measure, operator: string, count: number, guid?: string);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+}
+/**
+ * @internal
+ */
+export declare class NumericFilter extends DoubleOperatorFilter<number> {
+    constructor(att: Attribute, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number, guid?: string);
+}
+/**
+ * @internal
+ */
+export declare class TextFilter extends DoubleOperatorFilter<string> {
+    constructor(att: Attribute, operator: string, value: string, guid?: string);
+}
+/**
+ * @internal
+ */
+export declare class DateRangeFilter extends DoubleOperatorFilter<Date | string> {
+    constructor(l: LevelAttribute, valueFrom?: Date | string, valueTo?: Date | string, guid?: string);
+    get level(): LevelAttribute;
+    get from(): string;
+    get to(): string;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+}
+/**
+ * @internal
+ */
+export declare class RelativeDateFilter extends AbstractFilter {
+    readonly offset: number;
+    readonly count: number;
+    readonly operator: string;
+    readonly anchor?: Date | string;
+    constructor(l: LevelAttribute, offset: number, count: number, operator?: string, anchor?: Date | string, guid?: string);
+    get level(): LevelAttribute;
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets JAQL representing this Filter instance
+     *
+     */
+    filterJaql(): any;
+}
+/**
+ * @param json - Filter JSON representation
+ * @internal
+ */
+export declare function createFilter(json: any): Filter;
+export {};