/*
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 { Base, PropertyChangedEventArgs, runOn, delegateRemove, delegateCombine, enumGetBox, typeCast, markType } from "./type";
import { IDataSource_$type } from "./IDataSource";
import { IDataSourceDataProviderUpdateNotifier_$type } from "./IDataSourceDataProviderUpdateNotifier";
import { SortDescriptionCollection } from "./SortDescriptionCollection";
import { FilterExpressionCollection } from "./FilterExpressionCollection";
import { SummaryDescriptionCollection } from "./SummaryDescriptionCollection";
import { DataSourceSummaryScope_$type } from "./DataSourceSummaryScope";
import { DataSourceSectionHeaderDisplayMode_$type } from "./DataSourceSectionHeaderDisplayMode";
import { DataSourceRowExpansionChangedEventArgs } from "./DataSourceRowExpansionChangedEventArgs";
import { DataSourceSchemaChangedEventArgs } from "./DataSourceSchemaChangedEventArgs";
/**
 * @hidden
 */
export let BaseDataSource = /*@__PURE__*/ (() => {
    class BaseDataSource extends Base {
        constructor() {
            super();
            this.aj = false;
            this.aq = null;
            this._externalDataSource = null;
            this.q = null;
            this.p = null;
            this.g = null;
            this.r = null;
            this.h = null;
            this.m = null;
            this.am = 0;
            this.an = 0;
            this.ao = 0;
            this.n = null;
            this.propertyChanged = null;
            this.j = null;
            this.l = null;
            this.schemaChanged = null;
            this.rowExpansionChanged = null;
            this.w = false;
            this.f = 0;
            this.u = false;
            this.b = null;
            this.a = null;
            this.c = null;
            this.ac = false;
            this.ad = false;
            this.s = false;
            this.e = 0;
            this.x = false;
            this.z = true;
            this.v = false;
            this.ab = false;
            this.aa = false;
            this.y = true;
            this.af = true;
            this.ae = false;
            this.ag = true;
            this.t = false;
            this.d = null;
            this.j = new DefaultDataSourceDataProviderUpdateNotifier(this);
            this.q = new SortDescriptionCollection();
            this.p = new SortDescriptionCollection();
            this.r = new SummaryDescriptionCollection();
            this.q.n(runOn(this, this.cc));
            this.p.n(runOn(this, this.bk));
            this.r.n(runOn(this, this.cd));
            this.g = new FilterExpressionCollection();
            this.g.m(runOn(this, this.bi));
        }
        cc(a, b) {
            this.onSortDescriptionsChanged(b);
        }
        bk(a, b) {
            this.onGroupDescriptionsChanged(b);
        }
        cd(a, b) {
            this.onSummaryDescriptionsChanged(b);
        }
        bi(a, b) {
            this.onFilterExpressionsChanged(b);
        }
        onSortDescriptionsChanged(a) {
            this.queueAutoRefresh();
        }
        onGroupDescriptionsChanged(a) {
            if (this.isGroupingSupported) {
                if (this.groupDescriptions != null && this.groupDescriptions.k.count > 0) {
                    this.aj = true;
                }
                else {
                    this.aj = false;
                }
                this.queueAutoRefresh();
            }
        }
        onSummaryDescriptionsChanged(a) {
            this.queueAutoRefresh();
        }
        onFilterExpressionsChanged(a) {
            this.queueAutoRefresh();
        }
        onRowExpansionChanged(a, b, c) {
            if (this.rowExpansionChanged != null) {
                this.rowExpansionChanged(this, new DataSourceRowExpansionChangedEventArgs(a, b, c));
            }
        }
        isPlaceholderItem(a) {
            return false;
        }
        get externalDataSource() {
            return this._externalDataSource;
        }
        set externalDataSource(a) {
            this._externalDataSource = a;
        }
        get actualSchema() {
            return this.m;
        }
        set actualSchema(a) {
            let b = this.m;
            this.m = a;
            if (b != this.m) {
                this.onPropertyUpdated("ActualSchema", b, this.m);
            }
        }
        get actualCount() {
            return this.am;
        }
        set actualCount(a) {
            let b = this.am;
            this.am = a;
            if (b != this.am) {
                this.onPropertyUpdated("ActualCount", b, this.am);
            }
        }
        get firstVisibleIndexRequested() {
            return this.an;
        }
        set firstVisibleIndexRequested(a) {
            let b = this.an;
            this.an = a;
            if (b != this.an) {
                this.onPropertyUpdated("FirstVisibleIndexRequested", b, this.an);
            }
        }
        get lastVisibleIndexRequested() {
            return this.ao;
        }
        set lastVisibleIndexRequested(a) {
            let b = this.ao;
            this.ao = a;
            if (b != this.ao) {
                this.onPropertyUpdated("LastVisibleIndexRequested", b, this.ao);
            }
        }
        get updateNotifier() {
            return this.n;
        }
        set updateNotifier(a) {
            let b = this.n;
            this.n = a;
            if (b != this.n) {
                this.onPropertyUpdated("UpdateNotifier", b, this.n);
            }
        }
        getItemAtIndex(a) {
            return null;
        }
        getItemProperty(a, b) {
            if (this.actualBaseDataProvider != null) {
                let item_ = a;
                if ((item_ != null && item_.$$isSpecialRow !== undefined)) {
                    return this.getSpecialRowItemValue(a, b);
                }
                return this.actualBaseDataProvider.getItemValue(a, b);
            }
            return null;
        }
        getSpecialRowItemValue(a, b) {
            if (a.rowType == 3) {
                return this.getItemProperty(a.targetRow, b);
            }
            return a.getSectionValue(b);
        }
        getItemPropertyAtIndex(a, b) {
            return null;
        }
        get_fullSectionInformationWillForceLoad() {
            return false;
        }
        get fullSectionInformationWillForceLoad() {
            return this.get_fullSectionInformationWillForceLoad();
        }
        onPropertyUpdated(a, b, c) {
            if (this.propertyChanged != null) {
                this.propertyChanged(this, new PropertyChangedEventArgs(a));
            }
            this.propertyUpdatedOverride(a, b, c);
        }
        propertyUpdatedOverride(a, b, c) {
            switch (a) {
                case "PrimaryKey":
                    this.actualPrimaryKey = this.primaryKey;
                    break;
                case "ActualPrimaryKey":
                    this.onActualPrimaryKeyChanged(b, c);
                    break;
                case "ExecutionContext":
                    if (this.actualBaseDataProvider != null) {
                        this.actualBaseDataProvider.executionContext = this.executionContext;
                    }
                    this.queueAutoRefresh();
                    break;
                case "LastVisibleIndexRequested":
                case "FirstVisibleIndexRequested":
                    this.onRequestedVisibleRangeChanged();
                    break;
                case "ActualDataProvider":
                    this.onActualDataProviderChanged(b, c);
                    break;
                case "DeferAutoRefresh":
                    if (this.actualBaseDataProvider != null) {
                        this.actualBaseDataProvider.deferAutoRefresh = this.deferAutoRefresh;
                    }
                    if (!c) {
                        this.queueAutoRefresh();
                    }
                    break;
                case "PropertiesRequested":
                    if (this.actualBaseDataProvider != null) {
                        this.actualBaseDataProvider.propertiesRequested = this.propertiesRequested;
                    }
                    break;
                case "ShouldEmitSectionFooters":
                case "ShouldEmitSectionHeaders":
                case "ShouldEmitShiftedRows":
                case "SectionHeaderDisplayMode":
                case "IsSectionCollapsable":
                case "IncludeSummaryRowsInSection":
                case "IsSectionSummaryRowsAtBottom":
                case "IsSectionContentVisible":
                    this.queueAutoRefresh();
                    break;
                case "SummaryScope":
                    if (this.actualBaseDataProvider != null) {
                        this.actualBaseDataProvider.summaryScope = this.summaryScope;
                    }
                    this.queueAutoRefresh();
                    break;
            }
        }
        onActualPrimaryKeyChanged(a, b) {
            this.onActualPrimaryKeyChangedOverrride(a, b);
        }
        onActualPrimaryKeyChangedOverrride(a, b) {
        }
        get_isVirtual() {
            return false;
        }
        get isVirtual() {
            return this.get_isVirtual();
        }
        get dataProviderUpdateNotifier() {
            return this.j;
        }
        onActualDataProviderChanged(a, b) {
            let c = a;
            let d = b;
            if (c != null) {
                c.updateNotifier = null;
            }
            if (d != null) {
                d.updateNotifier = this.j;
            }
            if (c != null) {
                c.schemaChanged = delegateRemove(c.schemaChanged, runOn(this, this.be));
            }
            if (d != null) {
                d.schemaChanged = delegateCombine(d.schemaChanged, runOn(this, this.be));
                d.executionContext = this.executionContext;
                this.notifyUsingSourceIndexes = this.actualBaseDataProvider.notifyUsingSourceIndexes;
            }
            else {
                this.notifyUsingSourceIndexes = false;
            }
            if (c != null) {
                this.sortDescriptions.syncTarget = null;
                this.groupDescriptions.syncTarget = null;
                this.filterExpressions.syncTarget = null;
                this.summaryDescriptions.syncTarget = null;
            }
            if (d != null) {
                this.sortDescriptions.syncTarget = d.sortDescriptions;
                this.groupDescriptions.syncTarget = d.groupDescriptions;
                this.filterExpressions.syncTarget = d.filterExpressions;
                this.summaryDescriptions.syncTarget = d.summaryDescriptions;
                if (this.propertiesRequested != null) {
                    d.propertiesRequested = this.propertiesRequested;
                }
                d.summaryScope = this.summaryScope;
            }
            this.queueAutoRefresh();
        }
        onRequestedVisibleRangeChanged() {
        }
        get executionContext() {
            return this.l;
        }
        set executionContext(a) {
            let b = this.l;
            this.l = a;
            if (this.l != b) {
                this.onPropertyUpdated("ExecutionContext", b, this.l);
            }
        }
        canInitialize() {
            if (this.l != null && this.actualBaseDataProvider != null) {
                return true;
            }
            return false;
        }
        get isInitializing() {
            return this.w;
        }
        get_isSortingSupported() {
            return false;
        }
        get isSortingSupported() {
            return this.get_isSortingSupported();
        }
        get_isFilteringSupported() {
            return false;
        }
        get isFilteringSupported() {
            return this.get_isFilteringSupported();
        }
        get sortDescriptions() {
            return this.q;
        }
        get groupDescriptions() {
            return this.p;
        }
        get filterExpressions() {
            return this.g;
        }
        get summaryDescriptions() {
            return this.r;
        }
        get summaryScope() {
            return this.f;
        }
        set summaryScope(a) {
            let b = this.f;
            this.f = a;
            if (this.f != b) {
                this.onPropertyUpdated("SummaryScope", enumGetBox(DataSourceSummaryScope_$type, b), enumGetBox(DataSourceSummaryScope_$type, this.f));
            }
        }
        get deferAutoRefresh() {
            return this.u;
        }
        set deferAutoRefresh(a) {
            let b = this.u;
            this.u = a;
            if (this.u != b) {
                this.onPropertyUpdated("DeferAutoRefresh", b, this.u);
            }
        }
        get primaryKey() {
            return this.b;
        }
        set primaryKey(a) {
            let b = this.b;
            this.b = a;
            if (this.b != b) {
                this.onPropertyUpdated("PrimaryKey", b, this.b);
            }
        }
        get actualPrimaryKey() {
            return this.a;
        }
        set actualPrimaryKey(a) {
            let b = this.a;
            this.a = a;
            if (this.a != b) {
                this.onPropertyUpdated("ActualPrimaryKey", b, this.a);
            }
        }
        get propertiesRequested() {
            return this.c;
        }
        set propertiesRequested(a) {
            let b = this.c;
            this.c = a;
            if (this.c != b) {
                this.onPropertyUpdated("PropertiesRequested", b, this.c);
            }
        }
        get notifyUsingSourceIndexes() {
            return this.ac;
        }
        set notifyUsingSourceIndexes(a) {
            let b = this.ac;
            this.ac = a;
            if (this.ac != b) {
                this.onPropertyUpdated("NotifyUsingSourceIndexes", b, this.ac);
            }
        }
        get_isItemIndexLookupSupported() {
            return false;
        }
        get isItemIndexLookupSupported() {
            return this.get_isItemIndexLookupSupported();
        }
        get_isKeyIndexLookupSupported() {
            return false;
        }
        get isKeyIndexLookupSupported() {
            return this.get_isKeyIndexLookupSupported();
        }
        initializeOverride() {
        }
        resolveFullCount(a) {
            return a;
        }
        be(a, b) {
            let c = this.executionContext;
            c.execute(() => {
                this.ad = true;
                this.t = true;
                this.queueAutoRefresh();
                if (this.deferAutoRefresh) {
                    this.actualSchema = b.schema;
                    this.actualCount = this.resolveFullCount(b.count);
                    this.bm();
                }
            });
        }
        bm() {
            if (this.schemaChanged != null) {
                this.schemaChanged(this, new DataSourceSchemaChangedEventArgs(this.actualSchema, this.actualCount));
            }
        }
        onSetItem(a, b, c) {
            this.onSetItemOverride(a, b, c);
        }
        onBroadcastSetItem(a, b, c) {
            if (this.updateNotifier != null) {
                this.updateNotifier.notifySetItem(a, b, c);
            }
        }
        onSetItemOverride(a, b, c) {
            if (this.actualBaseDataProvider != null) {
                this.actualCount = this.resolveFullCount(this.actualBaseDataProvider.actualCount);
            }
            this.onBroadcastSetItem(a, b, c);
        }
        onClearItems() {
            this.onClearItemsOverride();
        }
        onBroadcastClearItems() {
            if (this.updateNotifier != null) {
                this.updateNotifier.notifyClearItems();
            }
        }
        onClearItemsOverride() {
            if (this.actualBaseDataProvider != null) {
                this.actualCount = this.resolveFullCount(this.actualBaseDataProvider.actualCount);
            }
            this.onBroadcastClearItems();
        }
        onInsertItem(a, b) {
            this.onInsertItemOverride(a, b);
        }
        onBroadcastInsertItem(a, b) {
            if (this.updateNotifier != null) {
                this.updateNotifier.notifyInsertItem(a, b);
            }
        }
        onInsertItemOverride(a, b) {
            if (this.actualBaseDataProvider != null) {
                this.actualCount = this.resolveFullCount(this.actualBaseDataProvider.actualCount);
            }
            this.onBroadcastInsertItem(a, b);
        }
        onRemoveItem(a, b) {
            this.onRemoveItemOverride(a, b);
        }
        onBroadcastRemoveItem(a, b) {
            if (this.updateNotifier != null) {
                this.updateNotifier.notifyRemoveItem(a, b);
            }
        }
        onRemoveItemOverride(a, b) {
            if (this.actualBaseDataProvider != null) {
                this.actualCount = this.resolveFullCount(this.actualBaseDataProvider.actualCount);
            }
            this.onBroadcastRemoveItem(a, b);
        }
        notifySetItem(a, b, c) {
            if (this.actualBaseDataProvider != null) {
                this.actualBaseDataProvider.notifySetItem(a, b, c);
            }
        }
        notifyClearItems() {
            if (this.actualBaseDataProvider != null) {
                this.actualBaseDataProvider.notifyClearItems();
            }
        }
        notifyInsertItem(a, b) {
            if (this.actualBaseDataProvider != null) {
                this.actualBaseDataProvider.notifyInsertItem(a, b);
            }
            ;
        }
        notifyRemoveItem(a, b) {
            if (this.actualBaseDataProvider != null) {
                this.actualBaseDataProvider.notifyRemoveItem(a, b);
            }
            ;
        }
        queueAutoRefresh() {
            if (this.deferAutoRefresh) {
                return;
            }
            if (this.actualBaseDataProvider != null) {
                this.actualBaseDataProvider.queueAutoRefresh();
            }
            if (this.s) {
                return;
            }
            if (this.executionContext != null) {
                this.s = true;
                this.executionContext.enqueueAction(runOn(this, this.bg));
            }
        }
        bg() {
            if (this.deferAutoRefresh) {
                this.s = false;
                return;
            }
            if (this.actualBaseDataProvider != null) {
                this.actualBaseDataProvider.flushAutoRefresh();
            }
            if (!this.s) {
                return;
            }
            this.s = false;
            this.ca();
        }
        ca() {
            if (this.actualBaseDataProvider != null) {
                this.actualSchema = this.actualBaseDataProvider.actualSchema;
                this.actualCount = this.resolveFullCount(this.actualBaseDataProvider.actualCount);
            }
            if (this.actualSchema != null && this.primaryKey == null) {
                this.actualPrimaryKey = this.actualSchema.primaryKey;
            }
            this.refreshInternalOverride();
            if (this.ad) {
                this.ad = false;
                this.bm();
            }
        }
        refreshInternalOverride() {
        }
        flushAutoRefresh() {
            this.bg();
        }
        refresh() {
            if (this.actualBaseDataProvider != null) {
                this.actualBaseDataProvider.refresh();
            }
            this.ca();
        }
        indexOfItem(a) {
            return -1;
        }
        indexOfKey(a) {
            return -1;
        }
        getPrimaryKeyValue(a, b) {
            let c = this.actualPrimaryKey;
            if (c == null || c.length < 1 || this.actualBaseDataProvider == null) {
                return;
            }
            for (let d = 0; d < c.length; d++) {
                b[d] = this.actualBaseDataProvider.getItemValue(a, c[d]);
            }
        }
        getRowType(a) {
            return 0;
        }
        getMainValuePath(a) {
            return "SectionInformation";
        }
        getStickyRows() {
            return this.getStickyRowsInRange(this.firstVisibleIndexRequested, this.lastVisibleIndexRequested);
        }
        getStickyRowsInRange(a, b) {
            return null;
        }
        isRowSpanning(a) {
            return a == 1 || a == 2;
        }
        getStickyRowPriority(a) {
            return -1;
        }
        isExclusivelySticky(a) {
            return false;
        }
        pinRow(a) {
        }
        unpinRow(a) {
        }
        clearPinnedRows() {
        }
        isRowPinned(a) {
            return false;
        }
        get_isGroupingSupported() {
            return false;
        }
        get isGroupingSupported() {
            return this.get_isGroupingSupported();
        }
        get_sectionHeaderDisplayMode() {
            return this.e;
        }
        set_sectionHeaderDisplayMode(a) {
            let b = this.e;
            this.e = a;
            if (b != this.e) {
                this.onPropertyUpdated("SectionHeaderDisplayMode", enumGetBox(DataSourceSectionHeaderDisplayMode_$type, b), enumGetBox(DataSourceSectionHeaderDisplayMode_$type, this.e));
            }
        }
        get sectionHeaderDisplayMode() {
            return this.get_sectionHeaderDisplayMode();
        }
        set sectionHeaderDisplayMode(a) {
            this.set_sectionHeaderDisplayMode(a);
        }
        get_isSectionCollapsable() {
            return this.x;
        }
        set_isSectionCollapsable(a) {
            let b = this.x;
            this.x = a;
            if (this.x != b) {
                this.onPropertyUpdated("IsSectionCollapsable", b, this.x);
            }
        }
        get isSectionCollapsable() {
            return this.get_isSectionCollapsable();
        }
        set isSectionCollapsable(a) {
            this.set_isSectionCollapsable(a);
        }
        get_isSectionExpandedDefault() {
            return this.z;
        }
        set_isSectionExpandedDefault(a) {
            this.z = a;
        }
        get isSectionExpandedDefault() {
            return this.get_isSectionExpandedDefault();
        }
        set isSectionExpandedDefault(a) {
            this.set_isSectionExpandedDefault(a);
        }
        get_includeSummaryRowsInSection() {
            return this.v;
        }
        set_includeSummaryRowsInSection(a) {
            let b = this.v;
            this.v = a;
            if (this.v != b) {
                this.onPropertyUpdated("IncludeSummaryRowsInSection", b, this.v);
            }
        }
        get includeSummaryRowsInSection() {
            return this.get_includeSummaryRowsInSection();
        }
        set includeSummaryRowsInSection(a) {
            this.set_includeSummaryRowsInSection(a);
        }
        get_isSectionSummaryRowsAtBottom() {
            return this.ab;
        }
        set_isSectionSummaryRowsAtBottom(a) {
            let b = this.ab;
            this.ab = a;
            if (this.ab != b) {
                this.onPropertyUpdated("IsSectionSummaryRowsAtBottom", b, this.ab);
            }
        }
        get isSectionSummaryRowsAtBottom() {
            return this.get_isSectionSummaryRowsAtBottom();
        }
        set isSectionSummaryRowsAtBottom(a) {
            this.set_isSectionSummaryRowsAtBottom(a);
        }
        get_isSectionHeaderNormalRow() {
            return this.aa;
        }
        set_isSectionHeaderNormalRow(a) {
            let b = this.aa;
            this.aa = a;
            if (this.aa != b) {
                this.onPropertyUpdated("IsSectionHeaderNormalRow", b, this.aa);
            }
        }
        get isSectionHeaderNormalRow() {
            return this.get_isSectionHeaderNormalRow();
        }
        set isSectionHeaderNormalRow(a) {
            this.set_isSectionHeaderNormalRow(a);
        }
        get_isSectionContentVisible() {
            return this.y;
        }
        set_isSectionContentVisible(a) {
            let b = this.y;
            this.y = a;
            if (this.y != b) {
                this.onPropertyUpdated("IsSectionContentVisible", b, this.y);
            }
        }
        get isSectionContentVisible() {
            return this.get_isSectionContentVisible();
        }
        set isSectionContentVisible(a) {
            this.set_isSectionContentVisible(a);
        }
        get shouldEmitSectionHeaders() {
            return this.af;
        }
        set shouldEmitSectionHeaders(a) {
            let b = this.af;
            this.af = a;
            if (this.af != b) {
                this.onPropertyUpdated("ShouldEmitSectionHeaders", b, this.af);
            }
        }
        get shouldEmitSectionFooters() {
            return this.ae;
        }
        set shouldEmitSectionFooters(a) {
            let b = this.ae;
            this.ae = a;
            if (this.ae != b) {
                this.onPropertyUpdated("ShouldEmitSectionFooters", b, this.ae);
            }
        }
        get shouldEmitShiftedRows() {
            return this.ag;
        }
        set shouldEmitShiftedRows(a) {
            let b = this.ag;
            this.ag = a;
            if (this.ag != b) {
                this.onPropertyUpdated("ShouldEmitShiftedRows", b, this.ag);
            }
        }
        ensureComparables(a) {
            if (this.t && this.actualCount > 0 && this.actualBaseDataProvider != null) {
                this.d = new Array(a.propertyNames.length);
                this.t = false;
            }
        }
        resolveSchemaPropertyType(a) {
            return this.actualBaseDataProvider.resolveSchemaPropertyType(a);
        }
        setIsRowExpandedAtIndex(a, b) {
        }
        getIsRowExpandedAtIndex(a) {
            return true;
        }
        getRowLevel(a) {
            return 0;
        }
        getRootSummaryRowCount() {
            return 0;
        }
        getRootSummaryResults() {
            return null;
        }
        getSectionSummaryResults(a) {
            return null;
        }
        clone() {
            return null;
        }
        cloneProperties(a) {
            let b = typeCast(BaseDataSource.$, a);
            if (b != null) {
                b.executionContext = this.executionContext;
                b.includeSummaryRowsInSection = this.includeSummaryRowsInSection;
                b.isSectionCollapsable = this.isSectionCollapsable;
                b.isSectionExpandedDefault = this.isSectionExpandedDefault;
                b.isSectionHeaderNormalRow = this.isSectionHeaderNormalRow;
                b.isSectionSummaryRowsAtBottom = this.isSectionSummaryRowsAtBottom;
                b.isSectionContentVisible = this.isSectionContentVisible;
                b.primaryKey = this.primaryKey;
                b.propertiesRequested = this.propertiesRequested;
                b.sectionHeaderDisplayMode = this.sectionHeaderDisplayMode;
                b.shouldEmitSectionFooters = this.shouldEmitSectionFooters;
                b.shouldEmitSectionHeaders = this.shouldEmitSectionHeaders;
                b.shouldEmitShiftedRows = this.shouldEmitShiftedRows;
                b.summaryScope = this.summaryScope;
                for (let c = 0; c < this.groupDescriptions.k.count; c++) {
                    b.groupDescriptions.add(this.groupDescriptions.k.item(c));
                }
                for (let d = 0; d < this.sortDescriptions.k.count; d++) {
                    b.sortDescriptions.add(this.sortDescriptions.k.item(d));
                }
                for (let e = 0; e < this.filterExpressions.j.count; e++) {
                    b.filterExpressions.add(this.filterExpressions.j.item(e));
                }
                for (let f = 0; f < this.summaryDescriptions.k.count; f++) {
                    b.summaryDescriptions.add(this.summaryDescriptions.k.item(f));
                }
            }
        }
    }
    BaseDataSource.$t = /*@__PURE__*/ markType(BaseDataSource, 'BaseDataSource', Base.$, [IDataSource_$type]);
    return BaseDataSource;
})();
/**
 * @hidden
 */
export let DefaultDataSourceDataProviderUpdateNotifier = /*@__PURE__*/ (() => {
    class DefaultDataSourceDataProviderUpdateNotifier extends Base {
        constructor(a) {
            super();
            this.a = null;
            this.a = a;
        }
        notifySetItem(a, b, c) {
            this.a.onSetItem(a, b, c);
        }
        notifyClearItems() {
            this.a.onClearItems();
        }
        notifyInsertItem(a, b) {
            this.a.onInsertItem(a, b);
        }
        notifyRemoveItem(a, b) {
            this.a.onRemoveItem(a, b);
        }
    }
    DefaultDataSourceDataProviderUpdateNotifier.$t = /*@__PURE__*/ markType(DefaultDataSourceDataProviderUpdateNotifier, 'DefaultDataSourceDataProviderUpdateNotifier', Base.$, [IDataSourceDataProviderUpdateNotifier_$type]);
    return DefaultDataSourceDataProviderUpdateNotifier;
})();
//# sourceMappingURL=BaseDataSource_combined.js.map
