import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
import * as i0 from '@angular/core';
import { InjectionToken, TemplateRef, ElementRef, QueryList, OnDestroy, ChangeDetectorRef, EventEmitter, AfterViewInit, NgZone, AfterContentInit, OnInit } from '@angular/core';
import { NxViewportService } from '@aposin/ng-aquila/utils';
import { Subject } from 'rxjs';
import { FocusMonitor } from '@angular/cdk/a11y';
import * as _angular_cdk_bidi_module_d_IN1Vp56w from '@angular/cdk/bidi-module.d-IN1Vp56w';
import { Directionality, Direction } from '@angular/cdk/bidi';
import { ScrollDispatcher } from '@angular/cdk/scrolling';
import * as i1 from '@angular/common';
import * as i2 from '@aposin/ng-aquila/icon';
import { NxButtonBase } from '@aposin/ng-aquila/button';

interface ComparisonTableDefaultOptions {
    /** Sets if the expandable area of a row group uses the full width of the row or leaves out the first column. (optional) */
    useFullRowForExpandableArea?: boolean;
}
declare const COMPARISON_TABLE_DEFAULT_OPTIONS: InjectionToken<ComparisonTableDefaultOptions>;
/**
 * The size of the window.
 * @docs-private
 */
type NxComparisonTableViewType = 'mobile' | 'tablet' | 'desktop';
/** The type of the row. */
type NxComparisonTableRowType = 'header' | 'content' | 'footer';

