@progress/kendo-angular-grid 6.1.3 → 7.0.0-dev.202204150740

package/dist/es2015/column-resizing/column-handle.directive.js

@@ -1,256 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { ChangeDetectorRef, Directive, ElementRef, Host, HostBinding, HostListener, Input, NgZone } from '@angular/core';
-import { Subscription, of } from 'rxjs';
-import { LocalizationService } from '@progress/kendo-angular-l10n';
-import { isBlank, isPresent, isTruthy } from '../utils';
-import { ColumnBase } from '../columns/column-base';
-import { expandColumns, leafColumns, columnsToRender } from '../columns/column-common';
-import { DraggableDirective } from '@progress/kendo-angular-common';
-import { ColumnResizingService } from './column-resizing.service';
-import { delay, takeUntil, filter, take, tap, switchMap, map } from 'rxjs/operators';
-import { ColumnInfoService } from '../common/column-info.service';
-// TODO
-// tslint:disable:rxjs-no-unsafe-takeuntil
-/**
- * @hidden
- */
-const fromPercentage = (value, percent) => {
-    const sign = percent < 0 ? -1 : 1;
-    return Math.ceil((Math.abs(percent) / 100) * value) * sign;
-};
-const ɵ0 = fromPercentage;
-/**
- * @hidden
- */
-const toPercentage = (value, whole) => (value / whole) * 100;
-const ɵ1 = toPercentage;
-/**
- * @hidden
- */
-const headerWidth = (handle) => handle.nativeElement.parentElement.offsetWidth;
-const ɵ2 = headerWidth;
-/**
- * @hidden
- */
-const allLeafColumns = columns => expandColumns(columns)
-    .filter(c => !c.isColumnGroup);
-const ɵ3 = allLeafColumns;
-/**
- * @hidden
- */
-const stopPropagation = ({ originalEvent: event }) => {
-    event.stopPropagation();
-    event.preventDefault();
-};
-const ɵ4 = stopPropagation;
-/**
- * @hidden
- */
-const createMoveStream = (service, draggable) => mouseDown => draggable.kendoDrag.pipe(takeUntil(draggable.kendoRelease.pipe(tap(() => service.end()))), map(({ pageX }) => ({
-    originalX: mouseDown.pageX,
-    pageX
-})));
-const ɵ5 = createMoveStream;
-/**
- * @hidden
- */
-const preventOnDblClick = release => mouseDown => of(mouseDown).pipe(delay(150), takeUntil(release));
-const ɵ6 = preventOnDblClick;
-/**
- * @hidden
- */
-const isInSpanColumn = column => !!(column.parent && column.parent.isSpanColumn);
-const ɵ7 = isInSpanColumn;
-/**
- * @hidden
- *
- * Calculates the column index. If the column is stated in `SpanColumn`,
- * the index for all child columns equals the index of the first child.
- */
-const indexOf = (target, list) => {
-    let index = 0;
-    let ignore = 0;
-    let skip = 0;
-    while (index < list.length) {
-        const current = list[index];
-        const isParentSpanColumn = isInSpanColumn(current);
-        if (current === target) {
-            break;
-        }
-        if ((ignore-- <= 0) && isParentSpanColumn) {
-            ignore = current.parent.childColumns.length - 1;
-            skip += ignore;
-        }
-        index++;
-    }
-    return index - skip;
-};
-const ɵ8 = indexOf;
-/**
- * @hidden
- */
-let ColumnHandleDirective = class ColumnHandleDirective {
-    constructor(draggable, element, service, zone, cdr, localization, columnInfoService) {
-        this.draggable = draggable;
-        this.element = element;
-        this.service = service;
-        this.zone = zone;
-        this.cdr = cdr;
-        this.localization = localization;
-        this.columnInfoService = columnInfoService;
-        this.columns = [];
-        this.subscriptions = new Subscription();
-        this.rtl = false;
-    }
-    get visible() {
-        return this.column.resizable ? 'block' : 'none';
-    }
-    get leftStyle() {
-        return isTruthy(this.rtl) ? 0 : null;
-    }
-    get rightStyle() {
-        return isTruthy(this.rtl) ? null : 0;
-    }
-    autoFit() {
-        const allLeafs = allLeafColumns(this.columns);
-        const currentLeafs = leafColumns([this.column]).filter(column => isTruthy(column.resizable));
-        const columnInfo = currentLeafs.map(column => {
-            const isParentSpan = isInSpanColumn(column);
-            const isLastInSpan = isParentSpan ? column.parent.childColumns.last === column : false;
-            const index = indexOf(column, allLeafs);
-            return {
-                column,
-                headerIndex: this.columnsForLevel(column.level).indexOf(column),
-                index,
-                isLastInSpan,
-                isParentSpan,
-                level: column.level
-            };
-        });
-        currentLeafs.forEach(column => column.width = 0);
-        this.service.measureColumns(columnInfo);
-    }
-    ngOnInit() {
-        if (isBlank(this.column.width)) {
-            this.column.implicitWidth = headerWidth(this.element);
-        }
-        const service = this.service.changes.pipe(filter(() => this.column.resizable), filter(e => isPresent(e.columns.find(column => column === this.column))));
-        this.subscriptions.add(service.pipe(filter(e => e.type === 'start'))
-            .subscribe(this.initState.bind(this)));
-        this.subscriptions.add(service.pipe(filter(e => e.type === 'resizeColumn'))
-            .subscribe(this.resize.bind(this)));
-        this.subscriptions.add(this.service.changes.pipe(filter(e => e.type === 'start'), filter(this.shouldUpdate.bind(this)), take(1) //on first resize only
-        ).subscribe(this.initColumnWidth.bind(this)));
-        this.subscriptions.add(this.zone.runOutsideAngular(() => this.draggable.kendoPress.pipe(tap(stopPropagation), tap(() => this.service.start(this.column)), switchMap(preventOnDblClick(this.draggable.kendoRelease)), switchMap(createMoveStream(this.service, this.draggable)))
-            .subscribe(({ pageX, originalX }) => {
-            const delta = pageX - originalX;
-            const percent = toPercentage(delta, this.column.resizeStartWidth || this.column.width);
-            this.service.resizeColumns(percent);
-        })));
-        this.subscriptions.add(service.pipe(filter(e => e.type === 'autoFitComplete'))
-            .subscribe(this.sizeToFit.bind(this)));
-        this.subscriptions.add(service.pipe(filter(e => e.type === 'triggerAutoFit'))
-            .subscribe(this.autoFit.bind(this)));
-        this.subscriptions.add(this.localization.changes.subscribe(({ rtl }) => this.rtl = rtl));
-    }
-    ngOnDestroy() {
-        if (this.subscriptions) {
-            this.subscriptions.unsubscribe();
-        }
-    }
-    shouldUpdate() {
-        return !allLeafColumns(this.columns)
-            .map(column => column.width)
-            .some(isBlank);
-    }
-    initColumnWidth() {
-        this.column.width = headerWidth(this.element);
-    }
-    initState() {
-        this.column.resizeStartWidth = headerWidth(this.element);
-        this.service.resizedColumn({
-            column: this.column,
-            oldWidth: this.column.resizeStartWidth
-        });
-    }
-    resize({ deltaPercent }) {
-        let delta = fromPercentage(this.column.resizeStartWidth, deltaPercent);
-        if (isTruthy(this.rtl)) {
-            delta *= -1;
-        }
-        const newWidth = Math.max(this.column.resizeStartWidth + delta, this.column.minResizableWidth);
-        const tableDelta = newWidth > this.column.minResizableWidth ?
-            delta : this.column.minResizableWidth - this.column.resizeStartWidth;
-        this.updateWidth(this.column, newWidth);
-        this.service.resizeTable(this.column, tableDelta);
-    }
-    sizeToFit({ columns, widths }) {
-        const index = columns.indexOf(this.column);
-        const width = Math.max(...widths.map(w => w[index])) + 1; //add 1px for IE
-        const tableDelta = width - this.column.resizeStartWidth;
-        this.updateWidth(this.column, width);
-        this.service.resizeTable(this.column, tableDelta);
-    }
-    updateWidth(column, width) {
-        column.width = width;
-        this.columnInfoService.hiddenColumns.forEach((col) => {
-            if (isBlank(col.width) && isPresent(col.implicitWidth)) {
-                // Resize hidden columns to their implicit width so they
-                // can be displayed with the same width if made visible.
-                col.width = col.implicitWidth;
-            }
-        });
-        this.cdr.markForCheck(); //force CD cycle
-    }
-    columnsForLevel(level) {
-        return columnsToRender(this.columns ? this.columns.filter(column => column.level === level) : []);
-    }
-};
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", Array)
-], ColumnHandleDirective.prototype, "columns", void 0);
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", ColumnBase)
-], ColumnHandleDirective.prototype, "column", void 0);
-tslib_1.__decorate([
-    HostBinding('style.display'),
-    tslib_1.__metadata("design:type", String),
-    tslib_1.__metadata("design:paramtypes", [])
-], ColumnHandleDirective.prototype, "visible", null);
-tslib_1.__decorate([
-    HostBinding('style.left'),
-    tslib_1.__metadata("design:type", Number),
-    tslib_1.__metadata("design:paramtypes", [])
-], ColumnHandleDirective.prototype, "leftStyle", null);
-tslib_1.__decorate([
-    HostBinding('style.right'),
-    tslib_1.__metadata("design:type", Number),
-    tslib_1.__metadata("design:paramtypes", [])
-], ColumnHandleDirective.prototype, "rightStyle", null);
-tslib_1.__decorate([
-    HostListener('dblclick'),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", void 0)
-], ColumnHandleDirective.prototype, "autoFit", null);
-ColumnHandleDirective = tslib_1.__decorate([
-    Directive({
-        selector: '[kendoGridColumnHandle]'
-    }),
-    tslib_1.__param(0, Host()),
-    tslib_1.__metadata("design:paramtypes", [DraggableDirective,
-        ElementRef,
-        ColumnResizingService,
-        NgZone,
-        ChangeDetectorRef,
-        LocalizationService,
-        ColumnInfoService])
-], ColumnHandleDirective);
-export { ColumnHandleDirective };
-export { ɵ0, ɵ1, ɵ2, ɵ3, ɵ4, ɵ5, ɵ6, ɵ7, ɵ8 };

