@omnia/fx-models 7.8.72-preview → 7.8.74-preview

package/QueryFilter.d.ts

@@ -9,7 +9,8 @@ export declare enum FilterOperator {
     Like = 8,
     NotLike = 9,
     Ba = 10,
-    BNa = 11
+    BNa = 11,
+    NotIn = 12
 }
 export declare enum FilterLogicalOperator {
     And = 1,

package/QueryFilter.js

@@ -14,6 +14,7 @@ var FilterOperator;
     FilterOperator[FilterOperator["NotLike"] = 9] = "NotLike";
     FilterOperator[FilterOperator["Ba"] = 10] = "Ba";
     FilterOperator[FilterOperator["BNa"] = 11] = "BNa";
+    FilterOperator[FilterOperator["NotIn"] = 12] = "NotIn";
 })(FilterOperator = exports.FilterOperator || (exports.FilterOperator = {}));
 var FilterLogicalOperator;
 (function (FilterLogicalOperator) {

package/filterbuilder/FilterBuilder.d.ts

@@ -1,94 +1,42 @@
+import { FilterLogicalOperator } from "../QueryFilter";
 import { FilterComponent } from "./FilterComponent";
-export interface IFilterExpressionBuilder {
+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;
+    dateTimeOffsetProperty(propertyName: string): IDateTimeOffsetFilterOperatorBuilder;
     stringProperty(propertyName: string): IStringFilterOperatorBuilder;
-    expression(buildInnerExpression: (builder: IFilterExpressionBuilder) => IFilterLogicalOperatorBuilder): IFilterLogicalOperatorBuilder;
+    booleanProperty(propertyName: string): IBooleanFilterOperatorBuilder;
+    expression(buildInnerExpression: (builder: IFilterComponentBuilder) => IFilterLogicalOperatorBuilder): IFilterLogicalOperatorBuilder;
 }
-export declare class FilterExpressionBuilder implements IFilterExpressionBuilder {
+export interface IFilterLogicalOperatorBuilder {
+    and(): IFilterComponentBuilder;
+    or(): IFilterComponentBuilder;
+    getResult(): FilterComponent[];
+}
+export interface IFilterBuilder extends IFilterComponentBuilder, IFilterLogicalOperatorBuilder {
+}
+export declare class FilterBuilder implements IFilterBuilder {
     private filters;
+    private intFilterOperatorBuilder?;
+    private floatFilterOperatorBuilder?;
+    private dateTimeFilterOperatorBuilder?;
+    private dateTimeOffsetFilterOperatorBuilder?;
+    private stringFilterOperatorBuilder?;
+    private booleanFilterOperatorBuilder?;
+    propertyName?: string;
+    filterLogicalOperator: FilterLogicalOperator;
     constructor(filters?: FilterComponent[]);
+    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;
+    dateTimeOffsetProperty(propertyName: string): IDateTimeOffsetFilterOperatorBuilder;
     stringProperty(propertyName: string): IStringFilterOperatorBuilder;
-    expression(buildInnerExpression: (builder: IFilterExpressionBuilder) => IFilterLogicalOperatorBuilder): IFilterLogicalOperatorBuilder;
-}
-export interface IFilterOperatorBuilder<T> {
-    eq(value: T): IFilterLogicalOperatorBuilder;
-    ne(value: T): IFilterLogicalOperatorBuilder;
-    isNull(): IFilterLogicalOperatorBuilder;
-    isNotNull(): IFilterLogicalOperatorBuilder;
-    in(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;
-}
-export interface IIntFilterOperatorBuilder extends IComparableFilterOperatorBuilder<number> {
-    bitwiseAnd(value: number): IFilterLogicalOperatorBuilder;
-    bitwiseNotAnd(value: number): IFilterLogicalOperatorBuilder;
-}
-export interface IStringFilterOperatorBuilder extends IFilterOperatorBuilder<string> {
-    like(value: string): IFilterLogicalOperatorBuilder;
-    notLike(value: string): IFilterLogicalOperatorBuilder;
-}
-export interface IFloatFilterOperatorBuilder extends IComparableFilterOperatorBuilder<number> {
-}
-export interface IDateTimeFilterOperatorBuilder extends IComparableFilterOperatorBuilder<Date> {
-}
-export interface IDateTimeOffsetFilterOperatorBuilder extends IComparableFilterOperatorBuilder<string> {
-}
-export declare class FilterOperatorBuilder<T> implements IFilterOperatorBuilder<T> {
-    protected filters: FilterComponent[];
-    protected propertyName: string;
-    constructor(filters: FilterComponent[], propertyName: string);
-    eq(value: T): IFilterLogicalOperatorBuilder;
-    ne(value: T): IFilterLogicalOperatorBuilder;
-    in(values: T[]): IFilterLogicalOperatorBuilder;
-    isNull(): IFilterLogicalOperatorBuilder;
-    isNotNull(): IFilterLogicalOperatorBuilder;
-}
-export declare class StringFilterOperatorBuilder extends FilterOperatorBuilder<string> implements IStringFilterOperatorBuilder {
-    constructor(filters: FilterComponent[], propertyName: string);
-    like(value: string): IFilterLogicalOperatorBuilder;
-    notLike(value: string): IFilterLogicalOperatorBuilder;
-}
-export declare class ComparableFilterOperatorBuilder<T> extends FilterOperatorBuilder<T> implements IComparableFilterOperatorBuilder<T> {
-    constructor(filters: FilterComponent[], propertyName: string);
-    ge(value: T): IFilterLogicalOperatorBuilder;
-    gt(value: T): IFilterLogicalOperatorBuilder;
-    le(value: T): IFilterLogicalOperatorBuilder;
-    lt(value: T): IFilterLogicalOperatorBuilder;
-}
-export declare class IntFilterOperatorBuilder extends ComparableFilterOperatorBuilder<number> implements IIntFilterOperatorBuilder {
-    constructor(filters: FilterComponent[], propertyName: string);
-    bitwiseAnd(value: number): IFilterLogicalOperatorBuilder;
-    bitwiseNotAnd(value: number): IFilterLogicalOperatorBuilder;
-}
-export declare class FloatFilterOperatorBuilder extends ComparableFilterOperatorBuilder<number> implements IFloatFilterOperatorBuilder {
-    constructor(filters: FilterComponent[], propertyName: string);
-}
-export declare class DateTimeFilterOperatorBuilder extends ComparableFilterOperatorBuilder<Date> implements IDateTimeFilterOperatorBuilder {
-    constructor(filters: FilterComponent[], propertyName: string);
-}
-export declare class DateTimeOffsetFilterOperatorBuilder extends ComparableFilterOperatorBuilder<string> implements IDateTimeOffsetFilterOperatorBuilder {
-    constructor(filters: FilterComponent[], propertyName: string);
-}
-export interface IFilterLogicalOperatorBuilder {
-    and(): IFilterExpressionBuilder;
-    or(): IFilterExpressionBuilder;
-    getResult(): FilterComponent[];
-}
-export declare class FilterLogicalOperatorBuilder implements IFilterLogicalOperatorBuilder {
-    private filters;
-    constructor(filters: FilterComponent[]);
-    and(): IFilterExpressionBuilder;
-    or(): IFilterExpressionBuilder;
-    getResult(): FilterComponent[];
+    booleanProperty(propertyName: string): IBooleanFilterOperatorBuilder;
+    expression(buildInnerExpression: (builder: IFilterComponentBuilder) => IFilterLogicalOperatorBuilder): IFilterLogicalOperatorBuilder;
 }

package/filterbuilder/FilterBuilder.js

@@ -1,158 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FilterLogicalOperatorBuilder = exports.DateTimeOffsetFilterOperatorBuilder = exports.DateTimeFilterOperatorBuilder = exports.FloatFilterOperatorBuilder = exports.IntFilterOperatorBuilder = exports.ComparableFilterOperatorBuilder = exports.StringFilterOperatorBuilder = exports.FilterOperatorBuilder = exports.FilterExpressionBuilder = void 0;
+exports.FilterBuilder = void 0;
 const QueryFilter_1 = require("../QueryFilter");
 const FilterComponent_1 = require("./FilterComponent");
-class FilterExpressionBuilder {
-    constructor(filters = []) {
-        if (filters == null) {
-            throw new Error("filters cannot be null");
+const FilterOperatorBuilder_1 = require("./FilterOperatorBuilder");
+class FilterBuilder {
+    constructor(filters) {
+        this.filters = [];
+        this.filterLogicalOperator = QueryFilter_1.FilterLogicalOperator.And;
+        if (filters) {
+            this.filters = filters;
         }
-        this.filters = filters;
+    }
+    addFilter(filterComponent) {
+        this.filters.push(filterComponent);
+        this.propertyName = undefined;
+        this.filterLogicalOperator = QueryFilter_1.FilterLogicalOperator.And;
+    }
+    and() {
+        this.filterLogicalOperator = QueryFilter_1.FilterLogicalOperator.And;
+        return this;
+    }
+    or() {
+        this.filterLogicalOperator = QueryFilter_1.FilterLogicalOperator.Or;
+        return this;
+    }
+    getResult() {
+        return this.filters;
     }
     intProperty(propertyName) {
-        return new IntFilterOperatorBuilder(this.filters, propertyName);
+        this.propertyName = propertyName;
+        this.intFilterOperatorBuilder =
+            this.intFilterOperatorBuilder || new FilterOperatorBuilder_1.IntFilterOperatorBuilder(this);
+        return this.intFilterOperatorBuilder;
     }
     floatProperty(propertyName) {
-        return new FloatFilterOperatorBuilder(this.filters, propertyName);
+        this.propertyName = propertyName;
+        this.floatFilterOperatorBuilder =
+            this.floatFilterOperatorBuilder || new FilterOperatorBuilder_1.FloatFilterOperatorBuilder(this);
+        return this.floatFilterOperatorBuilder;
     }
     dateTimeProperty(propertyName) {
-        return new DateTimeFilterOperatorBuilder(this.filters, propertyName);
+        this.propertyName = propertyName;
+        this.dateTimeFilterOperatorBuilder =
+            this.dateTimeFilterOperatorBuilder || new FilterOperatorBuilder_1.DateTimeFilterOperatorBuilder(this);
+        return this.dateTimeFilterOperatorBuilder;
     }
-    dateTimeOffSetProperty(propertyName) {
-        return new DateTimeOffsetFilterOperatorBuilder(this.filters, propertyName);
+    dateTimeOffsetProperty(propertyName) {
+        this.propertyName = propertyName;
+        this.dateTimeOffsetFilterOperatorBuilder =
+            this.dateTimeOffsetFilterOperatorBuilder || new FilterOperatorBuilder_1.DateTimeOffsetFilterOperatorBuilder(this);
+        return this.dateTimeOffsetFilterOperatorBuilder;
     }
     stringProperty(propertyName) {
-        return new StringFilterOperatorBuilder(this.filters, propertyName);
+        this.propertyName = propertyName;
+        this.stringFilterOperatorBuilder =
+            this.stringFilterOperatorBuilder || new FilterOperatorBuilder_1.StringFilterOperatorBuilder(this);
+        return this.stringFilterOperatorBuilder;
+    }
+    booleanProperty(propertyName) {
+        this.propertyName = propertyName;
+        this.booleanFilterOperatorBuilder =
+            this.booleanFilterOperatorBuilder || new FilterOperatorBuilder_1.BooleanFilterOperatorBuilder(this);
+        return this.booleanFilterOperatorBuilder;
     }
     expression(buildInnerExpression) {
-        const filterExpression = new FilterExpressionBuilder();
-        const buildResult = buildInnerExpression(filterExpression);
-        const innerFilters = buildResult.getResult();
+        const innerFilterBuilder = new FilterBuilder([]);
+        const innerFilters = buildInnerExpression(innerFilterBuilder).getResult();
         if (innerFilters.length === 0) {
             throw new Error("There must be at least 1 filter in the expression.");
         }
-        this.filters.push(new FilterComponent_1.FilterExpressionComponent(innerFilters));
-        return new FilterLogicalOperatorBuilder(this.filters);
-    }
-}
-exports.FilterExpressionBuilder = FilterExpressionBuilder;
-class FilterOperatorBuilder {
-    constructor(filters, propertyName) {
-        if (!filters)
-            throw new Error("Filters cannot be null or undefined.");
-        if (!propertyName)
-            throw new Error("Property name cannot be null or undefined.");
-        this.filters = filters;
-        this.propertyName = propertyName;
-    }
-    eq(value) {
-        this.filters.push(new FilterComponent_1.FilterConditionComponent(this.propertyName, QueryFilter_1.FilterOperator.Eq, [value]));
-        return new FilterLogicalOperatorBuilder(this.filters);
-    }
-    ne(value) {
-        this.filters.push(new FilterComponent_1.FilterConditionComponent(this.propertyName, QueryFilter_1.FilterOperator.Ne, [value]));
-        return new FilterLogicalOperatorBuilder(this.filters);
-    }
-    in(values) {
-        this.filters.push(new FilterComponent_1.FilterConditionComponent(this.propertyName, QueryFilter_1.FilterOperator.In, values));
-        return new FilterLogicalOperatorBuilder(this.filters);
-    }
-    isNull() {
-        this.filters.push(new FilterComponent_1.FilterConditionComponent(this.propertyName, QueryFilter_1.FilterOperator.Eq, null));
-        return new FilterLogicalOperatorBuilder(this.filters);
-    }
-    isNotNull() {
-        this.filters.push(new FilterComponent_1.FilterConditionComponent(this.propertyName, QueryFilter_1.FilterOperator.Ne, null));
-        return new FilterLogicalOperatorBuilder(this.filters);
-    }
-}
-exports.FilterOperatorBuilder = FilterOperatorBuilder;
-class StringFilterOperatorBuilder extends FilterOperatorBuilder {
-    constructor(filters, propertyName) {
-        super(filters, propertyName);
-    }
-    like(value) {
-        this.filters.push(new FilterComponent_1.FilterConditionComponent(this.propertyName, QueryFilter_1.FilterOperator.Like, [value]));
-        return new FilterLogicalOperatorBuilder(this.filters);
-    }
-    notLike(value) {
-        this.filters.push(new FilterComponent_1.FilterConditionComponent(this.propertyName, QueryFilter_1.FilterOperator.NotLike, [value]));
-        return new FilterLogicalOperatorBuilder(this.filters);
-    }
-}
-exports.StringFilterOperatorBuilder = StringFilterOperatorBuilder;
-class ComparableFilterOperatorBuilder extends FilterOperatorBuilder {
-    constructor(filters, propertyName) {
-        super(filters, propertyName);
-    }
-    ge(value) {
-        this.filters.push(new FilterComponent_1.FilterConditionComponent(this.propertyName, QueryFilter_1.FilterOperator.Ge, [value]));
-        return new FilterLogicalOperatorBuilder(this.filters);
-    }
-    gt(value) {
-        this.filters.push(new FilterComponent_1.FilterConditionComponent(this.propertyName, QueryFilter_1.FilterOperator.Gt, [value]));
-        return new FilterLogicalOperatorBuilder(this.filters);
-    }
-    le(value) {
-        this.filters.push(new FilterComponent_1.FilterConditionComponent(this.propertyName, QueryFilter_1.FilterOperator.Le, [value]));
-        return new FilterLogicalOperatorBuilder(this.filters);
-    }
-    lt(value) {
-        this.filters.push(new FilterComponent_1.FilterConditionComponent(this.propertyName, QueryFilter_1.FilterOperator.Lt, [value]));
-        return new FilterLogicalOperatorBuilder(this.filters);
-    }
-}
-exports.ComparableFilterOperatorBuilder = ComparableFilterOperatorBuilder;
-class IntFilterOperatorBuilder extends ComparableFilterOperatorBuilder {
-    constructor(filters, propertyName) {
-        super(filters, propertyName);
-    }
-    bitwiseAnd(value) {
-        this.filters.push(new FilterComponent_1.FilterConditionComponent(this.propertyName, QueryFilter_1.FilterOperator.Ba, [value]));
-        return new FilterLogicalOperatorBuilder(this.filters);
-    }
-    bitwiseNotAnd(value) {
-        this.filters.push(new FilterComponent_1.FilterConditionComponent(this.propertyName, QueryFilter_1.FilterOperator.BNa, [value]));
-        return new FilterLogicalOperatorBuilder(this.filters);
-    }
-}
-exports.IntFilterOperatorBuilder = IntFilterOperatorBuilder;
-class FloatFilterOperatorBuilder extends ComparableFilterOperatorBuilder {
-    constructor(filters, propertyName) {
-        super(filters, propertyName);
-    }
-}
-exports.FloatFilterOperatorBuilder = FloatFilterOperatorBuilder;
-class DateTimeFilterOperatorBuilder extends ComparableFilterOperatorBuilder {
-    constructor(filters, propertyName) {
-        super(filters, propertyName);
-    }
-}
-exports.DateTimeFilterOperatorBuilder = DateTimeFilterOperatorBuilder;
-class DateTimeOffsetFilterOperatorBuilder extends ComparableFilterOperatorBuilder {
-    constructor(filters, propertyName) {
-        super(filters, propertyName);
-    }
-}
-exports.DateTimeOffsetFilterOperatorBuilder = DateTimeOffsetFilterOperatorBuilder;
-class FilterLogicalOperatorBuilder {
-    constructor(filters) {
-        if (!filters) {
-            throw new Error("Filters cannot be null or undefined.");
-        }
-        this.filters = filters;
-    }
-    and() {
-        this.filters.push(new FilterComponent_1.FilterLogicalOperatorComponent(QueryFilter_1.FilterLogicalOperator.And));
-        return new FilterExpressionBuilder(this.filters);
-    }
-    or() {
-        this.filters.push(new FilterComponent_1.FilterLogicalOperatorComponent(QueryFilter_1.FilterLogicalOperator.Or));
-        return new FilterExpressionBuilder(this.filters);
-    }
-    getResult() {
-        return this.filters;
+        this.filters.push(new FilterComponent_1.FilterExpressionComponent(innerFilters, this.filterLogicalOperator));
+        return this;
     }
 }
-exports.FilterLogicalOperatorBuilder = FilterLogicalOperatorBuilder;
+exports.FilterBuilder = FilterBuilder;

package/filterbuilder/FilterComponent.d.ts

@@ -1,26 +1,23 @@
 import { FilterLogicalOperator, FilterOperator } from "../QueryFilter";
 export declare enum FilterComponentType {
     Condition = 0,
-    LogicalOperator = 1,
-    Expression = 2
+    Expression = 1
 }
 export interface FilterComponent {
+    filterLogicalOperator: FilterLogicalOperator;
     type: FilterComponentType;
 }
 export declare class FilterConditionComponent implements FilterComponent {
-    type: FilterComponentType;
-    operator: FilterOperator;
     propertyName: string;
-    values: Array<any>;
-    constructor(propertyName: string, filterOperator: FilterOperator, values: Array<any>);
-}
-export declare class FilterLogicalOperatorComponent implements FilterComponent {
+    filterOperator: FilterOperator;
+    values: any[];
+    filterLogicalOperator: FilterLogicalOperator;
     type: FilterComponentType;
-    logicalOperator: FilterLogicalOperator;
-    constructor(logicalOperator: FilterLogicalOperator);
+    constructor(propertyName: string, filterOperator: FilterOperator, values: any[], filterLogicalOperator?: FilterLogicalOperator);
 }
 export declare class FilterExpressionComponent implements FilterComponent {
-    type: FilterComponentType;
     filters: FilterComponent[];
-    constructor(filters: FilterComponent[]);
+    filterLogicalOperator: FilterLogicalOperator;
+    type: FilterComponentType;
+    constructor(filters: FilterComponent[], filterLogicalOperator?: FilterLogicalOperator);
 }

package/filterbuilder/FilterComponent.js

@@ -1,32 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FilterExpressionComponent = exports.FilterLogicalOperatorComponent = exports.FilterConditionComponent = exports.FilterComponentType = void 0;
+exports.FilterExpressionComponent = exports.FilterConditionComponent = exports.FilterComponentType = void 0;
+const QueryFilter_1 = require("../QueryFilter");
 var FilterComponentType;
 (function (FilterComponentType) {
     FilterComponentType[FilterComponentType["Condition"] = 0] = "Condition";
-    FilterComponentType[FilterComponentType["LogicalOperator"] = 1] = "LogicalOperator";
-    FilterComponentType[FilterComponentType["Expression"] = 2] = "Expression";
+    FilterComponentType[FilterComponentType["Expression"] = 1] = "Expression";
 })(FilterComponentType = exports.FilterComponentType || (exports.FilterComponentType = {}));
 class FilterConditionComponent {
-    constructor(propertyName, filterOperator, values) {
-        this.type = FilterComponentType.Condition;
-        this.operator = filterOperator;
+    constructor(propertyName, filterOperator, values, filterLogicalOperator = QueryFilter_1.FilterLogicalOperator.And) {
         this.propertyName = propertyName;
+        this.filterOperator = filterOperator;
         this.values = values;
+        this.filterLogicalOperator = filterLogicalOperator;
+        this.type = FilterComponentType.Condition;
     }
 }
 exports.FilterConditionComponent = FilterConditionComponent;
-class FilterLogicalOperatorComponent {
-    constructor(logicalOperator) {
-        this.type = FilterComponentType.LogicalOperator;
-        this.logicalOperator = logicalOperator;
-    }
-}
-exports.FilterLogicalOperatorComponent = FilterLogicalOperatorComponent;
 class FilterExpressionComponent {
-    constructor(filters) {
-        this.type = FilterComponentType.Expression;
+    constructor(filters, filterLogicalOperator = QueryFilter_1.FilterLogicalOperator.And) {
         this.filters = filters;
+        this.filterLogicalOperator = filterLogicalOperator;
+        this.type = FilterComponentType.Expression;
     }
 }
 exports.FilterExpressionComponent = FilterExpressionComponent;

package/filterbuilder/FilterOperatorBuilder.d.ts

@@ -0,0 +1,68 @@
+import { FilterBuilder, IFilterLogicalOperatorBuilder } from "./FilterBuilder";
+export interface IFilterOperatorBuilder<T> {
+    eq(value: T): IFilterLogicalOperatorBuilder;
+    eq(value: T): IFilterLogicalOperatorBuilder;
+    ne(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;
+}
+export interface IIntFilterOperatorBuilder extends IComparableFilterOperatorBuilder<number> {
+    bitwiseAnd(value: number): IFilterLogicalOperatorBuilder;
+    bitwiseNotAnd(value: number): IFilterLogicalOperatorBuilder;
+}
+export interface IFloatFilterOperatorBuilder extends IComparableFilterOperatorBuilder<number> {
+}
+export interface IDateTimeFilterOperatorBuilder extends IComparableFilterOperatorBuilder<Date> {
+}
+export interface IDateTimeOffsetFilterOperatorBuilder extends IComparableFilterOperatorBuilder<Date> {
+}
+export interface IBooleanFilterOperatorBuilder extends IFilterOperatorBuilder<boolean> {
+}
+export interface IStringFilterOperatorBuilder extends IFilterOperatorBuilder<string> {
+    like(value: string): IFilterLogicalOperatorBuilder;
+    notLike(value: string): IFilterLogicalOperatorBuilder;
+}
+export declare class FilterOperatorBuilder<T> implements IFilterOperatorBuilder<T> {
+    protected readonly filterBuilder: FilterBuilder;
+    constructor(filterBuilder: FilterBuilder);
+    eq(value: T): IFilterLogicalOperatorBuilder;
+    ne(value: T): IFilterLogicalOperatorBuilder;
+    notIn(values: T[]): IFilterLogicalOperatorBuilder;
+    in(values: T[]): IFilterLogicalOperatorBuilder;
+    isNull(): IFilterLogicalOperatorBuilder;
+    isNotNull(): IFilterLogicalOperatorBuilder;
+}
+export declare class StringFilterOperatorBuilder extends FilterOperatorBuilder<string> implements IStringFilterOperatorBuilder {
+    like(value: string): IFilterLogicalOperatorBuilder;
+    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;
+}
+export declare class IntFilterOperatorBuilder extends ComparableFilterOperatorBuilder<number> implements IIntFilterOperatorBuilder {
+    bitwiseAnd(value: number): IFilterLogicalOperatorBuilder;
+    bitwiseNotAnd(value: number): IFilterLogicalOperatorBuilder;
+}
+export declare class FloatFilterOperatorBuilder extends ComparableFilterOperatorBuilder<number> implements IFloatFilterOperatorBuilder {
+    constructor(filterBuilder: FilterBuilder);
+}
+export declare class DateTimeFilterOperatorBuilder extends ComparableFilterOperatorBuilder<Date> implements IDateTimeFilterOperatorBuilder {
+    constructor(filterBuilder: FilterBuilder);
+}
+export declare class DateTimeOffsetFilterOperatorBuilder extends ComparableFilterOperatorBuilder<Date> implements IDateTimeOffsetFilterOperatorBuilder {
+    constructor(filterBuilder: FilterBuilder);
+}
+export declare class BooleanFilterOperatorBuilder extends ComparableFilterOperatorBuilder<boolean> implements IBooleanFilterOperatorBuilder {
+    constructor(filterBuilder: FilterBuilder);
+}

package/filterbuilder/FilterOperatorBuilder.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanFilterOperatorBuilder = exports.DateTimeOffsetFilterOperatorBuilder = exports.DateTimeFilterOperatorBuilder = exports.FloatFilterOperatorBuilder = exports.IntFilterOperatorBuilder = exports.ComparableFilterOperatorBuilder = exports.StringFilterOperatorBuilder = exports.FilterOperatorBuilder = void 0;
+const QueryFilter_1 = require("../QueryFilter");
+const FilterComponent_1 = require("./FilterComponent");
+class FilterOperatorBuilder {
+    constructor(filterBuilder) {
+        if (!filterBuilder) {
+            throw new Error("FilterBuilder cannot be null or undefined.");
+        }
+        this.filterBuilder = filterBuilder;
+    }
+    eq(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Eq, [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));
+        return this.filterBuilder;
+    }
+    notIn(values) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.NotIn, values.map((x) => x), this.filterBuilder.filterLogicalOperator));
+        return this.filterBuilder;
+    }
+    in(values) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.In, values.map((x) => x), this.filterBuilder.filterLogicalOperator));
+        return this.filterBuilder;
+    }
+    isNull() {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Eq, 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));
+        return this.filterBuilder;
+    }
+}
+exports.FilterOperatorBuilder = FilterOperatorBuilder;
+class StringFilterOperatorBuilder extends FilterOperatorBuilder {
+    like(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Like, [value], this.filterBuilder.filterLogicalOperator));
+        return this.filterBuilder;
+    }
+    notLike(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.NotLike, [value], this.filterBuilder.filterLogicalOperator));
+        return this.filterBuilder;
+    }
+}
+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));
+        return this.filterBuilder;
+    }
+    gt(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Gt, [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));
+        return this.filterBuilder;
+    }
+    lt(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Lt, [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));
+        return this.filterBuilder;
+    }
+    bitwiseNotAnd(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.BNa, [value], this.filterBuilder.filterLogicalOperator));
+        return this.filterBuilder;
+    }
+}
+exports.IntFilterOperatorBuilder = IntFilterOperatorBuilder;
+class FloatFilterOperatorBuilder extends ComparableFilterOperatorBuilder {
+    constructor(filterBuilder) {
+        super(filterBuilder);
+    }
+}
+exports.FloatFilterOperatorBuilder = FloatFilterOperatorBuilder;
+class DateTimeFilterOperatorBuilder extends ComparableFilterOperatorBuilder {
+    constructor(filterBuilder) {
+        super(filterBuilder);
+    }
+}
+exports.DateTimeFilterOperatorBuilder = DateTimeFilterOperatorBuilder;
+class DateTimeOffsetFilterOperatorBuilder extends ComparableFilterOperatorBuilder {
+    constructor(filterBuilder) {
+        super(filterBuilder);
+    }
+}
+exports.DateTimeOffsetFilterOperatorBuilder = DateTimeOffsetFilterOperatorBuilder;
+class BooleanFilterOperatorBuilder extends ComparableFilterOperatorBuilder {
+    constructor(filterBuilder) {
+        super(filterBuilder);
+    }
+}
+exports.BooleanFilterOperatorBuilder = BooleanFilterOperatorBuilder;

