@omnia/fx-models 7.8.16-preview → 7.8.16

package/analytics/BusinessProfileAnalyticsSettings.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BusinessProfileAnalyticsSettings = void 0;
+const models_1 = require("@omnia/fx-models/internal-do-not-import-from-here/shared/models");
+const BusinessProfile_1 = require("./../BusinessProfile");
+class BusinessProfileAnalyticsSettings extends BusinessProfile_1.BusinessProfileProperty {
+    constructor() {
+        super(new models_1.Guid("39df27aa-95f1-4a23-b3f6-8b231afcda82"), "bpanalyticssettings");
+        this.enabled = false;
+        this.idSite = -1;
+        this.mappings = [];
+        this.shared = false;
+    }
+}
+exports.BusinessProfileAnalyticsSettings = BusinessProfileAnalyticsSettings;
+BusinessProfileAnalyticsSettings.checkIfAnalyticsSwitchToDisabled = (currenttSetting, targetSetting) => targetSetting?.idSite !== currenttSetting?.idSite && !targetSetting?.enabled;
+BusinessProfileAnalyticsSettings.checkIfAnalyticsSwitchToEnabled = (currenttSetting, targetSetting) => targetSetting?.idSite !== currenttSetting?.idSite && targetSetting?.enabled;

package/analytics/EventAction.d.ts

@@ -1,5 +1,6 @@
-import { GuidValue } from "../Exposes";
+import { GuidValue } from "@omnia/fx-models";
 export interface EventAction {
     id: GuidValue;
     name: string;
+    customName?: string;
 }

package/analytics/index.d.ts

@@ -1,2 +1,4 @@
+export * from "./AnalyticsDimensionMappings";
+export * from "./BusinessProfileAnalyticsSettings";
 export * from "./AnalyticsSettings";
 export * from "./EventAction";

package/analytics/index.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./AnalyticsDimensionMappings"), exports);
+tslib_1.__exportStar(require("./BusinessProfileAnalyticsSettings"), exports);
 tslib_1.__exportStar(require("./AnalyticsSettings"), exports);
 tslib_1.__exportStar(require("./EventAction"), exports);

package/azure-openai/settings/OpenAISettings.d.ts

@@ -7,5 +7,8 @@ export interface DallESetting {
     apiBaseUrl: string;
     apiVersion: string;
 }
+export interface DeploymentNameSetting {
+    deploymentName: string;
+}
 export declare const azureTextCompletionVersion: readonly ["2023-03-15-preview", "2022-12-01"];
 export declare const azureDallEVersion: readonly ["2022-08-03-preview"];

package/filterbuilder/FilterBuilder.d.ts

@@ -0,0 +1,40 @@
+import { FilterLogicalOperator } from "../QueryFilter";
+import { FilterComponent } from "./FilterComponent";
+import { IBooleanFilterOperatorBuilder, IDateTimeFilterOperatorBuilder, IDateTimeOffsetFilterOperatorBuilder, IFloatFilterOperatorBuilder, IIntFilterOperatorBuilder, IStringFilterOperatorBuilder } from "./FilterOperatorBuilder";
+export interface IFilterComponentBuilder {
+    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;
+    build(): FilterComponent[];
+}
+export declare class FilterBuilder implements IFilterComponentBuilder, IFilterLogicalOperatorBuilder {
+    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;
+    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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterBuilder = void 0;
+const QueryFilter_1 = require("../QueryFilter");
+const FilterComponent_1 = require("./FilterComponent");
+const FilterOperatorBuilder_1 = require("./FilterOperatorBuilder");
+class FilterBuilder {
+    constructor(filters) {
+        this.filters = [];
+        this.filterLogicalOperator = QueryFilter_1.FilterLogicalOperator.And;
+        if (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;
+    }
+    build() {
+        return this.filters;
+    }
+    int(propertyName) {
+        this.propertyName = propertyName;
+        this.intFilterOperatorBuilder =
+            this.intFilterOperatorBuilder || new FilterOperatorBuilder_1.IntFilterOperatorBuilder(this);
+        return this.intFilterOperatorBuilder;
+    }
+    float(propertyName) {
+        this.propertyName = propertyName;
+        this.floatFilterOperatorBuilder =
+            this.floatFilterOperatorBuilder || new FilterOperatorBuilder_1.FloatFilterOperatorBuilder(this);
+        return this.floatFilterOperatorBuilder;
+    }
+    dateTime(propertyName) {
+        this.propertyName = propertyName;
+        this.dateTimeFilterOperatorBuilder =
+            this.dateTimeFilterOperatorBuilder || new FilterOperatorBuilder_1.DateTimeFilterOperatorBuilder(this);
+        return this.dateTimeFilterOperatorBuilder;
+    }
+    dateTimeOffset(propertyName) {
+        this.propertyName = propertyName;
+        this.dateTimeOffsetFilterOperatorBuilder =
+            this.dateTimeOffsetFilterOperatorBuilder || new FilterOperatorBuilder_1.DateTimeOffsetFilterOperatorBuilder(this);
+        return this.dateTimeOffsetFilterOperatorBuilder;
+    }
+    string(propertyName) {
+        this.propertyName = propertyName;
+        this.stringFilterOperatorBuilder =
+            this.stringFilterOperatorBuilder || new FilterOperatorBuilder_1.StringFilterOperatorBuilder(this);
+        return this.stringFilterOperatorBuilder;
+    }
+    boolean(propertyName) {
+        this.propertyName = propertyName;
+        this.booleanFilterOperatorBuilder =
+            this.booleanFilterOperatorBuilder || new FilterOperatorBuilder_1.BooleanFilterOperatorBuilder(this);
+        return this.booleanFilterOperatorBuilder;
+    }
+    expression(buildInnerExpression) {
+        const innerFilterBuilder = new FilterBuilder([]);
+        const innerFilters = buildInnerExpression(innerFilterBuilder).build();
+        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, this.filterLogicalOperator));
+        return this;
+    }
+}
+exports.FilterBuilder = FilterBuilder;

