igniteui-webcomponents-datasources 1.3.3 → 1.4.2

package/fesm5/igniteui-webcomponents-datasources.js

@@ -1,4 +1,11 @@
-import { fromEnum, XName, DataSourceSchemaPropertyType, XDocument, XmlNodeType, typeCast, XElement, ODataDataSourceSchema, XNamespace, markType, AsyncVirtualDataSourceProviderTaskDataHolder, SortDescriptionCollection, ListSortDirection, DataSourceSummaryScope, stringIsNullOrEmpty, Convert, DefaultSectionInformation, SummaryOperand, DefaultSummaryResult, AsyncVirtualDataTask, AsyncDataSourcePageTaskHolder, ODataDataSourceFilterExpressionVisitor, TransactionType, AsyncVirtualDataSourceProviderWorker, AsyncVirtualDataSourceDataProviderWorkerSettings, FilterExpressionCollection, SummaryDescriptionCollection, DataSourcePageRequestPriority, runOn, DataSourceDataProviderSchemaChangedEventArgs, stringContains, Base, IDataSourceVirtualDataProvider_$type, VirtualDataSource } from 'igniteui-webcomponents-core';
+/*!
+    THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+    https://www.infragistics.com/legal/license/igultimate-la
+    https://www.infragistics.com/legal/license/igultimate-eula
+    GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+  */
+  
+import { fromEnum, XName, DataSourceSchemaPropertyType, XDocument, XmlNodeType, typeCast, XElement, ODataDataSourceSchema, XNamespace, markType, AsyncVirtualDataSourceProviderTaskDataHolder, SortDescriptionCollection, ListSortDirection, DataSourceSummaryScope, stringIsNullOrEmpty, Convert, DefaultSectionInformation, SummaryOperand, DefaultSummaryResult, AsyncVirtualDataTask, AsyncDataSourcePageTaskHolder, ODataDataSourceFilterExpressionVisitor, TransactionType, AsyncVirtualDataSourceProviderWorker, AsyncVirtualDataSourceDataProviderWorkerSettings, FilterExpressionCollection, SummaryDescriptionCollection, DataSourcePageRequestPriority, runOn, DataSourceDataProviderSchemaChangedEventArgs, stringContains, Base, IDataSourceVirtualDataProvider_$type, VirtualDataSource, LocalDataSource } from 'igniteui-webcomponents-core';
 import { __values, __extends, __generator } from 'tslib';
 
 var EntityProperty = /** @class */ /*@__PURE__*/ (function () {
@@ -2336,5 +2343,2270 @@ var ODataVirtualDataSource = /** @class */ /*@__PURE__*/ (function (_super) {
     return ODataVirtualDataSource;
 }(VirtualDataSource));
 
-export { Entity, EntityProperty, EntitySet, LinkedList, LinkedListNode, ODataDataSourcePage, ODataSchemaProvider, ODataVirtualDataSource, ODataVirtualDataSourceDataProvider, ODataVirtualDataSourceDataProviderWorker, ODataVirtualDataSourceDataProviderWorkerSettings, ODataVirtualDataSourceProviderTaskDataHolder, Schema, first, toArray };
-//# sourceMappingURL=igniteui-webcomponents-datasources.js.map
+var RestVirtualDataSourceProviderTaskDataHolder = /** @class */ /*@__PURE__*/ (function (_super) {
+    __extends(RestVirtualDataSourceProviderTaskDataHolder, _super);
+    function RestVirtualDataSourceProviderTaskDataHolder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    RestVirtualDataSourceProviderTaskDataHolder.$t = markType(RestVirtualDataSourceProviderTaskDataHolder, 'ODataVirtualDataSourceProviderTaskDataHolder', AsyncVirtualDataSourceProviderTaskDataHolder.$type);
+    return RestVirtualDataSourceProviderTaskDataHolder;
+}(AsyncVirtualDataSourceProviderTaskDataHolder));
+
+var RestVirtualDataSourcePage = /** @class */ /*@__PURE__*/ (function () {
+    function RestVirtualDataSourcePage(sourceData_, schema, groupInformation, summaryInformation, pageIndex) {
+        this._actualData = null;
+        this._schema = null;
+        this._pageIndex = 0;
+        this._groupInformation = null;
+        this._summaryInformation = null;
+        if (sourceData_ == null) {
+            this._actualData = null;
+        }
+        else {
+            var count = (sourceData_.items.length);
+            this._actualData = [];
+            var dateProps = new Set();
+            for (var i = 0; i < schema.propertyNames.length; i++) {
+                if (schema.propertyTypes[i] == DataSourceSchemaPropertyType.DateTimeValue || schema.propertyTypes[i] == DataSourceSchemaPropertyType.DateTimeOffsetValue) {
+                    dateProps.add(schema.propertyNames[i]);
+                }
+            }
+            var value_ = void 0;
+            var _loop_1 = function (i_) {
+                var currItem_ = sourceData_.items[i_];
+                var dict = new Map();
+                var properties = Array.from(Object.keys(currItem_));
+                var values = (properties.map(function (k) { return currItem_[k]; }));
+                for (var i1 = 0; i1 < properties.length; i1++) {
+                    value_ = values[i1];
+                    if (dateProps.has(properties[i1])) {
+                        value_ = new Date(value_);
+                    }
+                    dict.set(properties[i1], value_);
+                }
+                this_1._actualData[i_] = dict;
+            };
+            var this_1 = this;
+            for (var i_ = 0; i_ < count; i_++) {
+                _loop_1(i_);
+            }
+        }
+        this._schema = schema;
+        this._groupInformation = groupInformation;
+        this._summaryInformation = summaryInformation;
+        this._pageIndex = pageIndex;
+    }
+    RestVirtualDataSourcePage.prototype.count = function () {
+        return this._actualData.length;
+    };
+    RestVirtualDataSourcePage.prototype.getItemAtIndex = function (index) {
+        return this._actualData[index];
+    };
+    RestVirtualDataSourcePage.prototype.getItemValueAtIndex = function (index, valueName) {
+        var item = this._actualData[index];
+        if (!item.has(valueName)) {
+            return null;
+        }
+        return item.get(valueName);
+    };
+    RestVirtualDataSourcePage.prototype.pageIndex = function () {
+        return this._pageIndex;
+    };
+    RestVirtualDataSourcePage.prototype.schema = function () {
+        return this._schema;
+    };
+    RestVirtualDataSourcePage.prototype.getGroupInformation = function () {
+        return this._groupInformation;
+    };
+    RestVirtualDataSourcePage.prototype.getSummaryInformation = function () {
+        return this._summaryInformation;
+    };
+    return RestVirtualDataSourcePage;
+}());
+
+var RestVirtualDataSourceDataProviderWorker = /** @class */ /*@__PURE__*/ (function (_super) {
+    __extends(RestVirtualDataSourceDataProviderWorker, _super);
+    function RestVirtualDataSourceDataProviderWorker(settings) {
+        var e_1, _a;
+        var _this = _super.call(this, settings) || this;
+        _this._baseUri = null;
+        _this._entitySet = null;
+        _this._sortDescriptions = null;
+        _this._groupDescriptions = null;
+        _this._filterExpressions = null;
+        _this._summaryDescriptions = null;
+        _this._desiredPropeties = null;
+        _this._enableJsonp = true;
+        _this._isAggregationSupported = false;
+        _this._provideFullCount = null;
+        _this._provideOrderByParameter = null;
+        _this._provideFilterParameter = null;
+        _this._provideAggregationParameter = null;
+        _this._provideAggregatedCount = null;
+        _this._providePagingParameter = null;
+        _this._provideDesiredPropertiesParameter = null;
+        _this._provideUri = null;
+        _this._performFetch = null;
+        _this._fixedFullCount = -1;
+        _this._groupInformation = null;
+        _this._summaryInformation = null;
+        _this._filterString = null;
+        _this._selectedString = null;
+        _this.doWork = _this.doWork.bind(_this);
+        _this._baseUri = settings.baseUri;
+        _this._entitySet = settings.entitySet;
+        _this._sortDescriptions = settings.sortDescriptions;
+        _this._groupDescriptions = settings.groupDescriptions;
+        if (_this._groupDescriptions != null && _this._groupDescriptions.size() > 0) {
+            _this._sortDescriptions = new SortDescriptionCollection();
+            try {
+                for (var _b = __values(_this.iter(settings.sortDescriptions)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var sd = _c.value;
+                    _this._sortDescriptions.add(sd);
+                }
+            }
+            catch (e_1_1) {
+                e_1 = { error: e_1_1 };
+            }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return))
+                        _a.call(_b);
+                }
+                finally {
+                    if (e_1)
+                        throw e_1.error;
+                }
+            }
+            for (var i = 0; i < _this._groupDescriptions.size(); i++) {
+                _this._sortDescriptions.insert(i, _this._groupDescriptions.get(i));
+            }
+        }
+        _this._filterExpressions = settings.filterExpressions;
+        _this._desiredPropeties = settings.propertiesRequested;
+        _this._summaryDescriptions = settings.summaryDescriptions;
+        _this._fixedFullCount = settings.fixedFullCount;
+        _this._summaryScope = settings.summaryScope;
+        _this._enableJsonp = settings.enableJsonp;
+        _this._provideFullCount = settings.provideFullCount;
+        _this._performFetch = settings.performFetch;
+        _this._provideAggregationParameter = settings.provideAggregationParameter;
+        _this._provideFilterParameter = settings.provideFilterParameter;
+        _this._provideOrderByParameter = settings.provideOrderByParameter;
+        _this._provideUri = settings.provideUri;
+        _this._providePagingParameter = settings.providePagingParameter;
+        _this._provideDesiredPropertiesParameter = settings.provideDesiredPropertiesParameter;
+        _this._provideItems = settings.provideItems;
+        _this._provideAggregatedCount = settings.provideAggregatedCount;
+        if (!_this._provideItems) {
+            _this._provideItems = function (res) {
+                return res ? res.items : null;
+            };
+        }
+        if (!_this._provideFullCount) {
+            _this._provideFullCount = function (p) {
+                if (p.fullCount) {
+                    return p.fullCount;
+                }
+                else {
+                    return _this._fixedFullCount >= 0 ? _this._fixedFullCount : 0;
+                }
+            };
+        }
+        if (!_this._provideOrderByParameter) {
+            _this._provideOrderByParameter = function (args, orderByString, orderBy) {
+                args.push({ name: "orderBy", value: encodeURIComponent(orderByString) });
+            };
+        }
+        if (!_this._providePagingParameter) {
+            _this._providePagingParameter = function (args, skip, take) {
+                args.push({ name: "skip", value: skip });
+                args.push({ name: "take", value: take });
+            };
+        }
+        if (!_this._provideAggregationParameter) {
+            _this._provideAggregationParameter = function (args, fetchCountOnly, groupByString, groupBy, summaryString, summary) {
+                args.push({ name: "groupBy", value: groupByString });
+                args.push({ name: "aggregate", value: "count" });
+            };
+        }
+        if (!_this._provideUri) {
+            _this._provideUri = function (baseUri, entitySet, args) {
+                var requestUri = baseUri;
+                requestUri += "/" + entitySet;
+                if (args.length > 0) {
+                    requestUri += "?";
+                }
+                var argsString = "";
+                for (var i = 0; i < args.length; i++) {
+                    if (i > 0) {
+                        argsString += "&";
+                    }
+                    argsString += args[i].name + "=" + args[i].value;
+                }
+                return requestUri + argsString;
+            };
+        }
+        _this._isAggregationSupported = settings.isAggregationSupported;
+        window.setTimeout(_this.doWork, 100);
+        return _this;
+    }
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorker.prototype, "sortDescriptions", {
+        get: function () {
+            return this._sortDescriptions;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorker.prototype, "filterExpressions", {
+        get: function () {
+            return this._filterExpressions;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorker.prototype, "desiredProperties", {
+        get: function () {
+            return this._desiredPropeties;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RestVirtualDataSourceDataProviderWorker.prototype.initialize = function () {
+        _super.prototype.initialize.call(this);
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.getTaskDataHolder = function () {
+        var holder = new RestVirtualDataSourceProviderTaskDataHolder();
+        return holder;
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.getCompletedTaskData = function (holder, completed) {
+        _super.prototype.getCompletedTaskData.call(this, holder, completed);
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.removeCompletedTaskData = function (holder, completed) {
+        _super.prototype.removeCompletedTaskData.call(this, holder, completed);
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.getTasksData = function (holder) {
+        _super.prototype.getTasksData.call(this, holder);
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.iter = function (coll) {
+        var i;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < coll.size()))
+                        return [3 /*break*/, 4];
+                    return [4 /*yield*/, coll.get(i)];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.iterFilter = function (coll) {
+        var i;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < coll.size()))
+                        return [3 /*break*/, 4];
+                    return [4 /*yield*/, coll.get(i)];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.iterSummaries = function (summaries) {
+        var i;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < summaries.size()))
+                        return [3 /*break*/, 4];
+                    return [4 /*yield*/, summaries.get(i)];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.processCompletedTask = function (completedTask, currentDelay, pageIndex, taskDataHolder) {
+        var _this = this;
+        var h = taskDataHolder;
+        var schema = null;
+        var result = null;
+        var schemaFetchCount = -1;
+        var task = completedTask.task;
+        try {
+            if (task.hasErrors) {
+                this.retryIndex(pageIndex, currentDelay);
+                return;
+            }
+            if (pageIndex == RestVirtualDataSourceDataProviderWorker.schemaRequestIndex) {
+                result = task.result;
+                schemaFetchCount = (this._provideFullCount(result));
+            }
+            else {
+                result = task.result;
+            }
+        }
+        catch (e) {
+            this.retryIndex(pageIndex, currentDelay);
+            return;
+        }
+        if (schemaFetchCount >= 0) {
+            this.actualCount = schemaFetchCount;
+        }
+        else {
+            this.actualCount = (this._provideFullCount(result));
+        }
+        schema = this.actualSchema;
+        if (schema == null) {
+            var requests_1 = 0;
+            this.resolveSchema(function (s) {
+                // resolveSchema success callback
+                _this.actualSchema = s;
+                if (_this._isAggregationSupported && (_this._groupDescriptions.size() !== 0 || _this._summaryDescriptions.size() !== 0)) {
+                    if (_this._groupDescriptions.size() > 0) {
+                        requests_1++;
+                        _this.resolveGroupInformation(function (g) {
+                            // group info success
+                            requests_1--;
+                            if (requests_1 === 0) {
+                                _this.finishProcessingCompletedTask(task, pageIndex, s, result);
+                            }
+                        }, function () {
+                            // group info failure
+                            _this.retryIndex(pageIndex, currentDelay);
+                            return;
+                        });
+                    }
+                    if (_this._summaryDescriptions.size() > 0) {
+                        requests_1++;
+                        _this.resolveSummaryInformation(function (g) {
+                            // summary info success
+                            requests_1--;
+                            if (requests_1 === 0) {
+                                _this.finishProcessingCompletedTask(task, pageIndex, s, result);
+                            }
+                        }, function () {
+                            // summary info failure
+                            _this.retryIndex(pageIndex, currentDelay);
+                            return;
+                        });
+                    }
+                }
+                else {
+                    _this.finishProcessingCompletedTask(task, pageIndex, s, result);
+                }
+            }, function () {
+                // resolveSchema failure callback
+                _this.retryIndex(pageIndex, currentDelay);
+                return;
+            });
+            return;
+        }
+        this.finishProcessingCompletedTask(task, pageIndex, schema, result);
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.finishProcessingCompletedTask = function (task, pageIndex, schema, result) {
+        var _this = this;
+        var executionContext;
+        var pageLoaded;
+        var groupInformation;
+        var summaryInformation;
+        this.actualSchema = schema;
+        executionContext = this.executionContext;
+        groupInformation = this._groupInformation;
+        summaryInformation = this._summaryInformation;
+        pageLoaded = this.pageLoaded;
+        var page = null;
+        if (result != null) {
+            page = new RestVirtualDataSourcePage(result, schema, groupInformation, summaryInformation, pageIndex);
+            if (!this.isLastPage(pageIndex) && page.count() > 0 && !this.populatedActualPageSize) {
+                this.populatedActualPageSize = true;
+                this.actualPageSize = page.count();
+            }
+        }
+        else {
+            page = new RestVirtualDataSourcePage(null, schema, groupInformation, summaryInformation, pageIndex);
+        }
+        if (this.pageLoaded != null) {
+            if (this.executionContext != null) {
+                if (executionContext == null || pageLoaded == null) {
+                    this.shutdown();
+                    return;
+                }
+                executionContext.execute(function () { return pageLoaded(page, _this.actualCount, _this.actualPageSize); });
+            }
+            else {
+                if (pageLoaded == null) {
+                    this.shutdown();
+                    return;
+                }
+                pageLoaded(page, this.actualCount, this.actualPageSize);
+            }
+        }
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.resolveGroupInformation = function (finishAction, failureAction) {
+        var e_2, _a;
+        var _this = this;
+        if (this._groupInformation != null) {
+            finishAction(this._groupInformation);
+            return;
+        }
+        var orderBy = "";
+        var groupBy = "";
+        var filter = null;
+        var summary = "";
+        if (this._groupDescriptions == null || this._groupDescriptions.size() == 0) {
+            finishAction(null);
+            return;
+        }
+        if (this._provideAggregationParameter == null) {
+            finishAction(null);
+            return;
+        }
+        filter = this._filterString;
+        this.updateFilterString();
+        if (this._groupDescriptions != null) {
+            var first1 = true;
+            try {
+                for (var _b = __values(this.iter(this._groupDescriptions)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var group = _c.value;
+                    if (first1) {
+                        first1 = false;
+                    }
+                    else {
+                        orderBy += ", ";
+                        groupBy += ", ";
+                    }
+                    groupBy += group.propertyName;
+                    if (group.direction === ListSortDirection.Descending) {
+                        orderBy += group.propertyName + " desc";
+                    }
+                    else {
+                        orderBy += group.propertyName + " asc";
+                    }
+                }
+            }
+            catch (e_2_1) {
+                e_2 = { error: e_2_1 };
+            }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return))
+                        _a.call(_b);
+                }
+                finally {
+                    if (e_2)
+                        throw e_2.error;
+                }
+            }
+        }
+        if (this._summaryScope === DataSourceSummaryScope.Both || this._summaryScope === DataSourceSummaryScope.Groups) {
+            var summaryParameters = this.getSummaryQueryParameters(true);
+            if (!stringIsNullOrEmpty(summaryParameters)) {
+                summary = ", " + summaryParameters;
+            }
+        }
+        var args = [];
+        if (this._provideOrderByParameter) {
+            this._provideOrderByParameter(args, orderBy, this._groupDescriptions);
+        }
+        if (this._provideFilterParameter && filter != null) {
+            this._provideFilterParameter(args, filter, this._filterExpressions);
+        }
+        if (this._provideAggregationParameter) {
+            this._provideAggregationParameter(args, true, groupBy, this._groupDescriptions, summary, this._summaryDescriptions);
+        }
+        var uri = this._provideUri(this._baseUri, this._entitySet, args);
+        try {
+            var groupInformation_1 = [];
+            var success_1 = function (data, response) { return _this.groupSuccess(data, response, finishAction, failureAction, groupInformation_1); };
+            var failure_1 = function (err) { return _this.groupError(err, finishAction, failureAction, groupInformation_1); };
+            var run_ = null;
+            var headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
+            var request = {
+                requestUri: uri,
+                enableJsonpCallback: this._enableJsonp,
+                method: 'GET',
+                headers: headers,
+                data: null
+            };
+            run_ = function () {
+                _this.fetchUri(request, success_1, failure_1);
+            };
+            run_();
+        }
+        catch (e) {
+            failureAction();
+        }
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.fetchUri = function (request, success, failure) {
+        if (this._performFetch) {
+            this._performFetch(request, success, failure);
+        }
+        else {
+            fetch(request.requestUri, {
+                method: request.method,
+                headers: request.headers,
+            }).then(function (res) {
+                res.json().then(function (j) {
+                    success(j, res);
+                });
+            }).catch(function (e) {
+                failure(e);
+            });
+        }
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.groupError = function (err, finishAction, failureAction, groupInformation) {
+        this._groupInformation = null;
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.groupSuccess = function (data, response, finishAction, failureAction, groupInformation) {
+        var e_3, _a;
+        var groupNames = [];
+        try {
+            for (var _b = __values(this.iter(this._groupDescriptions)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var group = _c.value;
+                groupNames.push(group.propertyName);
+            }
+        }
+        catch (e_3_1) {
+            e_3 = { error: e_3_1 };
+        }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return))
+                    _a.call(_b);
+            }
+            finally {
+                if (e_3)
+                    throw e_3.error;
+            }
+        }
+        var groupNamesArray = groupNames;
+        var items = this._provideItems(data);
+        if (items && items.length > 0) {
+            var currentIndex = 0;
+            for (var i = 0; i < items.length; i++) {
+                this.addGroup(groupInformation, groupNames, groupNames, currentIndex, items[i]);
+            }
+        }
+        this._groupInformation = groupInformation;
+        finishAction(this._groupInformation);
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.addGroup = function (groupInformation, groupNames, groupNamesArray, currentIndex, group) {
+        var e_4, _a;
+        var groupValues = [];
+        try {
+            for (var groupNames_1 = __values(groupNames), groupNames_1_1 = groupNames_1.next(); !groupNames_1_1.done; groupNames_1_1 = groupNames_1.next()) {
+                var name_1 = groupNames_1_1.value;
+                if (group[name_1]) {
+                    groupValues.push(group[name_1]);
+                }
+            }
+        }
+        catch (e_4_1) {
+            e_4 = { error: e_4_1 };
+        }
+        finally {
+            try {
+                if (groupNames_1_1 && !groupNames_1_1.done && (_a = groupNames_1.return))
+                    _a.call(groupNames_1);
+            }
+            finally {
+                if (e_4)
+                    throw e_4.error;
+            }
+        }
+        var groupCount = 0;
+        //todo: make this customizable
+        if (this._provideAggregatedCount) {
+            var ct = this._provideAggregatedCount(group);
+        }
+        else {
+            if (group["aggregatedCount"]) {
+                groupCount = Convert.toInt321(group["aggregatedCount"]);
+            }
+        }
+        var summaryResults = null;
+        if (this._summaryScope == DataSourceSummaryScope.Both || this._summaryScope == DataSourceSummaryScope.Groups) {
+            summaryResults = this.createSummaryResults(group);
+        }
+        var groupInfo = new DefaultSectionInformation(currentIndex, currentIndex + (groupCount - 1), groupNamesArray, groupValues, summaryResults);
+        groupInformation.push(groupInfo);
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.resolveSummaryInformation = function (finishAction, failureAction) {
+        var _this = this;
+        if (this._summaryInformation != null) {
+            finishAction(this._summaryInformation);
+            return;
+        }
+        var filter = null;
+        var summary = null;
+        if (this._summaryDescriptions == null ||
+            this._summaryDescriptions.size() == 0 ||
+            this._summaryScope == DataSourceSummaryScope.Groups ||
+            this._summaryScope == DataSourceSummaryScope.None) {
+            finishAction(null);
+            return;
+        }
+        filter = this._filterString;
+        this.updateFilterString();
+        summary = this.getSummaryQueryParameters(false);
+        var args = [];
+        // if (this._provideOrderByParameter) {
+        //     args.push({ name: "orderBy", value: this._provideOrderByParameter(orderBy, this._sortDescriptions) });
+        // }
+        if (this._provideFilterParameter && filter != null) {
+            this._provideFilterParameter(args, filter, this._filterExpressions);
+        }
+        if (this._provideAggregationParameter) {
+            this._provideAggregationParameter(args, true, null, null, summary, this._summaryDescriptions);
+        }
+        var uri = this._provideUri(this._baseUri, this._entitySet, args);
+        // let commandText = this._entitySet + "?$apply=";
+        // if (!stringIsNullOrEmpty(filter)) {
+        // 	commandText += "filter(" + filter + ")/";
+        // }
+        // commandText += "aggregate(" + summary + ")";
+        try {
+            var summaryInformation_1 = [];
+            var success_2 = function (data, response) { return _this.summarySuccess(data, response, finishAction, failureAction, summaryInformation_1); };
+            var failure_2 = function (err) { return _this.summaryError(err, finishAction, failureAction, summaryInformation_1); };
+            var run_ = null;
+            var headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
+            var request = {
+                requestUri: uri,
+                enableJsonpCallback: this._enableJsonp,
+                method: 'GET',
+                headers: headers,
+                data: null
+            };
+            run_ = function () {
+                _this.fetchUri(request, success_2, failure_2);
+            };
+            run_();
+        }
+        catch (e) {
+            failureAction();
+        }
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.summarySuccess = function (data, response, finishAction, failureAction, summaryInformation) {
+        if (data && data.value && data.value.length > 0) {
+            summaryInformation = this.createSummaryResults(data.value[0]);
+        }
+        this._summaryInformation = summaryInformation;
+        finishAction(this._summaryInformation);
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.summaryError = function (err, finishAction, failureAction, summaryInformation) {
+        this._summaryInformation = null;
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.getSummaryQueryParameters = function (ignoreCount) {
+        var e_5, _a;
+        var result = "";
+        if (this._summaryDescriptions != null) {
+            var first = true;
+            var countExists = false;
+            try {
+                for (var _b = __values(this.iterSummaries(this._summaryDescriptions)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var summary = _c.value;
+                    if (summary.operand == SummaryOperand.Count && (ignoreCount || countExists)) {
+                        continue;
+                    }
+                    if (!first) {
+                        result += ", ";
+                    }
+                    switch (summary.operand) {
+                        case SummaryOperand.Average:
+                            result += summary.propertyName + " with average as " + summary.propertyName + "Average";
+                            break;
+                        case SummaryOperand.Min:
+                            result += summary.propertyName + " with min as " + summary.propertyName + "Min";
+                            break;
+                        case SummaryOperand.Max:
+                            result += summary.propertyName + " with max as " + summary.propertyName + "Max";
+                            break;
+                        case SummaryOperand.Sum:
+                            result += summary.propertyName + " with sum as " + summary.propertyName + "Sum";
+                            break;
+                        case SummaryOperand.Count:
+                            result += "$count as $__count";
+                            countExists = true;
+                            break;
+                    }
+                    first = false;
+                }
+            }
+            catch (e_5_1) {
+                e_5 = { error: e_5_1 };
+            }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return))
+                        _a.call(_b);
+                }
+                finally {
+                    if (e_5)
+                        throw e_5.error;
+                }
+            }
+        }
+        return result;
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.createSummaryResults = function (data) {
+        var e_6, _a;
+        var summaryResults = [];
+        try {
+            for (var _b = __values(this.iterSummaries(this._summaryDescriptions)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var summary = _c.value;
+                var summaryName = summary.propertyName;
+                switch (summary.operand) {
+                    case SummaryOperand.Average:
+                        summaryName += "Average";
+                        break;
+                    case SummaryOperand.Min:
+                        summaryName += "Min";
+                        break;
+                    case SummaryOperand.Max:
+                        summaryName += "Max";
+                        break;
+                    case SummaryOperand.Sum:
+                        summaryName += "Sum";
+                        break;
+                    case SummaryOperand.Count:
+                        summaryName = "$__count";
+                        break;
+                }
+                var summaryValue = null;
+                if (data && data[summaryName]) {
+                    summaryValue = data[summaryName];
+                }
+                var summaryResult = new DefaultSummaryResult(summary.propertyName, summary.operand, summaryValue);
+                summaryResults.push(summaryResult);
+            }
+        }
+        catch (e_6_1) {
+            e_6 = { error: e_6_1 };
+        }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return))
+                    _a.call(_b);
+            }
+            finally {
+                if (e_6)
+                    throw e_6.error;
+            }
+        }
+        return summaryResults;
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.resolveSchemaFromItems = function (items) {
+        var lds = new LocalDataSource();
+        lds.dataSource = items;
+        lds.flushAutoRefresh();
+        return lds.actualSchema;
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.resolveSchema = function (finishAction, failureAction) {
+        var _this = this;
+        if (!this._provideItems || !this._providePagingParameter) {
+            failureAction("required providers for items and paging are not specified");
+            return;
+        }
+        var success_ = function (res) {
+            var items = _this._provideItems(res);
+            if (items && items.length > 0) {
+                var schema = _this.resolveSchemaFromItems(items);
+                finishAction(schema);
+            }
+            else {
+                failureAction("could not find items to resolve schema");
+            }
+        };
+        var failure_ = function (e) { return failureAction(e); };
+        var args = [];
+        if (this._providePagingParameter) {
+            this._providePagingParameter(args, 0, this.actualPageSize);
+        }
+        var uri = this._provideUri(this._baseUri, this._entitySet, args);
+        try {
+            var run_ = null;
+            var headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
+            var request = {
+                requestUri: uri,
+                enableJsonpCallback: this._enableJsonp,
+                method: 'GET',
+                headers: headers,
+                data: null
+            };
+            run_ = function () {
+                _this.fetchUri(request, success_, failure_);
+            };
+            run_();
+        }
+        catch (e) {
+            failureAction(e);
+        }
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.makeTaskForRequest = function (request, retryDelay) {
+        var e_7, _a;
+        var args = [];
+        // if (this._provideAggregationParameter) {
+        //     args.push({ name: "apply", value: this._provideAggregationParameter(true, groupBy, this._groupDescriptions, summary, this._summaryDescriptions) });
+        // }
+        var actualPageSize = 0;
+        var sortDescriptions = null;
+        actualPageSize = this.actualPageSize;
+        sortDescriptions = this.sortDescriptions;
+        //let requestUrl: string = this._baseUri;
+        //requestUrl += "/" + this._entitySet;
+        var queryStarted = false;
+        this.updateFilterString();
+        if (this._filterString != null) {
+            if (this._provideFilterParameter) {
+                this._provideFilterParameter(args, this._filterString, this._filterExpressions);
+            }
+        }
+        if (this.sortDescriptions != null) {
+            var sortString = null;
+            try {
+                for (var _b = __values(this.iter(this.sortDescriptions)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var sort = _c.value;
+                    if (sortString == null) {
+                        sortString = "";
+                    }
+                    else {
+                        sortString += ", ";
+                    }
+                    if (sort.direction == ListSortDirection.Descending) {
+                        sortString += sort.propertyName + " desc";
+                    }
+                    else {
+                        sortString += sort.propertyName;
+                    }
+                }
+            }
+            catch (e_7_1) {
+                e_7 = { error: e_7_1 };
+            }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return))
+                        _a.call(_b);
+                }
+                finally {
+                    if (e_7)
+                        throw e_7.error;
+                }
+            }
+            if (sortString != null) {
+                if (this._provideOrderByParameter) {
+                    this._provideOrderByParameter(args, sortString, this._sortDescriptions);
+                }
+            }
+        }
+        if (this.desiredProperties != null && this.desiredProperties.length > 0) {
+            var selectString = "";
+            var first = true;
+            var $t = this.desiredProperties;
+            for (var i = 0; i < $t.length; i++) {
+                var select = $t[i];
+                if (first) {
+                    first = false;
+                }
+                else {
+                    selectString += ", ";
+                }
+                selectString += select;
+            }
+            if (this._provideDesiredPropertiesParameter) {
+                this._provideDesiredPropertiesParameter(args, selectString, this._desiredPropeties);
+            }
+        }
+        if (this._providePagingParameter) {
+            if (request.index == RestVirtualDataSourceDataProviderWorker.schemaRequestIndex) {
+                this._providePagingParameter(args, 0, actualPageSize);
+            }
+            else {
+                this._providePagingParameter(args, request.index * actualPageSize, actualPageSize);
+            }
+        }
+        var task = new AsyncVirtualDataTask();
+        var uri = this._provideUri(this._baseUri, this._entitySet, args);
+        if (request.index == RestVirtualDataSourceDataProviderWorker.schemaRequestIndex) {
+            this.executeRequest(uri, queryStarted, 0, actualPageSize, task);
+        }
+        else {
+            this.executeRequest(uri, queryStarted, request.index * actualPageSize, actualPageSize, task);
+        }
+        request.taskHolder = new AsyncDataSourcePageTaskHolder();
+        request.taskHolder.task = task;
+        this.tasks.add(request);
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.updateFilterString = function () {
+        var e_8, _a;
+        if (this.filterExpressions != null && this.filterExpressions.size() > 0 && this._filterString == null) {
+            var sb = "";
+            var first = true;
+            try {
+                for (var _b = __values(this.iterFilter(this.filterExpressions)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var expr = _c.value;
+                    if (first) {
+                        first = false;
+                    }
+                    else {
+                        sb += " AND ";
+                    }
+                    var visitor = new ODataDataSourceFilterExpressionVisitor(0);
+                    visitor.visit(expr);
+                    var txt = visitor.toString();
+                    if (this.filterExpressions.size() > 1) {
+                        txt = "(" + txt + ")";
+                    }
+                    sb += (txt);
+                }
+            }
+            catch (e_8_1) {
+                e_8 = { error: e_8_1 };
+            }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return))
+                        _a.call(_b);
+                }
+                finally {
+                    if (e_8)
+                        throw e_8.error;
+                }
+            }
+            this._filterString = sb;
+        }
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.executeRequest = function (requestUrl, queryStarted, skip, top, task) {
+        var _this = this;
+        // if (!queryStarted) {
+        // 	queryStarted = true;
+        // 	requestUrl += "?";
+        // } else {
+        // 	requestUrl += "&";
+        // }
+        // requestUrl += "$skip=" + skip + "&$top=" + top + "&$count=true";
+        var requestUrl_ = requestUrl;
+        var self_ = this;
+        var success_ = function (data, response) { return _this.success(task, data, response); };
+        var failure_ = function (err) { return _this.error(task, err); };
+        var run_ = null;
+        var headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
+        var request = {
+            requestUri: requestUrl_,
+            enableJsonpCallback: this._enableJsonp,
+            method: 'GET',
+            headers: headers,
+            data: null
+        };
+        run_ = function () {
+            _this.fetchUri(request, success_, failure_);
+        };
+        task.run = run_;
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.success = function (t, data, response) {
+        t.result = data;
+        t.isCompleted = true;
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.error = function (t, result) {
+        t.isCompleted = true;
+        t.hasErrors = true;
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.createBatchRequest = function (changes) {
+        //TODO: updates
+    };
+    RestVirtualDataSourceDataProviderWorker.prototype.getRequestUriWithKey = function (key) {
+        var result = "";
+        var keys = Object.keys(key);
+        for (var i = 0; i < keys.length; i++) {
+            if (i > 0) {
+                result += ",";
+            }
+            result += keys[i] + "=" + key[keys[i]];
+        }
+        return this._entitySet + "(" + result + ")";
+    };
+    RestVirtualDataSourceDataProviderWorker.schemaRequestIndex = -1;
+    return RestVirtualDataSourceDataProviderWorker;
+}(AsyncVirtualDataSourceProviderWorker));
+
+var RestVirtualDataSourceDataProviderWorkerSettings = /** @class */ /*@__PURE__*/ (function (_super) {
+    __extends(RestVirtualDataSourceDataProviderWorkerSettings, _super);
+    function RestVirtualDataSourceDataProviderWorkerSettings() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this._baseUri = null;
+        _this._entitySet = null;
+        _this._sortDescriptions = null;
+        _this._filterExpressions = null;
+        _this._propertiesRequested = null;
+        _this._groupDescriptions = null;
+        _this._summaryDescriptions = null;
+        _this._fixedFullCount = -1;
+        _this._provideFullCount = null;
+        _this._provideOrderByParameter = null;
+        _this._provideFilterParameter = null;
+        _this._provideAggregationParameter = null;
+        _this._provideAggregatedCount = null;
+        _this._provideUri = null;
+        _this._providePagingParameter = null;
+        _this._provideDesiredPropertiesParameter = null;
+        _this._performFetch = null;
+        return _this;
+    }
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "baseUri", {
+        get: function () {
+            return this._baseUri;
+        },
+        set: function (value) {
+            this._baseUri = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "entitySet", {
+        get: function () {
+            return this._entitySet;
+        },
+        set: function (value) {
+            this._entitySet = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "sortDescriptions", {
+        get: function () {
+            return this._sortDescriptions;
+        },
+        set: function (value) {
+            this._sortDescriptions = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "filterExpressions", {
+        get: function () {
+            return this._filterExpressions;
+        },
+        set: function (value) {
+            this._filterExpressions = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "propertiesRequested", {
+        get: function () {
+            return this._propertiesRequested;
+        },
+        set: function (value) {
+            this._propertiesRequested = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "groupDescriptions", {
+        get: function () {
+            return this._groupDescriptions;
+        },
+        set: function (value) {
+            this._groupDescriptions = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "summaryDescriptions", {
+        get: function () {
+            return this._summaryDescriptions;
+        },
+        set: function (value) {
+            this._summaryDescriptions = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "summaryScope", {
+        get: function () {
+            return this._summaryscope;
+        },
+        set: function (value) {
+            this._summaryscope = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "enableJsonp", {
+        get: function () {
+            return this._enableJsonp;
+        },
+        set: function (isEnabled) {
+            this._enableJsonp = isEnabled;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "isAggregationSupported", {
+        get: function () {
+            return this._isAggregationSupported;
+        },
+        set: function (isSupported) {
+            this._isAggregationSupported = isSupported;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "fixedFullCount", {
+        get: function () {
+            return this._fixedFullCount;
+        },
+        set: function (value) {
+            this._fixedFullCount = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "provideFullCount", {
+        get: function () {
+            return this._provideFullCount;
+        },
+        set: function (value) {
+            this._provideFullCount = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "provideOrderByParameter", {
+        get: function () {
+            return this._provideOrderByParameter;
+        },
+        set: function (value) {
+            this._provideOrderByParameter = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "provideFilterParameter", {
+        get: function () {
+            return this._provideFilterParameter;
+        },
+        set: function (value) {
+            this._provideFilterParameter = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "provideAggregationParameter", {
+        get: function () {
+            return this._provideAggregationParameter;
+        },
+        set: function (value) {
+            this._provideAggregationParameter = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "provideAggregatedCount", {
+        get: function () {
+            return this._provideAggregatedCount;
+        },
+        set: function (value) {
+            this._provideAggregatedCount = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "provideUri", {
+        get: function () {
+            return this._provideUri;
+        },
+        set: function (value) {
+            this._provideUri = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "providePagingParameter", {
+        get: function () {
+            return this._providePagingParameter;
+        },
+        set: function (value) {
+            this._providePagingParameter = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "provideDesiredPropertiesParameter", {
+        get: function () {
+            return this._provideDesiredPropertiesParameter;
+        },
+        set: function (value) {
+            this._provideDesiredPropertiesParameter = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "provideItems", {
+        get: function () {
+            return this._provideItems;
+        },
+        set: function (value) {
+            this._provideItems = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProviderWorkerSettings.prototype, "performFetch", {
+        get: function () {
+            return this._performFetch;
+        },
+        set: function (value) {
+            this._performFetch = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RestVirtualDataSourceDataProviderWorkerSettings.$t = markType(RestVirtualDataSourceDataProviderWorkerSettings, 'RestVirtualDataSourceDataProviderWorkerSettings', AsyncVirtualDataSourceDataProviderWorkerSettings.$type);
+    return RestVirtualDataSourceDataProviderWorkerSettings;
+}(AsyncVirtualDataSourceDataProviderWorkerSettings));
+
+var RestVirtualDataSourceDataProvider = /** @class */ /*@__PURE__*/ (function (_super) {
+    __extends(RestVirtualDataSourceDataProvider, _super);
+    function RestVirtualDataSourceDataProvider() {
+        var _this = _super.call(this) || this;
+        _this._worker = null;
+        _this._requests = new LinkedList();
+        _this._callback = null;
+        _this._pageLoaded = null;
+        _this._pageSizeRequested = 50;
+        _this._baseUri = null;
+        _this._entitySet = null;
+        _this._timeoutMilliseconds = 10000;
+        _this.schemaChanged = null;
+        _this._currentFullCount = 0;
+        _this._currentSchema = null;
+        _this._executionContext = null;
+        _this._updateNotifier = null;
+        _this._deferAutoRefresh = false;
+        _this._sortDescriptions = null;
+        _this._groupDescriptions = null;
+        _this._propertiesRequested = null;
+        _this._filterExpressions = null;
+        _this._summaryDescriptions = null;
+        _this._enableJsonp = true;
+        _this._fixedFullCount = -1;
+        _this._provideFullCount = null;
+        _this._provideOrderByParameter = null;
+        _this._provideFilterParameter = null;
+        _this._provideAggregationParameter = null;
+        _this._provideAggregatedCount = null;
+        _this._provideUri = null;
+        _this._performFetch = null;
+        _this._providePagingParameter = null;
+        _this._provideDesiredPropertiesParameter = null;
+        _this._schemaFetchQueued = false;
+        _this._autoRefreshQueued = false;
+        _this._sortDescriptions = new SortDescriptionCollection();
+        _this._sortDescriptions.onChanged = function () { return _this.sortDescriptions_CollectionChanged(null, null); };
+        _this._groupDescriptions = new SortDescriptionCollection();
+        _this._groupDescriptions.onChanged = function () { return _this.groupDescriptions_CollectionChanged(null, null); };
+        _this._filterExpressions = new FilterExpressionCollection();
+        _this._filterExpressions.onChanged = function () { return _this.filterExpressions_CollectionChanged(null, null); };
+        _this._summaryDescriptions = new SummaryDescriptionCollection();
+        _this._summaryDescriptions.onChanged = function () { return _this.summaryDescriptions_CollectionChanged(null, null); };
+        return _this;
+    }
+    RestVirtualDataSourceDataProvider.prototype.filterExpressions_CollectionChanged = function (sender, e) {
+        this.queueAutoRefresh();
+    };
+    RestVirtualDataSourceDataProvider.prototype.sortDescriptions_CollectionChanged = function (sender, e) {
+        this.queueAutoRefresh();
+    };
+    RestVirtualDataSourceDataProvider.prototype.groupDescriptions_CollectionChanged = function (sender, e) {
+        this.queueAutoRefresh();
+    };
+    RestVirtualDataSourceDataProvider.prototype.summaryDescriptions_CollectionChanged = function (sender, e) {
+        this.queueAutoRefresh();
+    };
+    RestVirtualDataSourceDataProvider.prototype.addPageRequest = function (pageIndex, priority) {
+        if (this.deferAutoRefresh) {
+            return;
+        }
+        if (this._worker != null && this._worker.isShutdown) {
+            this._worker = null;
+            this._callback = null;
+        }
+        if (this._worker == null) {
+            this.createWorker();
+        }
+        if (priority == DataSourcePageRequestPriority.High) {
+            this._requests.addFirst(pageIndex);
+        }
+        else {
+            this._requests.addLast(pageIndex);
+        }
+        if (!this._worker.addPageRequest(pageIndex, priority)) {
+            this._worker = null;
+            this._callback = null;
+            this.addPageRequest(pageIndex, priority);
+        }
+    };
+    RestVirtualDataSourceDataProvider.prototype.createWorker = function () {
+        if (!this.valid()) {
+            return;
+        }
+        this._callback = runOn(this, this.raisePageLoaded);
+        var settings = this.getWorkerSettings();
+        this._worker = new RestVirtualDataSourceDataProviderWorker(settings);
+    };
+    RestVirtualDataSourceDataProvider.prototype.valid = function () {
+        return this.entitySet != null && this.baseUri != null;
+    };
+    RestVirtualDataSourceDataProvider.prototype.getWorkerSettings = function () {
+        var _this = this;
+        return ((function () {
+            var $ret = new RestVirtualDataSourceDataProviderWorkerSettings();
+            $ret.baseUri = _this._baseUri;
+            $ret.entitySet = _this._entitySet;
+            $ret.pageSizeRequested = _this._pageSizeRequested;
+            $ret.timeoutMilliseconds = _this._timeoutMilliseconds;
+            $ret.pageLoaded = _this._callback;
+            $ret.executionContext = _this._executionContext;
+            $ret.sortDescriptions = _this._sortDescriptions;
+            $ret.groupDescriptions = _this._groupDescriptions;
+            $ret.filterExpressions = _this._filterExpressions;
+            $ret.propertiesRequested = _this._propertiesRequested;
+            $ret.summaryDescriptions = _this._summaryDescriptions;
+            $ret.summaryScope = _this._summaryScope;
+            $ret.enableJsonp = _this._enableJsonp;
+            $ret.isAggregationSupported = _this.isAggregationSupported;
+            $ret.performFetch = _this.performFetch;
+            $ret.provideAggregationParameter = _this.provideAggregationParameter;
+            $ret.provideAggregatedCount = _this.provideAggregatedCount;
+            $ret.provideDesiredPropertiesParameter = _this.provideDesiredPropertiesParameter;
+            $ret.provideFilterParameter = _this.provideFilterParameter;
+            $ret.provideFullCount = _this.provideFullCount;
+            $ret.provideItems = _this.provideItems;
+            $ret.provideOrderByParameter = _this.provideOrderByParameter;
+            $ret.providePagingParameter = _this.providePagingParameter;
+            $ret.provideUri = _this.provideUri;
+            $ret.fixedFullCount = _this.fixedFullCount;
+            return $ret;
+        })());
+    };
+    RestVirtualDataSourceDataProvider.prototype.removePageRequest = function (pageIndex) {
+        var current = this._requests.first;
+        while (current != null) {
+            if (current.value == pageIndex) {
+                this._requests.remove(current);
+            }
+            current = current.next;
+        }
+        if (this._worker == null) {
+            return;
+        }
+        this._worker.removePageRequest(pageIndex);
+    };
+    RestVirtualDataSourceDataProvider.prototype.removeAllPageRequests = function () {
+        this._requests.clear();
+        if (this._worker == null) {
+            return;
+        }
+        this._worker.removeAllPageRequests();
+    };
+    RestVirtualDataSourceDataProvider.prototype.close = function () {
+        if (this._worker != null) {
+            this._worker.shutdown();
+            this._worker = null;
+            this._callback = null;
+        }
+    };
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "pageLoaded", {
+        get: function () {
+            return this._pageLoaded;
+        },
+        set: function (value) {
+            this._pageLoaded = value;
+            this.queueAutoRefresh();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RestVirtualDataSourceDataProvider.prototype.raisePageLoaded = function (page, fullCount, actualPageSize) {
+        if (this._pageLoaded != null) {
+            this._currentFullCount = fullCount;
+            if (this._currentSchema == null) {
+                var currentSchema = null;
+                if (page != null) {
+                    currentSchema = page.schema();
+                }
+                this._currentSchema = currentSchema;
+                if (this.schemaChanged != null) {
+                    this.schemaChanged(this, new DataSourceDataProviderSchemaChangedEventArgs(this._currentSchema, this._currentFullCount));
+                }
+            }
+            if (page.pageIndex() != RestVirtualDataSourceDataProviderWorker.schemaRequestIndex) {
+                this._pageLoaded(page, fullCount, actualPageSize);
+            }
+        }
+    };
+    RestVirtualDataSourceDataProvider.prototype.killWorker = function () {
+        if (this._worker != null) {
+            this._worker.shutdown();
+            this._worker = null;
+            this._callback = null;
+        }
+    };
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "pageSizeRequested", {
+        get: function () {
+            return this._pageSizeRequested;
+        },
+        set: function (value) {
+            this._pageSizeRequested = value;
+            this.queueAutoRefresh();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "baseUri", {
+        get: function () {
+            return this._baseUri;
+        },
+        set: function (value) {
+            var oldValue = this._baseUri;
+            this._baseUri = value;
+            if (oldValue != this._baseUri) {
+                this.queueAutoRefresh();
+                if (this.valid() && this.deferAutoRefresh) {
+                    this.queueSchemaFetch();
+                }
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "entitySet", {
+        get: function () {
+            return this._entitySet;
+        },
+        set: function (value) {
+            var oldValue = this._entitySet;
+            this._entitySet = value;
+            if (oldValue != this._entitySet) {
+                this.queueAutoRefresh();
+                if (this.valid() && this.deferAutoRefresh) {
+                    this.queueSchemaFetch();
+                }
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "timeoutMilliseconds", {
+        get: function () {
+            return this._timeoutMilliseconds;
+        },
+        set: function (value) {
+            this._timeoutMilliseconds = value;
+            this.queueAutoRefresh();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RestVirtualDataSourceDataProvider.prototype.getItemValue = function (item, valueName) {
+        var dic = item;
+        if (dic.has(valueName)) {
+            return dic.get(valueName);
+        }
+        else {
+            return null;
+        }
+    };
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "actualCount", {
+        get: function () {
+            return this._currentFullCount;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "actualSchema", {
+        get: function () {
+            return this._currentSchema;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "executionContext", {
+        get: function () {
+            return this._executionContext;
+        },
+        set: function (value) {
+            this._executionContext = value;
+            this.queueAutoRefresh();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "updateNotifier", {
+        get: function () {
+            return this._updateNotifier;
+        },
+        set: function (value) {
+            this._updateNotifier = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "deferAutoRefresh", {
+        get: function () {
+            return this._deferAutoRefresh;
+        },
+        set: function (value) {
+            this._deferAutoRefresh = value;
+            if (!this._deferAutoRefresh) {
+                this.queueAutoRefresh();
+            }
+            if (this._deferAutoRefresh && this.valid() && this._currentSchema == null) {
+                this.queueSchemaFetch();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "isSortingSupported", {
+        get: function () {
+            return true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "isGroupingSupported", {
+        get: function () {
+            return this.isAggregationSupported;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "isFilteringSupported", {
+        get: function () {
+            return true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "isAggregationSupported", {
+        get: function () {
+            return this._isAggregationSupported;
+        },
+        set: function (isSupported) {
+            this._isAggregationSupported = isSupported;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "sortDescriptions", {
+        get: function () {
+            return this._sortDescriptions;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "groupDescriptions", {
+        get: function () {
+            return this._groupDescriptions;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "propertiesRequested", {
+        get: function () {
+            return this._propertiesRequested;
+        },
+        set: function (value) {
+            this._propertiesRequested = value;
+            this.queueAutoRefresh();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "filterExpressions", {
+        get: function () {
+            return this._filterExpressions;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "summaryDescriptions", {
+        get: function () {
+            return this._summaryDescriptions;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "summaryScope", {
+        get: function () {
+            return this._summaryScope;
+        },
+        set: function (value) {
+            this._summaryScope = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "enableJsonp", {
+        get: function () {
+            return this._enableJsonp;
+        },
+        set: function (isEnabled) {
+            this._enableJsonp = isEnabled;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "fixedFullCount", {
+        get: function () {
+            return this._fixedFullCount;
+        },
+        set: function (value) {
+            this._fixedFullCount = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "provideFullCount", {
+        get: function () {
+            return this._provideFullCount;
+        },
+        set: function (value) {
+            this._provideFullCount = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "provideOrderByParameter", {
+        get: function () {
+            return this._provideOrderByParameter;
+        },
+        set: function (value) {
+            this._provideOrderByParameter = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "provideFilterParameter", {
+        get: function () {
+            return this._provideFilterParameter;
+        },
+        set: function (value) {
+            this._provideFilterParameter = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "provideAggregationParameter", {
+        get: function () {
+            return this._provideAggregationParameter;
+        },
+        set: function (value) {
+            this._provideAggregationParameter = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "provideAggregatedCount", {
+        get: function () {
+            return this._provideAggregatedCount;
+        },
+        set: function (value) {
+            this._provideAggregatedCount = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "provideUri", {
+        get: function () {
+            return this._provideUri;
+        },
+        set: function (value) {
+            this._provideUri = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "performFetch", {
+        get: function () {
+            return this._performFetch;
+        },
+        set: function (value) {
+            this._performFetch = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "providePagingParameter", {
+        get: function () {
+            return this._providePagingParameter;
+        },
+        set: function (value) {
+            this._providePagingParameter = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "provideDesiredPropertiesParameter", {
+        get: function () {
+            return this._provideDesiredPropertiesParameter;
+        },
+        set: function (value) {
+            this._provideDesiredPropertiesParameter = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "provideItems", {
+        get: function () {
+            return this._provideItems;
+        },
+        set: function (value) {
+            this._provideItems = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "notifyUsingSourceIndexes", {
+        get: function () {
+            return true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "isItemIndexLookupSupported", {
+        get: function () {
+            return false;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "isKeyIndexLookupSupported", {
+        get: function () {
+            return false;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RestVirtualDataSourceDataProvider.prototype.notifySetItem = function (index, oldItem, newItem) {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifySetItem(index, oldItem, newItem);
+        }
+    };
+    RestVirtualDataSourceDataProvider.prototype.notifyClearItems = function () {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifyClearItems();
+        }
+    };
+    RestVirtualDataSourceDataProvider.prototype.notifyInsertItem = function (index, newItem) {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifyInsertItem(index, newItem);
+        }
+    };
+    RestVirtualDataSourceDataProvider.prototype.notifyRemoveItem = function (index, oldItem) {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifyRemoveItem(index, oldItem);
+        }
+    };
+    RestVirtualDataSourceDataProvider.prototype.queueSchemaFetch = function () {
+        if (this._schemaFetchQueued) {
+            return;
+        }
+        if (this.executionContext != null) {
+            this._schemaFetchQueued = true;
+            this.executionContext.enqueueAction(runOn(this, this.doSchemaFetchInternal));
+        }
+    };
+    RestVirtualDataSourceDataProvider.prototype.doSchemaFetchInternal = function () {
+        if (!this._schemaFetchQueued) {
+            return;
+        }
+        this._schemaFetchQueued = false;
+        this.schemaFetchInternal();
+    };
+    RestVirtualDataSourceDataProvider.prototype.schemaFetchInternal = function () {
+        this.schemaFetchInternalOverride();
+    };
+    RestVirtualDataSourceDataProvider.prototype.schemaFetchInternalOverride = function () {
+        if (!this.deferAutoRefresh) {
+            return;
+        }
+        this.removeAllPageRequests();
+        this.killWorker();
+        this.createWorker();
+        this.addSchemaRequest();
+    };
+    RestVirtualDataSourceDataProvider.prototype.addSchemaRequest = function () {
+        this._worker.addPageRequest(RestVirtualDataSourceDataProviderWorker.schemaRequestIndex, DataSourcePageRequestPriority.High);
+    };
+    RestVirtualDataSourceDataProvider.prototype.queueAutoRefresh = function () {
+        if (this.deferAutoRefresh) {
+            return;
+        }
+        if (this._autoRefreshQueued) {
+            return;
+        }
+        if (this.executionContext != null) {
+            this._autoRefreshQueued = true;
+            this.executionContext.enqueueAction(runOn(this, this.doRefreshInternal));
+        }
+    };
+    RestVirtualDataSourceDataProvider.prototype.doRefreshInternal = function () {
+        if (this.deferAutoRefresh) {
+            this._autoRefreshQueued = false;
+            return;
+        }
+        if (!this._autoRefreshQueued) {
+            return;
+        }
+        this._autoRefreshQueued = false;
+        this.refreshInternal();
+    };
+    RestVirtualDataSourceDataProvider.prototype.refreshInternal = function () {
+        this.refreshInternalOverride();
+    };
+    RestVirtualDataSourceDataProvider.prototype.refreshInternalOverride = function () {
+        this.removeAllPageRequests();
+        this.killWorker();
+        this.createWorker();
+        this._worker.addPageRequest(0, DataSourcePageRequestPriority.Normal);
+    };
+    RestVirtualDataSourceDataProvider.prototype.flushAutoRefresh = function () {
+        this.doRefreshInternal();
+    };
+    RestVirtualDataSourceDataProvider.prototype.refresh = function () {
+        this.refreshInternal();
+    };
+    RestVirtualDataSourceDataProvider.prototype.indexOfItem = function (item) {
+        return -1;
+    };
+    RestVirtualDataSourceDataProvider.prototype.indexOfKey = function (key) {
+        return -1;
+    };
+    RestVirtualDataSourceDataProvider.prototype.resolveSchemaPropertyType = function (propertyPath) {
+        if (this.actualSchema == null) {
+            return DataSourceSchemaPropertyType.ObjectValue;
+        }
+        if (stringContains(propertyPath, ".")) {
+            return DataSourceSchemaPropertyType.ObjectValue;
+        }
+        for (var i = 0; i < this.actualSchema.propertyNames.length; i++) {
+            var name_1 = this.actualSchema.propertyNames[i];
+            if (name_1 == propertyPath) {
+                return this.actualSchema.propertyTypes[i];
+            }
+        }
+        return DataSourceSchemaPropertyType.ObjectValue;
+    };
+    RestVirtualDataSourceDataProvider.prototype.setItemValue = function (item, valueName, value) {
+        // does nothing.
+    };
+    RestVirtualDataSourceDataProvider.prototype.removeItem = function (item) {
+        // does nothing.
+    };
+    RestVirtualDataSourceDataProvider.prototype.addItem = function (item) {
+        // does nothing.
+    };
+    RestVirtualDataSourceDataProvider.prototype.createBatchRequest = function (changes) {
+        if (this._worker != null) {
+            this._worker.createBatchRequest(changes);
+        }
+    };
+    Object.defineProperty(RestVirtualDataSourceDataProvider.prototype, "batchCompleted", {
+        get: function () {
+            return this._batchCompleted;
+        },
+        set: function (v) {
+            this._batchCompleted = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RestVirtualDataSourceDataProvider.$t = markType(RestVirtualDataSourceDataProvider, 'ODataVirtualDataSourceDataProvider', Base.$type, [IDataSourceVirtualDataProvider_$type]);
+    return RestVirtualDataSourceDataProvider;
+}(Base));
+
+var RestVirtualDataSource = /** @class */ /*@__PURE__*/ (function (_super) {
+    __extends(RestVirtualDataSource, _super);
+    function RestVirtualDataSource() {
+        var _this = _super.call(this) || this;
+        _this._baseUri = null;
+        _this._isFilteringSupportedByServer = false;
+        _this._entitySet = null;
+        _this._timeoutMilliseconds = 10000;
+        _this._isAggregationSupportedByServer = false;
+        _this._enableJsonp = true;
+        _this._fixedFullCount = -1;
+        _this._provideFullCount = null;
+        _this._provideOrderByParameter = null;
+        _this._provideFilterParameter = null;
+        _this._provideAggregationParameter = null;
+        _this._provideAggregatedCount = null;
+        _this._provideUri = null;
+        _this._performFetch = null;
+        _this._providePagingParameter = null;
+        _this._provideDesiredPropertiesParameter = null;
+        _this.dataProvider = ((function () {
+            var $ret = new RestVirtualDataSourceDataProvider();
+            $ret.executionContext = _this.executionContext;
+            $ret.enableJsonp = _this.enableJsonp;
+            $ret.isAggregationSupported = _this.isGroupingSupported;
+            return $ret;
+        })());
+        _this.externalDataSource = _this;
+        return _this;
+    }
+    RestVirtualDataSource.prototype.onBaseUriChanged = function (oldValue, newValue) {
+        if (this.actualDataProvider) {
+            this.actualDataProvider.baseUri = this.baseUri;
+            this.queueAutoRefresh();
+        }
+    };
+    Object.defineProperty(RestVirtualDataSource.prototype, "baseUri", {
+        get: function () {
+            return this._baseUri;
+        },
+        set: function (value) {
+            var oldValue = this._baseUri;
+            this._baseUri = value;
+            if (oldValue != this._baseUri) {
+                this.onBaseUriChanged(oldValue, this._baseUri);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RestVirtualDataSource.prototype.onEntitySetChanged = function (oldValue, newValue) {
+        if (this.actualDataProvider) {
+            this.actualDataProvider.entitySet = this.entitySet;
+            this.queueAutoRefresh();
+        }
+        this.queueAutoRefresh();
+    };
+    Object.defineProperty(RestVirtualDataSource.prototype, "isFilteringSupportedByServer", {
+        get: function () {
+            return this._isFilteringSupportedByServer;
+        },
+        set: function (v) {
+            this._isFilteringSupportedByServer = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RestVirtualDataSource.prototype.get_isFilteringSupported = function () {
+        if (this._isFilteringSupportedByServer) {
+            return true;
+        }
+        return false;
+    };
+    Object.defineProperty(RestVirtualDataSource.prototype, "entitySet", {
+        get: function () {
+            return this._entitySet;
+        },
+        set: function (value) {
+            var oldValue = this._entitySet;
+            this._entitySet = value;
+            if (this._entitySet != oldValue) {
+                this.onEntitySetChanged(oldValue, this._entitySet);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RestVirtualDataSource.prototype.onTimeoutMillisecondsChanged = function (oldValue, newValue) {
+        if (this.actualDataProvider) {
+            this.actualDataProvider.timeoutMilliseconds = this.timeoutMilliseconds;
+        }
+    };
+    Object.defineProperty(RestVirtualDataSource.prototype, "timeoutMilliseconds", {
+        get: function () {
+            return this._timeoutMilliseconds;
+        },
+        set: function (value) {
+            var oldValue = this._timeoutMilliseconds;
+            this._timeoutMilliseconds = value;
+            if (oldValue != this._timeoutMilliseconds) {
+                this.onTimeoutMillisecondsChanged(oldValue, this._timeoutMilliseconds);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "isSortingSupportedOverride", {
+        get: function () {
+            return true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "isFilteringSupportedOverride", {
+        get: function () {
+            return true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "isGroupingSupportedOverride", {
+        get: function () {
+            return this.isAggregationSupportedByServer;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "isAggregationSupportedByServer", {
+        get: function () {
+            return this._isAggregationSupportedByServer;
+        },
+        set: function (isSupported) {
+            this._isAggregationSupportedByServer = isSupported;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.isAggregationSupported = this.isAggregationSupportedByServer;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "enableJsonp", {
+        get: function () {
+            return this._enableJsonp;
+        },
+        set: function (isEnabled) {
+            this._enableJsonp = isEnabled;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.enableJsonp = this.enableJsonp;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "fixedFullCount", {
+        get: function () {
+            return this._fixedFullCount;
+        },
+        set: function (value) {
+            this._fixedFullCount = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideFullCount", {
+        get: function () {
+            return this._provideFullCount;
+        },
+        set: function (value) {
+            this._provideFullCount = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideFullCount = this.provideFullCount;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideOrderByParameter", {
+        get: function () {
+            return this._provideOrderByParameter;
+        },
+        set: function (value) {
+            this._provideOrderByParameter = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideOrderByParameter = this.provideOrderByParameter;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideFilterParameter", {
+        get: function () {
+            return this._provideFilterParameter;
+        },
+        set: function (value) {
+            this._provideFilterParameter = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideFilterParameter = this.provideFilterParameter;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideAggregationParameter", {
+        get: function () {
+            return this._provideAggregationParameter;
+        },
+        set: function (value) {
+            this._provideAggregationParameter = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideAggregationParameter = this.provideAggregationParameter;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideAggregatedCount", {
+        get: function () {
+            return this._provideAggregatedCount;
+        },
+        set: function (value) {
+            this._provideAggregatedCount = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideAggregatedCount = this.provideAggregatedCount;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideUri", {
+        get: function () {
+            return this._provideUri;
+        },
+        set: function (value) {
+            this._provideUri = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideUri = this.provideUri;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "performFetch", {
+        get: function () {
+            return this._performFetch;
+        },
+        set: function (value) {
+            this._performFetch = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.performFetch = this.performFetch;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "providePagingParameter", {
+        get: function () {
+            return this._providePagingParameter;
+        },
+        set: function (value) {
+            this._providePagingParameter = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.providePagingParameter = this.providePagingParameter;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideDesiredPropertiesParameter", {
+        get: function () {
+            return this._provideDesiredPropertiesParameter;
+        },
+        set: function (value) {
+            this._provideDesiredPropertiesParameter = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideDesiredPropertiesParameter = this.provideDesiredPropertiesParameter;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideItems", {
+        get: function () {
+            return this._provideItems;
+        },
+        set: function (value) {
+            this._provideItems = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideItems = this.provideItems;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RestVirtualDataSource.prototype.clone = function () {
+        var dataSource = new RestVirtualDataSource();
+        dataSource.executionContext = this.executionContext;
+        dataSource.includeSummaryRowsInSection = this.includeSummaryRowsInSection;
+        dataSource.isSectionCollapsable = this.isSectionCollapsable;
+        dataSource.isSectionExpandedDefault = this.isSectionExpandedDefault;
+        //dataSource.isSectionHeaderNormalRow = this.isSectionHeaderNormalRow;
+        dataSource.isSectionSummaryRowsAtBottom = this.isSectionSummaryRowsAtBottom;
+        //dataSource.isSectionContentVisible = this.isSectionContentVisible;
+        dataSource.primaryKey = this.primaryKey;
+        dataSource.propertiesRequested = this.propertiesRequested;
+        dataSource.sectionHeaderDisplayMode = this.sectionHeaderDisplayMode;
+        dataSource.shouldEmitSectionFooters = this.shouldEmitSectionFooters;
+        dataSource.shouldEmitSectionHeaders = this.shouldEmitSectionHeaders;
+        dataSource.shouldEmitShiftedRows = this.shouldEmitShiftedRows;
+        dataSource.summaryScope = this.summaryScope;
+        for (var i = 0; i < this.groupDescriptions.size(); i++) {
+            dataSource.groupDescriptions.add(this.groupDescriptions.get(i));
+        }
+        for (var i = 0; i < this.sortDescriptions.size(); i++) {
+            dataSource.sortDescriptions.add(this.sortDescriptions.get(i));
+        }
+        for (var i = 0; i < this.filterExpressions.size(); i++) {
+            dataSource.filterExpressions.add(this.filterExpressions.get(i));
+        }
+        for (var i = 0; i < this.summaryDescriptions.size(); i++) {
+            dataSource.summaryDescriptions.add(this.summaryDescriptions.get(i));
+        }
+        dataSource.pageSizeRequested = this.pageSizeRequested;
+        dataSource.maxCachedPages = this.maxCachedPages;
+        dataSource.baseUri = this.baseUri;
+        dataSource.entitySet = this.entitySet;
+        dataSource.timeoutMilliseconds = this.timeoutMilliseconds;
+        dataSource.isAggregationSupportedByServer = this.isAggregationSupportedByServer;
+        dataSource.enableJsonp = this.enableJsonp;
+        dataSource.fixedFullCount = this.fixedFullCount;
+        dataSource.provideAggregationParameter = this.provideAggregationParameter;
+        dataSource.provideAggregatedCount = this.provideAggregatedCount;
+        dataSource.provideFilterParameter = this.provideFilterParameter;
+        dataSource.provideFullCount = this.provideFullCount;
+        dataSource.provideOrderByParameter = this.provideOrderByParameter;
+        dataSource.provideUri = this.provideUri;
+        dataSource.performFetch = this.performFetch;
+        dataSource.providePagingParameter = this.providePagingParameter;
+        dataSource.provideItems = this.provideItems;
+        dataSource.provideDesiredPropertiesParameter = this.provideDesiredPropertiesParameter;
+        return dataSource;
+    };
+    return RestVirtualDataSource;
+}(VirtualDataSource));
+
+export { Entity, EntityProperty, EntitySet, LinkedList, LinkedListNode, ODataDataSourcePage, ODataSchemaProvider, ODataVirtualDataSource, ODataVirtualDataSourceDataProvider, ODataVirtualDataSourceDataProviderWorker, ODataVirtualDataSourceDataProviderWorkerSettings, ODataVirtualDataSourceProviderTaskDataHolder, RestVirtualDataSource, RestVirtualDataSourceDataProvider, RestVirtualDataSourceDataProviderWorker, RestVirtualDataSourceDataProviderWorkerSettings, RestVirtualDataSourcePage, RestVirtualDataSourceProviderTaskDataHolder, Schema, first, toArray };