igniteui-webcomponents-datasources 7.1.1-beta.1 → 7.1.1-beta.2

package/fesm2022/igniteui-webcomponents-datasources.mjs

@@ -0,0 +1,3611 @@
+/*!
+    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, XNamespace, XDocument, XmlNodeType, typeCast, XElement, ODataDataSourceSchema, AsyncVirtualDataSourceProviderTaskDataHolder, markType, AsyncVirtualDataSourceProviderWorker, SortDescriptionCollection, ListSortDirection, DataSourceSummaryScope, stringIsNullOrEmpty, Convert, DefaultSectionInformation, DataSourceSummaryOperand, DefaultSummaryResult, AsyncVirtualDataTask, AsyncDataSourcePageTaskHolder, ODataDataSourceFilterExpressionVisitor, TransactionType, AsyncVirtualDataSourceDataProviderWorkerSettings, Base, IDataSourceVirtualDataProvider_$type, FilterExpressionCollection, SummaryDescriptionCollection, DataSourcePageRequestPriority, runOn, DataSourceDataProviderSchemaChangedEventArgs, stringContains, VirtualDataSource, LocalDataSource, DefaultDataSourceSchema } from 'igniteui-webcomponents-core';
+
+class EntityProperty {
+    constructor(name, schemaType) {
+        this._name = null;
+        this._isNullable = false;
+        this._type = null;
+        this.name = name;
+        this.type = schemaType;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get isNullable() {
+        return this._isNullable;
+    }
+    set isNullable(value) {
+        this._isNullable = value;
+    }
+    get type() {
+        return this._type;
+    }
+    set type(value) {
+        this._type = value;
+    }
+}
+
+function toArray(en) {
+    return Array.from(fromEnum(en));
+}
+function first(iter) {
+    for (let v of iter) {
+        return v;
+    }
+    throw new Error("Iterable contained no elements, expected at least one");
+}
+class LinkedList {
+    get first() {
+        return this._first;
+    }
+    get last() {
+        return this._last;
+    }
+    addFirst(item) {
+        if (this._first == null) {
+            this._first = new LinkedListNode(item);
+            this._last = this._first;
+        }
+        else {
+            var oldFirst = this._first;
+            this._first = new LinkedListNode(item);
+            this._first.next = oldFirst;
+            oldFirst.prev = this._first;
+        }
+    }
+    addLast(item) {
+        if (this._last == null) {
+            this._first = new LinkedListNode(item);
+            this._last = this._first;
+        }
+        else {
+            var oldLast = this._last;
+            this._last = new LinkedListNode(item);
+            this._last.prev = oldLast;
+            oldLast.next = this._last;
+        }
+    }
+    removeFirst() {
+        this.remove(this.first);
+    }
+    clear() {
+        this._first = null;
+        this._last = null;
+    }
+    contains(value) {
+        let curr = this.first;
+        while (curr != null) {
+            if (curr.value === value) {
+                return true;
+            }
+            curr = curr.next;
+        }
+        return false;
+    }
+    removeValue(value) {
+        let curr = this.first;
+        while (curr != null) {
+            if (curr.value === value) {
+                this.remove(curr);
+                return;
+            }
+            curr = curr.next;
+        }
+    }
+    remove(node) {
+        if (this._first == node) {
+            this._first = node.next;
+            if (node.next != null) {
+                node.next.prev = null;
+            }
+        }
+        if (this._last == node) {
+            this._last = node.prev;
+            if (node.prev != null) {
+                node.prev.next = null;
+            }
+        }
+        if (node.prev != null) {
+            node.prev.next = node.next;
+        }
+        if (node.next != null) {
+            node.next.prev = node.prev;
+        }
+        node.next = null;
+        node.prev = null;
+    }
+}
+class LinkedListNode {
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get prev() {
+        return this._prev;
+    }
+    set prev(value) {
+        this._prev = value;
+    }
+    get next() {
+        return this._next;
+    }
+    set next(value) {
+        this._next = value;
+    }
+    constructor(item) {
+        if (item !== undefined) {
+            this.value = item;
+        }
+    }
+}
+
+class Entity {
+    constructor(name, entityNode) {
+        this._properties = null;
+        this._primaryKey = null;
+        this._name = null;
+        this.name = name;
+        this.loadProperties(entityNode);
+        this.loadPrimaryKey(entityNode);
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get properties() {
+        if (null == this._properties) {
+            this._properties = new Map();
+        }
+        return this._properties;
+    }
+    get primaryKey() {
+        if (null == this._primaryKey) {
+            this._primaryKey = [];
+        }
+        return this._primaryKey;
+    }
+    loadProperties(entityNode) {
+        let children = toArray(entityNode.elements());
+        let elementCount = children.length;
+        let nameAttr = XName.get("Name", "");
+        let typeAttr = XName.get("Type", "");
+        for (let i = 0; i < elementCount; i++) {
+            let node = children[i];
+            if (node.name.localName == "Property") {
+                let name = node.attribute(nameAttr).value;
+                let type = node.attribute(typeAttr).value;
+                this.properties.set(name, new EntityProperty(name, type));
+            }
+        }
+        ;
+    }
+    loadPrimaryKey(entityNode) {
+        let children = toArray(entityNode.elements());
+        let elementCount = children.length;
+        let nameAttr = XName.get("Name", "");
+        for (let i = 0; i < elementCount; i++) {
+            let node = children[i];
+            if (node.name.localName == "Key") {
+                let subChildren = toArray(node.elements());
+                let keyNodeCOunt = subChildren.length;
+                for (let j = 0; j < keyNodeCOunt; j++) {
+                    let keyNode = subChildren[j];
+                    if (keyNode.name.localName == "PropertyRef") {
+                        this.primaryKey.push(keyNode.attribute(nameAttr).value);
+                    }
+                }
+            }
+        }
+        ;
+    }
+}
+
+class EntitySet {
+    constructor(name, entityType) {
+        this._entityName = null;
+        this._entityNamespace = null;
+        this._entityType = null;
+        this._name = null;
+        this.name = name;
+        this.entityType = entityType;
+        if (entityType.indexOf(".") >= 0) {
+            let parts = entityType.split('.');
+            if (parts.length == 2) {
+                this.entityNamespace = parts[0];
+                this.entityName = parts[1];
+            }
+            else {
+                let i = entityType.lastIndexOf('.');
+                this.entityNamespace = entityType.substr(0, i);
+                this.entityName = entityType.substr(i + 1);
+            }
+        }
+        else {
+            this.entityNamespace = entityType;
+            this.entityName = entityType;
+        }
+    }
+    get entityName() {
+        return this._entityName;
+    }
+    set entityName(value) {
+        this._entityName = value;
+    }
+    get entityNamespace() {
+        return this._entityNamespace;
+    }
+    set entityNamespace(value) {
+        this._entityNamespace = value;
+    }
+    get entityType() {
+        return this._entityType;
+    }
+    set entityType(value) {
+        this._entityType = value;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+}
+
+class ODataDataSourcePage {
+    constructor(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 {
+            let count = (sourceData_.value.length);
+            this._actualData = [];
+            let dateProps = new Set();
+            for (let i = 0; i < schema.propertyNames.length; i++) {
+                if (schema.propertyTypes[i] == DataSourceSchemaPropertyType.DateTimeValue || schema.propertyTypes[i] == DataSourceSchemaPropertyType.DateTimeOffsetValue) {
+                    dateProps.add(schema.propertyNames[i]);
+                }
+            }
+            let value_;
+            for (let i_ = 0; i_ < count; i_++) {
+                let currItem_ = sourceData_.value[i_];
+                let dict = new Map();
+                let properties = Array.from(Object.keys(currItem_));
+                let values = (properties.map((k) => currItem_[k]));
+                for (let i1 = 0; i1 < properties.length; i1++) {
+                    value_ = values[i1];
+                    if (dateProps.has(properties[i1])) {
+                        value_ = new Date(value_);
+                    }
+                    dict.set(properties[i1], value_);
+                }
+                this._actualData[i_] = dict;
+            }
+        }
+        this._schema = schema;
+        this._groupInformation = groupInformation;
+        this._summaryInformation = summaryInformation;
+        this._pageIndex = pageIndex;
+    }
+    count() {
+        return this._actualData.length;
+    }
+    getItemAtIndex(index) {
+        return this._actualData[index];
+    }
+    getItemValueAtIndex(index, valueName) {
+        let item = this._actualData[index];
+        if (!item.has(valueName)) {
+            return null;
+        }
+        return item.get(valueName);
+    }
+    pageIndex() {
+        return this._pageIndex;
+    }
+    schema() {
+        return this._schema;
+    }
+    getGroupInformation() {
+        return this._groupInformation;
+    }
+    getSummaryInformation() {
+        return this._summaryInformation;
+    }
+}
+
+class Schema {
+    constructor(namespace, entityTypeElements, entitySetElements) {
+        this._entities = null;
+        this._entitySets = null;
+        this._namespace = null;
+        this.namespace = namespace;
+        this.loadEntities(entityTypeElements);
+        this.loadEntitySets(entitySetElements);
+    }
+    get entities() {
+        if (null == this._entities) {
+            this._entities = new Map();
+        }
+        return this._entities;
+    }
+    get entitySets() {
+        if (null == this._entitySets) {
+            this._entitySets = new Map();
+        }
+        return this._entitySets;
+    }
+    get namespace() {
+        return this._namespace;
+    }
+    set namespace(value) {
+        this._namespace = value;
+    }
+    loadEntities(entityTypeElements) {
+        let list = entityTypeElements;
+        let elementCount = list.length;
+        let name = XName.get("Name", "");
+        for (let i = 0; i < elementCount; i++) {
+            let node = list[i];
+            let entity = new Entity(node.attribute(name).value, node);
+            this.entities.set(entity.name, entity);
+        }
+        ;
+    }
+    loadEntitySets(entitySetElements) {
+        let list = entitySetElements;
+        let elementCount = list.length;
+        let nameAttr = XName.get("Name", "");
+        let entityType = XName.get("EntityType", "");
+        for (let i = 0; i < elementCount; i++) {
+            let node = list[i];
+            let entitySet = new EntitySet(node.attribute(nameAttr).value, node.attribute(entityType).value);
+            this.entitySets.set(entitySet.name, entitySet);
+        }
+        ;
+    }
+}
+
+class ODataSchemaProvider {
+    static { this.nS = XNamespace.get("http://docs.oasis-open.org/odata/ns/edm"); }
+    constructor(metadataDocument) {
+        this._entityTypeSchemaNamespace = null;
+        this._entitySetSchemaNamespace = null;
+        this._schema = null;
+        if (null == metadataDocument) {
+            return;
+        }
+        let xmlDoc = XDocument.parse(metadataDocument);
+        let schemaElements = toArray(first(fromEnum(first(fromEnum(xmlDoc.elements())).elements())).elements1(XName.get("Schema", ODataSchemaProvider.nS.namespaceName)));
+        if (null == schemaElements) {
+            return;
+        }
+        let entitySetElements = null;
+        let entityTypeElements = null;
+        let elementCount = schemaElements.length;
+        let entityContainer = XName.get("EntityContainer", ODataSchemaProvider.nS.namespaceName);
+        let entitySet = XName.get("EntitySet", ODataSchemaProvider.nS.namespaceName);
+        let namespaceAttribute = XName.get("Namespace", "");
+        let entityType = XName.get("EntityType", ODataSchemaProvider.nS.namespaceName);
+        for (let i = 0; i < elementCount; i++) {
+            let node = schemaElements[i];
+            if (node.nodeType != XmlNodeType.Element) {
+                continue;
+            }
+            let schemaElement = schemaElements[i];
+            if (null == entitySetElements) {
+                let nodes = toArray(schemaElement.elements1(entityContainer));
+                if (null != nodes && nodes.length > 0) {
+                    entitySetElements = toArray((typeCast(XElement.$type, nodes[0])).elements1(entitySet));
+                    if (null != entitySetElements) {
+                        this._entitySetSchemaNamespace = schemaElement.attribute(namespaceAttribute).value;
+                    }
+                }
+            }
+            if (null == entityTypeElements) {
+                entityTypeElements = toArray(schemaElement.elements1(entityType));
+                if (null != entityTypeElements) {
+                    this._entityTypeSchemaNamespace = schemaElement.attribute(namespaceAttribute).value;
+                }
+            }
+        }
+        if (null == entitySetElements || null == entityTypeElements) {
+            return;
+        }
+        this.schema = new Schema(this._entityTypeSchemaNamespace, entityTypeElements, entitySetElements);
+    }
+    get schema() {
+        return this._schema;
+    }
+    set schema(value) {
+        this._schema = value;
+    }
+    getODataDataSourceSchema(entitySet) {
+        if (this.schema == null) {
+            return null;
+        }
+        let valueNames = [];
+        let valueTypes = [];
+        let primaryKey = [];
+        let es = this.schema.entitySets.get(entitySet);
+        if (null != es) {
+            let entity = this.schema.entities.get(es.entityName);
+            if (null != entity) {
+                for (let property of entity.properties.values()) {
+                    valueNames.push(property.name);
+                    if (property.type == "Edm.String") {
+                        valueTypes.push(DataSourceSchemaPropertyType.StringValue);
+                    }
+                    else if (property.type == "Edm.Int16" || property.type == "Edm.Int32") {
+                        valueTypes.push(DataSourceSchemaPropertyType.IntValue);
+                    }
+                    else if (property.type == "Edm.Double") {
+                        valueTypes.push(DataSourceSchemaPropertyType.DoubleValue);
+                    }
+                    else if (property.type == "Edm.Single") {
+                        valueTypes.push(DataSourceSchemaPropertyType.SingleValue);
+                    }
+                    else if (property.type == "Edm.Boolean") {
+                        valueTypes.push(DataSourceSchemaPropertyType.BooleanValue);
+                    }
+                    else if (property.type == "Edm.Byte") {
+                        valueTypes.push(DataSourceSchemaPropertyType.ShortValue);
+                    }
+                    else if (property.type == "Edm.DateTime" || property.type == "Edm.DateTimeOffset") {
+                        valueTypes.push(DataSourceSchemaPropertyType.DateTimeValue);
+                    }
+                    else if (property.type == "Edm.Int64") {
+                        valueTypes.push(DataSourceSchemaPropertyType.LongValue);
+                    }
+                    else if (property.type == "Edm.Decimal") {
+                        valueTypes.push(DataSourceSchemaPropertyType.DecimalValue);
+                    }
+                    else if (property.type == "Edm.SByte") {
+                        valueTypes.push(DataSourceSchemaPropertyType.ShortValue);
+                    }
+                    else {
+                        valueTypes.push(DataSourceSchemaPropertyType.ObjectValue);
+                    }
+                }
+                for (let k of entity.primaryKey) {
+                    primaryKey.push(k);
+                }
+            }
+        }
+        return new ODataDataSourceSchema(valueNames, valueTypes, primaryKey);
+    }
+}
+
+class ODataVirtualDataSourceProviderTaskDataHolder extends AsyncVirtualDataSourceProviderTaskDataHolder {
+    static { this.$t = markType(ODataVirtualDataSourceProviderTaskDataHolder, 'ODataVirtualDataSourceProviderTaskDataHolder', AsyncVirtualDataSourceProviderTaskDataHolder.$type); }
+}
+
+class ODataVirtualDataSourceDataProviderWorker extends AsyncVirtualDataSourceProviderWorker {
+    get sortDescriptions() {
+        return this._sortDescriptions;
+    }
+    get filterExpressions() {
+        return this._filterExpressions;
+    }
+    get desiredProperties() {
+        return this._desiredPropeties;
+    }
+    initialize() {
+        super.initialize();
+    }
+    getTaskDataHolder() {
+        let holder = new ODataVirtualDataSourceProviderTaskDataHolder();
+        return holder;
+    }
+    getCompletedTaskData(holder, completed) {
+        super.getCompletedTaskData(holder, completed);
+    }
+    removeCompletedTaskData(holder, completed) {
+        super.removeCompletedTaskData(holder, completed);
+    }
+    getTasksData(holder) {
+        super.getTasksData(holder);
+    }
+    *iter(coll) {
+        for (let i = 0; i < coll.size(); i++) {
+            yield coll.get(i);
+        }
+    }
+    *iterFilter(coll) {
+        for (let i = 0; i < coll.size(); i++) {
+            yield coll.get(i);
+        }
+    }
+    *iterSummaries(summaries) {
+        for (let i = 0; i < summaries.size(); i++) {
+            yield summaries.get(i);
+        }
+    }
+    constructor(settings) {
+        super(settings);
+        this._baseUri = null;
+        this._entitySet = null;
+        this._sortDescriptions = null;
+        this._groupDescriptions = null;
+        this._filterExpressions = null;
+        this._summaryDescriptions = null;
+        this._desiredPropeties = null;
+        this._schemaIncludedProperties = null;
+        this._enableJsonp = true;
+        this._isAggregationSupported = false;
+        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();
+            for (let sd of this.iter(settings.sortDescriptions)) {
+                this._sortDescriptions.add(sd);
+            }
+            for (let i = 0; i < this._groupDescriptions.size(); i++) {
+                this._sortDescriptions.insert(i, this._groupDescriptions.get(i));
+            }
+        }
+        this._filterExpressions = settings.filterExpressions;
+        this._desiredPropeties = settings.propertiesRequested;
+        if (settings.schemaIncludedProperties != null) {
+            this._schemaIncludedProperties = new Set();
+            for (let i = 0; i < settings.schemaIncludedProperties.length; i++) {
+                this._schemaIncludedProperties.add(settings.schemaIncludedProperties[i]);
+            }
+        }
+        this._summaryDescriptions = settings.summaryDescriptions;
+        this._summaryScope = settings.summaryScope;
+        this._enableJsonp = settings.enableJsonp;
+        this._isAggregationSupported = settings.isAggregationSupported;
+        window.setTimeout(this.doWork, 100);
+    }
+    processCompletedTask(completedTask, currentDelay, pageIndex, taskDataHolder) {
+        let h = taskDataHolder;
+        let schema = null;
+        let result = null;
+        let schemaFetchCount = -1;
+        let task = completedTask.task;
+        try {
+            if (task.hasErrors) {
+                this.retryIndex(pageIndex, currentDelay);
+                return;
+            }
+            if (pageIndex == ODataVirtualDataSourceDataProviderWorker.schemaRequestIndex) {
+                result = task.result;
+                schemaFetchCount = (result['@odata.count']);
+            }
+            else {
+                result = task.result;
+            }
+        }
+        catch (e) {
+            this.retryIndex(pageIndex, currentDelay);
+            return;
+        }
+        if (schemaFetchCount >= 0) {
+            this.actualCount = schemaFetchCount;
+        }
+        else {
+            this.actualCount = (result['@odata.count']);
+        }
+        schema = this.actualSchema;
+        if (schema == null) {
+            let requests = 0;
+            this.resolveSchema((s) => {
+                // resolveSchema success callback
+                this.actualSchema = s;
+                if (this._isAggregationSupported && (this._groupDescriptions.size() !== 0 || this._summaryDescriptions.size() !== 0)) {
+                    if (this._groupDescriptions.size() > 0) {
+                        requests++;
+                        this.resolveGroupInformation((g) => {
+                            // group info success
+                            requests--;
+                            if (requests === 0) {
+                                this.finishProcessingCompletedTask(task, pageIndex, s, result);
+                            }
+                        }, () => {
+                            // group info failure
+                            this.retryIndex(pageIndex, currentDelay);
+                            return;
+                        });
+                    }
+                    if (this._summaryDescriptions.size() > 0) {
+                        requests++;
+                        this.resolveSummaryInformation((g) => {
+                            // summary info success
+                            requests--;
+                            if (requests === 0) {
+                                this.finishProcessingCompletedTask(task, pageIndex, s, result);
+                            }
+                        }, () => {
+                            // summary info failure
+                            this.retryIndex(pageIndex, currentDelay);
+                            return;
+                        });
+                    }
+                }
+                else {
+                    this.finishProcessingCompletedTask(task, pageIndex, s, result);
+                }
+            }, () => {
+                // resolveSchema failure callback
+                this.retryIndex(pageIndex, currentDelay);
+                return;
+            });
+            return;
+        }
+        this.finishProcessingCompletedTask(task, pageIndex, schema, result);
+    }
+    finishProcessingCompletedTask(task, pageIndex, schema, result) {
+        let executionContext;
+        let pageLoaded;
+        let groupInformation;
+        let summaryInformation;
+        this.actualSchema = schema;
+        executionContext = this.executionContext;
+        groupInformation = this._groupInformation;
+        summaryInformation = this._summaryInformation;
+        pageLoaded = this.pageLoaded;
+        let page = null;
+        if (result != null) {
+            page = new ODataDataSourcePage(result, schema, groupInformation, summaryInformation, pageIndex);
+            if (!this.isLastPage(pageIndex) && page.count() > 0 && !this.populatedActualPageSize) {
+                this.populatedActualPageSize = true;
+                this.actualPageSize = page.count();
+            }
+        }
+        else {
+            page = new ODataDataSourcePage(null, schema, groupInformation, summaryInformation, pageIndex);
+        }
+        if (this.pageLoaded != null) {
+            if (this.executionContext != null) {
+                if (executionContext == null || pageLoaded == null) {
+                    this.shutdown();
+                    return;
+                }
+                executionContext.execute(() => pageLoaded(page, this.actualCount, this.actualPageSize));
+            }
+            else {
+                if (pageLoaded == null) {
+                    this.shutdown();
+                    return;
+                }
+                pageLoaded(page, this.actualCount, this.actualPageSize);
+            }
+        }
+    }
+    resolveGroupInformation(finishAction, failureAction) {
+        if (this._groupInformation != null) {
+            finishAction(this._groupInformation);
+            return;
+        }
+        let orderBy = "";
+        let groupBy = "";
+        let filter = null;
+        let summary = "";
+        if (this._groupDescriptions == null || this._groupDescriptions.size() == 0) {
+            finishAction(null);
+            return;
+        }
+        filter = this._filterString;
+        this.updateFilterString();
+        if (this._groupDescriptions != null) {
+            let first1 = true;
+            for (let group of this.iter(this._groupDescriptions)) {
+                if (first1) {
+                    first1 = false;
+                }
+                else {
+                    orderBy += ", ";
+                    groupBy += ", ";
+                }
+                groupBy += group.propertyName;
+                if (group.direction === ListSortDirection.Descending) {
+                    orderBy += group.propertyName + " desc";
+                }
+                else {
+                    orderBy += group.propertyName + " asc";
+                }
+            }
+        }
+        if (this._summaryScope === DataSourceSummaryScope.Both || this._summaryScope === DataSourceSummaryScope.Groups) {
+            let summaryParameters = this.getSummaryQueryParameters(true);
+            if (!stringIsNullOrEmpty(summaryParameters)) {
+                summary = ", " + summaryParameters;
+            }
+        }
+        let commandText = this._entitySet + "?$orderby=" + orderBy + "&$apply=";
+        if (!stringIsNullOrEmpty(filter)) {
+            commandText += "filter(" + filter + ")/";
+        }
+        commandText += "groupby((" + groupBy + "), aggregate($count as $__count" + summary + "))";
+        try {
+            let groupInformation = [];
+            let success_ = (data, response) => this.groupSuccess(data, response, finishAction, failureAction, groupInformation);
+            let failure_ = (err) => this.groupError(err, finishAction, failureAction, groupInformation);
+            let run_ = null;
+            var headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
+            var request = {
+                requestUri: this._baseUri + "/" + commandText,
+                enableJsonpCallback: this._enableJsonp,
+                method: 'GET',
+                headers: headers,
+                data: null
+            };
+            run_ = function () {
+                odatajs.oData.request(request, success_, failure_);
+            };
+            run_();
+        }
+        catch (e) {
+            failureAction();
+        }
+    }
+    groupError(err, finishAction, failureAction, groupInformation) {
+        this._groupInformation = null;
+    }
+    groupSuccess(data, response, finishAction, failureAction, groupInformation) {
+        let groupNames = [];
+        for (let group of this.iter(this._groupDescriptions)) {
+            groupNames.push(group.propertyName);
+        }
+        let groupNamesArray = groupNames;
+        if (data && data.value && data.value.length > 0) {
+            let currentIndex = 0;
+            for (let i = 0; i < data.value.length; i++) {
+                this.addGroup(groupInformation, groupNames, groupNames, currentIndex, data.value[i]);
+            }
+        }
+        this._groupInformation = groupInformation;
+        finishAction(this._groupInformation);
+    }
+    addGroup(groupInformation, groupNames, groupNamesArray, currentIndex, group) {
+        let groupValues = [];
+        for (let name of groupNames) {
+            if (group[name]) {
+                groupValues.push(group[name]);
+            }
+        }
+        let groupCount = 0;
+        if (group["$__count"]) {
+            groupCount = Convert.toInt321(group["$__count"]);
+        }
+        let summaryResults = null;
+        if (this._summaryScope == DataSourceSummaryScope.Both || this._summaryScope == DataSourceSummaryScope.Groups) {
+            summaryResults = this.createSummaryResults(group);
+        }
+        let groupInfo = new DefaultSectionInformation(currentIndex, currentIndex + (groupCount - 1), groupNamesArray, groupValues, summaryResults);
+        groupInformation.push(groupInfo);
+    }
+    resolveSummaryInformation(finishAction, failureAction) {
+        if (this._summaryInformation != null) {
+            finishAction(this._summaryInformation);
+            return;
+        }
+        let filter = null;
+        let 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);
+        let commandText = this._entitySet + "?$apply=";
+        if (!stringIsNullOrEmpty(filter)) {
+            commandText += "filter(" + filter + ")/";
+        }
+        commandText += "aggregate(" + summary + ")";
+        try {
+            let summaryInformation = [];
+            let success_ = (data, response) => this.summarySuccess(data, response, finishAction, failureAction, summaryInformation);
+            let failure_ = (err) => this.summaryError(err, finishAction, failureAction, summaryInformation);
+            let run_ = null;
+            var headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
+            var request = {
+                requestUri: this._baseUri + "/" + commandText,
+                enableJsonpCallback: this._enableJsonp,
+                method: 'GET',
+                headers: headers,
+                data: null
+            };
+            run_ = function () {
+                odatajs.oData.request(request, success_, failure_);
+            };
+            run_();
+        }
+        catch (e) {
+            failureAction();
+        }
+    }
+    summarySuccess(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);
+    }
+    summaryError(err, finishAction, failureAction, summaryInformation) {
+        this._summaryInformation = null;
+    }
+    getSummaryQueryParameters(ignoreCount) {
+        let result = "";
+        if (this._summaryDescriptions != null) {
+            let first = true;
+            let countExists = false;
+            for (let summary of this.iterSummaries(this._summaryDescriptions)) {
+                if (summary.operand == DataSourceSummaryOperand.Count && (ignoreCount || countExists)) {
+                    continue;
+                }
+                if (!first) {
+                    result += ", ";
+                }
+                switch (summary.operand) {
+                    case DataSourceSummaryOperand.Average:
+                        result += summary.propertyName + " with average as " + summary.propertyName + "Average";
+                        break;
+                    case DataSourceSummaryOperand.Min:
+                        result += summary.propertyName + " with min as " + summary.propertyName + "Min";
+                        break;
+                    case DataSourceSummaryOperand.Max:
+                        result += summary.propertyName + " with max as " + summary.propertyName + "Max";
+                        break;
+                    case DataSourceSummaryOperand.Sum:
+                        result += summary.propertyName + " with sum as " + summary.propertyName + "Sum";
+                        break;
+                    case DataSourceSummaryOperand.Count:
+                        result += "$count as $__count";
+                        countExists = true;
+                        break;
+                }
+                first = false;
+            }
+        }
+        return result;
+    }
+    createSummaryResults(data) {
+        let summaryResults = [];
+        for (let summary of this.iterSummaries(this._summaryDescriptions)) {
+            let summaryName = summary.propertyName;
+            switch (summary.operand) {
+                case DataSourceSummaryOperand.Average:
+                    summaryName += "Average";
+                    break;
+                case DataSourceSummaryOperand.Min:
+                    summaryName += "Min";
+                    break;
+                case DataSourceSummaryOperand.Max:
+                    summaryName += "Max";
+                    break;
+                case DataSourceSummaryOperand.Sum:
+                    summaryName += "Sum";
+                    break;
+                case DataSourceSummaryOperand.Count:
+                    summaryName = "$__count";
+                    break;
+            }
+            let summaryValue = null;
+            if (data && data[summaryName]) {
+                summaryValue = data[summaryName];
+            }
+            let summaryResult = new DefaultSummaryResult(summary.propertyName, summary.operand, summaryValue);
+            summaryResults.push(summaryResult);
+        }
+        return summaryResults;
+    }
+    resolveSchema(finishAction, failureAction) {
+        let success_ = (res) => {
+            let sp = new ODataSchemaProvider(res);
+            let schema = sp.getODataDataSourceSchema(this._entitySet);
+            if (this._schemaIncludedProperties != null) {
+                let propertyNames = [];
+                let propertyTypes = [];
+                for (let i = 0; i < schema.propertyNames.length; i++) {
+                    if (!this._schemaIncludedProperties.has(schema.propertyNames[i])) {
+                        continue;
+                    }
+                    propertyNames.push(schema.propertyNames[i]);
+                    propertyTypes.push(schema.propertyTypes[i]);
+                }
+                schema = new ODataDataSourceSchema(propertyNames, propertyTypes, schema.primaryKey);
+            }
+            finishAction(schema);
+        };
+        let failure_ = () => failureAction();
+        let baseUri_ = this._baseUri;
+        var request = new XMLHttpRequest();
+        request.onreadystatechange = function () {
+            if (request.readyState === 4) {
+                if (request.status === 200) {
+                    success_(request.responseText);
+                }
+                else {
+                    failure_();
+                }
+            }
+        };
+        request.open('Get', baseUri_ + '/$metadata');
+        request.send();
+        ;
+    }
+    static { this.schemaRequestIndex = -1; }
+    makeTaskForRequest(request, retryDelay) {
+        let actualPageSize = 0;
+        let sortDescriptions = null;
+        actualPageSize = this.actualPageSize;
+        sortDescriptions = this.sortDescriptions;
+        let requestUrl = this._baseUri;
+        requestUrl += "/" + this._entitySet;
+        let queryStarted = false;
+        this.updateFilterString();
+        if (this._filterString != null) {
+            if (!queryStarted) {
+                queryStarted = true;
+                requestUrl += "?";
+            }
+            else {
+                requestUrl += "&";
+            }
+            requestUrl += "$filter=" + this._filterString;
+        }
+        if (this.sortDescriptions != null) {
+            let sortString = null;
+            for (let sort of this.iter(this.sortDescriptions)) {
+                if (sortString == null) {
+                    sortString = "";
+                }
+                else {
+                    sortString += ", ";
+                }
+                if (sort.direction == ListSortDirection.Descending) {
+                    sortString += sort.propertyName + " desc";
+                }
+                else {
+                    sortString += sort.propertyName;
+                }
+            }
+            if (sortString != null) {
+                if (!queryStarted) {
+                    queryStarted = true;
+                    requestUrl += "?";
+                }
+                else {
+                    requestUrl += "&";
+                }
+                requestUrl += "$orderby=" + sortString;
+            }
+        }
+        if (this.desiredProperties != null && this.desiredProperties.length > 0) {
+            let selectString = "";
+            let first = true;
+            let $t = this.desiredProperties;
+            for (let i = 0; i < $t.length; i++) {
+                let select = $t[i];
+                if (first) {
+                    first = false;
+                }
+                else {
+                    selectString += ", ";
+                }
+                selectString += select;
+            }
+            if (!queryStarted) {
+                queryStarted = true;
+                requestUrl += "?";
+            }
+            else {
+                requestUrl += "&";
+            }
+            requestUrl += "$select=" + selectString;
+        }
+        let task = new AsyncVirtualDataTask();
+        if (request.index == ODataVirtualDataSourceDataProviderWorker.schemaRequestIndex) {
+            this.executeRequest(requestUrl, queryStarted, 0, actualPageSize, task);
+        }
+        else {
+            this.executeRequest(requestUrl, queryStarted, request.index * actualPageSize, actualPageSize, task);
+        }
+        request.taskHolder = new AsyncDataSourcePageTaskHolder();
+        request.taskHolder.task = task;
+        this.tasks.add(request);
+    }
+    updateFilterString() {
+        if (this.filterExpressions != null && this.filterExpressions.size() > 0 && this._filterString == null) {
+            let sb = "";
+            let first = true;
+            for (let expr of this.iterFilter(this.filterExpressions)) {
+                if (first) {
+                    first = false;
+                }
+                else {
+                    sb += " AND ";
+                }
+                let visitor = new ODataDataSourceFilterExpressionVisitor(0);
+                visitor.visit(expr);
+                let txt = visitor.toString();
+                if (this.filterExpressions.size() > 1) {
+                    txt = "(" + txt + ")";
+                }
+                sb += (txt);
+            }
+            this._filterString = sb;
+        }
+    }
+    executeRequest(requestUrl, queryStarted, skip, top, task) {
+        if (!queryStarted) {
+            queryStarted = true;
+            requestUrl += "?";
+        }
+        else {
+            requestUrl += "&";
+        }
+        requestUrl += "$skip=" + skip + "&$top=" + top + "&$count=true";
+        let requestUrl_ = requestUrl;
+        let self_ = this;
+        let success_ = (data, response) => this.success(task, data, response);
+        let failure_ = (err) => this.error(task, err);
+        let 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 () {
+            odatajs.oData.request(request, success_, failure_);
+        };
+        task.run = run_;
+    }
+    success(t, data, response) {
+        t.result = data;
+        t.isCompleted = true;
+    }
+    error(t, result) {
+        t.isCompleted = true;
+        t.hasErrors = true;
+    }
+    createBatchRequest(changes) {
+        const requests = [];
+        for (let i = 0; i < changes.length; i++) {
+            let c = changes[i];
+            const headers = { "Content-Type": "application/json", "odata-version": "4.0" };
+            if (c.transactionType === TransactionType.Add) {
+                requests.push({
+                    method: "POST",
+                    id: `r${i}`,
+                    atomicityGroup: "g1",
+                    url: `${this._baseUri}/${this._entitySet}`,
+                    headers: headers,
+                    body: c.value,
+                });
+            }
+            else if (c.transactionType === TransactionType.Update) {
+                if (c.version) {
+                    headers["If-Match"] = c.version;
+                }
+                requests.push({
+                    method: "PATCH",
+                    id: `r${i}`,
+                    atomicityGroup: "g1",
+                    url: `${this._baseUri}/${this.getRequestUriWithKey(c.id)}`,
+                    headers: headers,
+                    body: c.value,
+                });
+            }
+            else if (c.transactionType === TransactionType.Delete) {
+                if (c.version) {
+                    headers["If-Match"] = c.version;
+                }
+                requests.push({
+                    method: "DELETE",
+                    id: `r${i}`,
+                    atomicityGroup: "g1",
+                    url: `${this._baseUri}/${this.getRequestUriWithKey(c.id)}`,
+                    headers: headers,
+                });
+            }
+        }
+        let request = {
+            requestUri: `${this._baseUri}/$batch`,
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ requests: requests })
+        };
+        let self = this;
+        odatajs.oData.request(request, function (data) {
+            if (data && data.responses) {
+                if (data.responses.length > 0) {
+                    let success = true;
+                    let messages = [];
+                    for (let i = 0; i < data.responses.length; i++) {
+                        if (data.responses[i].status !== 200 &&
+                            data.responses[i].status !== 204) {
+                            success = false;
+                            let failedRequest = requests.filter(r => r.id == data.responses[i].id)[0];
+                            if (failedRequest) {
+                                let msg = `${failedRequest.method} request failed with code ${data.responses[i].status}`;
+                                messages.push(msg);
+                                console.error(msg);
+                            }
+                            break;
+                        }
+                    }
+                    if (success) {
+                        self.batchCompleted(true, true, null);
+                    }
+                    else {
+                        self.batchCompleted(false, true, messages);
+                    }
+                }
+                else {
+                    self.batchCompleted(false, true, null);
+                }
+            }
+        }, function (error) {
+            const messages = [];
+            if (error && error.message) {
+                messages.push(error.message);
+            }
+            self.batchCompleted(false, true, messages);
+        });
+    }
+    getRequestUriWithKey(key) {
+        let result = "";
+        const keys = Object.keys(key);
+        for (let i = 0; i < keys.length; i++) {
+            if (i > 0) {
+                result += ",";
+            }
+            result += `${keys[i]}=${key[keys[i]]}`;
+        }
+        return `${this._entitySet}(${result})`;
+    }
+}
+
+class ODataVirtualDataSourceDataProviderWorkerSettings extends AsyncVirtualDataSourceDataProviderWorkerSettings {
+    constructor() {
+        super(...arguments);
+        this._baseUri = null;
+        this._entitySet = null;
+        this._sortDescriptions = null;
+        this._filterExpressions = null;
+        this._propertiesRequested = null;
+        this._schemaIncludedProperties = null;
+        this._groupDescriptions = null;
+        this._summaryDescriptions = null;
+    }
+    static { this.$t = markType(ODataVirtualDataSourceDataProviderWorkerSettings, 'ODataVirtualDataSourceDataProviderWorkerSettings', AsyncVirtualDataSourceDataProviderWorkerSettings.$type); }
+    get baseUri() {
+        return this._baseUri;
+    }
+    set baseUri(value) {
+        this._baseUri = value;
+    }
+    get entitySet() {
+        return this._entitySet;
+    }
+    set entitySet(value) {
+        this._entitySet = value;
+    }
+    get sortDescriptions() {
+        return this._sortDescriptions;
+    }
+    set sortDescriptions(value) {
+        this._sortDescriptions = value;
+    }
+    get filterExpressions() {
+        return this._filterExpressions;
+    }
+    set filterExpressions(value) {
+        this._filterExpressions = value;
+    }
+    get propertiesRequested() {
+        return this._propertiesRequested;
+    }
+    set propertiesRequested(value) {
+        this._propertiesRequested = value;
+    }
+    get schemaIncludedProperties() {
+        return this._schemaIncludedProperties;
+    }
+    set schemaIncludedProperties(value) {
+        this._schemaIncludedProperties = value;
+    }
+    get groupDescriptions() {
+        return this._groupDescriptions;
+    }
+    set groupDescriptions(value) {
+        this._groupDescriptions = value;
+    }
+    get summaryDescriptions() {
+        return this._summaryDescriptions;
+    }
+    set summaryDescriptions(value) {
+        this._summaryDescriptions = value;
+    }
+    get summaryScope() {
+        return this._summaryscope;
+    }
+    set summaryScope(value) {
+        this._summaryscope = value;
+    }
+    get enableJsonp() {
+        return this._enableJsonp;
+    }
+    set enableJsonp(isEnabled) {
+        this._enableJsonp = isEnabled;
+    }
+    get isAggregationSupported() {
+        return this._isAggregationSupported;
+    }
+    set isAggregationSupported(isSupported) {
+        this._isAggregationSupported = isSupported;
+    }
+}
+
+class ODataVirtualDataSourceDataProvider extends Base {
+    static { this.$t = markType(ODataVirtualDataSourceDataProvider, 'ODataVirtualDataSourceDataProvider', Base.$type, [IDataSourceVirtualDataProvider_$type]); }
+    constructor() {
+        super();
+        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._schemaIncludedProperties = null;
+        this._filterExpressions = null;
+        this._summaryDescriptions = null;
+        this._enableJsonp = true;
+        this._schemaFetchQueued = false;
+        this._autoRefreshQueued = false;
+        this._batchCompleted = null;
+        this._sortDescriptions = new SortDescriptionCollection();
+        this._sortDescriptions.onChanged = () => this.sortDescriptions_CollectionChanged(null, null);
+        this._groupDescriptions = new SortDescriptionCollection();
+        this._groupDescriptions.onChanged = () => this.groupDescriptions_CollectionChanged(null, null);
+        this._filterExpressions = new FilterExpressionCollection();
+        this._filterExpressions.onChanged = () => this.filterExpressions_CollectionChanged(null, null);
+        this._summaryDescriptions = new SummaryDescriptionCollection();
+        this._summaryDescriptions.onChanged = () => this.summaryDescriptions_CollectionChanged(null, null);
+    }
+    filterExpressions_CollectionChanged(sender, e) {
+        this.queueAutoRefresh();
+    }
+    sortDescriptions_CollectionChanged(sender, e) {
+        this.queueAutoRefresh();
+    }
+    groupDescriptions_CollectionChanged(sender, e) {
+        this.queueAutoRefresh();
+    }
+    summaryDescriptions_CollectionChanged(sender, e) {
+        this.queueAutoRefresh();
+    }
+    addPageRequest(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);
+        }
+    }
+    createWorker() {
+        if (!this.valid()) {
+            return;
+        }
+        this._callback = runOn(this, this.raisePageLoaded);
+        let settings = this.getWorkerSettings();
+        this._worker = new ODataVirtualDataSourceDataProviderWorker(settings);
+    }
+    valid() {
+        return this.entitySet != null && this.baseUri != null;
+    }
+    getWorkerSettings() {
+        return ((() => {
+            let $ret = new ODataVirtualDataSourceDataProviderWorkerSettings();
+            $ret.baseUri = this._baseUri;
+            $ret.entitySet = this._entitySet;
+            $ret.pageSizeRequested = this._pageSizeRequested;
+            $ret.timeoutMilliseconds = this._timeoutMilliseconds;
+            $ret.pageLoaded = this._callback;
+            $ret.batchCompleted = this._batchCompleted;
+            $ret.executionContext = this._executionContext;
+            $ret.sortDescriptions = this._sortDescriptions;
+            $ret.groupDescriptions = this._groupDescriptions;
+            $ret.filterExpressions = this._filterExpressions;
+            $ret.propertiesRequested = this._propertiesRequested;
+            $ret.schemaIncludedProperties = this._schemaIncludedProperties;
+            $ret.summaryDescriptions = this._summaryDescriptions;
+            $ret.summaryScope = this._summaryScope;
+            $ret.enableJsonp = this._enableJsonp;
+            $ret.isAggregationSupported = this.isAggregationSupported;
+            return $ret;
+        })());
+    }
+    removePageRequest(pageIndex) {
+        let 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);
+    }
+    removeAllPageRequests() {
+        this._requests.clear();
+        if (this._worker == null) {
+            return;
+        }
+        this._worker.removeAllPageRequests();
+    }
+    close() {
+        if (this._worker != null) {
+            this._worker.shutdown();
+            this._worker = null;
+            this._callback = null;
+        }
+    }
+    get pageLoaded() {
+        return this._pageLoaded;
+    }
+    set pageLoaded(value) {
+        this._pageLoaded = value;
+        this.queueAutoRefresh();
+    }
+    raisePageLoaded(page, fullCount, actualPageSize) {
+        if (this._pageLoaded != null) {
+            this._currentFullCount = fullCount;
+            if (this._currentSchema == null) {
+                let 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() != ODataVirtualDataSourceDataProviderWorker.schemaRequestIndex) {
+                this._pageLoaded(page, fullCount, actualPageSize);
+            }
+        }
+    }
+    killWorker() {
+        if (this._worker != null) {
+            this._worker.shutdown();
+            this._worker = null;
+            this._callback = null;
+        }
+    }
+    get pageSizeRequested() {
+        return this._pageSizeRequested;
+    }
+    set pageSizeRequested(value) {
+        this._pageSizeRequested = value;
+        this.queueAutoRefresh();
+    }
+    get baseUri() {
+        return this._baseUri;
+    }
+    set baseUri(value) {
+        let oldValue = this._baseUri;
+        this._baseUri = value;
+        if (oldValue != this._baseUri) {
+            this.queueAutoRefresh();
+            if (this.valid() && this.deferAutoRefresh) {
+                this.queueSchemaFetch();
+            }
+        }
+    }
+    get entitySet() {
+        return this._entitySet;
+    }
+    set entitySet(value) {
+        let oldValue = this._entitySet;
+        this._entitySet = value;
+        if (oldValue != this._entitySet) {
+            this.queueAutoRefresh();
+            if (this.valid() && this.deferAutoRefresh) {
+                this.queueSchemaFetch();
+            }
+        }
+    }
+    get timeoutMilliseconds() {
+        return this._timeoutMilliseconds;
+    }
+    set timeoutMilliseconds(value) {
+        this._timeoutMilliseconds = value;
+        this.queueAutoRefresh();
+    }
+    getItemValue(item, valueName) {
+        let dic = item;
+        if (dic.has(valueName)) {
+            return dic.get(valueName);
+        }
+        else {
+            return null;
+        }
+    }
+    setItemValue(item, valueName, value) {
+        // does nothing for virtual data.
+    }
+    removeItem(item) {
+        // does nothing for virtual data.
+    }
+    addItem(item) {
+        // does nothing for virtual data.
+    }
+    get actualCount() {
+        return this._currentFullCount;
+    }
+    get actualSchema() {
+        return this._currentSchema;
+    }
+    get executionContext() {
+        return this._executionContext;
+    }
+    set executionContext(value) {
+        this._executionContext = value;
+        this.queueAutoRefresh();
+    }
+    get updateNotifier() {
+        return this._updateNotifier;
+    }
+    set updateNotifier(value) {
+        this._updateNotifier = value;
+    }
+    get deferAutoRefresh() {
+        return this._deferAutoRefresh;
+    }
+    set deferAutoRefresh(value) {
+        this._deferAutoRefresh = value;
+        if (!this._deferAutoRefresh) {
+            this.queueAutoRefresh();
+        }
+        if (this._deferAutoRefresh && this.valid() && this._currentSchema == null) {
+            this.queueSchemaFetch();
+        }
+    }
+    get isSortingSupported() {
+        return true;
+    }
+    get isGroupingSupported() {
+        return this.isAggregationSupported;
+    }
+    get isFilteringSupported() {
+        return true;
+    }
+    get isAggregationSupported() {
+        return this._isAggregationSupported;
+    }
+    set isAggregationSupported(isSupported) {
+        this._isAggregationSupported = isSupported;
+    }
+    get sortDescriptions() {
+        return this._sortDescriptions;
+    }
+    get groupDescriptions() {
+        return this._groupDescriptions;
+    }
+    get propertiesRequested() {
+        return this._propertiesRequested;
+    }
+    set propertiesRequested(value) {
+        this._propertiesRequested = value;
+        this.queueAutoRefresh();
+    }
+    get schemaIncludedProperties() {
+        return this._schemaIncludedProperties;
+    }
+    set schemaIncludedProperties(value) {
+        this._schemaIncludedProperties = value;
+        this.queueAutoRefresh();
+    }
+    get filterExpressions() {
+        return this._filterExpressions;
+    }
+    get summaryDescriptions() {
+        return this._summaryDescriptions;
+    }
+    get summaryScope() {
+        return this._summaryScope;
+    }
+    set summaryScope(value) {
+        this._summaryScope = value;
+    }
+    get enableJsonp() {
+        return this._enableJsonp;
+    }
+    set enableJsonp(isEnabled) {
+        this._enableJsonp = isEnabled;
+    }
+    get notifyUsingSourceIndexes() {
+        return true;
+    }
+    get isItemIndexLookupSupported() {
+        return false;
+    }
+    get isKeyIndexLookupSupported() {
+        return false;
+    }
+    notifySetItem(index, oldItem, newItem) {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifySetItem(index, oldItem, newItem);
+        }
+    }
+    notifyClearItems() {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifyClearItems();
+        }
+    }
+    notifyInsertItem(index, newItem) {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifyInsertItem(index, newItem);
+        }
+    }
+    notifyRemoveItem(index, oldItem) {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifyRemoveItem(index, oldItem);
+        }
+    }
+    queueSchemaFetch() {
+        if (this._schemaFetchQueued) {
+            return;
+        }
+        if (this.executionContext != null) {
+            this._schemaFetchQueued = true;
+            this.executionContext.enqueueAction(runOn(this, this.doSchemaFetchInternal));
+        }
+    }
+    doSchemaFetchInternal() {
+        if (!this._schemaFetchQueued) {
+            return;
+        }
+        this._schemaFetchQueued = false;
+        this.schemaFetchInternal();
+    }
+    schemaFetchInternal() {
+        this.schemaFetchInternalOverride();
+    }
+    schemaFetchInternalOverride() {
+        if (!this.deferAutoRefresh) {
+            return;
+        }
+        this.removeAllPageRequests();
+        this.killWorker();
+        this.createWorker();
+        this.addSchemaRequest();
+    }
+    addSchemaRequest() {
+        this._worker.addPageRequest(ODataVirtualDataSourceDataProviderWorker.schemaRequestIndex, DataSourcePageRequestPriority.High);
+    }
+    queueAutoRefresh() {
+        if (this.deferAutoRefresh) {
+            return;
+        }
+        if (this._autoRefreshQueued) {
+            return;
+        }
+        if (this.executionContext != null) {
+            this._autoRefreshQueued = true;
+            this.executionContext.enqueueAction(runOn(this, this.doRefreshInternal));
+        }
+    }
+    doRefreshInternal() {
+        if (this.deferAutoRefresh) {
+            this._autoRefreshQueued = false;
+            return;
+        }
+        if (!this._autoRefreshQueued) {
+            return;
+        }
+        this._autoRefreshQueued = false;
+        this.refreshInternal();
+    }
+    refreshInternal() {
+        this.refreshInternalOverride();
+    }
+    refreshInternalOverride() {
+        this.removeAllPageRequests();
+        this.killWorker();
+        this.createWorker();
+        this._worker.addPageRequest(0, DataSourcePageRequestPriority.Normal);
+    }
+    flushAutoRefresh() {
+        this.doRefreshInternal();
+    }
+    refresh() {
+        this.refreshInternal();
+    }
+    indexOfItem(item) {
+        return -1;
+    }
+    indexOfKey(key) {
+        return -1;
+    }
+    resolveSchemaPropertyType(propertyPath) {
+        if (this.actualSchema == null) {
+            return DataSourceSchemaPropertyType.ObjectValue;
+        }
+        if (stringContains(propertyPath, ".")) {
+            return DataSourceSchemaPropertyType.ObjectValue;
+        }
+        for (let i = 0; i < this.actualSchema.propertyNames.length; i++) {
+            let name = this.actualSchema.propertyNames[i];
+            if (name == propertyPath) {
+                return this.actualSchema.propertyTypes[i];
+            }
+        }
+        return DataSourceSchemaPropertyType.ObjectValue;
+    }
+    createBatchRequest(changes) {
+        if (this._worker) {
+            this._worker.createBatchRequest(changes);
+        }
+    }
+    get batchCompleted() {
+        return this._batchCompleted;
+    }
+    set batchCompleted(value) {
+        this._batchCompleted = value;
+    }
+}
+
+class ODataVirtualDataSource extends VirtualDataSource {
+    constructor() {
+        super();
+        this._baseUri = null;
+        this._entitySet = null;
+        this._timeoutMilliseconds = 10000;
+        this._isAggregationSupportedByServer = false;
+        this._enableJsonp = true;
+        this.dataProvider = ((() => {
+            let $ret = new ODataVirtualDataSourceDataProvider();
+            $ret.executionContext = this.executionContext;
+            $ret.enableJsonp = this.enableJsonp;
+            $ret.isAggregationSupported = this.isGroupingSupported;
+            return $ret;
+        })());
+        this.externalDataSource = this;
+    }
+    onBaseUriChanged(oldValue, newValue) {
+        if (typeCast(ODataVirtualDataSourceDataProvider.$type, this.actualDataProvider) !== null) {
+            this.actualDataProvider.baseUri = this.baseUri;
+        }
+        this.queueAutoRefresh();
+    }
+    get baseUri() {
+        return this._baseUri;
+    }
+    set baseUri(value) {
+        let oldValue = this._baseUri;
+        this._baseUri = value;
+        if (oldValue != this._baseUri) {
+            this.onBaseUriChanged(oldValue, this._baseUri);
+        }
+    }
+    onEntitySetChanged(oldValue, newValue) {
+        if (typeCast(ODataVirtualDataSourceDataProvider.$type, this.actualDataProvider) !== null) {
+            this.actualDataProvider.entitySet = this.entitySet;
+        }
+        this.queueAutoRefresh();
+    }
+    get entitySet() {
+        return this._entitySet;
+    }
+    set entitySet(value) {
+        let oldValue = this._entitySet;
+        this._entitySet = value;
+        if (this._entitySet != oldValue) {
+            this.onEntitySetChanged(oldValue, this._entitySet);
+        }
+    }
+    onTimeoutMillisecondsChanged(oldValue, newValue) {
+        if (typeCast(ODataVirtualDataSourceDataProvider.$type, this.actualDataProvider) !== null) {
+            this.actualDataProvider.timeoutMilliseconds = this.timeoutMilliseconds;
+        }
+    }
+    get timeoutMilliseconds() {
+        return this._timeoutMilliseconds;
+    }
+    set timeoutMilliseconds(value) {
+        let oldValue = this._timeoutMilliseconds;
+        this._timeoutMilliseconds = value;
+        if (oldValue != this._timeoutMilliseconds) {
+            this.onTimeoutMillisecondsChanged(oldValue, this._timeoutMilliseconds);
+        }
+    }
+    get isSortingSupportedOverride() {
+        return true;
+    }
+    get isFilteringSupportedOverride() {
+        return true;
+    }
+    get isGroupingSupportedOverride() {
+        return this.isAggregationSupportedByServer;
+    }
+    get isAggregationSupportedByServer() {
+        return this._isAggregationSupportedByServer;
+    }
+    set isAggregationSupportedByServer(isSupported) {
+        this._isAggregationSupportedByServer = isSupported;
+        if (typeCast(ODataVirtualDataSourceDataProvider.$type, this.actualDataProvider) !== null) {
+            this.actualDataProvider.isAggregationSupported = isSupported;
+        }
+    }
+    get enableJsonp() {
+        return this._enableJsonp;
+    }
+    set enableJsonp(isEnabled) {
+        this._enableJsonp = isEnabled;
+        if (typeCast(ODataVirtualDataSourceDataProvider.$type, this.actualDataProvider) !== null) {
+            this.actualDataProvider.enableJsonp = isEnabled;
+        }
+    }
+    clone() {
+        let dataSource = new ODataVirtualDataSource();
+        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;
+        return dataSource;
+    }
+}
+
+class RestVirtualDataSourceProviderTaskDataHolder extends AsyncVirtualDataSourceProviderTaskDataHolder {
+    static { this.$t = markType(RestVirtualDataSourceProviderTaskDataHolder, 'ODataVirtualDataSourceProviderTaskDataHolder', AsyncVirtualDataSourceProviderTaskDataHolder.$type); }
+}
+
+class RestVirtualDataSourcePage {
+    constructor(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 {
+            let count = (sourceData_.items.length);
+            this._actualData = [];
+            let dateProps = new Set();
+            for (let i = 0; i < schema.propertyNames.length; i++) {
+                if (schema.propertyTypes[i] == DataSourceSchemaPropertyType.DateTimeValue || schema.propertyTypes[i] == DataSourceSchemaPropertyType.DateTimeOffsetValue) {
+                    dateProps.add(schema.propertyNames[i]);
+                }
+            }
+            let value_;
+            for (let i_ = 0; i_ < count; i_++) {
+                let currItem_ = sourceData_.items[i_];
+                let dict = new Map();
+                let properties = Array.from(Object.keys(currItem_));
+                let values = (properties.map((k) => currItem_[k]));
+                for (let i1 = 0; i1 < properties.length; i1++) {
+                    value_ = values[i1];
+                    if (dateProps.has(properties[i1])) {
+                        value_ = new Date(value_);
+                    }
+                    dict.set(properties[i1], value_);
+                }
+                this._actualData[i_] = dict;
+            }
+        }
+        this._schema = schema;
+        this._groupInformation = groupInformation;
+        this._summaryInformation = summaryInformation;
+        this._pageIndex = pageIndex;
+    }
+    count() {
+        return this._actualData.length;
+    }
+    getItemAtIndex(index) {
+        return this._actualData[index];
+    }
+    getItemValueAtIndex(index, valueName) {
+        let item = this._actualData[index];
+        if (!item.has(valueName)) {
+            return null;
+        }
+        return item.get(valueName);
+    }
+    pageIndex() {
+        return this._pageIndex;
+    }
+    schema() {
+        return this._schema;
+    }
+    getGroupInformation() {
+        return this._groupInformation;
+    }
+    getSummaryInformation() {
+        return this._summaryInformation;
+    }
+}
+
+class RestVirtualDataSourceDataProviderWorker extends AsyncVirtualDataSourceProviderWorker {
+    get sortDescriptions() {
+        return this._sortDescriptions;
+    }
+    get filterExpressions() {
+        return this._filterExpressions;
+    }
+    get desiredProperties() {
+        return this._desiredPropeties;
+    }
+    initialize() {
+        super.initialize();
+    }
+    getTaskDataHolder() {
+        let holder = new RestVirtualDataSourceProviderTaskDataHolder();
+        return holder;
+    }
+    getCompletedTaskData(holder, completed) {
+        super.getCompletedTaskData(holder, completed);
+    }
+    removeCompletedTaskData(holder, completed) {
+        super.removeCompletedTaskData(holder, completed);
+    }
+    getTasksData(holder) {
+        super.getTasksData(holder);
+    }
+    *iter(coll) {
+        for (let i = 0; i < coll.size(); i++) {
+            yield coll.get(i);
+        }
+    }
+    *iterFilter(coll) {
+        for (let i = 0; i < coll.size(); i++) {
+            yield coll.get(i);
+        }
+    }
+    *iterSummaries(summaries) {
+        for (let i = 0; i < summaries.size(); i++) {
+            yield summaries.get(i);
+        }
+    }
+    constructor(settings) {
+        super(settings);
+        this._baseUri = null;
+        this._entitySet = null;
+        this._sortDescriptions = null;
+        this._groupDescriptions = null;
+        this._filterExpressions = null;
+        this._summaryDescriptions = null;
+        this._desiredPropeties = null;
+        this._schemaIncludedProperties = 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();
+            for (let sd of this.iter(settings.sortDescriptions)) {
+                this._sortDescriptions.add(sd);
+            }
+            for (let i = 0; i < this._groupDescriptions.size(); i++) {
+                this._sortDescriptions.insert(i, this._groupDescriptions.get(i));
+            }
+        }
+        this._filterExpressions = settings.filterExpressions;
+        this._desiredPropeties = settings.propertiesRequested;
+        if (settings.schemaIncludedProperties != null) {
+            this._schemaIncludedProperties = new Set();
+            for (let i = 0; i < settings.schemaIncludedProperties.length; i++) {
+                this._schemaIncludedProperties.add(settings.schemaIncludedProperties[i]);
+            }
+        }
+        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 = (res) => {
+                return res ? res.items : null;
+            };
+        }
+        if (!this._provideFullCount) {
+            this._provideFullCount = (p) => {
+                if (p.fullCount) {
+                    return p.fullCount;
+                }
+                else {
+                    return this._fixedFullCount >= 0 ? this._fixedFullCount : 0;
+                }
+            };
+        }
+        if (!this._provideOrderByParameter) {
+            this._provideOrderByParameter = (args, orderByString, orderBy) => {
+                args.push({ name: "orderBy", value: encodeURIComponent(orderByString) });
+            };
+        }
+        if (!this._providePagingParameter) {
+            this._providePagingParameter = (args, skip, take) => {
+                args.push({ name: "skip", value: skip });
+                args.push({ name: "take", value: take });
+            };
+        }
+        if (!this._provideAggregationParameter) {
+            this._provideAggregationParameter = (args, fetchCountOnly, groupByString, groupBy, summaryString, summary) => {
+                args.push({ name: "groupBy", value: groupByString });
+                args.push({ name: "aggregate", value: "count" });
+            };
+        }
+        if (!this._provideUri) {
+            this._provideUri = (baseUri, entitySet, args) => {
+                let requestUri = baseUri;
+                requestUri += "/" + entitySet;
+                if (args.length > 0) {
+                    requestUri += "?";
+                }
+                let 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);
+    }
+    processCompletedTask(completedTask, currentDelay, pageIndex, taskDataHolder) {
+        let h = taskDataHolder;
+        let schema = null;
+        let result = null;
+        let schemaFetchCount = -1;
+        let 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) {
+            let requests = 0;
+            this.resolveSchema((s) => {
+                // resolveSchema success callback
+                this.actualSchema = s;
+                if (this._isAggregationSupported && (this._groupDescriptions.size() !== 0 || this._summaryDescriptions.size() !== 0)) {
+                    if (this._groupDescriptions.size() > 0) {
+                        requests++;
+                        this.resolveGroupInformation((g) => {
+                            // group info success
+                            requests--;
+                            if (requests === 0) {
+                                this.finishProcessingCompletedTask(task, pageIndex, s, result);
+                            }
+                        }, () => {
+                            // group info failure
+                            this.retryIndex(pageIndex, currentDelay);
+                            return;
+                        });
+                    }
+                    if (this._summaryDescriptions.size() > 0) {
+                        requests++;
+                        this.resolveSummaryInformation((g) => {
+                            // summary info success
+                            requests--;
+                            if (requests === 0) {
+                                this.finishProcessingCompletedTask(task, pageIndex, s, result);
+                            }
+                        }, () => {
+                            // summary info failure
+                            this.retryIndex(pageIndex, currentDelay);
+                            return;
+                        });
+                    }
+                }
+                else {
+                    this.finishProcessingCompletedTask(task, pageIndex, s, result);
+                }
+            }, () => {
+                // resolveSchema failure callback
+                this.retryIndex(pageIndex, currentDelay);
+                return;
+            });
+            return;
+        }
+        this.finishProcessingCompletedTask(task, pageIndex, schema, result);
+    }
+    finishProcessingCompletedTask(task, pageIndex, schema, result) {
+        let executionContext;
+        let pageLoaded;
+        let groupInformation;
+        let summaryInformation;
+        this.actualSchema = schema;
+        executionContext = this.executionContext;
+        groupInformation = this._groupInformation;
+        summaryInformation = this._summaryInformation;
+        pageLoaded = this.pageLoaded;
+        let 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(() => pageLoaded(page, this.actualCount, this.actualPageSize));
+            }
+            else {
+                if (pageLoaded == null) {
+                    this.shutdown();
+                    return;
+                }
+                pageLoaded(page, this.actualCount, this.actualPageSize);
+            }
+        }
+    }
+    resolveGroupInformation(finishAction, failureAction) {
+        if (this._groupInformation != null) {
+            finishAction(this._groupInformation);
+            return;
+        }
+        let orderBy = "";
+        let groupBy = "";
+        let filter = null;
+        let 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) {
+            let first1 = true;
+            for (let group of this.iter(this._groupDescriptions)) {
+                if (first1) {
+                    first1 = false;
+                }
+                else {
+                    orderBy += ", ";
+                    groupBy += ", ";
+                }
+                groupBy += group.propertyName;
+                if (group.direction === ListSortDirection.Descending) {
+                    orderBy += group.propertyName + " desc";
+                }
+                else {
+                    orderBy += group.propertyName + " asc";
+                }
+            }
+        }
+        if (this._summaryScope === DataSourceSummaryScope.Both || this._summaryScope === DataSourceSummaryScope.Groups) {
+            let summaryParameters = this.getSummaryQueryParameters(true);
+            if (!stringIsNullOrEmpty(summaryParameters)) {
+                summary = ", " + summaryParameters;
+            }
+        }
+        let 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 {
+            let groupInformation = [];
+            let success_ = (data, response) => this.groupSuccess(data, response, finishAction, failureAction, groupInformation);
+            let failure_ = (err) => this.groupError(err, finishAction, failureAction, groupInformation);
+            let 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_ = () => {
+                this.fetchUri(request, success_, failure_);
+            };
+            run_();
+        }
+        catch (e) {
+            failureAction();
+        }
+    }
+    fetchUri(request, success, failure) {
+        if (this._performFetch) {
+            this._performFetch(request, success, failure);
+        }
+        else {
+            fetch(request.requestUri, {
+                method: request.method,
+                headers: request.headers,
+            }).then((res) => {
+                res.json().then((j) => {
+                    success(j, res);
+                });
+            }).catch((e) => {
+                failure(e);
+            });
+        }
+    }
+    groupError(err, finishAction, failureAction, groupInformation) {
+        this._groupInformation = null;
+    }
+    groupSuccess(data, response, finishAction, failureAction, groupInformation) {
+        let groupNames = [];
+        for (let group of this.iter(this._groupDescriptions)) {
+            groupNames.push(group.propertyName);
+        }
+        let groupNamesArray = groupNames;
+        let items = this._provideItems(data);
+        if (items && items.length > 0) {
+            let currentIndex = 0;
+            for (let i = 0; i < items.length; i++) {
+                this.addGroup(groupInformation, groupNames, groupNames, currentIndex, items[i]);
+            }
+        }
+        this._groupInformation = groupInformation;
+        finishAction(this._groupInformation);
+    }
+    addGroup(groupInformation, groupNames, groupNamesArray, currentIndex, group) {
+        let groupValues = [];
+        for (let name of groupNames) {
+            if (group[name]) {
+                groupValues.push(group[name]);
+            }
+        }
+        let groupCount = 0;
+        //todo: make this customizable
+        if (this._provideAggregatedCount) {
+            let ct = this._provideAggregatedCount(group);
+        }
+        else {
+            if (group["aggregatedCount"]) {
+                groupCount = Convert.toInt321(group["aggregatedCount"]);
+            }
+        }
+        let summaryResults = null;
+        if (this._summaryScope == DataSourceSummaryScope.Both || this._summaryScope == DataSourceSummaryScope.Groups) {
+            summaryResults = this.createSummaryResults(group);
+        }
+        let groupInfo = new DefaultSectionInformation(currentIndex, currentIndex + (groupCount - 1), groupNamesArray, groupValues, summaryResults);
+        groupInformation.push(groupInfo);
+    }
+    resolveSummaryInformation(finishAction, failureAction) {
+        if (this._summaryInformation != null) {
+            finishAction(this._summaryInformation);
+            return;
+        }
+        let filter = null;
+        let 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);
+        let 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 {
+            let summaryInformation = [];
+            let success_ = (data, response) => this.summarySuccess(data, response, finishAction, failureAction, summaryInformation);
+            let failure_ = (err) => this.summaryError(err, finishAction, failureAction, summaryInformation);
+            let 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_ = () => {
+                this.fetchUri(request, success_, failure_);
+            };
+            run_();
+        }
+        catch (e) {
+            failureAction();
+        }
+    }
+    summarySuccess(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);
+    }
+    summaryError(err, finishAction, failureAction, summaryInformation) {
+        this._summaryInformation = null;
+    }
+    getSummaryQueryParameters(ignoreCount) {
+        let result = "";
+        if (this._summaryDescriptions != null) {
+            let first = true;
+            let countExists = false;
+            for (let summary of this.iterSummaries(this._summaryDescriptions)) {
+                if (summary.operand == DataSourceSummaryOperand.Count && (ignoreCount || countExists)) {
+                    continue;
+                }
+                if (!first) {
+                    result += ", ";
+                }
+                switch (summary.operand) {
+                    case DataSourceSummaryOperand.Average:
+                        result += summary.propertyName + " with average as " + summary.propertyName + "Average";
+                        break;
+                    case DataSourceSummaryOperand.Min:
+                        result += summary.propertyName + " with min as " + summary.propertyName + "Min";
+                        break;
+                    case DataSourceSummaryOperand.Max:
+                        result += summary.propertyName + " with max as " + summary.propertyName + "Max";
+                        break;
+                    case DataSourceSummaryOperand.Sum:
+                        result += summary.propertyName + " with sum as " + summary.propertyName + "Sum";
+                        break;
+                    case DataSourceSummaryOperand.Count:
+                        result += "$count as $__count";
+                        countExists = true;
+                        break;
+                }
+                first = false;
+            }
+        }
+        return result;
+    }
+    createSummaryResults(data) {
+        let summaryResults = [];
+        for (let summary of this.iterSummaries(this._summaryDescriptions)) {
+            let summaryName = summary.propertyName;
+            switch (summary.operand) {
+                case DataSourceSummaryOperand.Average:
+                    summaryName += "Average";
+                    break;
+                case DataSourceSummaryOperand.Min:
+                    summaryName += "Min";
+                    break;
+                case DataSourceSummaryOperand.Max:
+                    summaryName += "Max";
+                    break;
+                case DataSourceSummaryOperand.Sum:
+                    summaryName += "Sum";
+                    break;
+                case DataSourceSummaryOperand.Count:
+                    summaryName = "$__count";
+                    break;
+            }
+            let summaryValue = null;
+            if (data && data[summaryName]) {
+                summaryValue = data[summaryName];
+            }
+            let summaryResult = new DefaultSummaryResult(summary.propertyName, summary.operand, summaryValue);
+            summaryResults.push(summaryResult);
+        }
+        return summaryResults;
+    }
+    resolveSchemaFromItems(items) {
+        let lds = new LocalDataSource();
+        lds.dataSource = items;
+        lds.flushAutoRefresh();
+        return lds.actualSchema;
+    }
+    resolveSchema(finishAction, failureAction) {
+        if (!this._provideItems || !this._providePagingParameter) {
+            failureAction("required providers for items and paging are not specified");
+            return;
+        }
+        let success_ = (res) => {
+            let items = this._provideItems(res);
+            if (items && items.length > 0) {
+                let schema = this.resolveSchemaFromItems(items);
+                if (this._schemaIncludedProperties != null) {
+                    let propertyNames = [];
+                    let propertyTypes = [];
+                    for (let i = 0; i < schema.propertyNames.length; i++) {
+                        if (!this._schemaIncludedProperties.has(schema.propertyNames[i])) {
+                            continue;
+                        }
+                        propertyNames.push(schema.propertyNames[i]);
+                        propertyTypes.push(schema.propertyTypes[i]);
+                    }
+                    schema = new DefaultDataSourceSchema(propertyNames, propertyTypes, schema.primaryKey, schema.propertyDataIntents, schema.subSchemas);
+                }
+                finishAction(schema);
+            }
+            else {
+                failureAction("could not find items to resolve schema");
+            }
+        };
+        let failure_ = (e) => failureAction(e);
+        let args = [];
+        if (this._providePagingParameter) {
+            this._providePagingParameter(args, 0, this.actualPageSize);
+        }
+        let uri = this._provideUri(this._baseUri, this._entitySet, args);
+        try {
+            let 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_ = () => {
+                this.fetchUri(request, success_, failure_);
+            };
+            run_();
+        }
+        catch (e) {
+            failureAction(e);
+        }
+    }
+    static { this.schemaRequestIndex = -1; }
+    makeTaskForRequest(request, retryDelay) {
+        let args = [];
+        // if (this._provideAggregationParameter) {
+        //     args.push({ name: "apply", value: this._provideAggregationParameter(true, groupBy, this._groupDescriptions, summary, this._summaryDescriptions) });
+        // }
+        let actualPageSize = 0;
+        let sortDescriptions = null;
+        actualPageSize = this.actualPageSize;
+        sortDescriptions = this.sortDescriptions;
+        //let requestUrl: string = this._baseUri;
+        //requestUrl += "/" + this._entitySet;
+        let queryStarted = false;
+        this.updateFilterString();
+        if (this._filterString != null) {
+            if (this._provideFilterParameter) {
+                this._provideFilterParameter(args, this._filterString, this._filterExpressions);
+            }
+        }
+        if (this.sortDescriptions != null) {
+            let sortString = null;
+            for (let sort of this.iter(this.sortDescriptions)) {
+                if (sortString == null) {
+                    sortString = "";
+                }
+                else {
+                    sortString += ", ";
+                }
+                if (sort.direction == ListSortDirection.Descending) {
+                    sortString += sort.propertyName + " desc";
+                }
+                else {
+                    sortString += sort.propertyName;
+                }
+            }
+            if (sortString != null) {
+                if (this._provideOrderByParameter) {
+                    this._provideOrderByParameter(args, sortString, this._sortDescriptions);
+                }
+            }
+        }
+        if (this.desiredProperties != null && this.desiredProperties.length > 0) {
+            let selectString = "";
+            let first = true;
+            let $t = this.desiredProperties;
+            for (let i = 0; i < $t.length; i++) {
+                let 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);
+            }
+        }
+        let task = new AsyncVirtualDataTask();
+        let 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);
+    }
+    updateFilterString() {
+        if (this.filterExpressions != null && this.filterExpressions.size() > 0 && this._filterString == null) {
+            let sb = "";
+            let first = true;
+            for (let expr of this.iterFilter(this.filterExpressions)) {
+                if (first) {
+                    first = false;
+                }
+                else {
+                    sb += " AND ";
+                }
+                let visitor = new ODataDataSourceFilterExpressionVisitor(0);
+                visitor.visit(expr);
+                let txt = visitor.toString();
+                if (this.filterExpressions.size() > 1) {
+                    txt = "(" + txt + ")";
+                }
+                sb += (txt);
+            }
+            this._filterString = sb;
+        }
+    }
+    executeRequest(requestUrl, queryStarted, skip, top, task) {
+        // if (!queryStarted) {
+        // 	queryStarted = true;
+        // 	requestUrl += "?";
+        // } else {
+        // 	requestUrl += "&";
+        // }
+        // requestUrl += "$skip=" + skip + "&$top=" + top + "&$count=true";
+        let requestUrl_ = requestUrl;
+        let self_ = this;
+        let success_ = (data, response) => this.success(task, data, response);
+        let failure_ = (err) => this.error(task, err);
+        let 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_ = () => {
+            this.fetchUri(request, success_, failure_);
+        };
+        task.run = run_;
+    }
+    success(t, data, response) {
+        t.result = data;
+        t.isCompleted = true;
+    }
+    error(t, result) {
+        t.isCompleted = true;
+        t.hasErrors = true;
+    }
+    createBatchRequest(changes) {
+        //TODO: updates
+    }
+    getRequestUriWithKey(key) {
+        let result = "";
+        const keys = Object.keys(key);
+        for (let i = 0; i < keys.length; i++) {
+            if (i > 0) {
+                result += ",";
+            }
+            result += `${keys[i]}=${key[keys[i]]}`;
+        }
+        return `${this._entitySet}(${result})`;
+    }
+}
+
+class RestVirtualDataSourceDataProviderWorkerSettings extends AsyncVirtualDataSourceDataProviderWorkerSettings {
+    constructor() {
+        super(...arguments);
+        this._baseUri = null;
+        this._entitySet = null;
+        this._sortDescriptions = null;
+        this._filterExpressions = null;
+        this._propertiesRequested = null;
+        this._schemaIncludedProperties = 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;
+    }
+    static { this.$t = markType(RestVirtualDataSourceDataProviderWorkerSettings, 'RestVirtualDataSourceDataProviderWorkerSettings', AsyncVirtualDataSourceDataProviderWorkerSettings.$type); }
+    get baseUri() {
+        return this._baseUri;
+    }
+    set baseUri(value) {
+        this._baseUri = value;
+    }
+    get entitySet() {
+        return this._entitySet;
+    }
+    set entitySet(value) {
+        this._entitySet = value;
+    }
+    get sortDescriptions() {
+        return this._sortDescriptions;
+    }
+    set sortDescriptions(value) {
+        this._sortDescriptions = value;
+    }
+    get filterExpressions() {
+        return this._filterExpressions;
+    }
+    set filterExpressions(value) {
+        this._filterExpressions = value;
+    }
+    get propertiesRequested() {
+        return this._propertiesRequested;
+    }
+    set propertiesRequested(value) {
+        this._propertiesRequested = value;
+    }
+    get schemaIncludedProperties() {
+        return this._schemaIncludedProperties;
+    }
+    set schemaIncludedProperties(value) {
+        this._schemaIncludedProperties = value;
+    }
+    get groupDescriptions() {
+        return this._groupDescriptions;
+    }
+    set groupDescriptions(value) {
+        this._groupDescriptions = value;
+    }
+    get summaryDescriptions() {
+        return this._summaryDescriptions;
+    }
+    set summaryDescriptions(value) {
+        this._summaryDescriptions = value;
+    }
+    get summaryScope() {
+        return this._summaryscope;
+    }
+    set summaryScope(value) {
+        this._summaryscope = value;
+    }
+    get enableJsonp() {
+        return this._enableJsonp;
+    }
+    set enableJsonp(isEnabled) {
+        this._enableJsonp = isEnabled;
+    }
+    get isAggregationSupported() {
+        return this._isAggregationSupported;
+    }
+    set isAggregationSupported(isSupported) {
+        this._isAggregationSupported = isSupported;
+    }
+    get fixedFullCount() {
+        return this._fixedFullCount;
+    }
+    set fixedFullCount(value) {
+        this._fixedFullCount = value;
+    }
+    get provideFullCount() {
+        return this._provideFullCount;
+    }
+    set provideFullCount(value) {
+        this._provideFullCount = value;
+    }
+    get provideOrderByParameter() {
+        return this._provideOrderByParameter;
+    }
+    set provideOrderByParameter(value) {
+        this._provideOrderByParameter = value;
+    }
+    get provideFilterParameter() {
+        return this._provideFilterParameter;
+    }
+    set provideFilterParameter(value) {
+        this._provideFilterParameter = value;
+    }
+    get provideAggregationParameter() {
+        return this._provideAggregationParameter;
+    }
+    set provideAggregationParameter(value) {
+        this._provideAggregationParameter = value;
+    }
+    get provideAggregatedCount() {
+        return this._provideAggregatedCount;
+    }
+    set provideAggregatedCount(value) {
+        this._provideAggregatedCount = value;
+    }
+    get provideUri() {
+        return this._provideUri;
+    }
+    set provideUri(value) {
+        this._provideUri = value;
+    }
+    get providePagingParameter() {
+        return this._providePagingParameter;
+    }
+    set providePagingParameter(value) {
+        this._providePagingParameter = value;
+    }
+    get provideDesiredPropertiesParameter() {
+        return this._provideDesiredPropertiesParameter;
+    }
+    set provideDesiredPropertiesParameter(value) {
+        this._provideDesiredPropertiesParameter = value;
+    }
+    get provideItems() {
+        return this._provideItems;
+    }
+    set provideItems(value) {
+        this._provideItems = value;
+    }
+    get performFetch() {
+        return this._performFetch;
+    }
+    set performFetch(value) {
+        this._performFetch = value;
+    }
+}
+
+class RestVirtualDataSourceDataProvider extends Base {
+    static { this.$t = markType(RestVirtualDataSourceDataProvider, 'ODataVirtualDataSourceDataProvider', Base.$type, [IDataSourceVirtualDataProvider_$type]); }
+    constructor() {
+        super();
+        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._schemaIncludedProperties = 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 = () => this.sortDescriptions_CollectionChanged(null, null);
+        this._groupDescriptions = new SortDescriptionCollection();
+        this._groupDescriptions.onChanged = () => this.groupDescriptions_CollectionChanged(null, null);
+        this._filterExpressions = new FilterExpressionCollection();
+        this._filterExpressions.onChanged = () => this.filterExpressions_CollectionChanged(null, null);
+        this._summaryDescriptions = new SummaryDescriptionCollection();
+        this._summaryDescriptions.onChanged = () => this.summaryDescriptions_CollectionChanged(null, null);
+    }
+    filterExpressions_CollectionChanged(sender, e) {
+        this.queueAutoRefresh();
+    }
+    sortDescriptions_CollectionChanged(sender, e) {
+        this.queueAutoRefresh();
+    }
+    groupDescriptions_CollectionChanged(sender, e) {
+        this.queueAutoRefresh();
+    }
+    summaryDescriptions_CollectionChanged(sender, e) {
+        this.queueAutoRefresh();
+    }
+    addPageRequest(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);
+        }
+    }
+    createWorker() {
+        if (!this.valid()) {
+            return;
+        }
+        this._callback = runOn(this, this.raisePageLoaded);
+        let settings = this.getWorkerSettings();
+        this._worker = new RestVirtualDataSourceDataProviderWorker(settings);
+    }
+    valid() {
+        return this.entitySet != null && this.baseUri != null;
+    }
+    getWorkerSettings() {
+        return ((() => {
+            let $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.schemaIncludedProperties = this._schemaIncludedProperties;
+            $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;
+        })());
+    }
+    removePageRequest(pageIndex) {
+        let 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);
+    }
+    removeAllPageRequests() {
+        this._requests.clear();
+        if (this._worker == null) {
+            return;
+        }
+        this._worker.removeAllPageRequests();
+    }
+    close() {
+        if (this._worker != null) {
+            this._worker.shutdown();
+            this._worker = null;
+            this._callback = null;
+        }
+    }
+    get pageLoaded() {
+        return this._pageLoaded;
+    }
+    set pageLoaded(value) {
+        this._pageLoaded = value;
+        this.queueAutoRefresh();
+    }
+    raisePageLoaded(page, fullCount, actualPageSize) {
+        if (this._pageLoaded != null) {
+            this._currentFullCount = fullCount;
+            if (this._currentSchema == null) {
+                let 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);
+            }
+        }
+    }
+    killWorker() {
+        if (this._worker != null) {
+            this._worker.shutdown();
+            this._worker = null;
+            this._callback = null;
+        }
+    }
+    get pageSizeRequested() {
+        return this._pageSizeRequested;
+    }
+    set pageSizeRequested(value) {
+        this._pageSizeRequested = value;
+        this.queueAutoRefresh();
+    }
+    get baseUri() {
+        return this._baseUri;
+    }
+    set baseUri(value) {
+        let oldValue = this._baseUri;
+        this._baseUri = value;
+        if (oldValue != this._baseUri) {
+            this.queueAutoRefresh();
+            if (this.valid() && this.deferAutoRefresh) {
+                this.queueSchemaFetch();
+            }
+        }
+    }
+    get entitySet() {
+        return this._entitySet;
+    }
+    set entitySet(value) {
+        let oldValue = this._entitySet;
+        this._entitySet = value;
+        if (oldValue != this._entitySet) {
+            this.queueAutoRefresh();
+            if (this.valid() && this.deferAutoRefresh) {
+                this.queueSchemaFetch();
+            }
+        }
+    }
+    get timeoutMilliseconds() {
+        return this._timeoutMilliseconds;
+    }
+    set timeoutMilliseconds(value) {
+        this._timeoutMilliseconds = value;
+        this.queueAutoRefresh();
+    }
+    getItemValue(item, valueName) {
+        let dic = item;
+        if (dic.has(valueName)) {
+            return dic.get(valueName);
+        }
+        else {
+            return null;
+        }
+    }
+    get actualCount() {
+        return this._currentFullCount;
+    }
+    get actualSchema() {
+        return this._currentSchema;
+    }
+    get executionContext() {
+        return this._executionContext;
+    }
+    set executionContext(value) {
+        this._executionContext = value;
+        this.queueAutoRefresh();
+    }
+    get updateNotifier() {
+        return this._updateNotifier;
+    }
+    set updateNotifier(value) {
+        this._updateNotifier = value;
+    }
+    get deferAutoRefresh() {
+        return this._deferAutoRefresh;
+    }
+    set deferAutoRefresh(value) {
+        this._deferAutoRefresh = value;
+        if (!this._deferAutoRefresh) {
+            this.queueAutoRefresh();
+        }
+        if (this._deferAutoRefresh && this.valid() && this._currentSchema == null) {
+            this.queueSchemaFetch();
+        }
+    }
+    get isSortingSupported() {
+        return true;
+    }
+    get isGroupingSupported() {
+        return this.isAggregationSupported;
+    }
+    get isFilteringSupported() {
+        return true;
+    }
+    get isAggregationSupported() {
+        return this._isAggregationSupported;
+    }
+    set isAggregationSupported(isSupported) {
+        this._isAggregationSupported = isSupported;
+    }
+    get sortDescriptions() {
+        return this._sortDescriptions;
+    }
+    get groupDescriptions() {
+        return this._groupDescriptions;
+    }
+    get propertiesRequested() {
+        return this._propertiesRequested;
+    }
+    set propertiesRequested(value) {
+        this._propertiesRequested = value;
+        this.queueAutoRefresh();
+    }
+    get schemaIncludedProperties() {
+        return this._schemaIncludedProperties;
+    }
+    set schemaIncludedProperties(value) {
+        this._schemaIncludedProperties = value;
+        this.queueAutoRefresh();
+    }
+    get filterExpressions() {
+        return this._filterExpressions;
+    }
+    get summaryDescriptions() {
+        return this._summaryDescriptions;
+    }
+    get summaryScope() {
+        return this._summaryScope;
+    }
+    set summaryScope(value) {
+        this._summaryScope = value;
+    }
+    get enableJsonp() {
+        return this._enableJsonp;
+    }
+    set enableJsonp(isEnabled) {
+        this._enableJsonp = isEnabled;
+    }
+    get fixedFullCount() {
+        return this._fixedFullCount;
+    }
+    set fixedFullCount(value) {
+        this._fixedFullCount = value;
+    }
+    get provideFullCount() {
+        return this._provideFullCount;
+    }
+    set provideFullCount(value) {
+        this._provideFullCount = value;
+    }
+    get provideOrderByParameter() {
+        return this._provideOrderByParameter;
+    }
+    set provideOrderByParameter(value) {
+        this._provideOrderByParameter = value;
+    }
+    get provideFilterParameter() {
+        return this._provideFilterParameter;
+    }
+    set provideFilterParameter(value) {
+        this._provideFilterParameter = value;
+    }
+    get provideAggregationParameter() {
+        return this._provideAggregationParameter;
+    }
+    set provideAggregationParameter(value) {
+        this._provideAggregationParameter = value;
+    }
+    get provideAggregatedCount() {
+        return this._provideAggregatedCount;
+    }
+    set provideAggregatedCount(value) {
+        this._provideAggregatedCount = value;
+    }
+    get provideUri() {
+        return this._provideUri;
+    }
+    set provideUri(value) {
+        this._provideUri = value;
+    }
+    get performFetch() {
+        return this._performFetch;
+    }
+    set performFetch(value) {
+        this._performFetch = value;
+    }
+    get providePagingParameter() {
+        return this._providePagingParameter;
+    }
+    set providePagingParameter(value) {
+        this._providePagingParameter = value;
+    }
+    get provideDesiredPropertiesParameter() {
+        return this._provideDesiredPropertiesParameter;
+    }
+    set provideDesiredPropertiesParameter(value) {
+        this._provideDesiredPropertiesParameter = value;
+    }
+    get provideItems() {
+        return this._provideItems;
+    }
+    set provideItems(value) {
+        this._provideItems = value;
+    }
+    get notifyUsingSourceIndexes() {
+        return true;
+    }
+    get isItemIndexLookupSupported() {
+        return false;
+    }
+    get isKeyIndexLookupSupported() {
+        return false;
+    }
+    notifySetItem(index, oldItem, newItem) {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifySetItem(index, oldItem, newItem);
+        }
+    }
+    notifyClearItems() {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifyClearItems();
+        }
+    }
+    notifyInsertItem(index, newItem) {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifyInsertItem(index, newItem);
+        }
+    }
+    notifyRemoveItem(index, oldItem) {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifyRemoveItem(index, oldItem);
+        }
+    }
+    queueSchemaFetch() {
+        if (this._schemaFetchQueued) {
+            return;
+        }
+        if (this.executionContext != null) {
+            this._schemaFetchQueued = true;
+            this.executionContext.enqueueAction(runOn(this, this.doSchemaFetchInternal));
+        }
+    }
+    doSchemaFetchInternal() {
+        if (!this._schemaFetchQueued) {
+            return;
+        }
+        this._schemaFetchQueued = false;
+        this.schemaFetchInternal();
+    }
+    schemaFetchInternal() {
+        this.schemaFetchInternalOverride();
+    }
+    schemaFetchInternalOverride() {
+        if (!this.deferAutoRefresh) {
+            return;
+        }
+        this.removeAllPageRequests();
+        this.killWorker();
+        this.createWorker();
+        this.addSchemaRequest();
+    }
+    addSchemaRequest() {
+        this._worker.addPageRequest(RestVirtualDataSourceDataProviderWorker.schemaRequestIndex, DataSourcePageRequestPriority.High);
+    }
+    queueAutoRefresh() {
+        if (this.deferAutoRefresh) {
+            return;
+        }
+        if (this._autoRefreshQueued) {
+            return;
+        }
+        if (this.executionContext != null) {
+            this._autoRefreshQueued = true;
+            this.executionContext.enqueueAction(runOn(this, this.doRefreshInternal));
+        }
+    }
+    doRefreshInternal() {
+        if (this.deferAutoRefresh) {
+            this._autoRefreshQueued = false;
+            return;
+        }
+        if (!this._autoRefreshQueued) {
+            return;
+        }
+        this._autoRefreshQueued = false;
+        this.refreshInternal();
+    }
+    refreshInternal() {
+        this.refreshInternalOverride();
+    }
+    refreshInternalOverride() {
+        this.removeAllPageRequests();
+        this.killWorker();
+        this.createWorker();
+        this._worker.addPageRequest(0, DataSourcePageRequestPriority.Normal);
+    }
+    flushAutoRefresh() {
+        this.doRefreshInternal();
+    }
+    refresh() {
+        this.refreshInternal();
+    }
+    indexOfItem(item) {
+        return -1;
+    }
+    indexOfKey(key) {
+        return -1;
+    }
+    resolveSchemaPropertyType(propertyPath) {
+        if (this.actualSchema == null) {
+            return DataSourceSchemaPropertyType.ObjectValue;
+        }
+        if (stringContains(propertyPath, ".")) {
+            return DataSourceSchemaPropertyType.ObjectValue;
+        }
+        for (let i = 0; i < this.actualSchema.propertyNames.length; i++) {
+            let name = this.actualSchema.propertyNames[i];
+            if (name == propertyPath) {
+                return this.actualSchema.propertyTypes[i];
+            }
+        }
+        return DataSourceSchemaPropertyType.ObjectValue;
+    }
+    setItemValue(item, valueName, value) {
+        // does nothing.
+    }
+    removeItem(item) {
+        // does nothing.
+    }
+    addItem(item) {
+        // does nothing.
+    }
+    createBatchRequest(changes) {
+        if (this._worker != null) {
+            this._worker.createBatchRequest(changes);
+        }
+    }
+    get batchCompleted() {
+        return this._batchCompleted;
+    }
+    set batchCompleted(v) {
+        this._batchCompleted = v;
+    }
+}
+
+class RestVirtualDataSource extends VirtualDataSource {
+    constructor() {
+        super();
+        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 = ((() => {
+            let $ret = new RestVirtualDataSourceDataProvider();
+            $ret.executionContext = this.executionContext;
+            $ret.enableJsonp = this.enableJsonp;
+            $ret.isAggregationSupported = this.isGroupingSupported;
+            return $ret;
+        })());
+        this.externalDataSource = this;
+    }
+    onBaseUriChanged(oldValue, newValue) {
+        if (this.actualDataProvider) {
+            this.actualDataProvider.baseUri = this.baseUri;
+            this.queueAutoRefresh();
+        }
+    }
+    get baseUri() {
+        return this._baseUri;
+    }
+    set baseUri(value) {
+        let oldValue = this._baseUri;
+        this._baseUri = value;
+        if (oldValue != this._baseUri) {
+            this.onBaseUriChanged(oldValue, this._baseUri);
+        }
+    }
+    onEntitySetChanged(oldValue, newValue) {
+        if (this.actualDataProvider) {
+            this.actualDataProvider.entitySet = this.entitySet;
+            this.queueAutoRefresh();
+        }
+        this.queueAutoRefresh();
+    }
+    set isFilteringSupportedByServer(v) {
+        this._isFilteringSupportedByServer = v;
+    }
+    get isFilteringSupportedByServer() {
+        return this._isFilteringSupportedByServer;
+    }
+    get_isFilteringSupported() {
+        if (this._isFilteringSupportedByServer) {
+            return true;
+        }
+        return false;
+    }
+    get entitySet() {
+        return this._entitySet;
+    }
+    set entitySet(value) {
+        let oldValue = this._entitySet;
+        this._entitySet = value;
+        if (this._entitySet != oldValue) {
+            this.onEntitySetChanged(oldValue, this._entitySet);
+        }
+    }
+    onTimeoutMillisecondsChanged(oldValue, newValue) {
+        if (this.actualDataProvider) {
+            this.actualDataProvider.timeoutMilliseconds = this.timeoutMilliseconds;
+        }
+    }
+    get timeoutMilliseconds() {
+        return this._timeoutMilliseconds;
+    }
+    set timeoutMilliseconds(value) {
+        let oldValue = this._timeoutMilliseconds;
+        this._timeoutMilliseconds = value;
+        if (oldValue != this._timeoutMilliseconds) {
+            this.onTimeoutMillisecondsChanged(oldValue, this._timeoutMilliseconds);
+        }
+    }
+    get isSortingSupportedOverride() {
+        return true;
+    }
+    get isFilteringSupportedOverride() {
+        return true;
+    }
+    get isGroupingSupportedOverride() {
+        return this.isAggregationSupportedByServer;
+    }
+    get isAggregationSupportedByServer() {
+        return this._isAggregationSupportedByServer;
+    }
+    set isAggregationSupportedByServer(isSupported) {
+        this._isAggregationSupportedByServer = isSupported;
+        if (this.actualDataProvider) {
+            this.actualDataProvider.isAggregationSupported = this.isAggregationSupportedByServer;
+        }
+    }
+    get enableJsonp() {
+        return this._enableJsonp;
+    }
+    set enableJsonp(isEnabled) {
+        this._enableJsonp = isEnabled;
+        if (this.actualDataProvider) {
+            this.actualDataProvider.enableJsonp = this.enableJsonp;
+        }
+    }
+    get fixedFullCount() {
+        return this._fixedFullCount;
+    }
+    set fixedFullCount(value) {
+        this._fixedFullCount = value;
+    }
+    get provideFullCount() {
+        return this._provideFullCount;
+    }
+    set provideFullCount(value) {
+        this._provideFullCount = value;
+        if (this.actualDataProvider) {
+            this.actualDataProvider.provideFullCount = this.provideFullCount;
+            this.queueAutoRefresh();
+        }
+    }
+    get provideOrderByParameter() {
+        return this._provideOrderByParameter;
+    }
+    set provideOrderByParameter(value) {
+        this._provideOrderByParameter = value;
+        if (this.actualDataProvider) {
+            this.actualDataProvider.provideOrderByParameter = this.provideOrderByParameter;
+            this.queueAutoRefresh();
+        }
+    }
+    get provideFilterParameter() {
+        return this._provideFilterParameter;
+    }
+    set provideFilterParameter(value) {
+        this._provideFilterParameter = value;
+        if (this.actualDataProvider) {
+            this.actualDataProvider.provideFilterParameter = this.provideFilterParameter;
+            this.queueAutoRefresh();
+        }
+    }
+    get provideAggregationParameter() {
+        return this._provideAggregationParameter;
+    }
+    set provideAggregationParameter(value) {
+        this._provideAggregationParameter = value;
+        if (this.actualDataProvider) {
+            this.actualDataProvider.provideAggregationParameter = this.provideAggregationParameter;
+            this.queueAutoRefresh();
+        }
+    }
+    get provideAggregatedCount() {
+        return this._provideAggregatedCount;
+    }
+    set provideAggregatedCount(value) {
+        this._provideAggregatedCount = value;
+        if (this.actualDataProvider) {
+            this.actualDataProvider.provideAggregatedCount = this.provideAggregatedCount;
+            this.queueAutoRefresh();
+        }
+    }
+    get provideUri() {
+        return this._provideUri;
+    }
+    set provideUri(value) {
+        this._provideUri = value;
+        if (this.actualDataProvider) {
+            this.actualDataProvider.provideUri = this.provideUri;
+            this.queueAutoRefresh();
+        }
+    }
+    get performFetch() {
+        return this._performFetch;
+    }
+    set performFetch(value) {
+        this._performFetch = value;
+        if (this.actualDataProvider) {
+            this.actualDataProvider.performFetch = this.performFetch;
+            this.queueAutoRefresh();
+        }
+    }
+    get providePagingParameter() {
+        return this._providePagingParameter;
+    }
+    set providePagingParameter(value) {
+        this._providePagingParameter = value;
+        if (this.actualDataProvider) {
+            this.actualDataProvider.providePagingParameter = this.providePagingParameter;
+            this.queueAutoRefresh();
+        }
+    }
+    get provideDesiredPropertiesParameter() {
+        return this._provideDesiredPropertiesParameter;
+    }
+    set provideDesiredPropertiesParameter(value) {
+        this._provideDesiredPropertiesParameter = value;
+        if (this.actualDataProvider) {
+            this.actualDataProvider.provideDesiredPropertiesParameter = this.provideDesiredPropertiesParameter;
+            this.queueAutoRefresh();
+        }
+    }
+    get provideItems() {
+        return this._provideItems;
+    }
+    set provideItems(value) {
+        this._provideItems = value;
+        if (this.actualDataProvider) {
+            this.actualDataProvider.provideItems = this.provideItems;
+            this.queueAutoRefresh();
+        }
+    }
+    clone() {
+        let 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;
+    }
+}
+
+export { Entity, EntityProperty, EntitySet, LinkedList, LinkedListNode, ODataDataSourcePage, ODataSchemaProvider, ODataVirtualDataSource, ODataVirtualDataSourceDataProvider, ODataVirtualDataSourceDataProviderWorker, ODataVirtualDataSourceDataProviderWorkerSettings, ODataVirtualDataSourceProviderTaskDataHolder, RestVirtualDataSource, RestVirtualDataSourceDataProvider, RestVirtualDataSourceDataProviderWorker, RestVirtualDataSourceDataProviderWorkerSettings, RestVirtualDataSourcePage, RestVirtualDataSourceProviderTaskDataHolder, Schema, first, toArray };