@omnia/fx-models 8.0.401-dev → 8.0.403-dev

package/QueryFilter.d.ts

@@ -1,15 +1,15 @@
 export declare enum FilterOperator {
-    Eq = 1,
-    Ne = 2,
-    Lt = 3,
-    Gt = 4,
-    Le = 5,
-    Ge = 6,
+    Equal = 1,
+    NotEqual = 2,
+    LessThan = 3,
+    GreaterThan = 4,
+    LessThanOrEqual = 5,
+    GreaterThanOrEqual = 6,
     In = 7,
     Like = 8,
     NotLike = 9,
-    Ba = 10,
-    BNa = 11,
+    BitwiseAnd = 10,
+    BitwiseNotAnd = 11,
     NotIn = 12
 }
 export declare enum FilterLogicalOperator {

package/QueryFilter.js

@@ -3,17 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilterLogicalOperator = exports.FilterOperator = void 0;
 var FilterOperator;
 (function (FilterOperator) {
-    FilterOperator[FilterOperator["Eq"] = 1] = "Eq";
-    FilterOperator[FilterOperator["Ne"] = 2] = "Ne";
-    FilterOperator[FilterOperator["Lt"] = 3] = "Lt";
-    FilterOperator[FilterOperator["Gt"] = 4] = "Gt";
-    FilterOperator[FilterOperator["Le"] = 5] = "Le";
-    FilterOperator[FilterOperator["Ge"] = 6] = "Ge";
+    FilterOperator[FilterOperator["Equal"] = 1] = "Equal";
+    FilterOperator[FilterOperator["NotEqual"] = 2] = "NotEqual";
+    FilterOperator[FilterOperator["LessThan"] = 3] = "LessThan";
+    FilterOperator[FilterOperator["GreaterThan"] = 4] = "GreaterThan";
+    FilterOperator[FilterOperator["LessThanOrEqual"] = 5] = "LessThanOrEqual";
+    FilterOperator[FilterOperator["GreaterThanOrEqual"] = 6] = "GreaterThanOrEqual";
     FilterOperator[FilterOperator["In"] = 7] = "In";
     FilterOperator[FilterOperator["Like"] = 8] = "Like";
     FilterOperator[FilterOperator["NotLike"] = 9] = "NotLike";
-    FilterOperator[FilterOperator["Ba"] = 10] = "Ba";
-    FilterOperator[FilterOperator["BNa"] = 11] = "BNa";
+    FilterOperator[FilterOperator["BitwiseAnd"] = 10] = "BitwiseAnd";
+    FilterOperator[FilterOperator["BitwiseNotAnd"] = 11] = "BitwiseNotAnd";
     FilterOperator[FilterOperator["NotIn"] = 12] = "NotIn";
 })(FilterOperator || (exports.FilterOperator = FilterOperator = {}));
 var FilterLogicalOperator;

package/filterbuilder/FilterBuilder.d.ts

@@ -2,22 +2,20 @@ import { FilterLogicalOperator } from "../QueryFilter";
 import { FilterComponent } from "./FilterComponent";
 import { IBooleanFilterOperatorBuilder, IDateTimeFilterOperatorBuilder, IDateTimeOffsetFilterOperatorBuilder, IFloatFilterOperatorBuilder, IIntFilterOperatorBuilder, IStringFilterOperatorBuilder } from "./FilterOperatorBuilder";
 export interface IFilterComponentBuilder {
-    intProperty(propertyName: string): IIntFilterOperatorBuilder;
-    floatProperty(propertyName: string): IFloatFilterOperatorBuilder;
-    dateTimeProperty(propertyName: string): IDateTimeFilterOperatorBuilder;
-    dateTimeOffsetProperty(propertyName: string): IDateTimeOffsetFilterOperatorBuilder;
-    stringProperty(propertyName: string): IStringFilterOperatorBuilder;
-    booleanProperty(propertyName: string): IBooleanFilterOperatorBuilder;
+    int(propertyName: string): IIntFilterOperatorBuilder;
+    float(propertyName: string): IFloatFilterOperatorBuilder;
+    dateTime(propertyName: string): IDateTimeFilterOperatorBuilder;
+    dateTimeOffset(propertyName: string): IDateTimeOffsetFilterOperatorBuilder;
+    string(propertyName: string): IStringFilterOperatorBuilder;
+    boolean(propertyName: string): IBooleanFilterOperatorBuilder;
     expression(buildInnerExpression: (builder: IFilterComponentBuilder) => IFilterLogicalOperatorBuilder): IFilterLogicalOperatorBuilder;
 }
 export interface IFilterLogicalOperatorBuilder {
     and(): IFilterComponentBuilder;
     or(): IFilterComponentBuilder;
-    getResult(): FilterComponent[];
+    build(): FilterComponent[];
 }
-export interface IFilterBuilder extends IFilterComponentBuilder, IFilterLogicalOperatorBuilder {
-}
-export declare class FilterBuilder implements IFilterBuilder {
+export declare class FilterBuilder implements IFilterComponentBuilder, IFilterLogicalOperatorBuilder {
     private filters;
     private intFilterOperatorBuilder?;
     private floatFilterOperatorBuilder?;
@@ -31,12 +29,12 @@ export declare class FilterBuilder implements IFilterBuilder {
     addFilter(filterComponent: FilterComponent): void;
     and(): IFilterComponentBuilder;
     or(): IFilterComponentBuilder;
-    getResult(): FilterComponent[];
-    intProperty(propertyName: string): IIntFilterOperatorBuilder;
-    floatProperty(propertyName: string): IFloatFilterOperatorBuilder;
-    dateTimeProperty(propertyName: string): IDateTimeFilterOperatorBuilder;
-    dateTimeOffsetProperty(propertyName: string): IDateTimeOffsetFilterOperatorBuilder;
-    stringProperty(propertyName: string): IStringFilterOperatorBuilder;
-    booleanProperty(propertyName: string): IBooleanFilterOperatorBuilder;
+    build(): FilterComponent[];
+    int(propertyName: string): IIntFilterOperatorBuilder;
+    float(propertyName: string): IFloatFilterOperatorBuilder;
+    dateTime(propertyName: string): IDateTimeFilterOperatorBuilder;
+    dateTimeOffset(propertyName: string): IDateTimeOffsetFilterOperatorBuilder;
+    string(propertyName: string): IStringFilterOperatorBuilder;
+    boolean(propertyName: string): IBooleanFilterOperatorBuilder;
     expression(buildInnerExpression: (builder: IFilterComponentBuilder) => IFilterLogicalOperatorBuilder): IFilterLogicalOperatorBuilder;
 }

package/filterbuilder/FilterBuilder.js

@@ -25,40 +25,40 @@ class FilterBuilder {
         this.filterLogicalOperator = QueryFilter_1.FilterLogicalOperator.Or;
         return this;
     }
-    getResult() {
+    build() {
         return this.filters;
     }
-    intProperty(propertyName) {
+    int(propertyName) {
         this.propertyName = propertyName;
         this.intFilterOperatorBuilder =
             this.intFilterOperatorBuilder || new FilterOperatorBuilder_1.IntFilterOperatorBuilder(this);
         return this.intFilterOperatorBuilder;
     }
-    floatProperty(propertyName) {
+    float(propertyName) {
         this.propertyName = propertyName;
         this.floatFilterOperatorBuilder =
             this.floatFilterOperatorBuilder || new FilterOperatorBuilder_1.FloatFilterOperatorBuilder(this);
         return this.floatFilterOperatorBuilder;
     }
-    dateTimeProperty(propertyName) {
+    dateTime(propertyName) {
         this.propertyName = propertyName;
         this.dateTimeFilterOperatorBuilder =
             this.dateTimeFilterOperatorBuilder || new FilterOperatorBuilder_1.DateTimeFilterOperatorBuilder(this);
         return this.dateTimeFilterOperatorBuilder;
     }
-    dateTimeOffsetProperty(propertyName) {
+    dateTimeOffset(propertyName) {
         this.propertyName = propertyName;
         this.dateTimeOffsetFilterOperatorBuilder =
             this.dateTimeOffsetFilterOperatorBuilder || new FilterOperatorBuilder_1.DateTimeOffsetFilterOperatorBuilder(this);
         return this.dateTimeOffsetFilterOperatorBuilder;
     }
-    stringProperty(propertyName) {
+    string(propertyName) {
         this.propertyName = propertyName;
         this.stringFilterOperatorBuilder =
             this.stringFilterOperatorBuilder || new FilterOperatorBuilder_1.StringFilterOperatorBuilder(this);
         return this.stringFilterOperatorBuilder;
     }
-    booleanProperty(propertyName) {
+    boolean(propertyName) {
         this.propertyName = propertyName;
         this.booleanFilterOperatorBuilder =
             this.booleanFilterOperatorBuilder || new FilterOperatorBuilder_1.BooleanFilterOperatorBuilder(this);
@@ -66,8 +66,7 @@ class FilterBuilder {
     }
     expression(buildInnerExpression) {
         const innerFilterBuilder = new FilterBuilder([]);
-        buildInnerExpression(innerFilterBuilder);
-        const innerFilters = innerFilterBuilder.getResult();
+        const innerFilters = buildInnerExpression(innerFilterBuilder).build();
         if (innerFilters.length === 0) {
             throw new Error("There must be at least 1 filter in the expression.");
         }

package/filterbuilder/FilterComponent.d.ts

@@ -1,7 +1,7 @@
 import { FilterLogicalOperator, FilterOperator } from "../QueryFilter";
 export declare enum FilterComponentType {
-    Condition = 0,
-    Expression = 1
+    Condition = 1,
+    Expression = 2
 }
 export interface FilterComponent {
     filterLogicalOperator: FilterLogicalOperator;

package/filterbuilder/FilterComponent.js

@@ -4,8 +4,8 @@ exports.FilterExpressionComponent = exports.FilterConditionComponent = exports.F
 const QueryFilter_1 = require("../QueryFilter");
 var FilterComponentType;
 (function (FilterComponentType) {
-    FilterComponentType[FilterComponentType["Condition"] = 0] = "Condition";
-    FilterComponentType[FilterComponentType["Expression"] = 1] = "Expression";
+    FilterComponentType[FilterComponentType["Condition"] = 1] = "Condition";
+    FilterComponentType[FilterComponentType["Expression"] = 2] = "Expression";
 })(FilterComponentType || (exports.FilterComponentType = FilterComponentType = {}));
 class FilterConditionComponent {
     constructor(propertyName, filterOperator, values, filterLogicalOperator = QueryFilter_1.FilterLogicalOperator.And) {

package/filterbuilder/FilterOperatorBuilder.d.ts

@@ -1,18 +1,17 @@
 import { FilterBuilder, IFilterLogicalOperatorBuilder } from "./FilterBuilder";
 export interface IFilterOperatorBuilder<T> {
-    eq(value: T): IFilterLogicalOperatorBuilder;
-    eq(value: T): IFilterLogicalOperatorBuilder;
-    ne(value: T): IFilterLogicalOperatorBuilder;
+    equals(value: T): IFilterLogicalOperatorBuilder;
+    notEquals(value: T): IFilterLogicalOperatorBuilder;
     isNull(): IFilterLogicalOperatorBuilder;
     isNotNull(): IFilterLogicalOperatorBuilder;
     in(values: T[]): IFilterLogicalOperatorBuilder;
     notIn(values: T[]): IFilterLogicalOperatorBuilder;
 }
 export interface IComparableFilterOperatorBuilder<T> extends IFilterOperatorBuilder<T> {
-    lt(value: T): IFilterLogicalOperatorBuilder;
-    gt(value: T): IFilterLogicalOperatorBuilder;
-    le(value: T): IFilterLogicalOperatorBuilder;
-    ge(value: T): IFilterLogicalOperatorBuilder;
+    lessThan(value: T): IFilterLogicalOperatorBuilder;
+    greaterThan(value: T): IFilterLogicalOperatorBuilder;
+    lessThanOrEqual(value: T): IFilterLogicalOperatorBuilder;
+    greaterThanOrEqual(value: T): IFilterLogicalOperatorBuilder;
 }
 export interface IIntFilterOperatorBuilder extends IComparableFilterOperatorBuilder<number> {
     bitwiseAnd(value: number): IFilterLogicalOperatorBuilder;
@@ -33,8 +32,8 @@ export interface IStringFilterOperatorBuilder extends IFilterOperatorBuilder<str
 export declare class FilterOperatorBuilder<T> implements IFilterOperatorBuilder<T> {
     protected readonly filterBuilder: FilterBuilder;
     constructor(filterBuilder: FilterBuilder);
-    eq(value: T): IFilterLogicalOperatorBuilder;
-    ne(value: T): IFilterLogicalOperatorBuilder;
+    equals(value: T): IFilterLogicalOperatorBuilder;
+    notEquals(value: T): IFilterLogicalOperatorBuilder;
     notIn(values: T[]): IFilterLogicalOperatorBuilder;
     in(values: T[]): IFilterLogicalOperatorBuilder;
     isNull(): IFilterLogicalOperatorBuilder;
@@ -45,10 +44,10 @@ export declare class StringFilterOperatorBuilder extends FilterOperatorBuilder<s
     notLike(value: string): IFilterLogicalOperatorBuilder;
 }
 export declare class ComparableFilterOperatorBuilder<T> extends FilterOperatorBuilder<T> implements IComparableFilterOperatorBuilder<T> {
-    ge(value: T): IFilterLogicalOperatorBuilder;
-    gt(value: T): IFilterLogicalOperatorBuilder;
-    le(value: T): IFilterLogicalOperatorBuilder;
-    lt(value: T): IFilterLogicalOperatorBuilder;
+    greaterThanOrEqual(value: T): IFilterLogicalOperatorBuilder;
+    greaterThan(value: T): IFilterLogicalOperatorBuilder;
+    lessThanOrEqual(value: T): IFilterLogicalOperatorBuilder;
+    lessThan(value: T): IFilterLogicalOperatorBuilder;
 }
 export declare class IntFilterOperatorBuilder extends ComparableFilterOperatorBuilder<number> implements IIntFilterOperatorBuilder {
     bitwiseAnd(value: number): IFilterLogicalOperatorBuilder;

package/filterbuilder/FilterOperatorBuilder.js

@@ -10,12 +10,12 @@ class FilterOperatorBuilder {
         }
         this.filterBuilder = filterBuilder;
     }
-    eq(value) {
-        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Eq, [value], this.filterBuilder.filterLogicalOperator));
+    equals(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Equal, [value], this.filterBuilder.filterLogicalOperator));
         return this.filterBuilder;
     }
-    ne(value) {
-        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Ne, [value], this.filterBuilder.filterLogicalOperator));
+    notEquals(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.NotEqual, [value], this.filterBuilder.filterLogicalOperator));
         return this.filterBuilder;
     }
     notIn(values) {
@@ -27,11 +27,11 @@ class FilterOperatorBuilder {
         return this.filterBuilder;
     }
     isNull() {
-        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Eq, null, this.filterBuilder.filterLogicalOperator));
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Equal, null, this.filterBuilder.filterLogicalOperator));
         return this.filterBuilder;
     }
     isNotNull() {
-        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Ne, null, this.filterBuilder.filterLogicalOperator));
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.NotEqual, null, this.filterBuilder.filterLogicalOperator));
         return this.filterBuilder;
     }
 }
@@ -48,31 +48,31 @@ class StringFilterOperatorBuilder extends FilterOperatorBuilder {
 }
 exports.StringFilterOperatorBuilder = StringFilterOperatorBuilder;
 class ComparableFilterOperatorBuilder extends FilterOperatorBuilder {
-    ge(value) {
-        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Ge, [value], this.filterBuilder.filterLogicalOperator));
+    greaterThanOrEqual(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.GreaterThanOrEqual, [value], this.filterBuilder.filterLogicalOperator));
         return this.filterBuilder;
     }