package/filterbuilder/FilterComponent.d.ts

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

package/filterbuilder/FilterComponent.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterExpressionComponent = exports.FilterConditionComponent = exports.FilterComponentType = void 0;
+const QueryFilter_1 = require("../QueryFilter");
+var FilterComponentType;
+(function (FilterComponentType) {
+    FilterComponentType[FilterComponentType["Condition"] = 1] = "Condition";
+    FilterComponentType[FilterComponentType["Expression"] = 2] = "Expression";
+})(FilterComponentType = exports.FilterComponentType || (exports.FilterComponentType = {}));
+class FilterConditionComponent {
+    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 FilterExpressionComponent {
+    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,67 @@
+import { FilterBuilder, IFilterLogicalOperatorBuilder } from "./FilterBuilder";
+export interface IFilterOperatorBuilder<T> {
+    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> {
+    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;
+    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);
+    equals(value: T): IFilterLogicalOperatorBuilder;
+    notEquals(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> {
+    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;
+    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;
+    }
+    equals(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.Equal, [value], this.filterBuilder.filterLogicalOperator));
+        return this.filterBuilder;
+    }
+    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) {
+        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.Equal, null, this.filterBuilder.filterLogicalOperator));
+        return this.filterBuilder;
+    }
+    isNotNull() {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.NotEqual, 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 {
+    greaterThanOrEqual(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.GreaterThanOrEqual, [value], this.filterBuilder.filterLogicalOperator));
+        return this.filterBuilder;
+    }
+    greaterThan(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.GreaterThan, [value], this.filterBuilder.filterLogicalOperator));
+        return this.filterBuilder;
+    }
+    lessThanOrEqual(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.LessThanOrEqual, [value], this.filterBuilder.filterLogicalOperator));
+        return this.filterBuilder;
+    }
+    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.BitwiseAnd, [value], this.filterBuilder.filterLogicalOperator));
+        return this.filterBuilder;
+    }
+    bitwiseNotAnd(value) {
+        this.filterBuilder.addFilter(new FilterComponent_1.FilterConditionComponent(this.filterBuilder.propertyName, QueryFilter_1.FilterOperator.BitwiseNotAnd, [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

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

package/filterbuilder/helper/FilterHelper.js

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

package/filterbuilder/index.d.ts

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

package/filterbuilder/index.js

@@ -0,0 +1,8 @@
+"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("./FilterOperatorBuilder"), exports);
+tslib_1.__exportStar(require("./helper/FilterHelper"), exports);
+tslib_1.__exportStar(require("./transformers"), 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/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

@@ -117,7 +117,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/identities/IdentityCreationRequest.d.ts

@@ -16,6 +16,7 @@ export interface UserRequestFormDisplaySetting {
     userTypeId: GuidValue;
     userTypeDisplayName: MultilingualString;
     propertyBindings: Array<PropertyBindingDisplay>;
+    magicLinkExpiration: number;
 }
 export declare enum ConfirmEmailStatus {
     Incomplete = 0,

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

@@ -15,6 +15,14 @@ export declare class Future<T> extends Promise<T> {
      * @memberof Future
      */
     tryCatch(): Future<[success: T, error: Error]>;
+    unwrapAxiosApiResponse<T2>(): Future<T2>;
+    unwrap<T2>(executor: (value: T, resolve: (value: T2) => void, reject: (reason?: any) => void) => void): Future<T2>;
+    /**
+     * Expose abort for other future to use.
+     * chain method for future
+     * @param onAbort
+     */
+    abortIf(onAbort: (cb: (reason?: any) => void) => void): this;
     /**
      * Aborts the request
      *