@sisense/sdk-data 1.7.2 → 1.9.0

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

@@ -0,0 +1,49 @@
+/**
+ * Stringifies the argument
+ *
+ * @param arg - argument to stringify
+ * @returns stringified argument
+ */
+export function stringifyHelper(arg) {
+    try {
+        if (arg === null || arg === undefined) {
+            return JSON.stringify(arg);
+        }
+        if (arg === Object(arg) && 'composeCode' in arg) {
+            return arg.composeCode;
+        }
+        if (Array.isArray(arg)) {
+            return ('[' +
+                arg
+                    .map((e) => {
+                    return stringifyHelper(e);
+                })
+                    .join(', ') +
+                ']');
+        }
+        if (typeof arg === 'string') {
+            return `'${arg}'`;
+        }
+        if (typeof arg === 'number' || !isNaN(arg)) {
+            return arg;
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return JSON.stringify(arg);
+}
+/**
+ * High order function to construct compose code for filter factory functions
+ *
+ * @param func - filter factory function
+ */
+export function withComposeCode(func) {
+    return function (...args) {
+        const argValues = args.map(stringifyHelper).join(', ');
+        const signature = `filterFactory.${func.name}(${argValues})`;
+        const filter = func(...args);
+        filter.composeCode = signature;
+        return filter;
+    };
+}

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

@@ -0,0 +1,67 @@
+import { ConditionFilterJaql, FilterJaqlInternal, PeriodFilterJaql, RangeFilterJaql, SpecificItemsFilterJaql } from './types.js';
+import { Attribute, BaseMeasure, 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.
+ *
+ * @param jaql - The JAQL object.
+ * @param instanceid - The instance ID.
+ * @returns A generic Filter object.
+ */
+export declare const createGenericFilter: (jaql: FilterJaql | FilterJaqlInternal, instanceid?: string) => Filter;
+/**
+ * Creates a filter that includes all members of the attribute.
+ *
+ * @param attribute - The attribute.
+ * @returns The created Filter object.
+ */
+export declare const createFilterIncludeAll: (attribute: Attribute) => Filter;
+/**
+ * Creates a filter from a specific items filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param specificItemsFilterJaql - Specific Items Filter Jaql
+ * @returns Filter object
+ */
+export declare const createFilterFromSpecificItemsFilterJaql: (attribute: Attribute, specificItemsFilterJaql: SpecificItemsFilterJaql) => Filter;
+/**
+ * Creates a filter from a date range filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param rangeFilterJaql - Range Filter Jaql
+ * @returns Filter object
+ */
+export declare const createFilterFromDateRangeFilterJaql: (attribute: LevelAttribute, rangeFilterJaql: RangeFilterJaql) => Filter;
+/**
+ * Creates a filter from a numeric range filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param rangeFilterJaql - Range Filter Jaql
+ * @returns Filter object
+ */
+export declare const createFilterFromNumericRangeJaql: (attribute: Attribute, rangeFilterJaql: RangeFilterJaql) => Filter;
+/**
+ * Creates a filter from a period filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param periodFilterJaql - Period Filter Jaql
+ * @returns Filter object
+ */
+export declare const createFilterFromPeriodFilterJaql: (attribute: LevelAttribute, periodFilterJaql: PeriodFilterJaql) => Filter;
+/**
+ * Creates a filter from a condition filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param conditionFilterJaql - Condition Filter Jaql
+ * @param measure - measure
+ * @returns Filter object
+ */
+export declare const createFilterFromConditionFilterJaql: (attribute: Attribute, conditionFilterJaql: ConditionFilterJaql, measure?: BaseMeasure) => Filter;
+/**
+ * Creates a filter from a filter JAQL object.
+ *
+ * @param jaql - The filter JAQL object.
+ * @param instanceid - The instance ID.
+ * @returns Filter object.
+ */
+export declare const createFilterFromJaqlInternal: (jaql: FilterJaqlInternal, instanceid?: string) => Filter;

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

@@ -0,0 +1,149 @@
+import { FILTER_TYPES, } from './types.js';
+import * as filterFactory from '../factory.js';
+import { createAttributeFilterFromConditionFilterJaql, createMeasureFilterFromConditionFilterJaql, } from './condition-filter-util.js';
+import { extractFilterTypeFromFilterJaql } from './filter-types-util.js';
+import { withComposeCode } from './filter-code-util.js';
+import { createAttributeFromFilterJaql, createMeasureFromFilterJaql, } from './attribute-measure-util.js';
+/**
+ * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
+ *
+ * @param jaql - The JAQL object.
+ * @param instanceid - The instance ID.
+ * @returns A generic Filter object.
+ */
+export const createGenericFilter = (jaql, instanceid) => {
+    return {
+        guid: instanceid,
+        jaql: (nested) => {
+            if (nested) {
+                return jaql;
+            }
+            return {
+                jaql,
+                panel: 'scope',
+            };
+        },
+        attribute: {
+            id: jaql.dim,
+        },
+        type: 'filter',
+        serializable() {
+            return Object.assign(Object.assign({}, this), { jaql: this.jaql() });
+        },
+        toJSON() {
+            return this.serializable();
+        },
+    };
+};
+/**
+ * Creates a filter that includes all members of the attribute.
+ *
+ * @param attribute - The attribute.
+ * @returns The created Filter object.
+ */
+export const createFilterIncludeAll = (attribute) => {
+    return withComposeCode(filterFactory.members)(attribute, []);
+};
+/**
+ * Creates a filter from a specific items filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param specificItemsFilterJaql - Specific Items Filter Jaql
+ * @returns Filter object
+ */
+export const createFilterFromSpecificItemsFilterJaql = (attribute, specificItemsFilterJaql) => {
+    return withComposeCode(filterFactory.members)(attribute, specificItemsFilterJaql.members);
+};
+/**
+ * Creates a filter from a date range filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param rangeFilterJaql - Range Filter Jaql
+ * @returns Filter object
+ */
+export const createFilterFromDateRangeFilterJaql = (attribute, rangeFilterJaql) => {
+    return withComposeCode(filterFactory.dateRange)(attribute, rangeFilterJaql.from, rangeFilterJaql.to);
+};
+/**
+ * Creates a filter from a numeric range filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param rangeFilterJaql - Range Filter Jaql
+ * @returns Filter object
+ */
+export const createFilterFromNumericRangeJaql = (attribute, rangeFilterJaql) => {
+    return withComposeCode(filterFactory.between)(attribute, rangeFilterJaql.from, rangeFilterJaql.to);
+};
+/**
+ * Creates a filter from a period filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param periodFilterJaql - Period Filter Jaql
+ * @returns Filter object
+ */
+export const createFilterFromPeriodFilterJaql = (attribute, periodFilterJaql) => {
+    if (periodFilterJaql.last) {
+        return withComposeCode(filterFactory.dateRelativeTo)(attribute, periodFilterJaql.last.offset, periodFilterJaql.last.count, periodFilterJaql.last.anchor);
+    }
+    else {
+        return withComposeCode(filterFactory.dateRelativeFrom)(attribute, periodFilterJaql.next.offset, periodFilterJaql.next.count, periodFilterJaql.next.anchor);
+    }
+};
+/**
+ * Creates a filter from a condition filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param conditionFilterJaql - Condition Filter Jaql
+ * @param measure - measure
+ * @returns Filter object
+ */
+export const createFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, measure) => {
+    if (measure) {
+        return createMeasureFilterFromConditionFilterJaql(measure, conditionFilterJaql);
+    }
+    else {
+        return createAttributeFilterFromConditionFilterJaql(attribute, conditionFilterJaql);
+    }
+};
+/**
+ * Creates a filter from a filter JAQL object.
+ *
+ * @param jaql - The filter JAQL object.
+ * @param instanceid - The instance ID.
+ * @returns Filter object.
+ */
+export const createFilterFromJaqlInternal = (jaql, instanceid) => {
+    try {
+        if ('formula' in jaql) {
+            // generic pass-through JAQL filter will be used instead
+            throw 'Formula-based filter not supported yet: ' + JSON.stringify(jaql);
+        }
+        const filterJaqlWrapperWithType = extractFilterTypeFromFilterJaql(jaql, jaql.datatype);
+        const { filter: filterJaqlWithType } = filterJaqlWrapperWithType;
+        const { filterType } = filterJaqlWithType;
+        const attribute = createAttributeFromFilterJaql(jaql);
+        const measure = createMeasureFromFilterJaql(jaql);
+        switch (filterType) {
+            case FILTER_TYPES.INCLUDE_ALL:
+                return createFilterIncludeAll(attribute);
+            case FILTER_TYPES.SPECIFIC_ITEMS:
+                return createFilterFromSpecificItemsFilterJaql(attribute, filterJaqlWithType);
+            case FILTER_TYPES.CONDITION:
+                return createFilterFromConditionFilterJaql(attribute, filterJaqlWithType, measure);
+            case FILTER_TYPES.DATE_RANGE:
+                return createFilterFromDateRangeFilterJaql(attribute, filterJaqlWithType);
+            case FILTER_TYPES.PERIOD:
+                return createFilterFromPeriodFilterJaql(attribute, filterJaqlWithType);
+            case FILTER_TYPES.NUMERIC_RANGE:
+                return createFilterFromNumericRangeJaql(attribute, filterJaqlWithType);
+            case FILTER_TYPES.ADVANCED:
+            case FILTER_TYPES.INVALID:
+                return createGenericFilter(jaql, instanceid);
+        }
+    }
+    catch (e) {
+        // if a filter type is untranslatable, fall back to the generic pass-through JAQL filter
+        // console.error(e);
+    }
+    return createGenericFilter(jaql, instanceid);
+};

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

@@ -0,0 +1,15 @@
+import { FilterModalType, AnyTypeFilterJaql, DatetimeLevel, FilterType, FilterJaqlInternal, FilterJaqlWrapperWithType } from './types.js';
+export declare const isNumericRangeFilter: (filter: AnyTypeFilterJaql) => boolean;
+export declare const getFilterType: (filter: AnyTypeFilterJaql, dataType?: FilterModalType, timeData?: {
+    level?: DatetimeLevel;
+    bucket?: string;
+}) => FilterType;
+/**
+ * Extracts Filter Type from Filter Jaql
+ *
+ * @param jaql - jaql
+ * @param dataType - data type
+ * @return FilterJaqlWrapperType
+ * @internal
+ */
+export declare const extractFilterTypeFromFilterJaql: (jaql: FilterJaqlInternal, dataType: FilterModalType) => FilterJaqlWrapperWithType;

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

@@ -0,0 +1,71 @@
+import { getSelectedConditionOption } from './condition-filter-util.js';
+import { FilterModalType, DatetimeLevel, FILTER_TYPES, nonSupportedMinutesBuckets, ConditionFilterType, DEFAULT_FILTER_JAQL_WRAPPER, } from './types.js';
+import { getCorrectTimeLevel } from './date-time-filter-util.js';
+const isIncludeAllFilter = (filter) => filter === null || filter === void 0 ? void 0 : filter.all;
+const getInnerPeriodFilter = (filter) => (filter.last ? filter.last : filter.next);
+const isPeriodFilter = (filter) => { var _a; return ((_a = getInnerPeriodFilter(filter)) === null || _a === void 0 ? void 0 : _a.offset) < 2; };
+const isSpecificItemsFilter = (filter) => { var _a; return ((_a = filter === null || filter === void 0 ? void 0 : filter.members) === null || _a === void 0 ? void 0 : _a.length) > 0; };
+const isFromOrToDefined = (fromRange, toRange) => (fromRange && typeof fromRange === 'string') || (toRange && typeof toRange === 'string');
+const isFromAndToEmpty = (from, to) => from === '' && to === '';
+const isDateRangeFilter = (filter, dataType) => {
+    const { from, to } = filter;
+    if (dataType !== FilterModalType.DATE_TIME)
+        return false;
+    if (isFromOrToDefined(from, to))
+        return true;
+    return isFromAndToEmpty(from, to);
+};
+export const isNumericRangeFilter = (filter) => {
+    const { from, to } = filter;
+    return !!(from !== undefined && to !== undefined && !filter.isBetween);
+};
+const isConditionFilter = (filter) => getSelectedConditionOption(filter) !== ConditionFilterType.NONE;
+const isAdvancedFilter = (filter) => Object.keys(filter).includes('isAdvanced');
+const isTimeLevelNotSupported = (timeData) => !!(timeData.level &&
+    timeData.bucket &&
+    timeData.level === DatetimeLevel.MINUTES &&
+    nonSupportedMinutesBuckets.includes(timeData.bucket));
+const isInvalidFilter = (filter) => filter.filterType === FILTER_TYPES.INVALID;
+export const getFilterType = (filter, dataType = FilterModalType.DATE_TIME, timeData) => {
+    if (timeData && isTimeLevelNotSupported(timeData))
+        return FILTER_TYPES.ADVANCED;
+    if (isIncludeAllFilter(filter))
+        return FILTER_TYPES.INCLUDE_ALL;
+    if (isPeriodFilter(filter))
+        return FILTER_TYPES.PERIOD;
+    if (isSpecificItemsFilter(filter))
+        return FILTER_TYPES.SPECIFIC_ITEMS;
+    if (isDateRangeFilter(filter, dataType))
+        return FILTER_TYPES.DATE_RANGE;
+    if (isNumericRangeFilter(filter))
+        return FILTER_TYPES.NUMERIC_RANGE;
+    if (isConditionFilter(filter))
+        return FILTER_TYPES.CONDITION;
+    if (isAdvancedFilter(filter))
+        return FILTER_TYPES.ADVANCED;
+    if (isInvalidFilter(filter))
+        return FILTER_TYPES.INVALID;
+    return FILTER_TYPES.ADVANCED;
+};
+/**
+ * Extracts Filter Type from Filter Jaql
+ *
+ * @param jaql - jaql
+ * @param dataType - data type
+ * @return FilterJaqlWrapperType
+ * @internal
+ */
+export const extractFilterTypeFromFilterJaql = (jaql, dataType) => {
+    const { level: filterLevel, filter, bucket } = jaql;
+    const filterFromJaql = filter || DEFAULT_FILTER_JAQL_WRAPPER.filter;
+    const filterToReturn = {
+        filter: Object.assign(Object.assign({}, filterFromJaql), { filterType: getFilterType(filterFromJaql, dataType) }),
+    };
+    if (dataType === FilterModalType.DATE_TIME) {
+        const backgroundFilter = filterFromJaql;
+        const level = (backgroundFilter === null || backgroundFilter === void 0 ? void 0 : backgroundFilter.level) || filterLevel;
+        filterToReturn.level = getCorrectTimeLevel(level, bucket);
+        filterToReturn.filter.filterType = getFilterType(filterFromJaql, dataType, { level, bucket });
+    }
+    return filterToReturn;
+};

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

@@ -0,0 +1,200 @@
+declare type RequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
+}[Keys];
+export declare type JaqlContext = Record<string, Partial<FilterJaqlInternal>>;
+export declare type Id = string;
+export declare type Datasource = {
+    address: Id;
+    database: string;
+    id: string;
+    title: string;
+    live?: boolean;
+    fullname: string;
+    lastBuildTime?: string;
+    revisionId?: string;
+};
+export declare enum GeneralFilterType {
+    INCLUDE_ALL = "INCLUDE_ALL",
+    ADVANCED = "ADVANCED",
+    INVALID = "INVALID",
+    CONDITION = "CONDITION",
+    SPECIFIC_ITEMS = "SPECIFIC_ITEMS"
+}
+export declare enum DateTimeFilterType {
+    PERIOD = "PERIOD",
+    DATE_RANGE = "DATE_RANGE"
+}
+export declare enum NumericFilterType {
+    NUMERIC_RANGE = "NUMERIC_RANGE"
+}
+export declare type FilterType = GeneralFilterType | DateTimeFilterType | NumericFilterType;
+export interface BaseFilterJaql {
+    filterType?: FilterType;
+    custom?: boolean;
+    isAdvanced?: boolean;
+    rankingMessage?: string;
+    isBetween?: boolean;
+    isEmpty?: boolean;
+}
+export interface IncludeAllFilterJaql extends BaseFilterJaql {
+    all: boolean;
+}
+export declare type PeriodFilterDetails = {
+    count: number;
+    offset: number;
+    anchor?: string;
+};
+export interface PeriodFilterJaqlOptions extends BaseFilterJaql {
+    last: PeriodFilterDetails;
+    next: PeriodFilterDetails;
+    multiSelection?: boolean;
+    isNotCurrentPeriod?: boolean;
+}
+export declare type PeriodFilterJaql = RequireOnlyOne<PeriodFilterJaqlOptions, 'last' | 'next'>;
+export interface RangeFilterJaql extends BaseFilterJaql {
+    from?: string | number;
+    to?: string | number;
+    multiSelection?: boolean;
+}
+export declare type RankingFilterJaql = {
+    agg: string;
+    column: string;
+    datatype: string;
+    dim: string;
+    level?: string;
+    merged?: boolean;
+    table: string;
+};
+export declare type FilterMultiSelectJaql = {
+    explicit?: boolean;
+    multiSelection: boolean;
+    members: string[];
+    isCondition?: boolean;
+};
+export declare type FilterMultipleConditionJaql = {
+    or: ConditionFilterJaql[];
+    and: ConditionFilterJaql[];
+};
+export declare type ConditionFilterJaqlOptions = BaseFilterJaql & {
+    top: number;
+    bottom: number;
+    exclude: {
+        members?: string[];
+        from?: number;
+        to?: number;
+    };
+    startsWith: string;
+    doesntStartWith: string;
+    endsWith: string;
+    doesntEndWith: string;
+    doesntContain: string;
+    equals: number | string;
+    doesntEqual: number | string;
+    to: number;
+    toNotEqual: number;
+    from: number;
+    fromNotEqual: number;
+    contains: string;
+    by?: RankingFilterJaql;
+    rankingMessage?: string;
+} & Partial<FilterMultiSelectJaql> & Partial<PeriodFilterJaql> & Partial<RangeFilterJaql> & Partial<FilterMultipleConditionJaql>;
+export declare type ConditionFilterJaql = RequireOnlyOne<ConditionFilterJaqlOptions, 'top' | 'bottom' | 'exclude' | 'last' | 'next' | 'contains' | 'equals' | 'doesntEqual' | 'to' | 'toNotEqual' | 'from' | 'fromNotEqual' | 'startsWith' | 'doesntStartWith' | 'endsWith' | 'doesntEndWith' | 'doesntContain' | 'or' | 'and'>;
+export declare type InvalidTypeFilterJaql = BaseFilterJaql;
+export declare type SpecificItemsFilterJaql = BaseFilterJaql & FilterMultiSelectJaql;
+export declare type AnyTypeFilterJaql = IncludeAllFilterJaql | PeriodFilterJaql | RangeFilterJaql | ConditionFilterJaql | InvalidTypeFilterJaql | SpecificItemsFilterJaql;
+export declare enum DatetimeLevel {
+    YEARS = "years",
+    QUARTERS = "quarters",
+    MONTHS = "months",
+    WEEKS = "weeks",
+    DAYS = "days",
+    HOURS = "hours",
+    MINUTES = "minutes"
+}
+export declare type FilterJaqlInternal = {
+    title: string;
+    column: string;
+    datasource?: Datasource;
+    datatype: string;
+    dim: string;
+    dimension?: string;
+    fiscal?: string;
+    firstday?: string;
+    merged?: boolean;
+    table: string;
+    filter?: AnyTypeFilterJaql;
+    level?: DatetimeLevel;
+    locale?: string;
+    bucket?: string;
+    collapsed?: boolean;
+    isDashboardFilter?: boolean;
+    formula?: string;
+    context?: JaqlContext;
+    agg?: string;
+};
+export declare enum FilterModalType {
+    DATE_TIME = "datetime",
+    NUMERIC = "numeric",
+    TEXT = "text"
+}
+export declare type BackgroundFilterExtraProps = {
+    level?: DatetimeLevel;
+    turnedOff?: boolean;
+};
+export declare type BackgroundFilter = {
+    filter?: AnyTypeFilterJaql & BackgroundFilterExtraProps;
+};
+export declare type FilterJaqlWrapperWithType = {
+    filter: AnyTypeFilterJaql & BackgroundFilter;
+    level?: DatetimeLevel;
+    agg?: string;
+};
+export declare const nonSupportedMinutesBuckets: string[];
+export declare const FILTER_TYPES: {
+    NUMERIC_RANGE: NumericFilterType.NUMERIC_RANGE;
+    PERIOD: DateTimeFilterType.PERIOD;
+    DATE_RANGE: DateTimeFilterType.DATE_RANGE;
+    INCLUDE_ALL: GeneralFilterType.INCLUDE_ALL;
+    ADVANCED: GeneralFilterType.ADVANCED;
+    INVALID: GeneralFilterType.INVALID;
+    CONDITION: GeneralFilterType.CONDITION;
+    SPECIFIC_ITEMS: GeneralFilterType.SPECIFIC_ITEMS;
+};
+export declare type FilterJaqlByTypeMap = {
+    [FILTER_TYPES.INCLUDE_ALL]: IncludeAllFilterJaql;
+    [FILTER_TYPES.PERIOD]: PeriodFilterJaql;
+    [FILTER_TYPES.DATE_RANGE]: RangeFilterJaql;
+    [FILTER_TYPES.NUMERIC_RANGE]: RangeFilterJaql;
+    [FILTER_TYPES.CONDITION]: ConditionFilterJaql;
+    [FILTER_TYPES.SPECIFIC_ITEMS]: SpecificItemsFilterJaql;
+};
+export declare const DEFAULT_FILTER_JAQL_BY_TYPE_MAP: FilterJaqlByTypeMap;
+export declare const DEFAULT_FILTER_JAQL_WRAPPER: FilterJaqlWrapperWithType;
+export declare enum ConditionFilterType {
+    IS = "members",
+    IS_NOT = "exclude",
+    IS_WITHIN = "isWithin",
+    TOP = "top",
+    BOTTOM = "bottom",
+    AFTER = "after",
+    BEFORE = "before",
+    STARTS_WITH = "startsWith",
+    DOESNT_START_WITH = "doesntStartWith",
+    ENDS_WITH = "endsWith",
+    DOESNT_END_WITH = "doesntEndWith",
+    CONTAINS = "contains",
+    DOESNT_CONTAIN = "doesntContain",
+    EQUALS = "equals",
+    DOESNT_EQUAL = "doesntEqual",
+    IS_EMPTY = "isEmpty",
+    IS_NOT_EMPTY = "isNotEmpty",
+    GREATER_THAN = "fromNotEqual",
+    GREATER_THAN_OR_EQUAL = "from",
+    LESS_THAN = "toNotEqual",
+    LESS_THAN_OR_EQUAL = "to",
+    BETWEEN = "between",
+    IS_NOT_BETWEEN = "isNotBetween",
+    MULTIPLE_CONDITION = "multipleCondition",
+    NONE = "none"
+}
+export {};

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

@@ -0,0 +1,96 @@
+export var GeneralFilterType;
+(function (GeneralFilterType) {
+    GeneralFilterType["INCLUDE_ALL"] = "INCLUDE_ALL";
+    GeneralFilterType["ADVANCED"] = "ADVANCED";
+    GeneralFilterType["INVALID"] = "INVALID";
+    GeneralFilterType["CONDITION"] = "CONDITION";
+    GeneralFilterType["SPECIFIC_ITEMS"] = "SPECIFIC_ITEMS";
+})(GeneralFilterType = GeneralFilterType || (GeneralFilterType = {}));
+export var DateTimeFilterType;
+(function (DateTimeFilterType) {
+    DateTimeFilterType["PERIOD"] = "PERIOD";
+    DateTimeFilterType["DATE_RANGE"] = "DATE_RANGE";
+})(DateTimeFilterType = DateTimeFilterType || (DateTimeFilterType = {}));
+export var NumericFilterType;
+(function (NumericFilterType) {
+    NumericFilterType["NUMERIC_RANGE"] = "NUMERIC_RANGE";
+})(NumericFilterType = NumericFilterType || (NumericFilterType = {}));
+export var DatetimeLevel;
+(function (DatetimeLevel) {
+    DatetimeLevel["YEARS"] = "years";
+    DatetimeLevel["QUARTERS"] = "quarters";
+    DatetimeLevel["MONTHS"] = "months";
+    DatetimeLevel["WEEKS"] = "weeks";
+    DatetimeLevel["DAYS"] = "days";
+    DatetimeLevel["HOURS"] = "hours";
+    DatetimeLevel["MINUTES"] = "minutes";
+})(DatetimeLevel = DatetimeLevel || (DatetimeLevel = {}));
+export var FilterModalType;
+(function (FilterModalType) {
+    FilterModalType["DATE_TIME"] = "datetime";
+    FilterModalType["NUMERIC"] = "numeric";
+    FilterModalType["TEXT"] = "text";
+})(FilterModalType = FilterModalType || (FilterModalType = {}));
+export const nonSupportedMinutesBuckets = ['1', '30'];
+export const FILTER_TYPES = Object.assign(Object.assign(Object.assign({}, GeneralFilterType), DateTimeFilterType), NumericFilterType);
+export const DEFAULT_FILTER_JAQL_BY_TYPE_MAP = {
+    [FILTER_TYPES.INCLUDE_ALL]: {
+        all: true,
+        filterType: FILTER_TYPES.INCLUDE_ALL,
+    },
+    [FILTER_TYPES.PERIOD]: {
+        last: { count: 1, offset: 1 },
+        isNotCurrentPeriod: true,
+        filterType: FILTER_TYPES.PERIOD,
+    },
+    [FILTER_TYPES.DATE_RANGE]: {
+        filterType: FILTER_TYPES.DATE_RANGE,
+    },
+    [FILTER_TYPES.NUMERIC_RANGE]: {
+        filterType: FILTER_TYPES.NUMERIC_RANGE,
+    },
+    [FILTER_TYPES.CONDITION]: {
+        explicit: false,
+        multiSelection: true,
+        exclude: { members: [] },
+        filterType: FILTER_TYPES.CONDITION,
+    },
+    [FILTER_TYPES.SPECIFIC_ITEMS]: {
+        explicit: true,
+        multiSelection: true,
+        members: [],
+        filterType: FILTER_TYPES.SPECIFIC_ITEMS,
+    },
+};
+export const DEFAULT_FILTER_JAQL_WRAPPER = {
+    filter: DEFAULT_FILTER_JAQL_BY_TYPE_MAP.INCLUDE_ALL,
+    level: DatetimeLevel.YEARS,
+};
+export var ConditionFilterType;
+(function (ConditionFilterType) {
+    ConditionFilterType["IS"] = "members";
+    ConditionFilterType["IS_NOT"] = "exclude";
+    ConditionFilterType["IS_WITHIN"] = "isWithin";
+    ConditionFilterType["TOP"] = "top";
+    ConditionFilterType["BOTTOM"] = "bottom";
+    ConditionFilterType["AFTER"] = "after";
+    ConditionFilterType["BEFORE"] = "before";
+    ConditionFilterType["STARTS_WITH"] = "startsWith";
+    ConditionFilterType["DOESNT_START_WITH"] = "doesntStartWith";
+    ConditionFilterType["ENDS_WITH"] = "endsWith";
+    ConditionFilterType["DOESNT_END_WITH"] = "doesntEndWith";
+    ConditionFilterType["CONTAINS"] = "contains";
+    ConditionFilterType["DOESNT_CONTAIN"] = "doesntContain";
+    ConditionFilterType["EQUALS"] = "equals";
+    ConditionFilterType["DOESNT_EQUAL"] = "doesntEqual";
+    ConditionFilterType["IS_EMPTY"] = "isEmpty";
+    ConditionFilterType["IS_NOT_EMPTY"] = "isNotEmpty";
+    ConditionFilterType["GREATER_THAN"] = "fromNotEqual";
+    ConditionFilterType["GREATER_THAN_OR_EQUAL"] = "from";
+    ConditionFilterType["LESS_THAN"] = "toNotEqual";
+    ConditionFilterType["LESS_THAN_OR_EQUAL"] = "to";
+    ConditionFilterType["BETWEEN"] = "between";
+    ConditionFilterType["IS_NOT_BETWEEN"] = "isNotBetween";
+    ConditionFilterType["MULTIPLE_CONDITION"] = "multipleCondition";
+    ConditionFilterType["NONE"] = "none";
+})(ConditionFilterType = ConditionFilterType || (ConditionFilterType = {}));