@koobiq/components 20.4.1 → 21.0.0

package/types/koobiq-components-title.d.ts

@@ -0,0 +1,184 @@
+import * as i0 from '@angular/core';
+import { AfterViewInit, TemplateRef } from '@angular/core';
+import * as i1 from '@koobiq/components/tooltip';
+import { KbqTooltipTrigger } from '@koobiq/components/tooltip';
+
+/**
+ * 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 a resize of the measured container.
+ *
+ * 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 the container
+ * or is clipped by its siblings.
+ *
+ * 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 {
+    /** Optional host component that exposes the measured text/parent elements via `KBQ_TITLE_TEXT_REF`. */
+    private readonly 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 readonly contentObserver;
+    /**
+     * Application-wide `ResizeObserver` shared by every consumer. One directive instance therefore adds no
+     * listener of its own — which matters because `kbq-title` sits on every dropdown item, list option and
+     * tree option — and, unlike a `window:resize` listener, it also reacts to container-only resizes
+     * (splitter drag, sidebar collapse) that leave the window untouched.
+     */
+    private readonly resizeObserver;
+    /**
+     * 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<unknown>>;
+    /**
+     * Overrides the tooltip's hoverable default, as `KbqOptionTooltip` does. The hint spells out text that
+     * the host had to truncate, so it floats over the neighbouring content — and a pointer-capturing pane
+     * would swallow the clicks meant for it.
+     */
+    readonly ignoreTooltipPointerEvents: i0.InputSignal<boolean>;
+    /**
+     * The hint repeats text the host had to clip, so `kbqTooltipDisabled="false"` cannot conjure one for a
+     * fully visible title.
+     *
+     * @docs-private
+     */
+    protected readonly derivedDisabledWins = true;
+    /**
+     * `kbqTrigger` is a single input alias shared by the tooltip, the popover and this directive, so a host
+     * carrying both `kbq-title` and `kbqPopover` feeds one value to both. The title tooltip ignores it and
+     * always behaves as hover + keyboard focus; the setter exists only so such a host keeps working.
+     *
+     * Unifying the alias family is a breaking change owned by the pop-up base, not a title-local fix.
+     */
+    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.
+     */
+    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 — or, with several text elements, if one of
+     * them clips its own content.
+     */
+    get isOverflown(): boolean;
+    /** 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. Never falsy.
+     *
+     * @docs-private
+     */
+    protected get parent(): HTMLElement;
+    /**
+     * Whether the host element contains exactly one child node and that node is a text node.
+     */
+    private get hasOnlyText();
+    /**
+     * 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.
+     */
+    private get childElements();
+    /**
+     * Resolved tooltip content: the explicit `titleContent` input when provided, otherwise the host text.
+     */
+    private get resolvedContent();
+    /** Debounce/throttle interval (ms) applied to the resize and content-observer streams. */
+    private readonly debounceInterval;
+    /** Whether the host holds the keyboard focus, as the focus monitor reports it. */
+    private keyboardFocused;
+    /**
+     * Whether the pointer or the keyboard focus is on the host: the only time the overflow verdict is read. The two
+     * are tracked apart — `hovered` comes from the pop-up base, which binds it to the same `mouseenter`/`mouseleave`
+     * — because a click on a hovered host reports a mouse focus origin that hides the tooltip while the pointer stays
+     * where it was.
+     */
+    private get entered();
+    /** Projected text elements marked with the `#kbqTitleText` template reference. */
+    private readonly childContainer;
+    /** Projected container element marked with the `#kbqTitleContainer` template reference. */
+    private readonly parentContainer;
+    constructor();
+    /**
+     * Sets the initial tooltip content and wires the streams that toggle the tooltip's `disabled` state:
+     * container resizes and content mutations re-evaluate overflow, and keyboard focus opens the tooltip
+     * while other focus origins hide it.
+     */
+    ngAfterViewInit(): void;
+    /**
+     * Enables the tooltip only when the content is overflown. Bound to `mouseenter` and keyboard focus.
+     *
+     * @docs-private
+     */
+    protected handleElementEnter(): void;
+    /**
+     * Always disables (hides) the tooltip. Bound to `mouseleave` and non-keyboard focus changes.
+     *
+     * @docs-private
+     */
+    protected hideTooltip(): void;
+    /**
+     * Whether a single measured text element is clipped by the parent container. Both the single- and the
+     * multi-element host go through this method, so a filter-bar pipe or a two-line list option gets the same
+     * sub-pixel and ellipsis awareness as a plain text host.
+     */
+    private isElementOverflown;
+    /**
+     * Whether a text element is narrower than its own text. Text elements that share the parent can take width
+     * from each other, so one is clipped while its full text would still fit the parent — which the parent
+     * comparison above cannot see. An inline element reports a zero `clientWidth` and never clips.
+     */
+    private isClippedInOwnBox;
+    /**
+     * Compares the container against the width the text occupies when nothing clips it: a probe span
+     * carrying the same text is appended to the container, both are measured, and the probe is removed
+     * again. `finally` guarantees the probe never outlives the measurement — a throw between the append and
+     * the read (e.g. a layout call on a detached tree) would otherwise strand it in the consumer's DOM.
+     *
+     * The container is measured while the probe is attached, as it has been since the sub-pixel path was
+     * introduced: a shrink-to-fit container stretched by the probe must not be reported as clipping it.
+     */
+    private isTextWiderThanContainer;
+    /**
+     * 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.
+     */
+    private isWidthOverflown;
+    /**
+     * Whether the measured text truncates with an ellipsis on either the 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 text element, whereas `KbqTreeOption`
+     * styles the parent container that wraps it.
+     */
+    private hasEllipsis;
+    /**
+     * Whether the element's computed `text-overflow` renders an ellipsis.
+     */
+    private elementHasEllipsis;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTitleDirective, "[kbq-title]", ["kbqTitle"], { "titleContent": { "alias": "kbq-title"; "required": false; "isSignal": true; }; "ignoreTooltipPointerEvents": { "alias": "ignoreTooltipPointerEvents"; "required": false; "isSignal": true; }; }, {}, ["childContainer", "parentContainer"], 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/types/koobiq-components-toast.d.ts

