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

package/esm2022/lib/ODataVirtualDataSourceDataProviderWorkerSettings.d.ts

@@ -0,0 +1,42 @@
+import { AsyncVirtualDataSourceDataProviderWorkerSettings } from "igniteui-webcomponents-core";
+import { SortDescriptionCollection } from "igniteui-webcomponents-core";
+import { FilterExpressionCollection } from "igniteui-webcomponents-core";
+import { Type } from "igniteui-webcomponents-core";
+import { SummaryDescriptionCollection } from "igniteui-webcomponents-core";
+import { DataSourceSummaryScope } from "igniteui-webcomponents-core";
+export declare class ODataVirtualDataSourceDataProviderWorkerSettings extends AsyncVirtualDataSourceDataProviderWorkerSettings {
+    static $t: Type;
+    private _baseUri;
+    get baseUri(): string;
+    set baseUri(value: string);
+    private _entitySet;
+    get entitySet(): string;
+    set entitySet(value: string);
+    private _sortDescriptions;
+    get sortDescriptions(): SortDescriptionCollection;
+    set sortDescriptions(value: SortDescriptionCollection);
+    private _filterExpressions;
+    get filterExpressions(): FilterExpressionCollection;
+    set filterExpressions(value: FilterExpressionCollection);
+    private _propertiesRequested;
+    get propertiesRequested(): string[];
+    set propertiesRequested(value: string[]);
+    private _schemaIncludedProperties;
+    get schemaIncludedProperties(): string[];
+    set schemaIncludedProperties(value: string[]);
+    private _groupDescriptions;
+    get groupDescriptions(): SortDescriptionCollection;
+    set groupDescriptions(value: SortDescriptionCollection);
+    private _summaryDescriptions;
+    get summaryDescriptions(): SummaryDescriptionCollection;
+    set summaryDescriptions(value: SummaryDescriptionCollection);
+    private _summaryscope;
+    get summaryScope(): DataSourceSummaryScope;
+    set summaryScope(value: DataSourceSummaryScope);
+    private _enableJsonp;
+    get enableJsonp(): boolean;
+    set enableJsonp(isEnabled: boolean);
+    private _isAggregationSupported;
+    get isAggregationSupported(): boolean;
+    set isAggregationSupported(isSupported: boolean);
+}

package/esm2022/lib/ODataVirtualDataSourceDataProviderWorkerSettings.js

@@ -0,0 +1,83 @@
+import { AsyncVirtualDataSourceDataProviderWorkerSettings } from "igniteui-webcomponents-core";
+import { markType } from "igniteui-webcomponents-core";
+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;
+    }
+}
+export { ODataVirtualDataSourceDataProviderWorkerSettings };

package/esm2022/lib/ODataVirtualDataSourceProviderTaskDataHolder.d.ts

@@ -0,0 +1,5 @@
+import { AsyncVirtualDataSourceProviderTaskDataHolder } from "igniteui-webcomponents-core";
+import { Type } from "igniteui-webcomponents-core";
+export declare class ODataVirtualDataSourceProviderTaskDataHolder extends AsyncVirtualDataSourceProviderTaskDataHolder {
+    static $t: Type;
+}

package/esm2022/lib/ODataVirtualDataSourceProviderTaskDataHolder.js

@@ -0,0 +1,6 @@
+import { AsyncVirtualDataSourceProviderTaskDataHolder } from "igniteui-webcomponents-core";
+import { markType } from "igniteui-webcomponents-core";
+class ODataVirtualDataSourceProviderTaskDataHolder extends AsyncVirtualDataSourceProviderTaskDataHolder {
+    static { this.$t = markType(ODataVirtualDataSourceProviderTaskDataHolder, 'ODataVirtualDataSourceProviderTaskDataHolder', AsyncVirtualDataSourceProviderTaskDataHolder.$type); }
+}
+export { ODataVirtualDataSourceProviderTaskDataHolder };

package/esm2022/lib/RestVirtualDataSource.d.ts

