@angular/cdk-experimental 14.0.0-next.12 → 14.0.0-next.13

package/scrolling/index.d.ts

@@ -1,8 +1,175 @@
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import * as i0 from '@angular/core';
+import { ListRange } from '@angular/cdk/collections';
+import { NumberInput } from '@angular/cdk/coercion';
+import { Observable } from 'rxjs';
+import { OnChanges } from '@angular/core';
+import { VirtualScrollStrategy } from '@angular/cdk/scrolling';
+
+/** Virtual scrolling strategy for lists with items of unknown or dynamic size. */
+export declare class AutoSizeVirtualScrollStrategy implements VirtualScrollStrategy {
+    /** @docs-private Implemented as part of VirtualScrollStrategy. */
+    scrolledIndexChange: Observable<number>;
+    /** The attached viewport. */
+    private _viewport;
+    /** The minimum amount of buffer rendered beyond the viewport (in pixels). */
+    private _minBufferPx;
+    /** The number of buffer items to render beyond the edge of the viewport (in pixels). */
+    private _maxBufferPx;
+    /** The estimator used to estimate the size of unseen items. */
+    private _averager;
+    /** The last measured scroll offset of the viewport. */
+    private _lastScrollOffset;
+    /** The last measured size of the rendered content in the viewport. */
+    private _lastRenderedContentSize;
+    /** The last measured size of the rendered content in the viewport. */
+    private _lastRenderedContentOffset;
+    /**
+     * The number of consecutive cycles where removing extra items has failed. Failure here means that
+     * we estimated how many items we could safely remove, but our estimate turned out to be too much
+     * and it wasn't safe to remove that many elements.
+     */
+    private _removalFailures;
+    /**
+     * @param minBufferPx The minimum amount of buffer rendered beyond the viewport (in pixels).
+     *     If the amount of buffer dips below this number, more items will be rendered.
+     * @param maxBufferPx The number of pixels worth of buffer to shoot for when rendering new items.
+     *     If the actual amount turns out to be less it will not necessarily trigger an additional
+     *     rendering cycle (as long as the amount of buffer is still greater than `minBufferPx`).
+     * @param averager The averager used to estimate the size of unseen items.
+     */
+    constructor(minBufferPx: number, maxBufferPx: number, averager?: ItemSizeAverager);
+    /**
+     * Attaches this scroll strategy to a viewport.
+     * @param viewport The viewport to attach this strategy to.
+     */
+    attach(viewport: CdkVirtualScrollViewport): void;
+    /** Detaches this scroll strategy from the currently attached viewport. */
+    detach(): void;
+    /** @docs-private Implemented as part of VirtualScrollStrategy. */
+    onContentScrolled(): void;
+    /** @docs-private Implemented as part of VirtualScrollStrategy. */
+    onDataLengthChanged(): void;
+    /** @docs-private Implemented as part of VirtualScrollStrategy. */
+    onContentRendered(): void;
+    /** @docs-private Implemented as part of VirtualScrollStrategy. */
+    onRenderedOffsetChanged(): void;
+    /** Scroll to the offset for the given index. */
+    scrollToIndex(): void;
+    /**
+     * Update the buffer parameters.
+     * @param minBufferPx The minimum amount of buffer rendered beyond the viewport (in pixels).
+     * @param maxBufferPx The number of buffer items to render beyond the edge of the viewport (in
+     *     pixels).
+     */
+    updateBufferSize(minBufferPx: number, maxBufferPx: number): void;
+    /** Update the rendered content after the user scrolls. */
+    private _updateRenderedContentAfterScroll;
+    /**
+     * Checks the size of the currently rendered content and uses it to update the estimated item size
+     * and estimated total content size.
+     */
+    private _checkRenderedContentSize;
+    /** Checks the currently rendered content offset and saves the value for later use. */
+    private _checkRenderedContentOffset;
+    /**
+     * Recalculates the rendered content based on our estimate of what should be shown at the current
+     * scroll offset.
+     */
+    private _renderContentForCurrentOffset;
+    /**
+     * Gets the visible range of data for the given start index. If the start index is too close to
+     * the end of the list it may be backed up to ensure the estimated size of the range is enough to
+     * fill the viewport.
+     * Note: must not be called if `this._viewport` is null
+     * @param startIndex The index to start the range at
+     * @return a range estimated to be large enough to fill the viewport when rendered.
+     */
+    private _getVisibleRangeForIndex;
+    /**
+     * Expand the given range by the given amount in either direction.
+     * Note: must not be called if `this._viewport` is null
+     * @param range The range to expand
+     * @param expandStart The number of items to expand the start of the range by.
+     * @param expandEnd The number of items to expand the end of the range by.
+     * @return The expanded range.
+     */
+    private _expandRange;
+    /** Update the viewport's total content size. */
+    private _updateTotalContentSize;
+}
+
 /**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * Provider factory for `AutoSizeVirtualScrollStrategy` that simply extracts the already created
+ * `AutoSizeVirtualScrollStrategy` from the given directive.
+ * @param autoSizeDir The instance of `CdkAutoSizeVirtualScroll` to extract the
+ *     `AutoSizeVirtualScrollStrategy` from.
  */