-    gt(value) {
-        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Gt, [value], this.filterBuilder.filterLogicalOperator));
+    greaterThan(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.GreaterThan, [value], this.filterBuilder.filterLogicalOperator));
         return this.filterBuilder;
     }
-    le(value) {
-        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Le, [value], this.filterBuilder.filterLogicalOperator));
+    lessThanOrEqual(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.LessThanOrEqual, [value], this.filterBuilder.filterLogicalOperator));
         return this.filterBuilder;
     }
-    lt(value) {
-        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Lt, [value], this.filterBuilder.filterLogicalOperator));
+    lessThan(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.LessThan, [value], this.filterBuilder.filterLogicalOperator));
         return this.filterBuilder;
     }
 }
 exports.ComparableFilterOperatorBuilder = ComparableFilterOperatorBuilder;
 class IntFilterOperatorBuilder extends ComparableFilterOperatorBuilder {
     bitwiseAnd(value) {
-        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Ba, [value], this.filterBuilder.filterLogicalOperator));
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.BitwiseAnd, [value], this.filterBuilder.filterLogicalOperator));
         return this.filterBuilder;
     }
     bitwiseNotAnd(value) {
-        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.BNa, [value], this.filterBuilder.filterLogicalOperator));
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.BitwiseNotAnd, [value], this.filterBuilder.filterLogicalOperator));
         return this.filterBuilder;
     }
 }