package/dist/es2015/column-resizing/column-resize.interface.js

@@ -1,4 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/

package/dist/es2015/column-resizing/column-resizing.service.d.ts

@@ -1,31 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { EventEmitter } from '@angular/core';
-import { ColumnBase } from '../columns/column-base';
-import { ColumnResizeAction, ColumnResizeArgs, AutoFitFn } from './column-resize.interface';
-/**
- * @hidden
- */
-export declare class ColumnResizingService {
-    changes: EventEmitter<ColumnResizeAction>;
-    private column;
-    private resizedColumns;
-    private tables;
-    private batch;
-    start(column: ColumnBase): void;
-    resizeColumns(deltaPercent: number): void;
-    resizeTable(column: ColumnBase, delta: number): void;
-    resizedColumn(state: ColumnResizeArgs): void;
-    end(): void;
-    registerTable(tableMetadata: {
-        autoFit: AutoFitFn;
-        locked: boolean;
-    }): () => void;
-    measureColumns(info: Array<any>): void;
-    autoFit(...columns: ColumnBase[]): void;
-    private trackColumns;
-    private autoFitStart;
-    private autoFitBatch;
-}

package/dist/es2015/column-resizing/column-resizing.service.js

@@ -1,145 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { Injectable, EventEmitter } from '@angular/core';
-import { zip } from 'rxjs';
-import { leafColumns } from '../columns/column-common';
-import { take } from 'rxjs/operators';
-/**
- * @hidden
- */
-const isLocked = column => column.parent ? isLocked(column.parent) : !!column.locked;
-const ɵ0 = isLocked;
-/**
- * @hidden
- */
-const resizeArgs = (column, extra) => Object.assign({
-    columns: leafColumns([column]),
-    locked: isLocked(column)
-}, extra); // tslint:disable-line:align
-const ɵ1 = resizeArgs;
-/**
- * @hidden
- */
-let ColumnResizingService = class ColumnResizingService {
-    /**
-     * @hidden
-     */
-    constructor() {
-        this.changes = new EventEmitter();
-        this.tables = [];
-        this.batch = null;
-    }
-    start(column) {
-        this.trackColumns(column);
-        const columns = (this.column.isColumnGroup ? [column] : [])
-            .concat(leafColumns([column]));
-        this.changes.emit({
-            columns: columns,
-            locked: isLocked(this.column),
-            type: 'start'
-        });
-    }
-    resizeColumns(deltaPercent) {
-        const action = resizeArgs(this.column, {
-            deltaPercent,
-            type: 'resizeColumn'
-        });
-        this.changes.emit(action);
-    }
-    resizeTable(column, delta) {
-        const action = resizeArgs(column, {
-            delta,
-            type: 'resizeTable'
-        });
-        this.changes.emit(action);
-    }
-    resizedColumn(state) {
-        this.resizedColumns.push(state);
-    }
-    end() {
-        this.changes.emit({
-            columns: [],
-            resizedColumns: this.resizedColumns,
-            type: 'end'
-        });
-    }
-    registerTable(tableMetadata) {
-        this.tables.push(tableMetadata);
-        const unregisterTable = () => {
-            this.tables.splice(this.tables.indexOf(tableMetadata), 1);
-        };
-        return unregisterTable;
-    }
-    measureColumns(info) {
-        if (this.batch !== null) {
-            this.batch.push(...info);
-        }
-        else {
-            this.autoFitBatch(info, () => this.end());
-        }
-    }
-    autoFit(...columns) {
-        const nonLockedColumns = columns.filter(column => !column.isLocked);
-        this.autoFitStart(nonLockedColumns);
-        this.autoFitBatch(this.batch, () => {
-            if (nonLockedColumns.length < columns.length) {
-                const lockedColumns = columns.filter(column => column.isLocked);
-                this.autoFitStart(lockedColumns);
-                this.autoFitBatch(this.batch, () => this.end());
-            }
-            else {
-                this.end();
-            }
-        });
-    }
-    trackColumns(column) {
-        this.resizedColumns = [];
-        this.column = column;
-    }
-    autoFitStart(columns) {
-        this.batch = [];
-        this.resizedColumns = [];
-        if (columns.length === 0) {
-            return;
-        }
-        const locked = columns[0].isLocked;
-        this.changes.emit({
-            type: 'start',
-            columns,
-            locked
-        });
-        this.changes.emit({
-            type: 'triggerAutoFit',
-            columns,
-            locked
-        });
-    }
-    autoFitBatch(info, onComplete) {
-        const locked = info.length > 0 ? info[0].column.isLocked : false;
-        const observables = this.tables
-            .filter(table => table.locked === locked)
-            .map(table => table.autoFit(info));
-        zip(...observables)
-            .pipe(take(1))
-            .subscribe(widths => {
-            this.changes.emit({
-                columns: info.map(i => i.column),
-                type: 'autoFitComplete',
-                widths,
-                locked
-            });
-            if (onComplete) {
-                onComplete();
-            }
-        });
-        this.batch = null;
-    }
-};
-ColumnResizingService = tslib_1.__decorate([
-    Injectable()
-], ColumnResizingService);
-export { ColumnResizingService };
-export { ɵ0, ɵ1 };