-export * from './public-api';
+export declare function _autoSizeVirtualScrollStrategyFactory(autoSizeDir: CdkAutoSizeVirtualScroll): AutoSizeVirtualScrollStrategy;
+
+/** A virtual scroll strategy that supports unknown or dynamic size items. */
+export declare class CdkAutoSizeVirtualScroll implements OnChanges {
+    /**
+     * The minimum amount of buffer rendered beyond the viewport (in pixels).
+     * If the amount of buffer dips below this number, more items will be rendered. Defaults to 100px.
+     */
+    get minBufferPx(): number;
+    set minBufferPx(value: NumberInput);
+    _minBufferPx: number;
+    /**
+     * The number of pixels worth of buffer to shoot for when rendering new items.
+     * If the actual amount turns out to be less it will not necessarily trigger an additional
+     * rendering cycle (as long as the amount of buffer is still greater than `minBufferPx`).
+     * Defaults to 200px.
+     */
+    get maxBufferPx(): number;
+    set maxBufferPx(value: NumberInput);
+    _maxBufferPx: number;
+    /** The scroll strategy used by this directive. */
+    _scrollStrategy: AutoSizeVirtualScrollStrategy;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkAutoSizeVirtualScroll, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkAutoSizeVirtualScroll, "cdk-virtual-scroll-viewport[autosize]", never, { "minBufferPx": "minBufferPx"; "maxBufferPx": "maxBufferPx"; }, {}, never, never, false>;
+}
+
+declare namespace i1 {
+    export {
+        _autoSizeVirtualScrollStrategyFactory,
+        ItemSizeAverager,
+        AutoSizeVirtualScrollStrategy,
+        CdkAutoSizeVirtualScroll
+    }
+}
+
+/**
+ * A class that tracks the size of items that have been seen and uses it to estimate the average
+ * item size.
+ */
+export declare class ItemSizeAverager {
+    /** The total amount of weight behind the current average. */
+    private _totalWeight;
+    /** The current average item size. */
+    private _averageItemSize;
+    /** The default size to use for items when no data is available. */
+    private _defaultItemSize;
+    /** @param defaultItemSize The default size to use for items when no data is available. */
+    constructor(defaultItemSize?: number);
+    /** Returns the average item size. */
+    getAverageItemSize(): number;
+    /**
+     * Adds a measurement sample for the estimator to consider.
+     * @param range The measured range.
+     * @param size The measured size of the given range in pixels.
+     */
+    addSample(range: ListRange, size: number): void;
+    /** Resets the averager. */
+    reset(): void;
+}
+
+export declare class ScrollingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ScrollingModule, [typeof i1.CdkAutoSizeVirtualScroll], never, [typeof i1.CdkAutoSizeVirtualScroll]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ScrollingModule>;
+}
+
+export { }

package/selection/index.d.ts