package/filterbuilder/helper/FilterHelper.d.ts

@@ -1,6 +1,6 @@
-import { IFilterBuilder } from "../FilterBuilder";
+import { FilterBuilder } from "../FilterBuilder";
 import { FilterComponent } from "../FilterComponent";
-export declare class FilterHelper {
-    static createFilters(): IFilterBuilder;
-    static createFiltersWithExisting(filters: FilterComponent[]): IFilterBuilder;
+export declare class FilterBuilderFactory {
+    static createFilterBuilder(): FilterBuilder;
+    static createFilterBuilderWithExisting(filters: FilterComponent[]): FilterBuilder;
 }

package/filterbuilder/helper/FilterHelper.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FilterHelper = void 0;
+exports.FilterBuilderFactory = void 0;
 const FilterBuilder_1 = require("../FilterBuilder");
-class FilterHelper {
-    static createFilters() {
+class FilterBuilderFactory {
+    static createFilterBuilder() {
         return new FilterBuilder_1.FilterBuilder();
     }
-    static createFiltersWithExisting(filters) {
+    static createFilterBuilderWithExisting(filters) {
         return new FilterBuilder_1.FilterBuilder(filters);
     }
 }
-exports.FilterHelper = FilterHelper;
+exports.FilterBuilderFactory = FilterBuilderFactory;

package/filterbuilder/transformers/FilterTransformer.d.ts

@@ -0,0 +1,4 @@
+import { FilterComponent } from "../FilterComponent";
+export interface IFilterTransformer<T> {
+    transform(filters: FilterComponent[]): T;
+}

package/filterbuilder/transformers/FilterTransformer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/filterbuilder/transformers/OmniaSearchFilterTransformer.d.ts

@@ -0,0 +1,9 @@
+import { FilterComponent } from "../FilterComponent";
+import { IFilterTransformer } from "./FilterTransformer";
+export declare class OmniaSearchFilterTransformer implements IFilterTransformer<string> {
+    transform(filters: FilterComponent[]): string;
+    private transformFilterCondition;
+    private transformFilterLogicalOperator;
+    private transformFilterExpressionOperator;
+    private getQueryStringValue;
+}

package/filterbuilder/transformers/OmniaSearchFilterTransformer.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmniaSearchFilterTransformer = void 0;
+const QueryFilter_1 = require("../../QueryFilter");
+const FilterComponent_1 = require("../FilterComponent");
+class OmniaSearchFilterTransformer {
+    transform(filters) {
+        let result = "";
+        filters.forEach((filter, index) => {
+            if (index !== 0) {
+                result += this.transformFilterLogicalOperator(filter.filterLogicalOperator);
+            }
+            if (filter instanceof FilterComponent_1.FilterConditionComponent) {
+                result += this.transformFilterCondition(filter);
+            }
+            else if (filter instanceof FilterComponent_1.FilterExpressionComponent) {
+                result += this.transformFilterExpressionOperator(filter);
+            }
+        });
+        return result;
+    }
+    transformFilterCondition(filterCondition) {
+        let operatorString = "";
+        let valueString = "";
+        let firstValue = null;
+        if (!filterCondition.values) {
+            valueString = "NULL";
+            if (filterCondition.filterOperator === QueryFilter_1.FilterOperator.Equal) {
+                operatorString = " IS ";
+            }
+            else if (filterCondition.filterOperator === QueryFilter_1.FilterOperator.NotEqual) {
+                operatorString = " IS NOT ";
+            }
+            else {
+                throw new Error("Invalid operator for NULL value.");
+            }
+        }
+        else {
+            firstValue = filterCondition.values[0];
+            if (firstValue == null) {
+                if (filterCondition.filterOperator === QueryFilter_1.FilterOperator.Equal) {
+                    return `(${filterCondition.propertyName} IS NULL OR ${filterCondition.propertyName} IS EMPTY OR ${filterCondition.propertyName} NOT EXISTS)`;
+                }
+                else if (filterCondition.filterOperator === QueryFilter_1.FilterOperator.NotEqual) {
+                    return `(${filterCondition.propertyName} IS NOT NULL AND ${filterCondition.propertyName} IS NOT EMPTY)`;
+                }
+                else {
+                    throw new Error("Invalid operator for NULL value.");
+                }
+            }
+            valueString = this.getQueryStringValue(firstValue);
+            switch (filterCondition.filterOperator) {
+                case QueryFilter_1.FilterOperator.Equal:
+                    operatorString = "=";
+                    break;
+                case QueryFilter_1.FilterOperator.NotEqual:
+                    operatorString = "!=";
+                    break;
+                case QueryFilter_1.FilterOperator.GreaterThan:
+                    operatorString = ">";
+                    break;
+                case QueryFilter_1.FilterOperator.LessThan:
+                    operatorString = "<";
+                    break;
+                case QueryFilter_1.FilterOperator.GreaterThanOrEqual:
+                    operatorString = ">=";
+                    break;
+                case QueryFilter_1.FilterOperator.LessThanOrEqual:
+                    operatorString = "<=";
+                    break;
+                case QueryFilter_1.FilterOperator.In:
+                    operatorString = " IN ";
+                    valueString = `[${filterCondition.values.map((x) => this.getQueryStringValue(x)).join(", ")}]`;
+                    break;
+                case QueryFilter_1.FilterOperator.NotIn:
+                    operatorString = " IN ";
+                    valueString = `[${filterCondition.values.map((x) => this.getQueryStringValue(x)).join(", ")}]`;
+                    return `NOT ${filterCondition.propertyName}${operatorString}${valueString}`;
+                default:
+                    operatorString = " = ";
+                    break;
+            }
+        }
+        if (!operatorString) {
+            throw new Error(`Invalid operator ${filterCondition.filterOperator}`);
+        }
+        return `${filterCondition.propertyName}${operatorString}${valueString}`;
+    }
+    transformFilterLogicalOperator(filterLogicalOperator) {
+        switch (filterLogicalOperator) {
+            case QueryFilter_1.FilterLogicalOperator.And:
+                return " AND ";
+            case QueryFilter_1.FilterLogicalOperator.Or:
+                return " OR ";
+            default:
+                throw new Error(`Invalid logical operator: ${filterLogicalOperator}`);
+        }
+    }
+    transformFilterExpressionOperator(filterExpressionComponent) {
+        const innerExpressionString = this.transform(filterExpressionComponent.filters);
+        return `(${innerExpressionString})`;
+    }
+    getQueryStringValue(value) {
+        if (value == null) {
+            return "";
+        }
+        else if (typeof value === "number") {
+            return value.toString();
+        }
+        else if (typeof value === "boolean") {
+            return `${value}`;
+        }
+        return `"${value.toString()}"`;
+    }
+}
+exports.OmniaSearchFilterTransformer = OmniaSearchFilterTransformer;

package/filterbuilder/transformers/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./OmniaSearchFilterTransformer";
+export * from "./FilterTransformer";

package/filterbuilder/transformers/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./OmniaSearchFilterTransformer"), exports);
+tslib_1.__exportStar(require("./FilterTransformer"), exports);

package/filterengine/Shared.d.ts

@@ -162,7 +162,7 @@ export interface BaseFilterEngineProperty {
     entries?: Array<Refinement>;
 }
 export interface TypedFilterEnginePropertyOutput {
-    operator: FilterOperator.Eq | FilterOperator.Gt | FilterOperator.Lt | FilterOperator.Ne | FilterOperator.In;
+    operator: FilterOperator.Equal | FilterOperator.GreaterThan | FilterOperator.LessThan | FilterOperator.NotEqual | FilterOperator.In;
     logicalOperator: FilterLogicalOperator;
     internalName: string;
     type: PropertyIndexedType.Boolean | PropertyIndexedType.Text | PropertyIndexedType.Number | PropertyIndexedType.Person | PropertyIndexedType.Taxonomy | PropertyIndexedType.EnterpriseKeywords | PropertyIndexedType.DateTime | PropertyIndexedType.Tags;

package/internal-do-not-import-from-here/shared/models/theme/Typography.d.ts

@@ -87,9 +87,9 @@ export interface TextStyleDefinition {
 }
 export interface TextStyleBreakPoint {
     custom?: boolean;
-    weight: number;
-    size: number;
-    lineHeight: number;
+    weight?: number;
+    size?: number;
+    lineHeight?: number;
     letterSpacing?: number;
 }
 export interface TypographyFontRef {
@@ -102,7 +102,8 @@ export declare enum TextStyleTypes {
     navigation = "navigation",
     label = "label",
     variants = "variants",
-    fills = "fills"
+    fills = "fills",
+    typeScale = "typeScale"
 }
 export interface ThemedTextStyleValue {
     type: TextStyleType;
@@ -123,7 +124,17 @@ export declare enum TextStyleSizes {
     variant5 = "variant5",
     variant6 = "variant6",
     variant7 = "variant7",
-    variant8 = "variant8"
+    variant8 = "variant8",
+    scale1 = "s1",
+    scale2 = "s2",
+    scale3 = "s3",
+    scale4 = "s4",
+    scale5 = "s5",
+    scale6 = "s6",
+    scale7 = "s7",
+    scale8 = "s8",
+    scale9 = "s9",
+    scale10 = "s10"
 }
 /**this reflect TypographySizes for member check*/
 export declare const AvailableTextStyleSizes: string[];

package/internal-do-not-import-from-here/shared/models/theme/Typography.js

@@ -10,6 +10,7 @@ var TextStyleTypes;
     //button = "button",
     TextStyleTypes["variants"] = "variants";
     TextStyleTypes["fills"] = "fills";
+    TextStyleTypes["typeScale"] = "typeScale";
 })(TextStyleTypes || (exports.TextStyleTypes = TextStyleTypes = {}));
 var TextStyleSizes;
 (function (TextStyleSizes) {
@@ -26,6 +27,16 @@ var TextStyleSizes;
     TextStyleSizes["variant6"] = "variant6";
     TextStyleSizes["variant7"] = "variant7";
     TextStyleSizes["variant8"] = "variant8";
+    TextStyleSizes["scale1"] = "s1";
+    TextStyleSizes["scale2"] = "s2";
+    TextStyleSizes["scale3"] = "s3";
+    TextStyleSizes["scale4"] = "s4";
+    TextStyleSizes["scale5"] = "s5";
+    TextStyleSizes["scale6"] = "s6";
+    TextStyleSizes["scale7"] = "s7";
+    TextStyleSizes["scale8"] = "s8";
+    TextStyleSizes["scale9"] = "s9";
+    TextStyleSizes["scale10"] = "s10";
 })(TextStyleSizes || (exports.TextStyleSizes = TextStyleSizes = {}));
 /**this reflect TypographySizes for member check*/
-exports.AvailableTextStyleSizes = ["xl", "l", "m", "s", "xs", "variant1", "variant2", "variant3", "variant4", "variant5", "variant6", "variant7", "variant8"];
+exports.AvailableTextStyleSizes = ["xl", "l", "m", "s", "xs", "variant1", "variant2", "variant3", "variant4", "variant5", "variant6", "variant7", "variant8", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10"];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx-models",
   "license": "MIT",
-  "version": "8.0.401-dev",
+  "version": "8.0.403-dev",
   "description": "Provide Omnia Fx Models Stuffs.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"