declare class NxComparisonTableDescriptionCell {
    readonly _table: NxComparisonTableBase;
    readonly _row: NxComparisonTableRowBase;
    _content: TemplateRef<any>;
    _mobileCell: ElementRef;
    /** Sets the Id of the description cell. */
    set id(value: string);
    get id(): string;
    private _id;
    constructor(_table: NxComparisonTableBase, _row: NxComparisonTableRowBase);
    _getMobileClipPathInset(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxComparisonTableDescriptionCell, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxComparisonTableDescriptionCell, "nx-comparison-table-description-cell", never, { "id": { "alias": "id"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/** @docs-private */
declare abstract class NxComparisonTableRowBase {
    cells: QueryList<NxComparisonTableCell>;
    descriptionCell: NxComparisonTableDescriptionCell;
    popularCell?: NxComparisonTablePopularCell;
    abstract type: NxComparisonTableRowType;
    abstract mayStick: boolean;
    abstract _isPartOfToggleSection(): boolean;
    abstract _isPartOfRowGroup(): boolean;
    abstract _isIntersectionRow(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxComparisonTableRowBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxComparisonTableRowBase, never, never, {}, {}, never, never, true, never>;
}

declare class NxComparisonTablePopularCell {
    readonly _table: NxComparisonTableBase;
    readonly _row: NxComparisonTableRowBase;
    _content: TemplateRef<any>;
    /** Sets the Id of the popular cell. */
    set id(value: string);
    get id(): string;
    private _id;
    /**
     * Sets the id of the column above which the popular cell should be displayed.
     *
     * Note: counting starts from 1. If set to 1 the popular cell will appear above the first header column of the table.
     */
    set forColumn(value: NumberInput);
    get forColumn(): number;
    private _forColumn?;
    constructor(_table: NxComparisonTableBase, _row: NxComparisonTableRowBase);
    static ɵfac: i0.ɵɵFactoryDeclaration<NxComparisonTablePopularCell, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxComparisonTablePopularCell, "nx-comparison-table-popular-cell", never, { "id": { "alias": "id"; "required": false; }; "forColumn": { "alias": "forColumn"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/** @docs-private */
declare abstract class NxComparisonTableBase implements OnDestroy {
    private readonly viewportService;
    protected readonly _cdr: ChangeDetectorRef;
    selectedIndexChange: EventEmitter<number>;
    _disabledIndexes: number[];
    _hiddenIndexes: number[];
    _view?: NxComparisonTableViewType | null;
    abstract selectedIndex: number;
    readonly viewTypeChange: EventEmitter<NxComparisonTableViewType>;
    private _viewType;
    protected readonly _destroyed: Subject<void>;
    abstract isError: boolean;
    /** Get all header cells of the table. */
    abstract _getHeaderCells(): NxComparisonTableCell[];
    /** How many product columns the table has. */
    abstract _infoColumnCount(): number;
    /** Get the popular cell of the table. */
    abstract _getPopularCell(): NxComparisonTablePopularCell;
    /** Add a column to the list of disabled columns. */
    abstract _addDisabledColumn(disabledColumn: number): void;
    /** Remove a column from the list of disabled columns. */
    abstract _removeDisabledColumn(enabledColumn: number): void;
    /** Get the mobile clipping path for a cell that should be cut when scrolling. */
    abstract _getMobileClipPathInset(cellRect: DOMRect): string;
    /**
     * Bring an element into view in case it is hidden by the sticky header row on top,
     * optionally with some additional space above the element.
     */
    abstract _scrollElementIntoView(element: ElementRef, additionalSpacing?: number): void;
    /** @docs-private */
    get viewType(): NxComparisonTableViewType;
    readonly _viewChanges: Subject<void>;
    constructor(viewportService: NxViewportService, _cdr: ChangeDetectorRef);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxComparisonTableBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxComparisonTableBase, never, never, {}, {}, never, never, true, never>;
}

declare class NxToggleSectionHeaderComponent implements AfterViewInit, OnDestroy {
    readonly _table: NxComparisonTableBase;
    readonly _toggleSection: NxToggleSectionBase;
    private readonly _focusMonitor;
    private readonly _ngZone;
    _content: TemplateRef<any>;
    _mobileCell: ElementRef;
    _wrapperElement: ElementRef;
    /** Preserves the current value of the _wrapperElement ViewChild in case it changes. */
    private _wrapperElementPrevious;
    /** Sets the id of the toggle section header. */
    set id(value: string);
    get id(): string;
    private _id;
    private readonly _destroyed;
    constructor(_table: NxComparisonTableBase, _toggleSection: NxToggleSectionBase, _focusMonitor: FocusMonitor, _ngZone: NgZone, platformId: string);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private _updateFocusMonitoringTimeout;
    private _updateFocusMonitoring;
    /** Toggles the toggle section. */
    toggle(): void;
    _onKeydown($event: KeyboardEvent): void;
    _getMobileClipPathInset(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxToggleSectionHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxToggleSectionHeaderComponent, "nx-comparison-table-toggle-section-header", never, { "id": { "alias": "id"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/** @docs-private */
declare abstract class NxToggleSectionBase {
    /** Whether the toggle section is expanded. */
    abstract isExpanded: boolean;
    toggleSectionHeader: NxToggleSectionHeaderComponent;
    /** @docs-private */
    abstract _numberOfRows(): number;
    /** Toggles the toggle section. */
    toggleExpanded(): void;
    /** @docs-private */
    getOpenState(): "closed" | "open";
    static ɵfac: i0.ɵɵFactoryDeclaration<NxToggleSectionBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxToggleSectionBase, never, never, {}, {}, never, never, true, never>;
}

declare class NxComparisonTableCell {
    readonly _table: NxComparisonTableBase;
    private readonly _row;
    private readonly _toggleSection;
    _content: TemplateRef<any>;
    /** @docs-private */
    set index(newValue: number);
    get index(): number;
    private _index;
    /**
     * Sets all cells below a header cell to be disabled (disabled column).
     *
     * **Important**: this property can be set only on header cells.
     */
    set disabledColumn(value: BooleanInput);
    get disabledColumn(): boolean;
    private _disabledColumn;
    /** @docs-private */
    readonly indexChange: EventEmitter<number>;
    /** Sets the Id of the cell. */
    set id(value: string);
    get id(): string;
    private _id;
    /** Sets the type of the cell. Default: 'content'. */
    set type(value: NxComparisonTableRowType);
    get type(): NxComparisonTableRowType;
    private _type;
    get _isCellDisabled(): boolean;
    constructor(_table: NxComparisonTableBase, _row: NxComparisonTableRowBase, _toggleSection: NxToggleSectionBase | null);
    _isSelected(): boolean;
    _isCellHidden(): boolean;
    _selectCell(): void;
    _getHeaderIds(): string;
    _isFirst(): boolean;
    _isLast(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxComparisonTableCell, [null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxComparisonTableCell, "nx-comparison-table-cell", never, { "index": { "alias": "index"; "required": false; }; "disabledColumn": { "alias": "disabledColumn"; "required": false; }; "id": { "alias": "id"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "indexChange": "indexChange"; }, never, ["*"], true, never>;
}

/** @docs-private */
declare abstract class NxComparisonTableRowGroupBase {
    abstract _isPartOfToggleSection(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxComparisonTableRowGroupBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxComparisonTableRowGroupBase, never, never, {}, {}, never, never, true, never>;
}

declare class NxComparisonTableIntersectionCell {
    readonly _table: NxComparisonTableBase;
    readonly _row: NxComparisonTableRowBase;
    readonly _toggleSection: NxToggleSectionBase | null;
    _content: TemplateRef<any>;
    constructor(_table: NxComparisonTableBase, _row: NxComparisonTableRowBase, _toggleSection: NxToggleSectionBase | null);
    _getHeaderIds(): string;
    _getMobileRowspan(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxComparisonTableIntersectionCell, [null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxComparisonTableIntersectionCell, "nx-comparison-table-intersection-cell", never, {}, {}, never, ["*"], true, never>;
}

/**
 * This is a base class for `NxToggleSectionDirective` and `NxComparisonTableRowDirective`.
 * @docs-private
 */
declare class NxTableContentElement {
    static ɵfac: i0.ɵɵFactoryDeclaration<NxTableContentElement, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxTableContentElement, never, never, {}, {}, never, never, true, never>;
}

declare class NxComparisonTableRowDirective extends NxComparisonTableRowBase implements AfterContentInit, OnDestroy, NxTableContentElement {
    private readonly _toggleSection;
    private readonly _rowGroup;
    /** @docs-private */
    cells: QueryList<NxComparisonTableCell>;
    /** @docs-private */
    intersectionCell: NxComparisonTableIntersectionCell;
    /** @docs-private */
    descriptionCell: NxComparisonTableDescriptionCell;
    /** @docs-private */
    popularCell: NxComparisonTablePopularCell;
    readonly _requestCellClippingUpdate$: Subject<void>;
    /** Sets the type of the row. Default: 'content'. */
    set type(newValue: NxComparisonTableRowType);
    get type(): NxComparisonTableRowType;
    private _type;
    set mayStick(newValue: BooleanInput);
    get mayStick(): boolean;
    private _mayStick;
    private readonly _destroyed;
    constructor(_toggleSection: NxToggleSectionBase | null, _rowGroup: NxComparisonTableRowGroupBase | null);
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    _setCellIndexes(): void;
    _isPartOfToggleSection(): boolean;
    _isPartOfRowGroup(): boolean;
    _isIntersectionRow(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxComparisonTableRowDirective, [{ optional: true; }, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxComparisonTableRowDirective, "[nxComparisonTableRow]", never, { "type": { "alias": "type"; "required": false; }; "mayStick": { "alias": "mayStick"; "required": false; }; }, {}, ["intersectionCell", "descriptionCell", "popularCell", "cells"], never, true, never>;
}

declare class NxComparisonTableRowGroupDirective extends NxComparisonTableRowGroupBase implements NxTableContentElement {
    private readonly _toggleSection;
    private readonly _defaultOptions;
    /** @docs-private */
    rows: QueryList<NxComparisonTableRowDirective>;
    /**
     * Sets the label of the expandable area that is shown when the row group is collapsed.
     */
    set labelCollapsed(newValue: string);
    get labelCollapsed(): string;
    private _labelCollapsed;
    /** Sets the label of the expandable area that is shown when the row group is expanded. */
    set labelExpanded(newValue: string);
    get labelExpanded(): string;
    private _labelExpanded;
    /** Sets the number of rows that are visible when loading the component. Default: 5. */
    set visibleRows(value: NumberInput);
    get visibleRows(): number;
    private _visibleRows;
    /** Sets the expanded state of the row group */
    set isExpanded(value: BooleanInput);
    get isExpanded(): boolean;
    private _isExpanded;
    /**
     * **Expert Option**.
     *
     * Sets if the expandable area uses the full width of the row or leaves out the first column.
     *
     * Default: `false`.
     */
    set useFullRowForExpandableArea(value: BooleanInput);
    get useFullRowForExpandableArea(): boolean;
    private _useFullRowForExpandableArea?;
    /** An event emitted every time the expanded state of the group changes */
    readonly isExpandedChange: EventEmitter<boolean>;
    constructor(_toggleSection: NxToggleSectionBase | null, _defaultOptions: ComparisonTableDefaultOptions | null);
    _isPartOfToggleSection(): boolean;
    _handleIsExpandedChange(value: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxComparisonTableRowGroupDirective, [{ optional: true; }, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxComparisonTableRowGroupDirective, "[nxComparisonTableRowGroup]", never, { "labelCollapsed": { "alias": "labelCollapsed"; "required": false; }; "labelExpanded": { "alias": "labelExpanded"; "required": false; }; "visibleRows": { "alias": "visibleRows"; "required": false; }; "isExpanded": { "alias": "isExpanded"; "required": false; }; "useFullRowForExpandableArea": { "alias": "useFullRowForExpandableArea"; "required": false; }; }, { "isExpandedChange": "isExpandedChange"; }, ["rows"], never, true, never>;
}

/**
 *
 *Component that is only used internally for displaying a `nxComparisonTableRow`
 *(header, content and footer rows) in desktop and tablet view.
 * @docs-private
 */
declare class NxComparisonTableFlexRow implements OnDestroy, AfterViewInit {
    readonly _table: NxComparisonTableBase;
    private readonly _elementRef;
    private readonly _focusMonitor;
    row: NxComparisonTableRowDirective;
    private readonly _destroyed;
    constructor(_table: NxComparisonTableBase, _elementRef: ElementRef, _focusMonitor: FocusMonitor);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    get elementRef(): ElementRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxComparisonTableFlexRow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxComparisonTableFlexRow, "nx-comparison-table-flex-row", never, { "row": { "alias": "row"; "required": false; }; }, {}, never, never, true, never>;
}

declare class NxToggleSectionDirective extends NxToggleSectionBase implements NxTableContentElement {
    /** @docs-private */
    toggleSectionHeader: NxToggleSectionHeaderComponent;
    /** @docs-private */
    rows: QueryList<NxTableContentElement>;
    /** Whether the toggle section is expanded. Default: true. */
    set isExpanded(value: boolean);
    get isExpanded(): boolean;
    private _isExpanded;
    _numberOfRows(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxToggleSectionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxToggleSectionDirective, "[nxComparisonTableToggleSection]", never, { "isExpanded": { "alias": "isExpanded"; "required": false; }; }, {}, ["toggleSectionHeader", "rows"], never, true, never>;
}

declare class NxComparisonTableComponent extends NxComparisonTableBase implements OnInit, AfterViewInit, OnDestroy {
    private readonly _element;
    private readonly _dir;
    protected readonly _cdr: ChangeDetectorRef;
    private readonly scrollDispatch;
    private readonly _ngZone;
    /** @docs-private */
    elements: QueryList<NxTableContentElement>;
    set isError(error: boolean);
    get isError(): boolean;
    private _isError;
    private readonly _scrollableArea;
    _headerRowElement: NxComparisonTableFlexRow;
    _desktopContentDiv: ElementRef;
    /** The top value for the clip-path of the _desktopContentDiv. */
    _desktopContentClip: number;
    _stickyMobileCell: ElementRef;
    /**
     * The value of the right or left edge of the first column of the mobile table,
     * that describes the threshold for how much clip-path is needed.
     */
    private _mobileStickyEdge?;
    /** Sets which info column is selected. */
    set selectedIndex(value: NumberInput);
    get selectedIndex(): number;
    private _selectedIndex?;
    /** An event that is is dispatched each time selected index of the table has changed. */
    readonly selectedIndexChange: EventEmitter<number>;
    /** Sets which column is hidden. */
    set hiddenIndexes(value: number[]);
    get hiddenIndexes(): number[];
    /** Sets the layout explicitely. If not specified, a layout will be set based on the viewport. */
    set view(value: NxComparisonTableViewType | null | undefined);
    get view(): NxComparisonTableViewType | null | undefined;
    constructor(_element: ElementRef, _dir: Directionality | null, viewportService: NxViewportService, _cdr: ChangeDetectorRef, scrollDispatch: ScrollDispatcher, _ngZone: NgZone);
    /** @docs-private */
    get dir(): _angular_cdk_bidi_module_d_IN1Vp56w.a;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private _scrollHandler;
    _updateCellClipping(): void;
    _getMobileClipPathInset(cellRect: DOMRect): string;
    /** Whether the element is a row. */
    _isRow(element: NxTableContentElement): element is NxComparisonTableRowDirective;
    /** Whether the element is a toggle section. */
    _isToggleSection(element: NxTableContentElement): element is NxToggleSectionDirective;
    /** Whether the element is a row group. */
    _isRowGroup(element: NxTableContentElement): element is NxComparisonTableRowGroupDirective;
    /** Whether row is the first item in a new block of rows or a section. */
    _isFirstInfoOfBlock(rowIndex: number): boolean;
    _getHeaderCells(): NxComparisonTableCell[];
    _getPopularCell(): NxComparisonTablePopularCell;
    _getFooterCells(): NxComparisonTableCell[];
    _containsToggleSection(): boolean;
    _infoColumnCount(): number;
    _getMobileColumnCount(): number;
    _isMobileRowDisabled(i: number): boolean;
    _addDisabledColumn(disabledColumn: number): void;
    _removeDisabledColumn(enabledColumn: number): void;
    _getHeaderRow(): NxComparisonTableRowDirective;
    _scrollElementIntoView(element: ElementRef, additionalSpacing?: number): void;
    private _getScrollParent;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxComparisonTableComponent, [null, { optional: true; }, null, null, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxComparisonTableComponent, "nx-comparison-table", never, { "isError": { "alias": "isError"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "hiddenIndexes": { "alias": "hiddenIndexes"; "required": false; }; "view": { "alias": "view"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; }, ["elements"], never, true, never>;
}

declare class NxComparisonTableSelectButton extends NxButtonBase implements OnDestroy {
    readonly _cell: NxComparisonTableCell;
    private readonly _table;
    /** Sets the label that is displayed when the column is selected. Default: 'Selected'. */
    set selectedLabel(value: string);
    get selectedLabel(): string;
    private _selectedLabel;
    /** Sets the label that is displayed when the column is not selected. Default: 'Select'. */
    set unselectedLabel(value: string);
    get unselectedLabel(): string;
    private _unselectedLabel;
    /** Sets the classNames (style, size and negative) of the unselected button. Default: 'secondary small'. */
    set unselectedClassNames(value: string);
    get unselectedClassNames(): string;
    private _unselectedClassNames;
    /** Sets the classNames (style, size and negative) of the selected button. Default: 'primary small'. */
    set selectedClassNames(value: string);
    get selectedClassNames(): string;
    private _selectedClassNames;
    _ariaPressed: boolean;
    private readonly _destroyed;
    constructor(_cdr: ChangeDetectorRef, _elementRef: ElementRef, _cell: NxComparisonTableCell, _table: NxComparisonTableBase, _focusMonitor: FocusMonitor);
    ngOnDestroy(): void;
    private _setClassNames;
    _selectCell(): void;
    _getButtonLabel(): string;
    private _setAriaPressed;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxComparisonTableSelectButton, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxComparisonTableSelectButton, "button[nxComparisonTableSelectButton]", never, { "selectedLabel": { "alias": "selectedLabel"; "required": false; }; "unselectedLabel": { "alias": "unselectedLabel"; "required": false; }; "unselectedClassNames": { "alias": "unselectedClassNames"; "required": false; }; "selectedClassNames": { "alias": "selectedClassNames"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Component that is only used internally for displaying a `nxComparisonTableRowGroup` in desktop and tablet view.
 * @docs-private
 */
declare class NxComparisonTableDesktopGroup implements AfterViewInit, OnDestroy {
    readonly _table: NxComparisonTableBase;
    private readonly _focusMonitor;
    private readonly _dir;
    private readonly _defaultOptions;
    group: NxComparisonTableRowGroupDirective;
    _expansionCell: ElementRef;
    /** Preserves the current value of the _expansionCell ViewChild in case it changes. */
    private _expansionCellPrevious;
    /** Sets if the row group is expanded. Default: false. */
    set isExpanded(value: BooleanInput);
    get isExpanded(): boolean;
    _expanded: boolean;
    /** Sets if the expansion cell uses the full row of the table or leaves out the first column. Default: false. */
    set useFullRowForExpandableArea(value: BooleanInput);
    get useFullRowForExpandableArea(): boolean;
    _useFullRowForExpandableArea: boolean;
    readonly isExpandedChange: EventEmitter<boolean>;
    private readonly _destroyed;
    constructor(_table: NxComparisonTableBase, _focusMonitor: FocusMonitor, _dir: Directionality | null, _defaultOptions: ComparisonTableDefaultOptions | null);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /** The text direction of the containing app. */
    get dir(): Direction;
    toggleGroup(): void;
    _updateFocusMonitoring(): void;
    _onKeydown(event: KeyboardEvent): void;
    getOpenState(): "closed" | "open";
    get _expandedAreaColspan(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxComparisonTableDesktopGroup, [null, null, { optional: true; }, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxComparisonTableDesktopGroup, "nx-comparison-table-desktop-group", never, { "group": { "alias": "group"; "required": false; }; "isExpanded": { "alias": "isExpanded"; "required": false; }; "useFullRowForExpandableArea": { "alias": "useFullRowForExpandableArea"; "required": false; }; }, { "isExpandedChange": "isExpandedChange"; }, never, never, true, never>;
}

declare class NxComparisonTableModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NxComparisonTableModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NxComparisonTableModule, never, [typeof i1.CommonModule, typeof i2.NxIconModule, typeof NxComparisonTableComponent, typeof NxComparisonTableCell, typeof NxComparisonTableDescriptionCell, typeof NxComparisonTableIntersectionCell, typeof NxToggleSectionDirective, typeof NxToggleSectionHeaderComponent, typeof NxComparisonTableRowDirective, typeof NxComparisonTableSelectButton, typeof NxComparisonTableFlexRow, typeof NxComparisonTableRowGroupDirective, typeof NxComparisonTableDesktopGroup, typeof NxComparisonTablePopularCell], [typeof NxComparisonTableComponent, typeof NxComparisonTableCell, typeof NxComparisonTableDescriptionCell, typeof NxComparisonTableIntersectionCell, typeof NxToggleSectionDirective, typeof NxToggleSectionHeaderComponent, typeof NxComparisonTableRowDirective, typeof NxComparisonTableSelectButton, typeof NxComparisonTableFlexRow, typeof NxComparisonTableRowGroupDirective, typeof NxComparisonTableDesktopGroup, typeof NxComparisonTablePopularCell]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NxComparisonTableModule>;
}

export { COMPARISON_TABLE_DEFAULT_OPTIONS, NxComparisonTableBase, NxComparisonTableCell, NxComparisonTableComponent, NxComparisonTableDescriptionCell, NxComparisonTableDesktopGroup, NxComparisonTableFlexRow, NxComparisonTableIntersectionCell, NxComparisonTableModule, NxComparisonTablePopularCell, NxComparisonTableRowBase, NxComparisonTableRowDirective, NxComparisonTableRowGroupDirective, NxComparisonTableSelectButton, NxTableContentElement, NxToggleSectionDirective, NxToggleSectionHeaderComponent };
export type { ComparisonTableDefaultOptions, NxComparisonTableRowType, NxComparisonTableViewType };