@cute-widgets/base 20.0.1

package/bottom-sheet/index.d.ts

@@ -0,0 +1,231 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, EventEmitter, ViewContainerRef, Injector, InjectionToken, ComponentRef, TemplateRef } from '@angular/core';
+import * as i1 from '@angular/cdk/dialog';
+import { CdkDialogContainer, DialogRef } from '@angular/cdk/dialog';
+import * as i2 from '@angular/cdk/portal';
+import { ComponentType } from '@angular/cdk/portal';
+import * as i4 from '@angular/cdk/bidi';
+import { Direction } from '@angular/cdk/bidi';
+import { ScrollStrategy } from '@angular/cdk/overlay';
+import { Observable } from 'rxjs';
+
+/**
+ * @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).
+ */
+
+/**
+ * Internal component that wraps user-provided bottom sheet content.
+ * @docs-private
+ */
+declare class CuteBottomSheetContainer extends CdkDialogContainer implements OnDestroy {
+    private _breakpointSubscription;
+    protected _animationsDisabled: boolean;
+    /** The state of the bottom sheet animations. */
+    _animationState: 'void' | 'visible' | 'hidden';
+    /** Emits whenever the state of the animation changes. */
+    _animationStateChanged: EventEmitter<{
+        toState: "visible" | "hidden";
+        phase: "start" | "done";
+    }>;
+    /** Whether the component has been destroyed. */
+    private _destroyed;
+    constructor(...args: unknown[]);
+    /** Begin animation of bottom sheet entrance into view. */
+    enter(): void;
+    /** Begin animation of the bottom sheet exiting from view. */
+    exit(): void;
+    ngOnDestroy(): void;
+    private _simulateAnimation;
+    protected _trapFocus(): void;
+    protected _handleAnimationEvent(isStart: boolean, animationName: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteBottomSheetContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteBottomSheetContainer, "cute-bottom-sheet-container", never, {}, {}, never, never, true, never>;
+}
+
+declare class CuteBottomSheetModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteBottomSheetModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteBottomSheetModule, never, [typeof i1.DialogModule, typeof i2.PortalModule, typeof CuteBottomSheetContainer], [typeof CuteBottomSheetContainer, typeof i4.BidiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteBottomSheetModule>;
+}
+
+/**
+ * @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).
+ */
+
+/** Options for where to set focus to automatically on dialog open */
+type AutoFocusTarget = 'dialog' | 'first-tabbable' | 'first-heading';
+/** Injection token that can be used to access the data that was passed in to a bottom sheet. */
+declare const CUTE_BOTTOM_SHEET_DATA: InjectionToken<any>;
+/**
+ * Configuration used when opening a bottom sheet.
+ */
+declare class CuteBottomSheetConfig<D = any> {
+    /** The view container to place the overlay for the bottom sheet into. */
+    viewContainerRef?: ViewContainerRef;
+    /**
+     * Injector used for the instantiation of the component to be attached. If provided,
+     * takes precedence over the injector indirectly provided by `ViewContainerRef`.
+     */
+    injector?: Injector;
+    /** Extra CSS classes to be added to the bottom sheet container. */
+    panelClass?: string | string[];
+    /** Text layout direction for the bottom sheet. */
+    direction?: Direction;
+    /** Data being injected into the child component. */
+    data?: D | null;
+    /** Whether the bottom sheet has a backdrop. */
+    hasBackdrop?: boolean;
+    /** Custom class for the backdrop. */
+    backdropClass?: string;
+    /** Whether the user can use escape or clicking outside to close the bottom sheet. */
+    disableClose?: boolean;
+    /** Aria label to assign to the bottom sheet element. */
+    ariaLabel?: string | null;
+    /**
+     * Whether this is a modal dialog. Used to set the `aria-modal` attribute. Off by default,
+     * because it can interfere with other overlay-based components (e.g. `cute-select`) and because
+     * it is redundant since the dialog marks all outside content as `aria-hidden` anyway.
+     */
+    ariaModal?: boolean;
+    /**
+     * Whether the bottom sheet should close when the user goes backwards/forwards in history.
+     * Note that this usually doesn't include clicking on links (unless the user is using
+     * the `HashLocationStrategy`).
+     */
+    closeOnNavigation?: boolean;
+    /**
+     * Where the bottom sheet should focus on open.
+     * @breaking-change 14.0.0 Remove boolean option from autoFocus. Use string or
+     * AutoFocusTarget instead.
+     */
+    autoFocus?: AutoFocusTarget | string | boolean;
+    /**
+     * Whether the bottom sheet should restore focus to the
+     * previously-focused element, after it's closed.
+     */
+    restoreFocus?: boolean;
+    /** Scroll strategy to be used for the bottom sheet. */
+    scrollStrategy?: ScrollStrategy;
+    /** Height for the bottom sheet. */
+    height?: string;
+    /** Minimum height for the bottom sheet. If a number is provided, assumes pixel units. */
+    minHeight?: number | string;
+    /** Maximum height for the bottom sheet. If a number is provided, assumes pixel units. */
+    maxHeight?: number | string;
+}
+
+/**
+ * @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).
+ */
+
+/**
+ * Reference to a bottom sheet dispatched from the bottom sheet service.
+ */
+declare class CuteBottomSheetRef<T = any, R = any> {
+    private _ref;
+    /** Instance of the component making up the content of the bottom sheet. */
+    get instance(): T;
+    /**
+     * `ComponentRef` of the component opened into the bottom sheet. Will be
+     * null when the bottom sheet is opened using a `TemplateRef`.
+     */
+    get componentRef(): ComponentRef<T> | null;
+    /**
+     * Instance of the component into which the bottom sheet content is projected.
+     * @docs-private
+     */
+    containerInstance: CuteBottomSheetContainer;
+    /** Whether the user is allowed to close the bottom sheet. */
+    disableClose: boolean | undefined;
+    /** Subject for notifying the user that the bottom sheet has opened and appeared. */
+    private readonly _afterOpened;
+    /** Result to be passed down to the `afterDismissed` stream. */
+    private _result;
+    /** Handle to the timeout that's running as a fallback in case the exit animation doesn't fire. */
+    private _closeFallbackTimeout;
+    constructor(_ref: DialogRef<R, T>, config: CuteBottomSheetConfig, containerInstance: CuteBottomSheetContainer);
+    /**
+     * Dismisses the bottom sheet.
+     * @param result Data to be passed back to the bottom sheet opener.
+     */
+    dismiss(result?: R): void;
+    /** Gets an observable that is notified when the bottom sheet is finished closing. */
+    afterDismissed(): Observable<R | undefined>;
+    /** Gets an observable that is notified when the bottom sheet has opened and appeared. */
+    afterOpened(): Observable<void>;
+    /**
+     * Gets an observable that emits when the overlay's backdrop has been clicked.
+     */
+    backdropClick(): Observable<MouseEvent>;
+    /**
+     * Gets an observable that emits when keydown events are targeted on the overlay.
+     */
+    keydownEvents(): Observable<KeyboardEvent>;
+}
+
+/** Injection token that can be used to specify default bottom sheet options. */
+declare const CUTE_BOTTOM_SHEET_DEFAULT_OPTIONS: InjectionToken<CuteBottomSheetConfig<any>>;
+/**
+ * Service to trigger Material Design bottom sheets.
+ */
+declare class CuteBottomSheet implements OnDestroy {
+    private _injector;
+    private _parentBottomSheet;
+    private _animationsDisabled;
+    private _defaultOptions;
+    private _bottomSheetRefAtThisLevel;
+    private _dialog;
+    /** Reference to the currently opened bottom sheet. */
+    get _openedBottomSheetRef(): CuteBottomSheetRef<any> | null;
+    set _openedBottomSheetRef(value: CuteBottomSheetRef<any> | null);
+    constructor(...args: unknown[]);
+    /**
+     * Opens a bottom sheet containing the given component.
+     * @param component Type of the component to load into the bottom sheet.
+     * @param config Extra configuration options.
+     * @returns Reference to the newly-opened bottom sheet.
+     */
+    open<T, D = any, R = any>(component: ComponentType<T>, config?: CuteBottomSheetConfig<D>): CuteBottomSheetRef<T, R>;
+    /**
+     * Opens a bottom sheet containing the given template.
+     * @param template TemplateRef to instantiate as the bottom sheet content.
+     * @param config Extra configuration options.
+     * @returns Reference to the newly-opened bottom sheet.
+     */
+    open<T, D = any, R = any>(template: TemplateRef<T>, config?: CuteBottomSheetConfig<D>): CuteBottomSheetRef<T, R>;
+    /**
+     * Dismisses the currently-visible bottom sheet.
+     * @param result Data to pass to the bottom sheet instance.
+     */
+    dismiss<R = any>(result?: R): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteBottomSheet, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuteBottomSheet>;
+}
+
+export { CUTE_BOTTOM_SHEET_DATA, CUTE_BOTTOM_SHEET_DEFAULT_OPTIONS, CuteBottomSheet, CuteBottomSheetConfig, CuteBottomSheetContainer, CuteBottomSheetModule, CuteBottomSheetRef };
+export type { AutoFocusTarget };

package/button/index.d.ts

@@ -0,0 +1,182 @@
+import * as i0 from '@angular/core';
+import { DoCheck, NgZone, InjectionToken, QueryList } from '@angular/core';
+import { CuteFocusableControl } from '@cute-widgets/base/abstract';
+import { RelativeSize7, ThemeColor, toThemeColor } from '@cute-widgets/base/core';
+import { Ripple } from '@cute-widgets/base/core/ripple';
+import { RelativeSize5 } from '@cute-widgets/base/core/types';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1 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).
+ */
+
+/** Button's appearance style */
+type CuteButtonStyle = "base-button" | "flat-button" | "outline-button" | "raised-button" | "pill-button" | "circle-button" | "close-button" | "icon-button" | "fab-button"
+/** Appearance styles for Angular Material compatibility */
+ | "text" | "filled" | "elevated" | "outlined" | "tonal";
+/** Object that can be used to configure the default options for the button component. */
+interface CuteButtonConfig {
+    /** Whether disabled buttons should be interactive. */
+    disabledInteractive?: boolean;
+    /** Default palette color to apply to buttons. */
+    color?: ThemeColor;
+}
+/** Injection token that can be used to provide the default options the button component. */
+declare const CUTE_BUTTON_CONFIG: InjectionToken<CuteButtonConfig>;
+/**
+ * Injection token that can be used to reference instances of `CuteButtonBase`.
+ * It serves as an alternative token to the actual `CuteButtonBase` class, which
+ * could cause unnecessary retention of the class and its component metadata.
+ */
+declare const CUTE_BUTTON_BASE: InjectionToken<CuteButtonBase>;
+declare abstract class CuteButtonBase extends CuteFocusableControl implements DoCheck {
+    private _cleanupClick;
+    private _destroyed$;
+    protected readonly _ripple: Ripple;
+    protected readonly _ngZone: NgZone;
+    protected readonly _isAnchor: boolean;
+    private _icons;
+    /** Button's appearance style in the following format: `{style}-button` */
+    get inputButtonStyle(): CuteButtonStyle;
+    set inputButtonStyle(value: CuteButtonStyle | undefined | "");
+    private _inputButtonStyle;
+    private _buttonStyle;
+    /** Relative size of the Button */
+    magnitude: RelativeSize7 | undefined;
+    /** Whether to disable text wrapping */
+    nowrap: boolean;
+    /** Whether to disable the ripple effect on button clicking */
+    get disableRipple(): boolean;
+    set disableRipple(value: boolean);
+    /** `aria-disabled` value of the button. */
+    ariaDisabled: boolean | undefined;
+    /** Whether to show the collapse/expand indicator based on the `aria-expanded` current value. */
+    withAriaExpandedIndicator: boolean;
+    /**
+     * Natively disabled buttons prevent focus and any pointer events from reaching the button.
+     * In some scenarios, this might not be desirable, because it can prevent users from finding out
+     * why the button is disabled (e.g., via tooltip).
+     *
+     * Enabling this input will change the button so that it is styled to be disabled and will be
+     * marked as `aria-disabled`, but it will allow the button to receive events and focus.
+     *
+     * Note that by enabling this, you need to set the `tabindex` yourself if the button isn't
+     * meant to be tabbable, and you have to prevent the button action (e.g., form submissions).
+     */
+    get disabledInteractive(): boolean | undefined;
+    set disabledInteractive(value: boolean | undefined);
+    private _disabledInteractive;
+    /** Label text that applied for visually hidden button */
+    visuallyHiddenLabel: string | undefined;
+    protected get classNames(): string;
+    /** Focus shadow color for `close-button` */
+    protected get _closeButtonShadowColor(): string;
+    protected get buttonLargestBinding(): boolean;
+    protected get buttonLargerBinding(): boolean;
+    protected get buttonLargeBinding(): boolean;
+    protected get buttonSmallBinding(): boolean;
+    protected get buttonSmallerBinding(): boolean;
+    protected get buttonSmallestBinding(): boolean;
+    protected get iconButtonColorBinding(): string;
+    protected get baseButtonColorBinding(): string;
+    /** Returns button style name. */
+    get buttonStyle(): string;
+    protected get bsColorVarName(): string;
+    protected constructor(...args: unknown[]);
+    protected generateId(): string;
+    protected _getTabIndex(): number | undefined;
+    private _setupAsAnchor;
+    protected setDisabledState(newState: boolean): boolean;
+    private _savedTabIndex;
+    protected _getAriaDisabled(): boolean | null;
+    protected _getDisabledAttribute(): true | null;
+    protected _haltDisabledEvents(event: Event): void;
+    /** Whether to apply a `focus-ring` css-class to the button when it focused via keyboard interaction */
+    protected get displayFocusRing(): boolean;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    /** mouse events handler */
+    private _onMouseEvent;
+    private _launchRipple;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteButtonBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteButtonBase, never, never, { "inputButtonStyle": { "alias": "cuteButton"; "required": false; }; "magnitude": { "alias": "magnitude"; "required": false; }; "nowrap": { "alias": "nowrap"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; "ariaDisabled": { "alias": "aria-disabled"; "required": false; }; "withAriaExpandedIndicator": { "alias": "withAriaExpandedIndicator"; "required": false; }; "disabledInteractive": { "alias": "disabledInteractive"; "required": false; }; "visuallyHiddenLabel": { "alias": "visuallyHiddenLabel"; "required": false; }; }, {}, ["_icons"], never, true, never>;
+    static ngAcceptInputType_ariaDisabled: unknown;
+    static ngAcceptInputType_withAriaExpandedIndicator: unknown;
+    static ngAcceptInputType_disabledInteractive: unknown;
+}
+
+declare class CuteButton extends CuteButtonBase {
+    constructor();
+    protected readonly toThemeColor: typeof toThemeColor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteButton, "button[cuteButton],             button[cute-button],             a[cuteButton],             a[cute-button],  ", ["cuteButton"], {}, {}, never, [".material-icons:not([iconPositionEnd]),\n                      .bi:not([iconPositionEnd]),\n                      cute-icon:not([iconPositionEnd]),\n                      cute-avatar:not([iconPositionEnd]),\n                      [cuteButtonIcon]:not([iconPositionEnd])", "*", ".material-icons[iconPositionEnd],\n                      .bi:[iconPositionEnd],\n                      cute-icon[iconPositionEnd],\n                      cute-avatar:[iconPositionEnd],\n                      [cuteButtonIcon][iconPositionEnd]"], 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
+ */
+
+/**
+ * Group a series of buttons together on a single line or stack them in a vertical column.
+ */
+declare class CuteButtonGroup extends CuteFocusableControl {
+    /** Whether to place the nested buttons in the vertical direction. */
+    vertical: boolean;
+    /** The relative size of the buttons group. */
+    magnitude: RelativeSize5 | undefined;
+    /** Default style for the content buttons */
+    buttonStyle: CuteButtonStyle | undefined;
+    protected get buttonLargerBinding(): boolean;
+    protected get buttonLargeBinding(): boolean;
+    protected get buttonSmallerBinding(): boolean;
+    protected get buttonSmallBinding(): boolean;
+    /** Child buttons. */
+    _buttons: QueryList<CuteButtonBase> | undefined;
+    constructor();
+    protected generateId(): string;
+    protected setDisabledState(newState: BooleanInput, emitEvent?: boolean): boolean;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteButtonGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteButtonGroup, "cute-button-group", ["cuteButtonGroup"], { "vertical": { "alias": "vertical"; "required": false; }; "magnitude": { "alias": "magnitude"; "required": false; }; "buttonStyle": { "alias": "buttonStyle"; "required": false; }; }, {}, ["_buttons"], never, true, never>;
+    static ngAcceptInputType_vertical: unknown;
+}
+
+declare class CuteButtonToolbar extends CuteFocusableControl {
+    private _gap;
+    /** The gutter between buttons */
+    get gap(): number;
+    set gap(value: number);
+    magnitude: RelativeSize5 | undefined;
+    /** Child buttons. */
+    constructor();
+    protected generateId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteButtonToolbar, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteButtonToolbar, "cute-button-toolbar", ["cuteButtonToolbar"], { "gap": { "alias": "gap"; "required": false; }; "magnitude": { "alias": "magnitude"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_gap: unknown;
+}
+
+declare class CuteButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteButtonModule, never, [typeof i1.CommonModule, typeof CuteButton, typeof CuteButtonGroup, typeof CuteButtonToolbar], [typeof CuteButton, typeof CuteButtonGroup, typeof CuteButtonToolbar]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteButtonModule>;
+}
+
+export { CUTE_BUTTON_BASE, CUTE_BUTTON_CONFIG, CuteButton, CuteButtonBase, CuteButtonGroup, CuteButtonModule, CuteButtonToolbar };
+export type { CuteButtonConfig, CuteButtonStyle };

package/button-toggle/index.d.ts

@@ -0,0 +1,225 @@
+import * as i0 from '@angular/core';
+import { OnInit, AfterContentInit, QueryList, EventEmitter, InjectionToken, OnDestroy } from '@angular/core';
+import { CuteButtonGroup, CuteButtonStyle, CuteButtonBase } from '@cute-widgets/base/button';
+import { ControlValueAccessor } from '@angular/forms';
+import { Direction } from '@angular/cdk/bidi';
+import { toThemeColor } from '@cute-widgets/base/core';
+import * as i1 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
+ */
+
+/**
+ * Injection token that can be used to reference instances of `CuteButtonToggleGroup`.
+ * It serves as an alternative token to the actual `CuteButtonToggleGroup` class which
+ * could cause unnecessary retention of the class and its component metadata.
+ */
+declare const CUTE_BUTTON_TOGGLE_GROUP: InjectionToken<CuteButtonToggleGroup>;
+/**
+ * Provider Expression that allows cute-button-toggle-group to register as a ControlValueAccessor.
+ * This allows it to support [(ngModel)].
+ * @docs-private
+ */
+declare const CUTE_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR: any;
+/** Exclusive selection button toggle group that behaves like a radio-button group. */
+declare class CuteButtonToggleGroup extends CuteButtonGroup implements ControlValueAccessor, OnInit, AfterContentInit {
+    private _dir;
+    private _multiple;
+    private _selectionModel;
+    /**
+     * Reference to the raw value that the consumer tried to assign. The real
+     * value will exclude any values from this one that don't correspond to a
+     * toggle. Useful for the cases where the value is assigned before the toggles
+     * have been initialized or at the same that they're being swapped out.
+     */
+    private _rawValue;
+    /**
+     * The method to be called in order to update ngModel.
+     * Now `ngModel` binding is not supported in multiple selection mode.
+     */
+    private _controlValueAccessorChangeFn;
+    /** onTouch function registered via registerOnTouch (ControlValueAccessor). */
+    _onTouched: () => any;
+    /** Child button toggle buttons. */
+    _buttonToggles: QueryList<CuteButtonToggle> | undefined;
+    /** The button toggle default style. Only outlined buttons supported. */
+    buttonStyle: Extract<CuteButtonStyle, "outlined" | "outline-button">;
+    /** `name` attribute for the underlying `input` element. */
+    get name(): string;
+    set name(value: string);
+    private _name;
+    /** Value of the toggle group. */
+    get value(): any;
+    set value(newValue: any);
+    /** Selected button toggles in the group. */
+    get selected(): CuteButtonToggle | CuteButtonToggle[];
+    /** Whether multiple button toggles can be selected. */
+    get multiple(): boolean;
+    set multiple(value: boolean);
+    /** Whether buttons in the group should be interactive while they're disabled. */
+    get disabledInteractive(): boolean;
+    set disabledInteractive(value: boolean);
+    private _disabledInteractive;
+    /** Whether the checkmark indicator for single-selection button toggle groups is hidden. */
+    get hideSingleSelectionIndicator(): boolean;
+    set hideSingleSelectionIndicator(value: boolean);
+    private _hideSingleSelectionIndicator;
+    /** Whether the checkmark indicator for multiple-selection button toggle groups is hidden. */
+    get hideMultipleSelectionIndicator(): boolean;
+    set hideMultipleSelectionIndicator(value: boolean);
+    private _hideMultipleSelectionIndicator;
+    /**
+     * Event that emits whenever the value of the group changes.
+     * Used to facilitate two-way data binding.
+     * @docs-private
+     */
+    readonly valueChange: EventEmitter<any>;
+    /** Event emitted when the group's value changes. */
+    readonly change: EventEmitter<CuteButtonToggleChange>;
+    /** The layout direction of the toggle button group. */
+    get dir(): Direction;
+    constructor(...args: unknown[]);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    /** Initializes the tabindex attribute using the radio pattern. */
+    private _initializeTabIndex;
+    /**
+     * Sets the model value. Implemented as part of ControlValueAccessor.
+     * @param value Value to be set to the model.
+     */
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): boolean;
+    /** Handle keydown event calling to single-select button toggle. */
+    protected _keydown(event: KeyboardEvent): void;
+    /** Dispatch change event with current selection and group value. */
+    private _emitChangeEvent;
+    /**
+     * Syncs a button toggle's selected state with the model value.
+     * @param toggle Toggle to be synced.
+     * @param select Whether the toggle should be selected.
+     * @param isUserInput Whether the change was a result of a user interaction.
+     * @param deferEvents Whether to defer emitting the change events.
+     */
+    _syncButtonToggle(toggle: CuteButtonToggle, select: boolean, isUserInput?: boolean, deferEvents?: boolean): void;
+    /** Checks whether a button toggle is selected. */
+    _isSelected(toggle: CuteButtonToggle): boolean;
+    /** Determines whether a button toggle should be checked on init. */
+    _isPrechecked(toggle: CuteButtonToggle): boolean;
+    /** Obtains the subsequent toggle to which the focus shifts. */
+    private _getNextButton;
+    /** Updates the selection state of the toggles in the group based on a value. */
+    private _setSelectionByValue;
+    /** Clears the selected toggles. */
+    private _clearSelection;
+    /** Selects a value if there's a toggle that corresponds to it. */
+    private _selectValue;
+    /** Syncs up the group's value with the model and emits the change event. */
+    private _updateModelValue;
+    /** Marks all the child button toggles to be checked. */
+    private _markButtonsForCheck;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteButtonToggleGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteButtonToggleGroup, "cute-button-toggle-group", ["cuteButtonToggleGroup"], { "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "disabledInteractive": { "alias": "disabledInteractive"; "required": false; }; "hideSingleSelectionIndicator": { "alias": "hideSingleSelectionIndicator"; "required": false; }; "hideMultipleSelectionIndicator": { "alias": "hideMultipleSelectionIndicator"; "required": false; }; }, { "valueChange": "valueChange"; "change": "change"; }, ["_buttonToggles"], never, true, never>;
+    static ngAcceptInputType_multiple: unknown;
+    static ngAcceptInputType_disabledInteractive: unknown;
+    static ngAcceptInputType_hideSingleSelectionIndicator: unknown;
+    static ngAcceptInputType_hideMultipleSelectionIndicator: unknown;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Represents the default options for the button toggle that can be configured
+ * using the `CUTE_BUTTON_TOGGLE_DEFAULT_OPTIONS` injection token.
+ */
+interface CuteButtonToggleDefaultOptions {
+    /**
+     * Default appearance to be used by button toggles. Can be overridden by explicitly
+     * setting an appearance on a button toggle or group.
+     */
+    /** Whether icon indicators should be hidden for single-selection button toggle groups. */
+    hideSingleSelectionIndicator?: boolean;
+    /** Whether icon indicators should be hidden for multiple-selection button toggle groups. */
+    hideMultipleSelectionIndicator?: boolean;
+    /** Whether disabled toggle buttons should be interactive. */
+    disabledInteractive?: boolean;
+}
+/**
+ * Injection token that can be used to configure the
+ * default options for all button toggles within an app.
+ */
+declare const CUTE_BUTTON_TOGGLE_DEFAULT_OPTIONS: InjectionToken<CuteButtonToggleDefaultOptions>;
+/** Change event object emitted by button toggle. */
+declare class CuteButtonToggleChange {
+    /** The button toggle that emits the event. */
+    source: CuteButtonToggle;
+    /** The value assigned to the button toggle. */
+    value: any;
+    constructor(
+    /** The button toggle that emits the event. */
+    source: CuteButtonToggle, 
+    /** The value assigned to the button toggle. */
+    value: any);
+}
+/** Single toggle button that should be nested directly inside a toggle group.  */
+declare class CuteButtonToggle extends CuteButtonBase implements OnInit, OnDestroy {
+    private _animationDisabled;
+    protected _multiple: boolean;
+    /** The parent button toggle group (exclusive selection). Optional. */
+    protected readonly buttonToggleGroup: CuteButtonToggleGroup;
+    /** Unique ID for the underlying `button` element. */
+    get buttonId(): string;
+    get inputButtonStyle(): Extract<CuteButtonStyle, "outlined" | "outline-button">;
+    set inputButtonStyle(value: Extract<CuteButtonStyle, "outlined" | "outline-button">);
+    /** HTML's 'name' attribute used to group radios for unique selection. */
+    name: string | undefined;
+    /** CuteButtonToggleGroup reads this to assign its own value. */
+    value: any;
+    /** Whether ripples are disabled on the button toggle. */
+    /** Whether the button is checked. */
+    get checked(): boolean;
+    set checked(value: boolean);
+    private _checked;
+    /** Whether the button should remain interactive when it is disabled. */
+    get disabledInteractive(): boolean;
+    set disabledInteractive(value: boolean);
+    /** Event emitted when the group value changes. */
+    readonly change: EventEmitter<CuteButtonToggleChange>;
+    /** Whether the button is disabled. */
+    constructor(...args: unknown[]);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Checks the button toggle due to an interaction with the underlying native button. */
+    _onButtonClick(): void;
+    /** Gets the name that should be assigned to the inner DOM node. */
+    protected _getButtonName(): string | null;
+    /** Whether the toggle is in single selection mode. */
+    private isSingleSelector;
+    protected readonly toThemeColor: typeof toThemeColor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteButtonToggle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteButtonToggle, "cute-button-toggle", ["cuteButtonToggle"], { "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; }, { "change": "change"; }, never, [".material-icons:not([iconPositionEnd]),\n                      .bi:not([iconPositionEnd]),\n                      cute-icon:not([iconPositionEnd]),\n                      cute-avatar:not([iconPositionEnd]),\n                      [cuteButtonIcon]:not([iconPositionEnd])", "*", ".material-icons[iconPositionEnd],\n                      .bi:[iconPositionEnd],\n                      cute-icon[iconPositionEnd],\n                      cute-avatar:[iconPositionEnd],\n                      [cuteButtonIcon][iconPositionEnd]"], true, never>;
+    static ngAcceptInputType_checked: unknown;
+}
+
+declare class CuteButtonToggleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteButtonToggleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteButtonToggleModule, never, [typeof i1.CommonModule, typeof CuteButtonToggle, typeof CuteButtonToggleGroup], [typeof CuteButtonToggle, typeof CuteButtonToggleGroup]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteButtonToggleModule>;
+}
+
+export { CUTE_BUTTON_TOGGLE_DEFAULT_OPTIONS, CUTE_BUTTON_TOGGLE_GROUP, CUTE_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR, CuteButtonToggle, CuteButtonToggleChange, CuteButtonToggleGroup, CuteButtonToggleModule };
+export type { CuteButtonToggleDefaultOptions };