package/filterbuilder/helper/FilterHelper.d.ts

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

package/filterbuilder/helper/FilterHelper.js

@@ -4,10 +4,10 @@ exports.FilterHelper = void 0;
 const FilterBuilder_1 = require("../FilterBuilder");
 class FilterHelper {
     static createFilters() {
-        return new FilterBuilder_1.FilterExpressionBuilder();
+        return new FilterBuilder_1.FilterBuilder();
     }
-    static createFiltersWithExisting(fitlers) {
-        return new FilterBuilder_1.FilterExpressionBuilder(fitlers);
+    static createFiltersWithExisting(filters) {
+        return new FilterBuilder_1.FilterBuilder(filters);
     }
 }
 exports.FilterHelper = FilterHelper;

package/filterbuilder/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./FilterComponent";
 export * from "./FilterBuilder";
+export * from "./FilterOperatorBuilder";
 export * from "./helper/FilterHelper";
+export * from "./transformers/FilterTransformer";

package/filterbuilder/index.js

@@ -3,4 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./FilterComponent"), exports);
 tslib_1.__exportStar(require("./FilterBuilder"), exports);
+tslib_1.__exportStar(require("./FilterOperatorBuilder"), exports);
 tslib_1.__exportStar(require("./helper/FilterHelper"), exports);
+tslib_1.__exportStar(require("./transformers/FilterTransformer"), exports);

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/omniasearch/SearchPropertyFilter.d.ts

@@ -0,0 +1,55 @@
+import { Language } from "highlight.js";
+import { PropertyIndexedType } from "../Enums";
+import { Identity } from "../identities";
+import { RollupEnums, DatePropertyFilterCustomValue } from "../RollupQuery";
+import { Tag } from "../Tags";
+import { GuidValue } from "@omnia/fx-models";
+export declare enum OmniaSearchScopes {
+    Tenant = 1,
+    PublishingApps = 2,
+    PageCollections = 3,
+    Channels = 4,
+    BusinessProfiles = 5
+}
+export declare enum OmniaSearchFilterTypes {
+    FixedValue = 1,
+    User = 2
+}
+export interface OmniaSearchPropertyFilter {
+    property: string;
+    type: PropertyIndexedType.Boolean | PropertyIndexedType.DateTime | PropertyIndexedType.Text | PropertyIndexedType.Number | PropertyIndexedType.Person | PropertyIndexedType.Taxonomy | PropertyIndexedType.EnterpriseKeywords | PropertyIndexedType.Language | PropertyIndexedType.Tags;
+    valueObj: OmniaSearchPropertyFilterValue;
+}
+export interface OmniaSearchPropertyFilterValue {
+}
+export interface OmniaSearchBooleanPropertyFilterValue extends OmniaSearchPropertyFilterValue {
+    value: boolean;
+}
+export interface OmniaSearchNumberPropertyFilterValue extends OmniaSearchPropertyFilterValue {
+    value: number;
+}
+export interface OmniaSearchTextPropertyFilterValue extends OmniaSearchPropertyFilterValue {
+    value: string;
+    text?: string;
+}
+export interface OmniaSearchPersonPropertyFilterValue extends OmniaSearchPropertyFilterValue {
+    value: Array<Identity>;
+}
+export interface OmniaSearchDatePropertyFilterValue extends OmniaSearchPropertyFilterValue {
+    value: RollupEnums.DatePeriods;
+    customValueDetails?: {
+        from: DatePropertyFilterCustomValue;
+        to: DatePropertyFilterCustomValue;
+    };
+}
+export interface OmniaSearchTagPropertyFilterValue extends OmniaSearchPropertyFilterValue {
+    value: Array<Tag>;
+}
+export interface OmniaSearchTaxonomyPropertyFilterValue extends OmniaSearchPropertyFilterValue {
+    fixedTermIds?: Array<GuidValue>;
+    includeEmpty: boolean;
+}
+export interface OmniaSearchLanguageFilterValue extends OmniaSearchPropertyFilterValue {
+    value: Language;
+    filterType: OmniaSearchFilterTypes;
+}

package/omniasearch/SearchPropertyFilter.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmniaSearchFilterTypes = exports.OmniaSearchScopes = void 0;
+var OmniaSearchScopes;
+(function (OmniaSearchScopes) {
+    OmniaSearchScopes[OmniaSearchScopes["Tenant"] = 1] = "Tenant";
+    OmniaSearchScopes[OmniaSearchScopes["PublishingApps"] = 2] = "PublishingApps";
+    OmniaSearchScopes[OmniaSearchScopes["PageCollections"] = 3] = "PageCollections";
+    OmniaSearchScopes[OmniaSearchScopes["Channels"] = 4] = "Channels";
+    OmniaSearchScopes[OmniaSearchScopes["BusinessProfiles"] = 5] = "BusinessProfiles";
+})(OmniaSearchScopes = exports.OmniaSearchScopes || (exports.OmniaSearchScopes = {}));
+var OmniaSearchFilterTypes;
+(function (OmniaSearchFilterTypes) {
+    OmniaSearchFilterTypes[OmniaSearchFilterTypes["FixedValue"] = 1] = "FixedValue";
+    OmniaSearchFilterTypes[OmniaSearchFilterTypes["User"] = 2] = "User";
+})(OmniaSearchFilterTypes = exports.OmniaSearchFilterTypes || (exports.OmniaSearchFilterTypes = {}));

package/omniasearch/index.d.ts

@@ -18,3 +18,4 @@ export * from "./PagedOmniaSearchResult";
 export * from "./SearchUserQuery";
 export * from "./OmniaRefiner";
 export * from "./OmniaSearchUser";
+export * from "./SearchPropertyFilter";

package/omniasearch/index.js

@@ -21,3 +21,4 @@ tslib_1.__exportStar(require("./PagedOmniaSearchResult"), exports);
 tslib_1.__exportStar(require("./SearchUserQuery"), exports);
 tslib_1.__exportStar(require("./OmniaRefiner"), exports);
 tslib_1.__exportStar(require("./OmniaSearchUser"), exports);
+tslib_1.__exportStar(require("./SearchPropertyFilter"), exports);

package/package.json

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