@@ -0,0 +1,86 @@
+import { FilterExpressionCollection } from "igniteui-webcomponents-core";
+import { SortDescriptionCollection } from "igniteui-webcomponents-core";
+import { SummaryDescriptionCollection } from "igniteui-webcomponents-core";
+import { VirtualDataSource } from "igniteui-webcomponents-core";
+import { IDataSource } from "igniteui-webcomponents-core";
+import { IExternalDataSource } from "igniteui-webcomponents-core";
+export declare class RestVirtualDataSource extends VirtualDataSource implements IExternalDataSource {
+    constructor();
+    private onBaseUriChanged;
+    private _baseUri;
+    get baseUri(): string;
+    set baseUri(value: string);
+    private onEntitySetChanged;
+    private _isFilteringSupportedByServer;
+    set isFilteringSupportedByServer(v: boolean);
+    get isFilteringSupportedByServer(): boolean;
+    protected get_isFilteringSupported(): boolean;
+    private _entitySet;
+    get entitySet(): string;
+    set entitySet(value: string);
+    private onTimeoutMillisecondsChanged;
+    private _timeoutMilliseconds;
+    get timeoutMilliseconds(): number;
+    set timeoutMilliseconds(value: number);
+    get isSortingSupportedOverride(): boolean;
+    get isFilteringSupportedOverride(): boolean;
+    get isGroupingSupportedOverride(): boolean;
+    private _isAggregationSupportedByServer;
+    get isAggregationSupportedByServer(): boolean;
+    set isAggregationSupportedByServer(isSupported: boolean);
+    private _enableJsonp;
+    get enableJsonp(): boolean;
+    set enableJsonp(isEnabled: boolean);
+    private _fixedFullCount;
+    get fixedFullCount(): number;
+    set fixedFullCount(value: number);
+    private _provideFullCount;
+    get provideFullCount(): (page: any) => number;
+    set provideFullCount(value: (page: any) => number);
+    private _provideOrderByParameter;
+    get provideOrderByParameter(): (args: any[], orderByString: string, orderBy: SortDescriptionCollection) => void;
+    set provideOrderByParameter(value: (args: any[], orderByString: string, orderBy: SortDescriptionCollection) => void);
+    private _provideFilterParameter;
+    get provideFilterParameter(): (args: any[], filterString: string, filterExpressions: FilterExpressionCollection) => void;
+    set provideFilterParameter(value: (args: any[], filterString: string, filterExpressions: FilterExpressionCollection) => void);
+    private _provideAggregationParameter;
+    get provideAggregationParameter(): (args: any[], fetchCountOnly: boolean, groupByString: string, groupBy: SortDescriptionCollection, summaryString: string, summary: SummaryDescriptionCollection) => void;
+    set provideAggregationParameter(value: (args: any[], fetchCountOnly: boolean, groupByString: string, groupBy: SortDescriptionCollection, summaryString: string, summary: SummaryDescriptionCollection) => void);
+    private _provideAggregatedCount;
+    get provideAggregatedCount(): (item: any) => number;
+    set provideAggregatedCount(value: (item: any) => number);
+    private _provideUri;
+    get provideUri(): (baseUri: string, entitySet: string, args: {
+        name: string;
+        value: any;
+    }[]) => string;
+    set provideUri(value: (baseUri: string, entitySet: string, args: {
+        name: string;
+        value: any;
+    }[]) => string);
+    private _performFetch;
+    get performFetch(): (request: {
+        requestUri: string;
+        enableJsonpCallback: boolean;
+        method: 'GET';
+        headers: any;
+        data: null;
+    }, success: (data: any, response: any) => void, failure: (err: any) => void) => void;
+    set performFetch(value: (request: {
+        requestUri: string;
+        enableJsonpCallback: boolean;
+        method: 'GET';
+        headers: any;
+        data: null;
+    }, success: (data: any, response: any) => void, failure: (err: any) => void) => void);
+    private _providePagingParameter;
+    get providePagingParameter(): (args: any[], skip: number, take: number) => void;
+    set providePagingParameter(value: (args: any[], skip: number, take: number) => void);
+    private _provideDesiredPropertiesParameter;
+    get provideDesiredPropertiesParameter(): (args: any[], selectString: string, desiredProperties: string[]) => void;
+    set provideDesiredPropertiesParameter(value: (args: any[], selectString: string, desiredProperties: string[]) => void);
+    private _provideItems;
+    get provideItems(): (result: any) => any[];
+    set provideItems(value: (result: any) => any[]);
+    clone(): IDataSource;
+}

package/esm2022/lib/RestVirtualDataSource.js

@@ -0,0 +1,272 @@
+import { VirtualDataSource } from "igniteui-webcomponents-core";
+import { RestVirtualDataSourceDataProvider } from "./RestVirtualDataSourceDataProvider";
+export 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;
+    }
+}

package/esm2022/lib/RestVirtualDataSourceDataProvider.d.ts