package/dist/es2015/column-resizing/table.directive.d.ts

@@ -1,30 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { ChangeDetectorRef, ElementRef, NgZone, OnDestroy, OnInit, Renderer2 } from '@angular/core';
-import { ColumnResizingService } from './column-resizing.service';
-/**
- * @hidden
- */
-export declare class TableDirective implements OnInit, OnDestroy {
-    private element;
-    private renderer;
-    private service;
-    private zone;
-    private cdr;
-    locked: boolean;
-    virtualColumns: boolean;
-    readonly minWidth: number | null;
-    private originalWidth;
-    private firstResize;
-    private subscription;
-    private autoFitSubscription;
-    constructor(element: ElementRef, renderer: Renderer2, service: ColumnResizingService, zone: NgZone, cdr: ChangeDetectorRef);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    private initState;
-    private resize;
-    private autoFitObservable;
-    private measureColumn;
-}

package/dist/es2015/column-resizing/table.directive.js

@@ -1,136 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { ChangeDetectorRef, Directive, ElementRef, HostBinding, Input, NgZone, Renderer2 } from '@angular/core';
-import { Observable } from 'rxjs';
-import { resizableColumns } from '../columns/column-common';
-import { ColumnResizingService } from './column-resizing.service';
-import { filter, tap, map, switchMap, bufferCount } from 'rxjs/operators';
-/**
- * @hidden
- */
-const columnsToResize = ({ columns }) => Math.max(1, resizableColumns(columns).length);
-const ɵ0 = columnsToResize;
-/**
- * @hidden
- */
-const row = selector => element => element.querySelector(selector);
-const ɵ1 = row;
-/**
- * @hidden
- */
-const headerRow = index => element => element.querySelectorAll('thead>tr')[index];
-const ɵ2 = headerRow;
-/**
- * @hidden
- */
-const cell = (index, selector = 'td') => element => element.querySelectorAll(`${selector}:not(.k-group-cell):not(.k-hierarchy-cell)`)[index];
-const ɵ3 = cell;
-/**
- * @hidden
- */
-const offsetWidth = element => element.offsetWidth;
-const ɵ4 = offsetWidth;
-/**
- * @hidden
- */
-const pipe = (...fns) => data => fns.reduce((state, fn) => state ? fn(state) : 0, data);
-const ɵ5 = pipe;
-/**
- * @hidden
- */
-let TableDirective = class TableDirective {
-    constructor(element, renderer, service, zone, cdr) {
-        this.element = element;
-        this.renderer = renderer;
-        this.service = service;
-        this.zone = zone;
-        this.cdr = cdr;
-        this.locked = false;
-        this.firstResize = false;
-    }
-    get minWidth() {
-        return this.firstResize ? 0 : null;
-    }
-    ngOnInit() {
-        const obs = this.service
-            .changes.pipe(filter(e => this.locked === e.locked));
-        this.subscription = obs.pipe(filter(e => e.type === 'start'), tap(this.initState.bind(this)), map(columnsToResize), switchMap((take) => obs.pipe(filter(e => e.type === 'resizeTable'), map(e => e.delta), bufferCount(take)))).subscribe(this.resize.bind(this));
-        this.autoFitSubscription = this.service
-            .registerTable({
-            autoFit: this.autoFitObservable.bind(this),
-            locked: this.locked
-        });
-    }
-    ngOnDestroy() {
-        if (this.subscription) {
-            this.subscription.unsubscribe();
-        }
-        if (this.autoFitSubscription) {
-            this.autoFitSubscription();
-            this.autoFitSubscription = null;
-        }
-    }
-    initState() {
-        this.firstResize = true;
-        if (!this.virtualColumns || this.locked) {
-            this.originalWidth = offsetWidth(this.element.nativeElement);
-        }
-    }
-    resize(deltas) {
-        if (!this.virtualColumns || this.locked) {
-            const delta = deltas.reduce((sum, item) => sum + item, 0);
-            const width = this.originalWidth + delta;
-            this.renderer.setStyle(this.element.nativeElement, 'width', width + 'px');
-        }
-        this.cdr.detectChanges();
-    }
-    autoFitObservable(columnInfo) {
-        return Observable.create(observer => {
-            this.zone.runOutsideAngular(() => {
-                this.renderer.addClass(this.element.nativeElement, 'k-autofitting');
-                this.cdr.detectChanges();
-                const widths = columnInfo.map(this.measureColumn.bind(this));
-                this.renderer.removeClass(this.element.nativeElement, 'k-autofitting');
-                observer.next(widths);
-            });
-        });
-    }
-    measureColumn(info) {
-        const dom = this.element.nativeElement;
-        const header = pipe(headerRow(info.level), cell(info.headerIndex, 'th'), offsetWidth)(dom);
-        let data = 0;
-        if (!info.isParentSpan || (info.isParentSpan && info.isLastInSpan)) {
-            data = pipe(row('tbody>tr:not(.k-grouping-row):not(.k-grid-norecords)'), cell(info.index), offsetWidth)(dom);
-        }
-        const footer = pipe(row('tfoot>tr'), cell(info.index), offsetWidth)(dom);
-        return Math.max(header, data, footer);
-    }
-};
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", Boolean)
-], TableDirective.prototype, "locked", void 0);
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", Boolean)
-], TableDirective.prototype, "virtualColumns", void 0);
-tslib_1.__decorate([
-    HostBinding('style.min-width'),
-    tslib_1.__metadata("design:type", Number),
-    tslib_1.__metadata("design:paramtypes", [])
-], TableDirective.prototype, "minWidth", null);
-TableDirective = tslib_1.__decorate([
-    Directive({
-        selector: 'table' // tslint:disable-line:directive-selector
-    }),
-    tslib_1.__metadata("design:paramtypes", [ElementRef,
-        Renderer2,
-        ColumnResizingService,
-        NgZone,
-        ChangeDetectorRef])
-], TableDirective);
-export { TableDirective };
-export { ɵ0, ɵ1, ɵ2, ɵ3, ɵ4, ɵ5 };

