@koobiq/components 19.8.3 → 20.1.0

package/timezone/index.d.ts

@@ -1 +1,123 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { ElementRef, AfterViewInit, OnDestroy, AfterContentInit, PipeTransform } from '@angular/core';
+import * as i2 from '@koobiq/components/core';
+import { KbqOption } from '@koobiq/components/core';
+import * as i6 from '@koobiq/components/tooltip';
+import { KbqTooltipTrigger } from '@koobiq/components/tooltip';
+import * as i3 from '@koobiq/components/select';
+import { KbqSelect, KbqSelectPanelWidth } from '@koobiq/components/select';
+import * as i1 from '@angular/cdk/overlay';
+import * as i4 from '@koobiq/components/icon';
+import * as i5 from '@koobiq/components/tags';
+import * as i7 from '@angular/common';
+import * as i8 from '@angular/cdk/a11y';
+import * as i14 from '@koobiq/components/form-field';
+
+interface KbqTimezoneZone {
+    id: string;
+    offset: string;
+    city: string;
+    countryCode: string;
+    countryName: string;
+    cities: string;
+}
+interface KbqTimezoneGroup {
+    countryName: string;
+    countryCode: string;
+    zones: KbqTimezoneZone[];
+}
+interface KbqTimezonesByCountry {
+    [countryName: string]: KbqTimezoneZone[];
+}
+
+declare class KbqTimezoneOption extends KbqOption {
+    readonly tooltipContentWrapper: i0.Signal<ElementRef<HTMLElement>>;
+    readonly tooltipContent: i0.Signal<ElementRef<HTMLElement>>;
+    readonly highlightText: i0.InputSignal<string>;
+    get timezone(): KbqTimezoneZone;
+    set timezone(zone: KbqTimezoneZone);
+    private _timezone;
+    get viewValue(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneOption, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTimezoneOption, "kbq-timezone-option", ["kbqTimezoneOption"], { "highlightText": { "alias": "highlightText"; "required": false; "isSignal": true; }; "timezone": { "alias": "timezone"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const TOOLTIP_VISIBLE_ROWS_COUNT = 3;
+declare class KbqTimezoneOptionTooltip extends KbqTooltipTrigger implements AfterViewInit, OnDestroy {
+    private readonly option;
+    private readonly changeDetectorRef;
+    private readonly resizeObserver;
+    private readonly contentObserver;
+    private readonly platform;
+    private readonly debounceInterval;
+    private resizeSubscription;
+    private contentObserverSubscription;
+    private focusMonitorSubscription;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    handleElementEnter(): void;
+    handleElementLeave(): void;
+    private checkTooltipDisabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneOptionTooltip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTimezoneOptionTooltip, "kbq-timezone-option", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqTimezoneSelectTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneSelectTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTimezoneSelectTrigger, "kbq-timezone-select-trigger", never, {}, {}, never, never, true, never>;
+}
+declare class KbqTimezoneSelect extends KbqSelect implements AfterContentInit {
+    readonly customTrigger: i0.Signal<KbqTimezoneSelectTrigger | undefined>;
+    panelWidth: KbqSelectPanelWidth;
+    panelMinWidth: number;
+    ngAfterContentInit(): void;
+    private updateLocaleParamsForSearch;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneSelect, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTimezoneSelect, "kbq-timezone-select", ["kbqTimezoneSelect"], {}, {}, ["customTrigger"], ["kbq-timezone-select-trigger", "kbq-cleaner", "[kbqSelectSearch]", "[kbq-select-search-empty-result]", "*"], true, never>;
+}
+
+declare class UtcOffsetPipe implements PipeTransform {
+    transform(value: string): {
+        [UTC: string]: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtcOffsetPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UtcOffsetPipe, "utcOffset", true>;
+}
+
+declare class CitiesByFilterPipe implements PipeTransform {
+    transform(value: string, searchPattern?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CitiesByFilterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CitiesByFilterPipe, "citiesByFilter", true>;
+}
+
+declare class KbqTimezoneModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqTimezoneModule, never, [typeof i1.OverlayModule, typeof i2.KbqOptionModule, typeof i3.KbqSelectModule, typeof i4.KbqIconModule, typeof i5.KbqTagsModule, typeof i6.KbqToolTipModule, typeof i2.KbqHighlightModule, typeof i7.KeyValuePipe, typeof i8.A11yModule, typeof UtcOffsetPipe, typeof CitiesByFilterPipe, typeof KbqTimezoneSelect, typeof KbqTimezoneOption, typeof KbqTimezoneOptionTooltip, typeof KbqTimezoneSelectTrigger], [typeof KbqTimezoneSelect, typeof KbqTimezoneOption, typeof KbqTimezoneOptionTooltip, typeof KbqTimezoneSelectTrigger, typeof i14.KbqFormFieldModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqTimezoneModule>;
+}
+
+/**
+ * Convert string timezone offset (formatted offset) to number (minutes)
+ */
+declare function parseOffset(offset: string): number;
+/**
+ * Grouping timezones by countries
+ */
+declare function getZonesGroupedByCountry(data: KbqTimezoneZone[], otherCountriesLabel?: string, priorityCountry?: string): KbqTimezoneGroup[];
+declare function offset(value: any): string;
+declare function offsetFormatter(value: string): string;
+declare function offsetFormatterAsObject(value: string): {
+    [UTC: string]: string;
+};
+/**
+ * Comparator for timezone sorting. Sort by offset and country name
+ */
+declare function timezonesSortComparator(first: KbqTimezoneZone, second: KbqTimezoneZone): number;
+/**
+ * Filtering timezone cities by search string
+ */
+declare function filterCitiesBySearchString(cities: string, searchPattern?: string): string;
+
+export { KbqTimezoneModule, KbqTimezoneOption, KbqTimezoneOptionTooltip, KbqTimezoneSelect, KbqTimezoneSelectTrigger, TOOLTIP_VISIBLE_ROWS_COUNT, filterCitiesBySearchString, getZonesGroupedByCountry, offset, offsetFormatter, offsetFormatterAsObject, parseOffset, timezonesSortComparator };
+export type { KbqTimezoneGroup, KbqTimezoneZone, KbqTimezonesByCountry };

package/title/index.d.ts

@@ -1 +1,131 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, TemplateRef } from '@angular/core';
+import * as i1 from '@koobiq/components/tooltip';
+import { KbqTooltipTrigger } from '@koobiq/components/tooltip';
+import { Subject } from 'rxjs';
+
+/**
+ * Shows a tooltip with the full text of the host element, but only when that text is truncated —
+ * i.e. it overflows horizontally, or vertically when clamped to several lines. The tooltip opens on
+ * hover and on keyboard focus, and hides on blur, mouse leave, or window resize.
+ *
+ * By default, the tooltip content is the trimmed `textContent` of the host. Provide explicit content
+ * with `[kbq-title]="stringOrTemplateRef"`. For nested markup, mark the measured container with the
+ * `#kbqTitleContainer` template reference and the text element(s) with `#kbqTitleText`; several
+ * `#kbqTitleText` elements are supported and the tooltip is shown when any of them overflows.
+ *
+ * Host components that provide `KBQ_TITLE_TEXT_REF` (e.g. `KbqOption`) supply the text and parent
+ * elements automatically, so the directive works without explicit template references.
+ */
+declare class KbqTitleDirective extends KbqTooltipTrigger implements AfterViewInit, OnDestroy {
+    /** Optional host component that exposes the measured text/parent elements via `KBQ_TITLE_TEXT_REF`. */
+    private componentInstance;
+    /** Host native element the directive is attached to. */
+    private readonly nativeElement;
+    /** SSR-safe window reference used for `getComputedStyle` reads. */
+    private readonly window;
+    /** Observes host content mutations to re-evaluate overflow and refresh the resolved tooltip content. */
+    private contentObserver;
+    /**
+     * Optional explicit tooltip content. Accepts a `TemplateRef` (rendered as rich tooltip content) or a string.
+     * When omitted (a bare `kbq-title` attribute resolves to an empty string), the directive falls back to the
+     * trimmed `textContent` of the host (`viewValue`), preserving the default behavior.
+     */
+    readonly titleContent: i0.InputSignal<string | TemplateRef<any>>;
+    set trigger(value: string);
+    /**
+     * The pop-up trigger. Always reports `PopUpTriggers.Hover`, so the title tooltip reacts to hover and
+     * keyboard focus regardless of the assigned value. The setter is kept only as a no-op workaround so a
+     * host that also uses a popover can assign a trigger without breaking `kbq-title`.
+     */
+    get trigger(): string;
+    /**
+     * Whether the host content is clipped and therefore needs a tooltip. Returns `true` if any measured
+     * text element overflows the parent — covering multiple `#kbqTitleText` elements, the sub-pixel
+     * special case, and both horizontal and vertical overflow.
+     */
+    get isOverflown(): boolean;
+    /** Whether the text is clipped horizontally: the parent `offsetWidth` is smaller than the child `scrollWidth`. */
+    get isHorizontalOverflown(): boolean;
+    /** Whether the text is clipped vertically: the parent `offsetHeight` is smaller than the child `scrollHeight`. */
+    get isVerticalOverflown(): boolean;
+    /**
+     * Compares measured widths, treating only *visible* clipping as overflow. With `text-overflow: ellipsis`
+     * any positive difference counts (even a sub-pixel overflow shows `…`). With `text-overflow: clip` the
+     * widths are rounded to whole CSS pixels first — mirroring the integer `offsetWidth`/`scrollWidth` path —
+     * so an imperceptible sub-pixel clip is not treated as truncation.
+     * @docs-private */
+    private isWidthOverflown;
+    /** Trimmed `textContent` of the measured parent, used as the default tooltip content. */
+    get viewValue(): string;
+    /**
+     * Measured container element. Resolved as the projected `#kbqTitleContainer`, otherwise the
+     * `KBQ_TITLE_TEXT_REF` host's `parentTextElement`, otherwise the host element itself.
+     * @docs-private */
+    get parent(): HTMLElement;
+    /** First effective text element used for overflow detection (the first entry of `childElements`).
+     * @docs-private */
+    get child(): HTMLElement;
+    /** Whether the host element contains exactly one child node and that node is a text node. */
+    get hasOnlyText(): boolean;
+    /**
+     * Whether the measured text truncates with an ellipsis on either the child text element or its
+     * wrapping container. Only then is a sub-pixel overflow actually visible (the trailing glyph is
+     * replaced by `…`); with the default `text-overflow: clip` a sub-pixel clip is imperceptible, so
+     * it must not be reported as truncation. Both elements are checked because `text-overflow` is not
+     * inherited and consumers place it differently: `KbqOption`/`KbqDropdownItem` style the measured
+     * `child`, whereas `KbqTreeOption` styles the `parent` container that wraps the child.
+     * @docs-private */
+    private get hasEllipsis();
+    /** Whether the element's computed `text-overflow` renders an ellipsis.
+     * @docs-private */
+    private elementHasEllipsis;
+    /**
+     * Effective text elements used for overflow detection. Resolves to the projected `#kbqTitleText` elements,
+     * otherwise falls back to the `KbqTitleTextRef` host's `textElement`, otherwise to the host element itself.
+     * Always contains at least one element.
+     * @docs-private */
+    private get childElements();
+    /** Resolved tooltip content: the explicit `titleContent` input when provided, otherwise the host text.
+     * @docs-private */
+    private get resolvedContent();
+    /** Emits `window:resize` events; subscribed to re-evaluate overflow after the viewport changes.
+     * @docs-private */
+    readonly resizeStream: Subject<Event>;
+    /** Debounce/throttle interval (ms) applied to the resize and content-observer streams. */
+    private readonly debounceInterval;
+    /** Subscription to `resizeStream`, torn down in `ngOnDestroy`. */
+    private resizeSubscription;
+    /** Subscription to the content observer, torn down in `ngOnDestroy`. */
+    private contentObserverSubscription;
+    /** Subscription to the focus monitor, torn down in `ngOnDestroy`. */
+    private focusMonitorSubscription;
+    /** Projected text elements marked with the `#kbqTitleText` template reference. */
+    private childContainer;
+    /** Projected container element marked with the `#kbqTitleContainer` template reference. */
+    private parentContainer;
+    /**
+     * Sets the initial tooltip content and wires the streams that toggle the tooltip's `disabled` state:
+     * window resize and content mutations re-evaluate overflow, and keyboard focus opens the tooltip
+     * while other focus origins hide it.
+     */
+    ngAfterViewInit(): void;
+    /** Unsubscribes from the resize, content-observer and focus-monitor streams and stops focus monitoring. */
+    ngOnDestroy(): void;
+    /** Enables the tooltip only when the content is overflown. Bound to `mouseenter` and keyboard focus.
+     * @docs-private */
+    handleElementEnter(): void;
+    /** Always disables (hides) the tooltip. Bound to `mouseleave` and non-keyboard focus changes.
+     * @docs-private */
+    hideTooltip(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTitleDirective, "[kbq-title]", ["kbqTitle"], { "titleContent": { "alias": "kbq-title"; "required": false; "isSignal": true; }; }, {}, ["parentContainer", "childContainer"], never, true, never>;
+}
+
+declare class KbqTitleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTitleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqTitleModule, never, [typeof i1.KbqToolTipModule, typeof KbqTitleDirective], [typeof KbqTitleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqTitleModule>;
+}
+
+export { KbqTitleDirective, KbqTitleModule };

package/toast/index.d.ts

@@ -1 +1,164 @@
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { TemplateRef, InjectionToken, Provider, OnDestroy, ElementRef, ComponentRef, EmbeddedViewRef, ViewContainerRef, ViewRef, Injector } from '@angular/core';
+import { CdkScrollable } from '@angular/cdk/overlay';
+import * as rxjs from 'rxjs';
+import { BehaviorSubject } from 'rxjs';
+import { AnimationEvent } from '@angular/animations';
+import * as i1 from '@koobiq/components/core';
+import { KbqReadStateDirective, ThemePalette } from '@koobiq/components/core';
+
+declare enum KbqToastStyle {
+    Contrast = "contrast",
+    Success = "success",
+    Warning = "warning",
+    Error = "error"
+}
+declare enum KbqToastPosition {
+    TOP_RIGHT = "top-right",
+    TOP_LEFT = "top-left",
+    TOP_CENTER = "top-center",
+    BOTTOM_RIGHT = "bottom-right",
+    BOTTOM_LEFT = "bottom-left",
+    BOTTOM_CENTER = "bottom-center",
+    CENTER = "center"
+}
+declare class KbqToastData {
+    id?: string;
+    title?: string | TemplateRef<any>;
+    style?: KbqToastStyle | string;
+    icon?: TemplateRef<any> | boolean;
+    iconClass?: string;
+    caption?: string | TemplateRef<any>;
+    content?: string | TemplateRef<any>;
+    actions?: TemplateRef<any>;
+    closeButton?: TemplateRef<any> | boolean;
+}
+interface KbqToastConfig {
+    position: KbqToastPosition;
+    duration: number;
+    delay: number;
+    onTop: boolean;
+    /** Custom indentation for positioning the toast stack overlay when using `GlobalPositionStrategy` */
+    indent: {
+        /** Vertical spacing from the top or bottom of the screen. */
+        vertical: number;
+        /** Horizontal spacing from the left or right of the screen. */
+        horizontal: number;
+    };
+}
+declare const defaultToastConfig: KbqToastConfig;
+declare const KBQ_TOAST_CONFIG: InjectionToken<KbqToastConfig>;
+/** Utility provider for `KBQ_TOAST_CONFIG`. */
+declare const kbqToastConfigurationProvider: (configuration: Partial<KbqToastConfig>) => Provider;
+
+declare class KbqToastCloseButton {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqToastCloseButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqToastCloseButton, "[kbq-toast-close-button]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqToastComponent implements OnDestroy {
+    readonly data: KbqToastData;
+    readonly service: KbqToastService<any>;
+    elementRef: ElementRef<HTMLElement>;
+    private focusMonitor;
+    protected readonly readStateDirective: KbqReadStateDirective;
+    themePalette: typeof ThemePalette;
+    animationState: string;
+    readonly hovered: BehaviorSubject<boolean>;
+    readonly focused: BehaviorSubject<boolean>;
+    id: number;
+    ttl: any;
+    delay: any;
+    $implicit: any;
+    get toastStyle(): {
+        [x: string]: boolean;
+    };
+    get isFocusedOrHovered(): boolean;
+    constructor();
+    ngOnDestroy(): void;
+    close(): void;
+    isTemplateRef(value: any): boolean;
+    onAnimation($event: AnimationEvent): void;
+    private runFocusMonitor;
+    private stopFocusMonitor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqToastComponent, "kbq-toast", never, {}, {}, never, never, true, [{ directive: typeof i1.KbqReadStateDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare const KBQ_TOAST_FACTORY: InjectionToken<typeof KbqToastComponent>;
+/** Generic `T` is a type hint only; the runtime component comes from `KBQ_TOAST_FACTORY`. */
+declare class KbqToastService<T extends KbqToastComponent = KbqToastComponent> implements OnDestroy {
+    private overlay;
+    private injector;
+    private overlayContainer;
+    private ngZone;
+    private toastFactory;
+    private toastConfig;
+    get toasts(): ComponentRef<T>[];
+    get templates(): EmbeddedViewRef<T>[];
+    readonly read: BehaviorSubject<KbqToastData | null>;
+    readonly hovered: BehaviorSubject<boolean>;
+    readonly focused: BehaviorSubject<boolean>;
+    readonly animation: BehaviorSubject<AnimationEvent | null>;
+    timer: rxjs.Observable<number>;
+    private containerInstance?;
+    private overlayRef?;
+    private portal?;
+    private timerSubscription;
+    private currentPosition?;
+    private toastsDict;
+    private templatesDict;
+    constructor();
+    ngOnDestroy(): void;
+    show(data: KbqToastData, duration?: number, onTop?: boolean): {
+        ref: ComponentRef<T>;
+        id: number;
+    };
+    showTemplate(data: KbqToastData, template: TemplateRef<any>, duration?: number, onTop?: boolean): {
+        ref: EmbeddedViewRef<T>;
+        id: number;
+    };
+    hide(id: number): void;
+    hideTemplate(id: number): void;
+    private detachOverlay;
+    private processToasts;
+    private updateTTLAfterDelete;
+    private addRemoveTimer;
+    private prepareContainer;
+    private toTop;
+    private createOverlay;
+    private getPositionStrategy;
+    private getTopCenter;
+    private getTopLeft;
+    private getTopRight;
+    private getBottomCenter;
+    private getBottomLeft;
+    private getBottomRight;
+    private getCenter;
+    private getGlobalOverlayPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqToastService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KbqToastService<any>>;
+}
+
+declare class KbqToastContainerComponent extends CdkScrollable {
+    private injector;
+    private changeDetectorRef;
+    readonly service: KbqToastService<any>;
+    readonly viewContainer: i0.Signal<ViewContainerRef>;
+    constructor();
+    createToast<C>(data: KbqToastData, componentType: any, onTop: boolean): ComponentRef<C>;
+    createTemplate<C>(data: KbqToastData, template: TemplateRef<any>, onTop: boolean): EmbeddedViewRef<C>;
+    remove(viewRef: ViewRef): void;
+    getInjector(data: KbqToastData): Injector;
+    dispatchScrollEvent: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqToastContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqToastContainerComponent, "kbq-toast-container", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqToastModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqToastModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqToastModule, never, [typeof KbqToastComponent, typeof KbqToastCloseButton, typeof KbqToastContainerComponent], [typeof KbqToastComponent, typeof KbqToastCloseButton, typeof KbqToastContainerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqToastModule>;
+}
+
+export { KBQ_TOAST_CONFIG, KBQ_TOAST_FACTORY, KbqToastCloseButton, KbqToastComponent, KbqToastContainerComponent, KbqToastData, KbqToastModule, KbqToastPosition, KbqToastService, KbqToastStyle, defaultToastConfig, kbqToastConfigurationProvider };
+export type { KbqToastConfig };

package/toggle/index.d.ts

@@ -1 +1,84 @@
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, OnDestroy, ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { TransitionCheckState, KbqCheckboxClickAction } from '@koobiq/components/checkbox';
+import { KbqColorDirective, KbqCheckedState } from '@koobiq/components/core';
+import * as i1 from '@angular/cdk/a11y';
+
+type ToggleLabelPositionType = 'left' | 'right';
+declare class KbqToggleChange {
+    source: KbqToggleComponent;
+    checked: boolean;
+}
+declare class KbqToggleComponent extends KbqColorDirective implements AfterViewInit, ControlValueAccessor, OnDestroy {
+    private focusMonitor;
+    private changeDetectorRef;
+    readonly big: _angular_core.InputSignal<boolean>;
+    readonly inputElement: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    readonly labelPosition: _angular_core.InputSignal<ToggleLabelPositionType>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    id: string;
+    get inputId(): string;
+    readonly name: _angular_core.InputSignal<string | null>;
+    readonly value: _angular_core.InputSignal<string>;
+    get disabled(): any;
+    set disabled(value: any);
+    private _disabled;
+    get tabIndex(): number;
+    set tabIndex(value: number);
+    private _tabIndex;
+    get checked(): boolean;
+    set checked(value: boolean);
+    private _checked;
+    /**
+     * Whether the toggle is indeterminate. This is also known as "mixed" mode and can be used to
+     * represent a checkbox with three states, e.g. a checkbox that represents a nested list of
+     * checkable items. Note that whenever checkbox is manually clicked, indeterminate is immediately
+     * set to false.
+     */
+    get indeterminate(): boolean;
+    set indeterminate(value: boolean);
+    private _indeterminate;
+    /**
+     * Property for manually set loading state.
+     */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly change: _angular_core.OutputEmitterRef<KbqToggleChange>;
+    /** Event emitted when the toggle's `indeterminate` value changes. */
+    readonly indeterminateChange: _angular_core.OutputEmitterRef<boolean>;
+    /** @docs-private */
+    protected currentCheckState: TransitionCheckState;
+    /** Defines the behavior when a user clicks on the toggle. */
+    clickAction: KbqCheckboxClickAction;
+    private uniqueId;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    focus(): void;
+    getAriaChecked(): KbqCheckedState;
+    onChangeEvent(event: Event): void;
+    onLabelTextChange(): void;
+    onInputClick(event: MouseEvent): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    private setTransitionCheckState;
+    private onTouchedCallback;
+    private onChangeCallback;
+    private transitionCheckState;
+    private emitChangeEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqToggleComponent, "kbq-toggle", ["kbqToggle"], { "big": { "alias": "big"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "clickAction": { "alias": "clickAction"; "required": false; }; }, { "change": "change"; "indeterminateChange": "indeterminateChange"; }, never, ["*", "kbq-hint"], true, never>;
+    static ngAcceptInputType_tabIndex: unknown;
+    static ngAcceptInputType_indeterminate: unknown;
+}
+
+declare class KbqToggleModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqToggleModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqToggleModule, never, [typeof i1.A11yModule, typeof KbqToggleComponent], [typeof KbqToggleComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqToggleModule>;
+}
+
+export { KbqToggleChange, KbqToggleComponent, KbqToggleModule };