@@ -0,0 +1,171 @@
+import { Base, Type } from "igniteui-webcomponents-core";
+import { IDataSourceVirtualDataProvider } from "igniteui-webcomponents-core";
+import { IDataSourcePage } from "igniteui-webcomponents-core";
+import { IDataSourceSchema } from "igniteui-webcomponents-core";
+import { IDataSourceExecutionContext } from "igniteui-webcomponents-core";
+import { IDataSourceDataProviderUpdateNotifier } from "igniteui-webcomponents-core";
+import { SortDescriptionCollection } from "igniteui-webcomponents-core";
+import { FilterExpressionCollection } from "igniteui-webcomponents-core";
+import { DataSourcePageRequestPriority } from "igniteui-webcomponents-core";
+import { DataSourceDataProviderSchemaChangedEventArgs } from "igniteui-webcomponents-core";
+import { DataSourceSchemaPropertyType } from "igniteui-webcomponents-core";
+import { SummaryDescriptionCollection } from "igniteui-webcomponents-core";
+import { DataSourceSummaryScope } from "igniteui-webcomponents-core";
+import { TransactionState } from "igniteui-webcomponents-core";
+export declare class RestVirtualDataSourceDataProvider extends Base implements IDataSourceVirtualDataProvider {
+    static $t: Type;
+    private _worker;
+    private _requests;
+    private _callback;
+    constructor();
+    private filterExpressions_CollectionChanged;
+    private sortDescriptions_CollectionChanged;
+    private groupDescriptions_CollectionChanged;
+    private summaryDescriptions_CollectionChanged;
+    addPageRequest(pageIndex: number, priority: DataSourcePageRequestPriority): void;
+    private createWorker;
+    private valid;
+    private getWorkerSettings;
+    removePageRequest(pageIndex: number): void;
+    removeAllPageRequests(): void;
+    close(): void;
+    private _pageLoaded;
+    get pageLoaded(): (page: IDataSourcePage, currentFullCount: number, actualPageSize: number) => void;
+    set pageLoaded(value: (page: IDataSourcePage, currentFullCount: number, actualPageSize: number) => void);
+    private raisePageLoaded;
+    private killWorker;
+    private _pageSizeRequested;
+    get pageSizeRequested(): number;
+    set pageSizeRequested(value: number);
+    private _baseUri;
+    get baseUri(): string;
+    set baseUri(value: string);
+    private _entitySet;
+    get entitySet(): string;
+    set entitySet(value: string);
+    private _timeoutMilliseconds;
+    get timeoutMilliseconds(): number;
+    set timeoutMilliseconds(value: number);
+    getItemValue(item: any, valueName: string): any;
+    schemaChanged: (sender: any, args: DataSourceDataProviderSchemaChangedEventArgs) => void;
+    private _currentFullCount;
+    private _currentSchema;
+    get actualCount(): number;
+    get actualSchema(): IDataSourceSchema;
+    private _executionContext;
+    get executionContext(): IDataSourceExecutionContext;
+    set executionContext(value: IDataSourceExecutionContext);
+    private _updateNotifier;
+    get updateNotifier(): IDataSourceDataProviderUpdateNotifier;
+    set updateNotifier(value: IDataSourceDataProviderUpdateNotifier);
+    private _deferAutoRefresh;
+    get deferAutoRefresh(): boolean;
+    set deferAutoRefresh(value: boolean);
+    get isSortingSupported(): boolean;
+    get isGroupingSupported(): boolean;
+    get isFilteringSupported(): boolean;
+    private _isAggregationSupported;
+    get isAggregationSupported(): boolean;
+    set isAggregationSupported(isSupported: boolean);
+    private _sortDescriptions;
+    get sortDescriptions(): SortDescriptionCollection;
+    private _groupDescriptions;
+    get groupDescriptions(): SortDescriptionCollection;
+    private _propertiesRequested;
+    get propertiesRequested(): string[];
+    set propertiesRequested(value: string[]);
+    private _schemaIncludedProperties;
+    get schemaIncludedProperties(): string[];
+    set schemaIncludedProperties(value: string[]);
+    private _filterExpressions;
+    get filterExpressions(): FilterExpressionCollection;
+    private _summaryDescriptions;
+    get summaryDescriptions(): SummaryDescriptionCollection;
+    private _summaryScope;
+    get summaryScope(): DataSourceSummaryScope;
+    set summaryScope(value: DataSourceSummaryScope);
+    private _enableJsonp;
+    get enableJsonp(): boolean;
+    set enableJsonp(isEnabled: boolean);
+    private _fixedFullCount;
+    get fixedFullCount(): number;
+    set fixedFullCount(value: number);
+    private _provideFullCount;
+    get provideFullCount(): (page: any) => number;
+    set provideFullCount(value: (page: any) => number);
+    private _provideOrderByParameter;
+    get provideOrderByParameter(): (args: any[], orderByString: string, orderBy: SortDescriptionCollection) => void;
+    set provideOrderByParameter(value: (args: any[], orderByString: string, orderBy: SortDescriptionCollection) => void);
+    private _provideFilterParameter;
+    get provideFilterParameter(): (args: any[], filterString: string, filterExpressions: FilterExpressionCollection) => void;
+    set provideFilterParameter(value: (args: any[], filterString: string, filterExpressions: FilterExpressionCollection) => void);
+    private _provideAggregationParameter;
+    get provideAggregationParameter(): (args: any[], fetchCountOnly: boolean, groupByString: string, groupBy: SortDescriptionCollection, summaryString: string, summary: SummaryDescriptionCollection) => void;
+    set provideAggregationParameter(value: (args: any[], fetchCountOnly: boolean, groupByString: string, groupBy: SortDescriptionCollection, summaryString: string, summary: SummaryDescriptionCollection) => void);
+    private _provideAggregatedCount;
+    get provideAggregatedCount(): (item: any) => number;
+    set provideAggregatedCount(value: (item: any) => number);
+    private _provideUri;
+    get provideUri(): (baseUri: string, entitySet: string, args: {
+        name: string;
+        value: any;
+    }[]) => string;
+    set provideUri(value: (baseUri: string, entitySet: string, args: {
+        name: string;
+        value: any;
+    }[]) => string);
+    private _performFetch;
+    get performFetch(): (request: {
+        requestUri: string;
+        enableJsonpCallback: boolean;
+        method: 'GET';
+        headers: any;
+        data: null;
+    }, success: (data: any, response: any) => void, failure: (err: any) => void) => void;
+    set performFetch(value: (request: {
+        requestUri: string;
+        enableJsonpCallback: boolean;
+        method: 'GET';
+        headers: any;
+        data: null;
+    }, success: (data: any, response: any) => void, failure: (err: any) => void) => void);
+    private _providePagingParameter;
+    get providePagingParameter(): (args: any[], skip: number, take: number) => void;
+    set providePagingParameter(value: (args: any[], skip: number, take: number) => void);
+    private _provideDesiredPropertiesParameter;
+    get provideDesiredPropertiesParameter(): (args: any[], selectString: string, desiredProperties: string[]) => void;
+    set provideDesiredPropertiesParameter(value: (args: any[], selectString: string, desiredProperties: string[]) => void);
+    private _provideItems;
+    get provideItems(): (result: any) => any[];
+    set provideItems(value: (result: any) => any[]);
+    get notifyUsingSourceIndexes(): boolean;
+    get isItemIndexLookupSupported(): boolean;
+    get isKeyIndexLookupSupported(): boolean;
+    notifySetItem(index: number, oldItem: any, newItem: any): void;
+    notifyClearItems(): void;
+    notifyInsertItem(index: number, newItem: any): void;
+    notifyRemoveItem(index: number, oldItem: any): void;
+    _schemaFetchQueued: boolean;
+    queueSchemaFetch(): void;
+    doSchemaFetchInternal(): void;
+    schemaFetchInternal(): void;
+    protected schemaFetchInternalOverride(): void;
+    private addSchemaRequest;
+    _autoRefreshQueued: boolean;
+    queueAutoRefresh(): void;
+    doRefreshInternal(): void;
+    refreshInternal(): void;
+    protected refreshInternalOverride(): void;
+    flushAutoRefresh(): void;
+    refresh(): void;
+    indexOfItem(item: any): number;
+    indexOfKey(key: any[]): number;
+    resolveSchemaPropertyType(propertyPath: string): DataSourceSchemaPropertyType;
+    setItemValue(item: any, valueName: string, value: any): void;
+    removeItem(item: any): void;
+    addItem(item: any): void;
+    createBatchRequest(changes: TransactionState[]): void;
+    private _batchCompleted;
+    get batchCompleted(): (success: boolean, requiresRefresh: boolean, messages: string[]) => void;
+    set batchCompleted(v: (success: boolean, requiresRefresh: boolean, messages: string[]) => void);
+}