@@ -1,8 +1,276 @@
+import { AfterContentChecked } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { CdkTable } from '@angular/cdk/table';
+import { CollectionViewer } from '@angular/cdk/collections';
+import { ControlValueAccessor } from '@angular/forms';
+import { DataSource } from '@angular/cdk/collections';
+import { EventEmitter } from '@angular/core';
+import * as i0 from '@angular/core';
+import * as i6 from '@angular/common';
+import * as i7 from '@angular/cdk/table';
+import { ListRange } from '@angular/cdk/collections';
+import { NumberInput } from '@angular/cdk/coercion';
+import { Observable } from 'rxjs';
+import { OnDestroy } from '@angular/core';
+import { OnInit } from '@angular/core';
+import { Subject } from 'rxjs';
+import { TrackByFunction } from '@angular/core';
+
 /**
- * @license
- * Copyright Google LLC All Rights Reserved.
+ * Applies `cdk-selected` class and `aria-selected` to an element.
  *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * Must be used within a parent `CdkSelection` directive.
+ * Must be provided with the value. The index is required if `trackBy` is used on the `CdkSelection`
+ * directive.
  */
-export * from './public-api';
+export declare class CdkRowSelection<T> {
+    readonly _selection: CdkSelection<T>;
+    value: T;
+    get index(): number | undefined;
+    set index(index: NumberInput);
+    protected _index?: number;
+    constructor(_selection: CdkSelection<T>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkRowSelection<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkRowSelection<any>, "[cdkRowSelection]", never, { "value": "cdkRowSelectionValue"; "index": "cdkRowSelectionIndex"; }, {}, never, never, false>;
+}
+
+/**
+ * Makes the element a select-all toggle.
+ *
+ * Must be used within a parent `CdkSelection` directive. It toggles the selection states
+ * of all the selection toggles connected with the `CdkSelection` directive.
+ * If the element implements `ControlValueAccessor`, e.g. `MatCheckbox`, the directive
+ * automatically connects it with the select-all state provided by the `CdkSelection` directive. If
+ * not, use `checked$` to get the checked state, `indeterminate$` to get the indeterminate state,
+ * and `toggle()` to change the selection state.
+ */
+export declare class CdkSelectAll<T> implements OnDestroy, OnInit {
+    private readonly _selection;
+    private readonly _controlValueAccessor;
+    /**
+     * The checked state of the toggle.
+     * Resolves to `true` if all the values are selected, `false` if no value is selected.
+     */
+    readonly checked: Observable<boolean>;
+    /**
+     * The indeterminate state of the toggle.
+     * Resolves to `true` if part (not all) of the values are selected, `false` if all values or no
+     * value at all are selected.
+     */
+    readonly indeterminate: Observable<boolean>;
+    /**
+     * Toggles the select-all state.
+     * @param event The click event if the toggle is triggered by a (mouse or keyboard) click. If
+     *     using with a native `<input type="checkbox">`, the parameter is required for the
+     *     indeterminate state to work properly.
+     */
+    toggle(event?: MouseEvent): void;
+    private readonly _destroyed;
+    constructor(_selection: CdkSelection<T>, _controlValueAccessor: ControlValueAccessor[]);
+    ngOnInit(): void;
+    private _configureControlValueAccessor;
+    private _assertValidParentSelection;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkSelectAll<any>, [{ optional: true; }, { optional: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkSelectAll<any>, "[cdkSelectAll]", ["cdkSelectAll"], {}, {}, never, never, false>;
+}
+
+/**
+ * Manages the selection states of the items and provides methods to check and update the selection
+ * states.
+ * It must be applied to the parent element if `cdkSelectionToggle`, `cdkSelectAll`,
+ * `cdkRowSelection` and `cdkSelectionColumn` are applied.
+ */
+export declare class CdkSelection<T> implements OnInit, AfterContentChecked, CollectionViewer, OnDestroy {
+    viewChange: Observable<ListRange>;
+    get dataSource(): TableDataSource<T>;
+    set dataSource(dataSource: TableDataSource<T>);
+    private _dataSource;
+    trackByFn: TrackByFunction<T>;
+    /** Whether to support multiple selection */
+    get multiple(): boolean;
+    set multiple(multiple: BooleanInput);
+    protected _multiple: boolean;
+    /** Emits when selection changes. */
+    readonly change: EventEmitter<SelectionChange<T>>;
+    /** Latest data provided by the data source. */
+    private _data;
+    /** Subscription that listens for the data provided by the data source.  */
+    private _renderChangeSubscription;
+    private _destroyed;
+    private _selection;
+    private _switchDataSource;
+    private _observeRenderChanges;
+    ngOnInit(): void;
+    ngAfterContentChecked(): void;
+    ngOnDestroy(): void;
+    /** Toggles selection for a given value. `index` is required if `trackBy` is used. */
+    toggleSelection(value: T, index?: number): void;
+    /**
+     * Toggles select-all. If no value is selected, select all values. If all values or some of the
+     * values are selected, de-select all values.
+     */
+    toggleSelectAll(): void;
+    /** Checks whether a value is selected. `index` is required if `trackBy` is used. */
+    isSelected(value: T, index?: number): boolean;
+    /** Checks whether all values are selected. */
+    isAllSelected(): boolean;
+    /** Checks whether partially selected. */
+    isPartialSelected(): boolean;
+    private _selectAll;
+    private _clearAll;
+    private _updateSelectAllState;
+    selectAllState: SelectAllState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkSelection<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkSelection<any>, "[cdkSelection]", ["cdkSelection"], { "dataSource": "dataSource"; "trackByFn": "trackBy"; "multiple": "cdkSelectionMultiple"; }, { "change": "cdkSelectionChange"; }, never, never, false>;
+}
+
+/**
+ * Column that adds row selecting checkboxes and a select-all checkbox if `cdkSelectionMultiple` is
+ * `true`.
+ *
+ * Must be used within a parent `CdkSelection` directive.
+ */
+export declare class CdkSelectionColumn<T> implements OnInit, OnDestroy {
+    private _table;
+    readonly selection: CdkSelection<T>;
+    /** Column name that should be used to reference this column. */
+    get name(): string;
+    set name(name: string);
+    private _name;
+    private readonly _columnDef;
+    private readonly _cell;
+    private readonly _headerCell;
+    constructor(_table: CdkTable<T>, selection: CdkSelection<T>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private _syncColumnDefName;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkSelectionColumn<any>, [{ optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CdkSelectionColumn<any>, "cdk-selection-column", never, { "name": "cdkSelectionColumnName"; }, {}, never, never, false>;
+}
+
+export declare class CdkSelectionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkSelectionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkSelectionModule, [typeof i1.CdkSelection, typeof i2.CdkSelectionToggle, typeof i3.CdkSelectAll, typeof i4.CdkSelectionColumn, typeof i5.CdkRowSelection], [typeof i6.CommonModule, typeof i7.CdkTableModule], [typeof i1.CdkSelection, typeof i2.CdkSelectionToggle, typeof i3.CdkSelectAll, typeof i4.CdkSelectionColumn, typeof i5.CdkRowSelection]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CdkSelectionModule>;
+}
+
+/**
+ * Makes the element a selection toggle.
+ *
+ * Must be used within a parent `CdkSelection` directive.
+ * Must be provided with the value. If `trackBy` is used on `CdkSelection`, the index of the value
+ * is required. If the element implements `ControlValueAccessor`, e.g. `MatCheckbox`, the directive
+ * automatically connects it with the selection state provided by the `CdkSelection` directive. If
+ * not, use `checked$` to get the checked state of the value, and `toggle()` to change the selection
+ * state.
+ */
+export declare class CdkSelectionToggle<T> implements OnDestroy, OnInit {
+    private _selection;
+    private _controlValueAccessors;
+    /** The value that is associated with the toggle */
+    value: T;
+    /** The index of the value in the list. Required when used with `trackBy` */
+    get index(): number | undefined;
+    set index(index: NumberInput);
+    protected _index?: number;
+    /** The checked state of the selection toggle */
+    readonly checked: Observable<boolean>;
+    /** Toggles the selection */
+    toggle(): void;
+    private _destroyed;
+    constructor(_selection: CdkSelection<T>, _controlValueAccessors: ControlValueAccessor[]);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private _assertValidParentSelection;
+    private _configureControlValueAccessor;
+    private _isSelected;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkSelectionToggle<any>, [{ optional: true; }, { optional: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkSelectionToggle<any>, "[cdkSelectionToggle]", ["cdkSelectionToggle"], { "value": "cdkSelectionToggleValue"; "index": "cdkSelectionToggleIndex"; }, {}, never, never, false>;
+}
+
+declare namespace i1 {
+    export {
+        CdkSelection
+    }
+}
+
+declare namespace i2 {
+    export {
+        CdkSelectionToggle
+    }
+}
+
+declare namespace i3 {
+    export {
+        CdkSelectAll
+    }
+}
+
+declare namespace i4 {
+    export {
+        CdkSelectionColumn
+    }
+}
+
+declare namespace i5 {
+    export {
+        CdkRowSelection
+    }
+}
+
+/**
+ * A selectable value with an optional index. The index is required when the selection is used with
+ * `trackBy`.
+ */
+export declare interface SelectableWithIndex<T> {
+    value: T;
+    index?: number;
+}
+
+declare type SelectAllState = 'all' | 'none' | 'partial';
+
+/**
+ * Represents the change in the selection set.
+ */
+export declare interface SelectionChange<T> {
+    before: SelectableWithIndex<T>[];
+    after: SelectableWithIndex<T>[];
+}
+
+/**
+ * Maintains a set of selected items. Support selecting and deselecting items, and checking if a
+ * value is selected.
+ * When constructed with a `trackByFn`, all the items will be identified by applying the `trackByFn`
+ * on them. Because `trackByFn` requires the index of the item to be passed in, the `index` field is
+ * expected to be set when calling `isSelected`, `select` and `deselect`.
+ */
+export declare class SelectionSet<T> implements TrackBySelection<T> {
+    private _multiple;
+    private _trackByFn?;
+    private _selectionMap;
+    changed: Subject<SelectionChange<T>>;
+    constructor(_multiple?: boolean, _trackByFn?: TrackByFunction<T> | undefined);
+    isSelected(value: SelectableWithIndex<T>): boolean;
+    select(...selects: SelectableWithIndex<T>[]): void;
+    deselect(...selects: SelectableWithIndex<T>[]): void;
+    private _markSelected;
+    private _markDeselected;
+    private _getTrackedByValue;
+    private _getCurrentSelection;
+}
+
+declare type TableDataSource<T> = DataSource<T> | Observable<readonly T[]> | readonly T[];
+
+/**
+ * Maintains a set of selected values. One or more values can be added to or removed from the
+ * selection.
+ */
+declare interface TrackBySelection<T> {
+    isSelected(value: SelectableWithIndex<T>): boolean;
+    select(...values: SelectableWithIndex<T>[]): void;
+    deselect(...values: SelectableWithIndex<T>[]): void;
+    changed: Subject<SelectionChange<T>>;
+}
+
+export { }

package/table-scroll-container/index.d.ts

@@ -1,8 +1,64 @@
+import { Directionality } from '@angular/cdk/bidi';
+import { ElementRef } from '@angular/core';
+import * as i0 from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { OnInit } from '@angular/core';
+import { StickyPositioningListener } from '@angular/cdk/table';
+import { StickyUpdate } from '@angular/cdk/table';
+
 /**
- * @license
- * Copyright Google LLC All Rights Reserved.
+ * Applies styles to the host element that make its scrollbars match up with
+ * the non-sticky scrollable portions of the CdkTable contained within.
  *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * This visual effect only works in Webkit and Blink based browsers (eg Chrome,
+ * Safari, Edge). Other browsers such as Firefox will gracefully degrade to
+ * normal scrollbar appearance.
+ * Further note: These styles have no effect when the browser is using OS-default
+ * scrollbars. The easiest way to force them into custom mode is to specify width
+ * and height for the scrollbar and thumb.
  */
-export * from './public-api';
+export declare class CdkTableScrollContainer implements StickyPositioningListener, OnDestroy, OnInit {
+    private readonly _elementRef;
+    private readonly _document;
+    private readonly _directionality?;
+    private readonly _uniqueClassName;
+    private _styleRoot;
+    private _styleElement?;
+    /** The most recent sticky column size values from the CdkTable. */
+    private _startSizes;
+    private _endSizes;
+    private _headerSizes;
+    private _footerSizes;
+    constructor(_elementRef: ElementRef<HTMLElement>, _document: Document, _directionality?: Directionality | undefined);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    stickyColumnsUpdated({ sizes }: StickyUpdate): void;
+    stickyEndColumnsUpdated({ sizes }: StickyUpdate): void;
+    stickyHeaderRowsUpdated({ sizes }: StickyUpdate): void;
+    stickyFooterRowsUpdated({ sizes }: StickyUpdate): void;
+    /**
+     * Set padding on the scrollbar track based on the sticky states from CdkTable.
+     */
+    private _updateScrollbar;
+    /** Gets the stylesheet for the scrollbar styles and creates it if need be. */
+    private _getStyleSheet;
+    /** Updates the stylesheet with the specified scrollbar style. */
+    private _applyCss;
+    private _clearCss;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTableScrollContainer, [null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkTableScrollContainer, "[cdkTableScrollContainer]", never, {}, {}, never, never, false>;
+}
+
+export declare class CdkTableScrollContainerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTableScrollContainerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkTableScrollContainerModule, [typeof i1.CdkTableScrollContainer], never, [typeof i1.CdkTableScrollContainer]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CdkTableScrollContainerModule>;
+}
+
+declare namespace i1 {
+    export {
+        CdkTableScrollContainer
+    }
+}
+
+export { }

package/column-resize/column-resize-directives/column-resize-flex.d.ts

@@ -1,28 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { ElementRef, NgZone } from '@angular/core';
-import { CdkTable } from '@angular/cdk/table';
-import { ColumnResize } from '../column-resize';
-import { ColumnResizeNotifier, ColumnResizeNotifierSource } from '../column-resize-notifier';
-import { HeaderRowEventDispatcher } from '../event-dispatcher';
-import * as i0 from "@angular/core";
-/**
- * Explicitly enables column resizing for a flexbox-based cdk-table.
- * Individual columns must be annotated specifically.
- */
-export declare class CdkColumnResizeFlex extends ColumnResize {
-    readonly columnResizeNotifier: ColumnResizeNotifier;
-    readonly elementRef: ElementRef<HTMLElement>;
-    protected readonly eventDispatcher: HeaderRowEventDispatcher;
-    protected readonly ngZone: NgZone;
-    protected readonly notifier: ColumnResizeNotifierSource;
-    protected readonly table: CdkTable<unknown>;
-    constructor(columnResizeNotifier: ColumnResizeNotifier, elementRef: ElementRef<HTMLElement>, eventDispatcher: HeaderRowEventDispatcher, ngZone: NgZone, notifier: ColumnResizeNotifierSource, table: CdkTable<unknown>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkColumnResizeFlex, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkColumnResizeFlex, "cdk-table[columnResize]", never, {}, {}, never, never, false>;
-}

package/column-resize/column-resize-directives/column-resize.d.ts

@@ -1,28 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { ElementRef, NgZone } from '@angular/core';
-import { CdkTable } from '@angular/cdk/table';
-import { ColumnResize } from '../column-resize';
-import { ColumnResizeNotifier, ColumnResizeNotifierSource } from '../column-resize-notifier';
-import { HeaderRowEventDispatcher } from '../event-dispatcher';
-import * as i0 from "@angular/core";
-/**
- * Explicitly enables column resizing for a table-based cdk-table.
- * Individual columns must be annotated specifically.
- */
-export declare class CdkColumnResize extends ColumnResize {
-    readonly columnResizeNotifier: ColumnResizeNotifier;
-    readonly elementRef: ElementRef<HTMLElement>;
-    protected readonly eventDispatcher: HeaderRowEventDispatcher;
-    protected readonly ngZone: NgZone;
-    protected readonly notifier: ColumnResizeNotifierSource;
-    protected readonly table: CdkTable<unknown>;
-    constructor(columnResizeNotifier: ColumnResizeNotifier, elementRef: ElementRef<HTMLElement>, eventDispatcher: HeaderRowEventDispatcher, ngZone: NgZone, notifier: ColumnResizeNotifierSource, table: CdkTable<unknown>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkColumnResize, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkColumnResize, "table[cdk-table][columnResize]", never, {}, {}, never, never, false>;
-}

package/column-resize/column-resize-directives/constants.d.ts

@@ -1,10 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { Provider } from '@angular/core';
-export declare const TABLE_PROVIDERS: Provider[];
-export declare const FLEX_PROVIDERS: Provider[];

package/column-resize/column-resize-directives/default-enabled-column-resize-flex.d.ts

@@ -1,28 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { ElementRef, NgZone } from '@angular/core';
-import { CdkTable } from '@angular/cdk/table';
-import { ColumnResize } from '../column-resize';
-import { ColumnResizeNotifier, ColumnResizeNotifierSource } from '../column-resize-notifier';
-import { HeaderRowEventDispatcher } from '../event-dispatcher';
-import * as i0 from "@angular/core";
-/**
- * Implicitly enables column resizing for a flex cdk-table.
- * Individual columns will be resizable unless opted out.
- */
-export declare class CdkDefaultEnabledColumnResizeFlex extends ColumnResize {
-    readonly columnResizeNotifier: ColumnResizeNotifier;
-    readonly elementRef: ElementRef<HTMLElement>;
-    protected readonly eventDispatcher: HeaderRowEventDispatcher;
-    protected readonly ngZone: NgZone;
-    protected readonly notifier: ColumnResizeNotifierSource;
-    protected readonly table: CdkTable<unknown>;
-    constructor(columnResizeNotifier: ColumnResizeNotifier, elementRef: ElementRef<HTMLElement>, eventDispatcher: HeaderRowEventDispatcher, ngZone: NgZone, notifier: ColumnResizeNotifierSource, table: CdkTable<unknown>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDefaultEnabledColumnResizeFlex, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDefaultEnabledColumnResizeFlex, "cdk-table", never, {}, {}, never, never, false>;
-}

package/column-resize/column-resize-directives/default-enabled-column-resize.d.ts

@@ -1,28 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { ElementRef, NgZone } from '@angular/core';
-import { CdkTable } from '@angular/cdk/table';
-import { ColumnResize } from '../column-resize';
-import { ColumnResizeNotifier, ColumnResizeNotifierSource } from '../column-resize-notifier';
-import { HeaderRowEventDispatcher } from '../event-dispatcher';
-import * as i0 from "@angular/core";
-/**
- * Implicitly enables column resizing for a table-based cdk-table.
- * Individual columns will be resizable unless opted out.
- */
-export declare class CdkDefaultEnabledColumnResize extends ColumnResize {
-    readonly columnResizeNotifier: ColumnResizeNotifier;
-    readonly elementRef: ElementRef<HTMLElement>;
-    protected readonly eventDispatcher: HeaderRowEventDispatcher;
-    protected readonly ngZone: NgZone;
-    protected readonly notifier: ColumnResizeNotifierSource;
-    protected readonly table: CdkTable<unknown>;
-    constructor(columnResizeNotifier: ColumnResizeNotifier, elementRef: ElementRef<HTMLElement>, eventDispatcher: HeaderRowEventDispatcher, ngZone: NgZone, notifier: ColumnResizeNotifierSource, table: CdkTable<unknown>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDefaultEnabledColumnResize, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDefaultEnabledColumnResize, "table[cdk-table]", never, {}, {}, never, never, false>;
-}