@omnia/fx-models 7.8.67-preview → 7.8.69-preview

package/Constants.d.ts

@@ -175,6 +175,7 @@ export declare const Constants: {
     };
     prefixTokens: {
         appInstance: string;
+        user: string;
     };
     microsoftTeamsDeepLinkApi: {
         chatBaseUrl: string;

package/Constants.js

@@ -206,6 +206,7 @@ exports.Constants = {
     },
     prefixTokens: {
         appInstance: "AppInstance",
+        user: "User",
     },
     microsoftTeamsDeepLinkApi: {
         chatBaseUrl: "https://teams.microsoft.com/l/chat/0/0?users=",

package/Exposes.d.ts

@@ -132,6 +132,7 @@ export * from "./statuscodelayout";
 export * from "./analytics";
 export * from "./semanticsearch";
 export * from "./aiengine";
+export * from "./filterbuilder";
 export * from "./FilePicker";
 export * from "./FileIdentifier";
 export * from "./UserAgent";

package/Exposes.js

@@ -144,6 +144,7 @@ tslib_1.__exportStar(require("./statuscodelayout"), exports);
 tslib_1.__exportStar(require("./analytics"), exports);
 tslib_1.__exportStar(require("./semanticsearch"), exports);
 tslib_1.__exportStar(require("./aiengine"), exports);
+tslib_1.__exportStar(require("./filterbuilder"), exports);
 //************************************************************************************ */
 // End of folder exports
 //************************************************************************************ */

package/ManifestIds.d.ts

@@ -115,6 +115,7 @@ export declare class OmniaResourceManifests {
     static get UserPropertiesProvider(): Guid;
     static get UserPropertiesByMicrosoftGraphProvider(): Guid;
     static get UserPropertiesBySharePointProvider(): Guid;
+    static get UserTokenProvider(): Guid;
     static get FxUxPropertyDataSourceApi(): Guid;
     static get IdentityPropertyApi(): Guid;
     static get BuiltinExtendedPropertiesRegistration(): Guid;

package/ManifestIds.js

@@ -376,6 +376,9 @@ class OmniaResourceManifests {
     static get UserPropertiesBySharePointProvider() {
         return new models_1.Guid("9a37a669-cb46-443a-b833-9155755f6cc3");
     }
+    static get UserTokenProvider() {
+        return new models_1.Guid("59ec874f-663b-4ad3-a13e-963c6dfec287");
+    }
     static get FxUxPropertyDataSourceApi() {
         return new models_1.Guid("8cf8a6b0-8ae5-4d6a-9e11-0f422243b885");
     }

package/QueryFilter.d.ts

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

package/QueryFilter.js

@@ -12,6 +12,8 @@ var FilterOperator;
     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 = exports.FilterOperator || (exports.FilterOperator = {}));
 var FilterLogicalOperator;
 (function (FilterLogicalOperator) {

package/filterbuilder/FilterBuilder.d.ts

@@ -0,0 +1,94 @@
+import { FilterComponent } from "./FilterComponent";
+export interface IFilterExpressionBuilder {
+    intProperty(propertyName: string): IIntFilterOperatorBuilder;
+    floatProperty(propertyName: string): IFloatFilterOperatorBuilder;
+    dateTimeProperty(propertyName: string): IDateTimeFilterOperatorBuilder;
+    dateTimeOffSetProperty(propertyName: string): IDateTimeOffsetFilterOperatorBuilder;
+    stringProperty(propertyName: string): IStringFilterOperatorBuilder;
+    expression(buildInnerExpression: (builder: IFilterExpressionBuilder) => IFilterLogicalOperatorBuilder): IFilterLogicalOperatorBuilder;
+}
+export declare class FilterExpressionBuilder implements IFilterExpressionBuilder {
+    private filters;
+    constructor(filters?: FilterComponent[]);
+    intProperty(propertyName: string): IIntFilterOperatorBuilder;
+    floatProperty(propertyName: string): IFloatFilterOperatorBuilder;
+    dateTimeProperty(propertyName: string): IDateTimeFilterOperatorBuilder;
+    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[];
+}

package/filterbuilder/FilterBuilder.js

@@ -0,0 +1,158 @@
+"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;
+const QueryFilter_1 = require("../QueryFilter");
+const FilterComponent_1 = require("./FilterComponent");
+class FilterExpressionBuilder {
+    constructor(filters = []) {
+        if (filters == null) {
+            throw new Error("filters cannot be null");
+        }
+        this.filters = filters;
+    }
+    intProperty(propertyName) {
+        return new IntFilterOperatorBuilder(this.filters, propertyName);
+    }
+    floatProperty(propertyName) {
+        return new FloatFilterOperatorBuilder(this.filters, propertyName);
+    }
+    dateTimeProperty(propertyName) {
+        return new DateTimeFilterOperatorBuilder(this.filters, propertyName);
+    }
+    dateTimeOffSetProperty(propertyName) {
+        return new DateTimeOffsetFilterOperatorBuilder(this.filters, propertyName);
+    }
+    stringProperty(propertyName) {
+        return new StringFilterOperatorBuilder(this.filters, propertyName);
+    }
+    expression(buildInnerExpression) {
+        const filterExpression = new FilterExpressionBuilder();
+        const buildResult = buildInnerExpression(filterExpression);
+        const innerFilters = buildResult.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;
+    }
+}
+exports.FilterLogicalOperatorBuilder = FilterLogicalOperatorBuilder;

package/filterbuilder/FilterComponent.d.ts

@@ -0,0 +1,26 @@
+import { FilterLogicalOperator, FilterOperator } from "../QueryFilter";
+export declare enum FilterComponentType {
+    Condition = 0,
+    LogicalOperator = 1,
+    Expression = 2
+}
+export interface FilterComponent {
+    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 {
+    type: FilterComponentType;
+    logicalOperator: FilterLogicalOperator;
+    constructor(logicalOperator: FilterLogicalOperator);
+}
+export declare class FilterExpressionComponent implements FilterComponent {
+    type: FilterComponentType;
+    filters: FilterComponent[];
+    constructor(filters: FilterComponent[]);
+}

package/filterbuilder/FilterComponent.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterExpressionComponent = exports.FilterLogicalOperatorComponent = exports.FilterConditionComponent = exports.FilterComponentType = void 0;
+var FilterComponentType;
+(function (FilterComponentType) {
+    FilterComponentType[FilterComponentType["Condition"] = 0] = "Condition";
+    FilterComponentType[FilterComponentType["LogicalOperator"] = 1] = "LogicalOperator";
+    FilterComponentType[FilterComponentType["Expression"] = 2] = "Expression";
+})(FilterComponentType = exports.FilterComponentType || (exports.FilterComponentType = {}));
+class FilterConditionComponent {
+    constructor(propertyName, filterOperator, values) {
+        this.type = FilterComponentType.Condition;
+        this.operator = filterOperator;
+        this.propertyName = propertyName;
+        this.values = values;
+    }
+}
+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;
+        this.filters = filters;
+    }
+}
+exports.FilterExpressionComponent = FilterExpressionComponent;

package/filterbuilder/helper/FilterHelper.d.ts

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

package/filterbuilder/helper/FilterHelper.js

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

package/filterbuilder/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./FilterComponent";
+export * from "./FilterBuilder";
+export * from "./helper/FilterHelper";

package/filterbuilder/index.js

@@ -0,0 +1,6 @@
+"use strict";
+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("./helper/FilterHelper"), exports);

package/package.json

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