package/dist/es2015/columns/checkbox-column.component.d.ts

@@ -1,81 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { TemplateRef } from '@angular/core';
-import { ColumnBase } from './column-base';
-import { CellTemplateDirective } from '../rendering/cell-template.directive';
-import { IdService } from '../common/id.service';
-/**
- * Represents the checkbox for selecting columns in the Grid. If the column is
- * defined as empty, it renders a default checkbox for row selection.
- * You can also define the content of the column inside an `<ng-template>` tag.
- * The input requires you to include the `SelectionCheckbox` option.
- *
- * The template context is set to the current data item and the following additional fields are passed:
- * - `columnIndex`&mdash;The current column index.
- * - `rowIndex`&mdash;The current data row index. If inside a new item row, it will be `-1`.
- * - `dataItem`&mdash;The current data item.
- * - `column`&mdash;The current column instance.
- * - `isNew`&mdash;The state of the current item.
- *
- * For more examples, refer to:
- * - [Selecting or deselecting all items on a page]({% slug selection_grid %}#toc-select-all-feature)
- * - [Persisting the selection]({% slug selection_grid %}#toc-in-combination-with-the-select-all-feature)
- *
- * @example
- * ```ts-preview
- *
- * _@Component({
- *    selector: 'my-app',
- *    template: `
- *        <kendo-grid [data]="gridData" [selectable]="{enabled: true, checkboxOnly: true}">
- *          <kendo-grid-column field="ProductID" title="Product ID" width="120">
- *          </kendo-grid-column>
- *          <kendo-grid-column field="ProductName" title="Product Name">
- *          </kendo-grid-column>
- *          <kendo-grid-checkbox-column title="Default checkbox">
- *          </kendo-grid-checkbox-column>
- *          <kendo-grid-checkbox-column title="Custom checkbox">
- *            <ng-template kendoGridCellTemplate let-idx="rowIndex">
- *              Select row <input [kendoGridSelectionCheckbox]="idx" />
- *            </ng-template>
- *          </kendo-grid-checkbox-column>
- *        </kendo-grid>
- *    `
- * })
- *
- * class AppComponent {
- *    public gridData: any[];
- *
- *    constructor() {
- *        this.gridData = products;
- *    }
- * }
- *
- * const products = [{
- *    "ProductID": 1,
- *    "ProductName": "Chai",
- *    "UnitPrice": 18.0000,
- *    "Discontinued": true
- *  }, {
- *    "ProductID": 2,
- *    "ProductName": "Chang",
- *    "UnitPrice": 19.0000,
- *    "Discontinued": false
- *  }
- * ];
- *
- * ```
- */
-export declare class CheckboxColumnComponent extends ColumnBase {
-    parent?: ColumnBase;
-    /**
-     * Determines whether a select-all `kendoGridSelectAllCheckbox` checkbox will be displayed in the header.
-     */
-    showSelectAll: boolean;
-    readonly isCheckboxColumn: boolean;
-    template: CellTemplateDirective;
-    constructor(parent?: ColumnBase, idService?: IdService);
-    readonly templateRef: TemplateRef<any>;
-}