@cute-widgets/base 20.0.1

package/list/index.d.ts

@@ -0,0 +1,659 @@
+import { CuteFocusableControl } from '@cute-widgets/base/abstract';
+import * as i0 from '@angular/core';
+import { InjectionToken, ElementRef, NgZone, QueryList, EventEmitter, SimpleChanges } from '@angular/core';
+import { LayoutBreakpoint, toThemeColor, RelativeSize } from '@cute-widgets/base/core';
+import * as _cute_widgets_base_list from '@cute-widgets/base/list';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { SelectionModel } from '@angular/cdk/collections';
+import * as i1 from '@angular/cdk/listbox';
+import { CdkOption, CdkListbox } from '@angular/cdk/listbox';
+import { ListKeyManager } from '@angular/cdk/a11y';
+import { ControlValueAccessor } from '@angular/forms';
+import { Subject } from 'rxjs';
+import * as i1$1 from '@angular/common';
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/** Object that can be used to configure the default options for the list module. */
+interface CuteListConfig {
+    /** Whether icon indicators should be hidden for single-selection. */
+    hideSingleSelectionIndicator?: boolean;
+}
+/** Injection token that can be used to provide the default options the list module. */
+declare const CUTE_LIST_CONFIG: InjectionToken<CuteListConfig>;
+declare abstract class CuteListBase extends CuteFocusableControl {
+    protected _defaultOptions: CuteListConfig | null;
+    /** Whether the list and its items are not interactive. */
+    _isNonInteractive: boolean;
+    /** Remove some borders and rounded corners to render list group items edge-to-edge in a parent container (e.g., cards) */
+    flushBorders: "full" | "partial" | undefined;
+    /** Generate numbered list group items */
+    numbered: boolean;
+    /**
+     * Whether to apply the layout of list group items from vertical to horizontal across all breakpoints.
+     * Note that currently, horizontal list groups cannot be combined with `flush` list groups.
+     */
+    horizontal: boolean;
+    /** Makes a list group horizontal responsive starting at the `Breakpoint`s _min-width_. */
+    horizontalBreakpoint: LayoutBreakpoint | undefined;
+    /**
+     * Adds `.list-group-horizontal` to change the layout of list group items from vertical to horizontal across all breakpoints.
+     * Currently, **horizontal list groups cannot be combined with flush list groups.**
+     */
+    get getClassList(): string | undefined;
+    protected generateId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteListBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteListBase, never, never, { "flushBorders": { "alias": "flushBorders"; "required": false; }; "numbered": { "alias": "numbered"; "required": false; }; "horizontal": { "alias": "horizontal"; "required": false; }; "horizontalBreakpoint": { "alias": "horizontalBreakpoint"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CuteActionList extends CuteListBase {
+    _isNonInteractive: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteActionList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteActionList, "cute-action-list", ["cuteActionList"], {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Injection token that can be used to inject instances of `CuteList`. It serves as
+ * an alternative token to the actual `CuteList` class which could cause unnecessary
+ * retention of the class and its component metadata.
+ */
+declare const CUTE_LIST: InjectionToken<CuteList>;
+/**
+ * Flexible and powerful component for displaying a series of content.
+ */
+declare class CuteList extends CuteListBase {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteList, "cute-list", ["cuteList"], {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Type describing possible positions of a checkbox or radio in a list option
+ * with respect to the list item's text.
+ */
+type CuteListOptionTogglePosition = 'before' | 'after';
+/**
+ * Interface describing a list option. This is used to avoid circular
+ * dependencies between the list-option and the styler directives.
+ * @docs-private
+ */
+interface ListOption {
+    _getTogglePosition(): CuteListOptionTogglePosition;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Directive capturing the title of a list item. A list item usually consists of a
+ * title and optional secondary or tertiary lines.
+ *
+ * Text content for the title never wraps. There can only be a single title per-list item.
+ */
+declare class CuteListItemTitle {
+    _elementRef: ElementRef<HTMLElement>;
+    constructor(_elementRef: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteListItemTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteListItemTitle, "[cuteListItemTitle]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive capturing a line in a list item. A list item usually consists of a
+ * title and optional secondary or tertiary lines.
+ *
+ * Text content inside a line never wraps. There can be at maximum two lines per list item.
+ */
+declare class CuteListItemLine {
+    _elementRef: ElementRef<HTMLElement>;
+    constructor(_elementRef: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteListItemLine, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteListItemLine, "[cuteListItemLine]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive matching an optional meta-section for list items.
+ *
+ * List items can reserve space at the end of an item to display a control,
+ * button or additional text content.
+ */
+declare class CuteListItemMeta {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteListItemMeta, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteListItemMeta, "[cuteListItemMeta]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * CuteWidgets uses the very intuitively named classes `.cute-list-item__start` and `.cute-list-item__end` to
+ * position content such as icons or checkboxes/radios that comes either before or after the text
+ * content respectively. This directive detects the placement of the checkbox/radio and applies the
+ * correct CuteWidgets class to position the icon/avatar on the opposite side.
+ */
+declare abstract class _CuteListItemGraphicBase {
+    _listOption: ListOption | null;
+    _isAlignedAtStart(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_CuteListItemGraphicBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_CuteListItemGraphicBase, never, never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive matching an optional avatar within a list item.
+ *
+ * List items can reserve space at the beginning of an item to display an avatar.
+ */
+declare class CuteListItemAvatar extends _CuteListItemGraphicBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteListItemAvatar, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteListItemAvatar, "[cuteListItemAvatar]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive matching an optional icon within a list item.
+ *
+ * List items can reserve space at the beginning of an item to display an icon.
+ */
+declare class CuteListItemIcon extends _CuteListItemGraphicBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteListItemIcon, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteListItemIcon, "[cuteListItemIcon]", never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class CuteListItemBase extends CuteFocusableControl {
+    private _document;
+    private _listBase;
+    protected _ngZone: NgZone;
+    protected _navList: _cute_widgets_base_list.CuteNavList | null;
+    protected _isInteractiveItem: boolean;
+    protected toThemeColor: typeof toThemeColor;
+    /** Query list matching list-item line elements. */
+    abstract _lines: QueryList<CuteListItemLine> | undefined;
+    /** Query list matching list-item title elements. */
+    abstract _titles: QueryList<CuteListItemTitle> | undefined;
+    /**
+     * Element reference to the unscoped content in a list item.
+     *
+     * Unscoped content is user-projected text content in a list item that is
+     * not part of an explicit line or title.
+     */
+    abstract _unscopedContent: ElementRef<HTMLSpanElement> | undefined;
+    /** Host element for the list item. */
+    protected _hostElement: HTMLElement;
+    /** indicate whether the host element is a button or not */
+    protected _isButtonElement: boolean;
+    /** Whether animations are disabled. */
+    protected _noopAnimations: boolean;
+    /** Whether the list item has unscoped text content. */
+    _hasUnscopedTextContent: boolean;
+    private _subscriptions;
+    _avatars: QueryList<never> | undefined;
+    _icons: QueryList<never> | undefined;
+    /**
+     * The number of lines this list item should reserve space for. If not specified,
+     * lines are inferred based on the projected content.
+     *
+     * Explicitly specifying the number of lines is useful if you want to acquire additional
+     * space and enable the wrapping of text. The unscoped text content of a list item will
+     * always be able to take up the remaining space of the item, unless it represents the title.
+     *
+     * A maximum of three lines is supported as per the Material Design specification.
+     */
+    set lines(lines: number | string | null);
+    _explicitLines: number | null;
+    protected constructor(...args: unknown[]);
+    private _initInteractiveListItem;
+    /**
+     * Subscribes to changes in the projected title and lines.
+     * Triggers item lines update whenever a change occurs.
+     */
+    private _monitorProjectedLinesAndTitle;
+    /**
+     * Updates the lines of the list item. Based on the projected user content and optional
+     * explicit lines setting, the visual appearance of the list item is determined.
+     *
+     * This method should be invoked whenever the projected user content changes, or
+     * when the explicit lines have been updated.
+     *
+     * @param recheckUnscopedContent Whether the projected unscoped content should be re-checked.
+     *   The unscoped content is not re-checked for every update as it is a rather expensive check
+     *   for content that is expected to not change very often.
+     */
+    _updateItemLines(recheckUnscopedContent: boolean): void;
+    /**
+     * Infers the number of lines based on the projected user content. This is useful
+     * if no explicit number of lines has been specified on the list item.
+     *
+     * The number of lines is inferred based on whether there is a title, the number of
+     * additional lines (secondary/tertiary). An additional line is acquired if there is
+     * unscoped text content.
+     */
+    private _inferLinesFromContent;
+    /** Checks whether the list item has unscoped text content. */
+    private _checkDomForUnscopedTextContent;
+    /** Whether the list item has icons or avatars. */
+    _hasIconOrAvatar(): boolean;
+    protected generateId(): string;
+    /**
+     * "Use `a`s or `button`s to create actionable list group items..." (`Bootstrap` docs)
+     * @returns Whether the list item is actionable
+     */
+    protected isActionItem(): boolean;
+    protected onClick(event: MouseEvent): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteListItemBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteListItemBase, never, never, { "lines": { "alias": "lines"; "required": false; }; }, {}, ["_avatars", "_icons"], never, true, never>;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+declare class CuteListItem extends CuteListItemBase {
+    _lines: QueryList<CuteListItemLine> | undefined;
+    _titles: QueryList<CuteListItemTitle> | undefined;
+    _meta: QueryList<CuteListItemMeta> | undefined;
+    _unscopedContent: ElementRef<HTMLSpanElement> | undefined;
+    _itemText: ElementRef<HTMLElement> | undefined;
+    /** Indicates whether an item in a `<cute-nav-list>` is the currently active page. */
+    get activated(): boolean;
+    set activated(activated: any);
+    private _activated;
+    /**
+     * Determine the value of `aria-current`. Return 'page' if this item is an activated anchor tag.
+     * Otherwise, return `null`. This method is safe to use with server-side rendering.
+     */
+    protected _getAriaCurrent(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteListItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteListItem, "cute-list-item, a[cute-list-item], button[cute-list-item]", ["cuteListItem"], { "activated": { "alias": "activated"; "required": false; }; }, {}, ["_lines", "_titles", "_meta"], ["[cuteListItemAvatar],[cuteListItemIcon]", "[cuteListItemTitle]", "[cuteListItemLine]", "*", "[cuteListItemMeta]", "cute-divider"], true, never>;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Injection token that can be used to reference instances of an `SelectionList`. It serves
+ * as an alternative token to an actual implementation which would result in circular references.
+ */
+declare const SELECTION_LIST: InjectionToken<SelectionList>;
+/**
+ * Interface describing the containing list of a list option. This is used to avoid
+ * circular dependencies between the list-option and the selection list.
+ */
+interface SelectionList extends CuteListBase {
+    multiple: boolean;
+    selectedOptions: SelectionModel<CuteListOption>;
+    hideSingleSelectionIndicator: boolean;
+    compareWith: (o1: any, o2: any) => boolean;
+    _value: string[] | null;
+    _reportValueChange(): void;
+    _emitChangeEvent(options: CuteListOption[]): void;
+    _onTouched(): void;
+}
+declare class CuteListOption extends CuteListItemBase implements ListOption {
+    protected _selectionList: SelectionList;
+    _lines: QueryList<CuteListItemLine> | undefined;
+    _titles: QueryList<CuteListItemTitle> | undefined;
+    _unscopedContent: ElementRef<HTMLSpanElement> | undefined;
+    /**
+     * Emits when the selected state of the option has changed.
+     * Use to facilitate two-data binding to the `selected` property.
+     */
+    readonly selectedChange: EventEmitter<boolean>;
+    /** Whether the label should appear before or after the checkbox/radio. Defaults to 'after' */
+    togglePosition: CuteListOptionTogglePosition;
+    /** Value of the option */
+    get value(): any;
+    set value(newValue: any);
+    private _value;
+    /** Whether the option is selected. */
+    get selected(): boolean;
+    set selected(value: BooleanInput);
+    private _selected;
+    /** Relative size of the internal input element. */
+    iconSize: RelativeSize;
+    protected get hideIndicator(): boolean;
+    protected get hiddenIndicatorSelected(): boolean;
+    /**
+     * This is set to true after the first OnChanges cycle, so we don't
+     * clear the value of `selected` in the first cycle.
+     */
+    private _inputsInitialized;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Toggles the selection state of the option. */
+    toggle(): void;
+    /** Gets the text label of the list option. Used for the typeahead functionality in the list. */
+    getLabel(): string;
+    /** Whether a checkbox is shown at the given position. */
+    _hasCheckboxAt(position: CuteListOptionTogglePosition): boolean;
+    /** Where a radio indicator is shown at the given position. */
+    _hasRadioAt(position: CuteListOptionTogglePosition): boolean;
+    /** Whether icons or avatars are shown at the given position. */
+    _hasIconsOrAvatarsAt(position: 'before' | 'after'): boolean;
+    /** Gets whether the given type of element is projected at the specified position. */
+    _hasProjected(type: 'icons' | 'avatars', position: 'before' | 'after'): boolean;
+    _handleBlur(): void;
+    /** Gets the current position of the checkbox/radio. */
+    _getTogglePosition(): CuteListOptionTogglePosition;
+    /**
+     * Sets the selected state of the option.
+     * @returns Whether the value has changed.
+     * @internal
+     */
+    _setSelected(selected: boolean): boolean;
+    /**
+     * Toggles the option's value based on a user interaction.
+     * @internal
+     */
+    _toggleOnInteraction(): void;
+    /** Sets the tabindex of the list option. */
+    _setTabindex(value: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteListOption, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteListOption, "cute-list-option", ["cuteListOption"], { "togglePosition": { "alias": "togglePosition"; "required": false; }; "value": { "alias": "value"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; }, { "selectedChange": "selectedChange"; }, ["_lines", "_titles"], ["[cuteListItemAvatar],[cuteListItemIcon]", "[cuteListItemTitle]", "[cuteListItemLine]", "*", "cute-divider"], true, never>;
+}
+
+/**
+ * An item within a listbox.
+ *
+ * @experimental
+ */
+declare class CuteListBoxOption extends CuteListItem {
+    protected listBox: CuteListBox;
+    protected cdkOption: CdkOption<any>;
+    /** The value of this option */
+    get value(): any;
+    set value(v: any);
+    /** Whether the option is selected or not. */
+    get selected(): boolean;
+    constructor(listBox: CuteListBox);
+    /** Sets focus to this option */
+    focus(): void;
+    /** Gets the option's label that is part of the `FocusableOption` interface */
+    getLabel(): string;
+    /** Whether this option is active */
+    isActive(): boolean;
+    /** Select this option if it is not selected */
+    select(): void;
+    /** Deselect this option if it is selected */
+    deselect(): void;
+    /** Toggle the selected state of this option */
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteListBoxOption, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteListBoxOption, "cute-listbox-option, a[cute-listbox-option], button[cute-listbox-option]", ["cuteListboxOption"], { "value": { "alias": "value"; "required": false; }; }, {}, never, ["[cuteListItemAvatar],[cuteListItemIcon]", "[cuteListItemTitle]", "[cuteListItemLine]", "*", "[cuteListItemMeta]", "cute-divider"], true, [{ directive: typeof i1.CdkOption; inputs: { "cdkOption": "value"; "cdkOptionTypeaheadLabel": "typeaheadLabel"; "cdkOptionDisabled": "disabled"; "tabindex": "tabindex"; "id": "id"; }; outputs: {}; }]>;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * Injection token that can be used to inject instances of `CuteListBox`. It serves as
+ * an alternative token to the actual `CuteListBox` class which could cause unnecessary
+ * retention of the class and its component metadata.
+ */
+declare const CUTE_LISTBOX: InjectionToken<CuteListBox>;
+/**
+ * A component that displays a list of options for users to select from, supporting keyboard navigation,
+ * single or multiple selection, and screen reader support.
+ *
+ * @experimental
+ */
+declare class CuteListBox extends CuteListBase implements ControlValueAccessor {
+    protected readonly cdkListbox: CdkListbox<any>;
+    protected _keyManager: ListKeyManager<CuteListBoxOption> | undefined;
+    protected _options: QueryList<CuteListBoxOption> | undefined;
+    constructor();
+    /** Deselect the given option */
+    deselect(option: CdkOption): void;
+    /** Deselect the given value */
+    deselectValue(value: any): void;
+    /** Focus the list-box's host element */
+    focus(): void;
+    /** Get whether the given option is active. */
+    isActive(option: CdkOption): boolean;
+    /** Get whether the given option is selected. */
+    isSelected(option: CdkOption): boolean;
+    /** Get whether the given value is selected. */
+    isValueSelected(value: any): boolean;
+    /** Select the given option. */
+    select(option: CdkOption): void;
+    /** Select the given value. */
+    selectValue(value: any): void;
+    /** Set the selected state of all options. */
+    setAllSelected(isSelected: boolean): void;
+    /** Toggle the selected state of the given option. */
+    toggle(option: CdkOption): void;
+    /** Toggle the selected state of the given value. */
+    toggleValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(obj: any): void;
+    setDisabledState(newState: boolean): boolean;
+    protected _handleKeydown(event: KeyboardEvent): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteListBox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteListBox, "cute-listbox", ["cuteListBox"], {}, {}, ["_options"], ["*"], true, [{ directive: typeof i1.CdkListbox; inputs: { "id": "id"; "tabindex": "tabindex"; "cdkListboxMultiple": "multiple"; "cdkListboxValue": "value"; "cdkListboxDisabled": "disabled"; "cdkListboxUseActiveDescendant": "useActiveDescendant"; "cdkListboxOrientation": "orientation"; "cdkListboxNavigationWrapDisabled": "navigationWrapDisabled"; "cdkListboxCompareWith": "compareWith"; "cdkListboxNavigatesDisabledOptions": "navigatesDisabledOptions"; }; outputs: { "cdkListboxValueChange": "valueChange"; }; }]>;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Injection token that can be used to inject instances of `CuteNavList`. It serves as
+ * an alternative token to the actual `CuteNavList` class which could cause unnecessary
+ * retention of the class and its component metadata.
+ */
+declare const CUTE_NAV_LIST: InjectionToken<CuteNavList>;
+declare class CuteNavList extends CuteListBase {
+    _isNonInteractive: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteNavList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteNavList, "cute-nav-list", ["cuteNavList"], {}, {}, never, ["*"], true, never>;
+}
+
+declare const CUTE_SELECTION_LIST_VALUE_ACCESSOR: any;
+/** Change event that is being fired whenever the selected state of an option changes. */
+declare class CuteSelectionListChange {
+    /** Reference to the selection list that emitted the event. */
+    source: CuteSelectionList;
+    /** Reference to the options that have been changed. */
+    options: CuteListOption[];
+    constructor(
+    /** Reference to the selection list that emitted the event. */
+    source: CuteSelectionList, 
+    /** Reference to the options that have been changed. */
+    options: CuteListOption[]);
+}
+declare class CuteSelectionList extends CuteListBase implements SelectionList, ControlValueAccessor {
+    _element: ElementRef<HTMLElement>;
+    private _ngZone;
+    private _initialized;
+    private _keyManager;
+    private _listenerCleanups;
+    /** Subject that emits when the component has been destroyed. */
+    protected readonly _destroyed: Subject<void>;
+    /** Whether the list has been destroyed. */
+    private _isDestroyed;
+    /** View to model callback that should be called whenever the selected options change. */
+    private _onChange;
+    _items: QueryList<CuteListOption> | undefined;
+    /** Emits a change event whenever the selected state of an option changes. */
+    readonly selectionChange: EventEmitter<CuteSelectionListChange>;
+    /**
+     * Function used for comparing an option against the selected value when determining which
+     * options should appear as selected. The first argument is the value of an options. The second
+     * one is a value from the selected value. A boolean must be returned.
+     */
+    compareWith: (o1: any, o2: any) => boolean;
+    /** Whether selection is limited to one or multiple items (default multiple). */
+    get multiple(): boolean;
+    set multiple(value: BooleanInput);
+    private _multiple;
+    /** Whether radio indicator for all list items is hidden. */
+    get hideSingleSelectionIndicator(): boolean;
+    set hideSingleSelectionIndicator(value: BooleanInput);
+    private _hideSingleSelectionIndicator;
+    /** The currently selected options. */
+    selectedOptions: SelectionModel<CuteListOption>;
+    /** Keeps track of the currently selected value. */
+    _value: string[] | null;
+    /** View to model callback that should be called if the list or its options lost focus. */
+    _onTouched: () => void;
+    constructor(...args: unknown[]);
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /** Selects all the options. Returns the options that changed as a result. */
+    selectAll(): CuteListOption[];
+    /** Deselects all the options. Returns the options that changed as a result. */
+    deselectAll(): CuteListOption[];
+    /** Reports a value change to the ControlValueAccessor */
+    _reportValueChange(): void;
+    /** Emits a change event if the selected state of an option changed. */
+    _emitChangeEvent(options: CuteListOption[]): void;
+    /** Implemented as part of ControlValueAccessor. */
+    writeValue(values: string[]): void;
+    /**
+     * Whether the *entire* selection list is disabled. When true, each list item is also disabled,
+     * and each list item is removed from the tab order (has tabindex="-1").
+     */
+    getDisabledState(): boolean;
+    /** Implemented as a part of ControlValueAccessor. */
+    setDisabledState(value: boolean | BooleanInput): boolean;
+    private _selectionListDisabled;
+    /** Implemented as part of ControlValueAccessor. */
+    registerOnChange(fn: (value: any) => void): void;
+    /** Implemented as part of ControlValueAccessor. */
+    registerOnTouched(fn: () => void): void;
+    /** Watches for changes in the selected state of the options and updates the list accordingly. */
+    private _watchForSelectionChange;
+    /** Sets the selected options based on the specified values. */
+    private _setOptionsFromValues;
+    /** Returns the values of the selected options. */
+    private _getSelectedOptionValues;
+    /** Marks all the options to be checked in the next change detection run. */
+    private _markOptionsForCheck;
+    /**
+     * Sets the selected state on all the options
+     * and emits an event if anything changed.
+     */
+    private _setAllOptionsSelected;
+    /** The option components contained within this selection-list. */
+    get options(): QueryList<CuteListOption> | undefined;
+    /** Handles keydown events within the list. */
+    protected _handleKeydown(event: KeyboardEvent): void;
+    /** Handles focusout events within the list. */
+    private _handleFocusout;
+    /** Handles focusin events within the list. */
+    private _handleFocusin;
+    /**
+     * Sets up the logic for maintaining the roving tabindex.
+     *
+     * `skipPredicate` determines if key manager should avoid putting a given list item in the tab
+     * index. Allow disabled list items to receive focus to align with WAI ARIA recommendation.
+     * Normally WAI ARIA's instructions are to exclude disabled items from the tab order, but it
+     * makes a few exceptions for compound widgets.
+     *
+     * From [Developing a Keyboard Interface](
+     * https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/):
+     *   "For the following composite widget elements, keep them focusable when disabled: Options in a
+     *   Listbox..."
+     */
+    private _setupRovingTabindex;
+    /**
+     * Sets an option as active.
+     * @param index Index of the active option. If set to -1, no option will be active.
+     */
+    private _setActiveOption;
+    /**
+     * Resets the active option. When the list is disabled, remove all options from to the tab order.
+     * Otherwise, focus on the first selected option.
+     */
+    private _resetActiveOption;
+    /** Returns whether the focus is currently within the list. */
+    private _containsFocus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteSelectionList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteSelectionList, "cute-selection-list", ["cuteSelectionList"], { "compareWith": { "alias": "compareWith"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "hideSingleSelectionIndicator": { "alias": "hideSingleSelectionIndicator"; "required": false; }; }, { "selectionChange": "selectionChange"; }, ["_items"], ["*"], true, never>;
+}
+
+/**
+ * Directive whose purpose is to add the `cute-` CSS styling to this selector.
+ */
+declare class CuteListSubheaderCssStyler {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteListSubheaderCssStyler, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteListSubheaderCssStyler, "[cute-subheader], [cuteSubheader]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CuteListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteListModule, never, [typeof i1$1.CommonModule, typeof CuteActionList, typeof CuteList, typeof CuteListItem, typeof CuteListItemLine, typeof CuteListItemTitle, typeof CuteListItemMeta, typeof CuteListItemAvatar, typeof CuteListItemIcon, typeof CuteListOption, typeof CuteListSubheaderCssStyler, typeof CuteListBox, typeof CuteListBoxOption, typeof CuteNavList, typeof CuteSelectionList], [typeof CuteActionList, typeof CuteList, typeof CuteListItem, typeof CuteListItemLine, typeof CuteListItemTitle, typeof CuteListItemMeta, typeof CuteListItemAvatar, typeof CuteListItemIcon, typeof CuteListOption, typeof CuteListSubheaderCssStyler, typeof CuteListBox, typeof CuteListBoxOption, typeof CuteNavList, typeof CuteSelectionList]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteListModule>;
+}
+
+export { CUTE_LIST, CUTE_LISTBOX, CUTE_LIST_CONFIG, CUTE_NAV_LIST, CUTE_SELECTION_LIST_VALUE_ACCESSOR, CuteActionList, CuteList, CuteListBase, CuteListBox, CuteListBoxOption, CuteListItem, CuteListItemAvatar, CuteListItemIcon, CuteListItemLine, CuteListItemMeta, CuteListItemTitle, CuteListModule, CuteListOption, CuteListSubheaderCssStyler, CuteNavList, CuteSelectionList, CuteSelectionListChange, SELECTION_LIST, _CuteListItemGraphicBase };
+export type { CuteListConfig, SelectionList };