@@ -0,0 +1,289 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, TemplateRef, Provider, OnDestroy, Signal, ComponentRef, EmbeddedViewRef, ViewContainerRef, Type, ViewRef, Injector } from '@angular/core';
+import * as _koobiq_components_core from '@koobiq/components/core';
+import { KbqReadStateDirective } from '@koobiq/components/core';
+import { CdkScrollable } from '@angular/cdk/overlay';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { Subject, BehaviorSubject, Observable } from 'rxjs';
+
+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>;
+    /** Visual style of the toast. Styles outside `KbqToastStyle` render without a default icon. */
+    style?: KbqToastStyle | (string & {});
+    icon?: TemplateRef<any> | boolean;
+    iconClass?: string;
+    caption?: string | TemplateRef<any>;
+    content?: string | TemplateRef<any>;
+    actions?: TemplateRef<any>;
+    closeButton?: TemplateRef<any> | boolean;
+}
+/**
+ * Context of a template rendered by `KbqToastService.showTemplate`.
+ *
+ * Note that it differs from the context of the slot templates passed through `KbqToastData` (title, caption,
+ * content, actions, icon and close button), whose `$implicit` is the `KbqToastComponent` instance.
+ */
+type KbqToastTemplateContext = {
+    $implicit: KbqToastData;
+};
+/**
+ * Narrow contract that a toast consumes from the service owning its stack.
+ *
+ * `KbqToastService` implements it and provides itself under `KBQ_TOAST_STACK` for every toast it creates, so
+ * that a toast never has to depend on the concrete service that instantiates it.
+ */
+interface KbqToastStack {
+    /** Emits the data of a toast once the user has read it. */
+    readonly read: Subject<KbqToastData | null>;
+    /** Removes the toast with the given id from the stack. */
+    hide(id: number): void;
+    /** Reports that the pointer entered or left the toast with the given id. */
+    setHovered(id: number, hovered: boolean): void;
+    /** Reports the origin the toast with the given id is focused with, or `null` once it loses focus. */
+    setFocused(id: number, origin: FocusOrigin): void;
+}
+/** Stack a toast belongs to. Provided by `KbqToastService` for every toast it creates. */
+declare const KBQ_TOAST_STACK: InjectionToken<KbqToastStack>;
+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;
+    };
+}
+/** Frozen so that the fallback every application shares cannot be reconfigured from a single consumer. */
+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;
+    private readonly stack;
+    private readonly elementRef;
+    private readonly focusMonitor;
+    private readonly injector;
+    protected readonly readStateDirective: KbqReadStateDirective;
+    protected readonly a11yLocaleConfiguration: Signal<_koobiq_components_core.KbqA11yLocaleConfiguration>;
+    /** Whether the toast appears and leaves without motion. */
+    protected readonly animationsDisabled: boolean;
+    /** Height the exit animation collapses from, set once the toast leaves. */
+    protected readonly leavingHeight: i0.WritableSignal<number | null>;
+    private readonly _hovered;
+    private readonly _focused;
+    /** Whether the pointer is over the toast. */
+    readonly hovered: Signal<boolean>;
+    /** Whether the toast or an element inside it holds the focus. */
+    readonly focused: Signal<boolean>;
+    id: number;
+    /** Context of the templates a consumer passes through `KbqToastData`. */
+    readonly $implicit: this;
+    protected readonly style: KbqToastStyle | (string & {});
+    protected readonly styleClass: string;
+    protected readonly role: string;
+    protected readonly closeButton: boolean | TemplateRef<any>;
+    protected readonly icon: boolean | TemplateRef<any>;
+    protected readonly defaultIcon: string | null;
+    protected readonly iconTemplate: TemplateRef<{
+        $implicit: KbqToastComponent;
+    }> | null;
+    protected readonly titleTemplate: TemplateRef<{
+        $implicit: KbqToastComponent;
+    }> | null;
+    protected readonly captionTemplate: TemplateRef<{
+        $implicit: KbqToastComponent;
+    }> | null;
+    protected readonly contentTemplate: TemplateRef<{
+        $implicit: KbqToastComponent;
+    }> | null;
+    protected readonly actionsTemplate: TemplateRef<{
+        $implicit: KbqToastComponent;
+    }> | null;
+    protected readonly closeButtonTemplate: TemplateRef<{
+        $implicit: KbqToastComponent;
+    }> | null;
+    private alreadyRead;
+    get isFocusedOrHovered(): boolean;
+    constructor();
+    ngOnDestroy(): void;
+    close(): void;
+    /**
+     * Plays the exit animation of a toast taken off the stack, then calls `done`.
+     *
+     * @docs-private
+     */
+    leave(done: () => void): void;
+    /** @docs-private */
+    protected setHovered(hovered: boolean): void;
+    private markAsRead;
+    private asTemplateRef;
+    private runFocusMonitor;
+    private stopFocusMonitor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqToastComponent, "kbq-toast", never, {}, {}, never, never, true, [{ directive: typeof _koobiq_components_core.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, KbqToastStack {
+    private readonly overlay;
+    private readonly injector;
+    private readonly overlayContainer;
+    private readonly ngZone;
+    private readonly focusMonitor;
+    private readonly document;
+    private readonly toastFactory;
+    private readonly toastConfig;
+    get toasts(): ComponentRef<T>[];
+    get templates(): EmbeddedViewRef<KbqToastTemplateContext>[];
+    readonly read: BehaviorSubject<KbqToastData | null>;
+    private readonly _hovered;
+    private readonly _focused;
+    /** Whether at least one toast is hovered. */
+    readonly hovered: Signal<boolean>;
+    /** Whether at least one toast holds the focus. */
+    readonly focused: Signal<boolean>;
+    private readonly stackSize;
+    /** Subscribed outside Angular so that a tick never runs change detection over the whole application. */
+    private readonly heartbeat;
+    /**
+     * Countdown heartbeat: emits every 500 ms while the stack holds something and is not paused by the pointer
+     * or the keyboard focus. No interval runs while the stack is empty.
+     */
+    readonly timer: Observable<number>;
+    private containerInstance?;
+    private overlayRef?;
+    private portal?;
+    private timerSubscription;
+    private currentPosition?;
+    /** Toasts taken off the stack that still play their exit animation in the container. */
+    private readonly leaving;
+    private toastsDict;
+    private templatesDict;
+    private readonly hoveredToasts;
+    private readonly focusedToasts;
+    private wasPaused;
+    private get isPaused();
+    constructor();
+    ngOnDestroy(): void;
+    show(data: KbqToastData, duration?: number, onTop?: boolean): {
+        ref: ComponentRef<T>;
+        id: number;
+    };
+    /** Body of `show()`. */
+    private addToast;
+    showTemplate(data: KbqToastData, template: TemplateRef<any>, duration?: number, onTop?: boolean): {
+        ref: EmbeddedViewRef<KbqToastTemplateContext>;
+        id: number;
+    };
+    /** Body of `showTemplate()`. */
+    private addTemplate;
+    hide(id: number): void;
+    /** Body of `hide()`. */
+    private removeToast;
+    hideTemplate(id: number): void;
+    /** Body of `hideTemplate()`. */
+    private removeTemplate;
+    /** Reports that the pointer entered or left the toast with the given id. @docs-private */
+    setHovered(id: number, hovered: boolean): void;
+    /** Reports the origin the toast with the given id is focused with, or `null` once it is not. @docs-private */
+    setFocused(id: number, origin: FocusOrigin): void;
+    private updatePauseState;
+    /** Focus must not fall back to the document body when the toast holding it goes away. */
+    private restoreFocus;
+    private getNextFocusTarget;
+    /** Plays the exit animation of a toast taken off the stack, then removes it from the container. */
+    private removeAfterExit;
+    /** Detaching destroys the container, so it waits for the stack to empty and the last exit to end. */
+    private detachOverlay;
+    private syncStackSize;
+    /**
+     * Drops the records whose view was destroyed from outside the service — by a consumer holding the ref,
+     * or by whatever owns the surrounding view. Nothing else deletes them: a record with a `ttl` of `0` is
+     * skipped by the countdown forever, so the stack would keep reporting a size and the heartbeat would
+     * keep running with nothing on screen.
+     */
+    private purgeDestroyed;
+    private processToasts;
+    /** Keeps every survivor on screen for at least the configured delay after a dismissal or a pause. */
+    private renewLifetimes;
+    private prepareContainer;
+    /** Every toast resolves its stack through the container, so that it never depends on this service. */
+    private createStackInjector;
+    /** Raises the stack above the overlays opened after it. */
+    private toTop;
+    private createOverlay;
+    private clear;
+    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 readonly injector;
+    protected readonly a11yLocaleConfiguration: i0.Signal<_koobiq_components_core.KbqA11yLocaleConfiguration>;
+    readonly service: KbqToastService<any>;
+    readonly viewContainer: i0.Signal<ViewContainerRef>;
+    private readonly overlayKeyboardDispatcher;
+    constructor();
+    createToast<C>(data: KbqToastData, componentType: Type<C>, onTop: boolean): ComponentRef<C>;
+    createTemplate(data: KbqToastData, template: TemplateRef<any>, onTop: boolean): EmbeddedViewRef<KbqToastTemplateContext>;
+    remove(viewRef: ViewRef): void;
+    getInjector(data: KbqToastData): Injector;
+    /**
+     * Re-applies the position of every overlay anchored to an element; one whose origin has not moved stays where it
+     * is. CDK keeps no public registry of attached overlays, but its keyboard dispatcher tracks each of them.
+     */
+    private repositionConnectedOverlays;
+    /**
+     * A template toast has no component host of its own, so its first element becomes the live region — screen
+     * readers announce a node inserted with `role="status"`. A template declaring its own role is left alone,
+     * and one whose root is a bare text node cannot carry the attribute at all — it needs an element around it.
+     */
+    private markAsLiveRegion;
+    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, KBQ_TOAST_STACK, KbqToastCloseButton, KbqToastComponent, KbqToastContainerComponent, KbqToastData, KbqToastModule, KbqToastPosition, KbqToastService, KbqToastStyle, defaultToastConfig, kbqToastConfigurationProvider };
+export type { KbqToastConfig, KbqToastStack, KbqToastTemplateContext };

package/types/koobiq-components-toggle.d.ts

@@ -0,0 +1,121 @@
+import * as _angular_core from '@angular/core';
+import { OnChanges, DoCheck, AfterViewInit, OnDestroy, Signal, ElementRef, SimpleChanges } from '@angular/core';
+import * as i1 from '@koobiq/components/core';
+import { KbqColorDirective, CanUpdateErrorState, ErrorStateMatcher, TransitionCheckState, KbqCheckableClickAction, KbqCheckedState } from '@koobiq/components/core';
+import * as i1$1 from '@angular/cdk/a11y';
+
+/** Position of the label relative to the switch. */
+type ToggleLabelPositionType = 'left' | 'right';
+/** Change event object emitted by `KbqToggleComponent`. */
+declare class KbqToggleChange {
+    /** The source toggle of the event. */
+    source: KbqToggleComponent;
+    /** The new `checked` value of the toggle. */
+    checked: boolean;
+}
+/**
+ * Toggle click action when user click on input element. Alias of `KbqCheckableClickAction`.
+ */
+type KbqToggleClickAction = KbqCheckableClickAction;
+/**
+ * A switch for turning an option on or off.
+ *
+ * To show a validation error, put its text in a `kbq-error` inside the toggle bound to a form control.
+ */
+declare class KbqToggleComponent extends KbqColorDirective implements OnChanges, DoCheck, AfterViewInit, OnDestroy, CanUpdateErrorState {
+    private readonly focusMonitor;
+    private readonly checkable;
+    private readonly destroyRef;
+    private readonly ngControl;
+    private readonly errorStateTracker;
+    /** Whether the toggle is in an error state. */
+    readonly errorState: Signal<boolean>;
+    /** An object used to control when the error state is shown. */
+    readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
+    /** Error text projected into the toggle. */
+    private readonly error;
+    readonly big: _angular_core.InputSignal<boolean>;
+    readonly inputElement: 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 | undefined>;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get tabIndex(): number;
+    set tabIndex(value: number);
+    get checked(): boolean;
+    set checked(value: boolean);
+    /**
+     * 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);
+    /**
+     * 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 readonly currentCheckState: Signal<TransitionCheckState>;
+    /** @docs-private */
+    protected readonly animationsDisabled: boolean;
+    /** Defines the behavior when a user clicks on the toggle. */
+    clickAction: KbqToggleClickAction;
+    /** @docs-private */
+    protected readonly uniqueId: string;
+    /** @docs-private */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly tabIndexInput: _angular_core.InputSignalWithTransform<number | undefined, string | number | null | undefined>;
+    /** @docs-private */
+    readonly checkedInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly indeterminateInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly clickActionInput: _angular_core.InputSignal<KbqCheckableClickAction>;
+    /** @docs-private */
+    readonly idInput: _angular_core.InputSignal<string | undefined>;
+    ngOnChanges(changes: SimpleChanges): void;
+    constructor();
+    ngDoCheck(): void;
+    /** Updates the error state based on the error state matcher. */
+    updateErrorState(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    focus(): void;
+    getAriaChecked(): KbqCheckedState;
+    onChangeEvent(event: Event): void;
+    /**
+     * Does nothing: the view reads nothing from the label, so a change of it needs no re-check.
+     *
+     * @deprecated Kept for back-compatibility. Will be removed in 22.0.0.
+     */
+    onLabelTextChange(): void;
+    onInputClick(event: MouseEvent): void;
+    /** Id of the element wrapping the projected hint, referenced by the input's `aria-describedby`. */
+    protected get hintId(): string;
+    /** A native checkbox only reacts to Space, so Enter is forwarded to it manually. */
+    protected onEnterKeydown(event: Event): void;
+    private setTransitionCheckState;
+    private emitChangeEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqToggleComponent, "kbq-toggle", ["kbqToggle"], { "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; "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; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "tabIndexInput": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "checkedInput": { "alias": "checked"; "required": false; "isSignal": true; }; "indeterminateInput": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "clickActionInput": { "alias": "clickAction"; "required": false; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; }, { "change": "change"; "indeterminateChange": "indeterminateChange"; }, ["error"], ["*", "kbq-error", "kbq-hint"], true, [{ directive: typeof i1.KbqCheckable; inputs: {}; outputs: {}; }]>;
+}
+
+declare class KbqToggleModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqToggleModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqToggleModule, never, [typeof i1$1.A11yModule, typeof KbqToggleComponent], [typeof KbqToggleComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqToggleModule>;
+}
+
+export { KbqToggleChange, KbqToggleComponent, KbqToggleModule };
+export type { KbqToggleClickAction, ToggleLabelPositionType };