@koobiq/components 20.4.2 → 21.0.1

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

@@ -0,0 +1,294 @@
+import * as _angular_core from '@angular/core';
+import { Provider, OnChanges, OnInit, AfterViewInit, OnDestroy, ElementRef, AfterContentChecked, DoCheck, AfterContentInit, SimpleChanges, QueryList } from '@angular/core';
+import * as i1 from '@angular/cdk/a11y';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { ControlValueAccessor } from '@angular/forms';
+import { KbqColorDirective, CanUpdateErrorState, ErrorStateMatcher } from '@koobiq/components/core';
+import { KbqHint } from '@koobiq/components/form-field';
+
+/** Change event object emitted by KbqRadio. */
+declare class KbqRadioChange {
+    /** The KbqRadioButton that emits the change event. */
+    source: KbqRadioButton;
+    /** The value of the KbqRadioButton. */
+    value: any;
+    constructor(
+    /** The KbqRadioButton that emits the change event. */
+    source: KbqRadioButton, 
+    /** The value of the KbqRadioButton. */
+    value: any);
+}
+/**
+ * Provider Expression that allows kbq-radio-group to register as a ControlValueAccessor. This
+ * allows it to support [(ngModel)] and ngControl.
+ *
+ * @docs-private
+ */
+declare const KBQ_RADIO_GROUP_CONTROL_VALUE_ACCESSOR: Provider;
+/**
+ * Selection group for `KbqRadioButton`.
+ *
+ * The host is a `radiogroup`, which is not a name-from-content role, so it reaches assistive
+ * technology unnamed unless the consumer names it. Name it with a plain `aria-label` /
+ * `aria-labelledby` attribute pointing at the visible group label: the host is the very element the
+ * consumer writes, so an input aliased to the same name would only write back what is already there —
+ * and would wipe an `[attr.aria-label]` binding, which never reaches the input.
+ *
+ * To show a validation error, bind the group to a form control and put the error text in a `kbq-error` inside the
+ * group. A `kbq-hint` put inside the group is shown under the options, below the error.
+ */
+declare class KbqRadioGroup extends KbqColorDirective implements AfterContentChecked, OnChanges, OnInit, DoCheck, AfterContentInit, ControlValueAccessor, CanUpdateErrorState {
+    private readonly injector;
+    private readonly errorStateTracker;
+    /** Whether the radio group is in an error state. */
+    readonly errorState: _angular_core.Signal<boolean>;
+    /** An object used to control when the error state is shown. */
+    readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
+    readonly big: _angular_core.InputSignal<boolean>;
+    /**
+     * Name of the radio button group. All radio buttons inside this group will use this name,
+     * unless they were given one of their own.
+     */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Whether the labels should appear after or before the radio-buttons. Defaults to 'after' */
+    readonly labelPosition: _angular_core.InputSignalWithTransform<"before" | "after", "before" | "after">;
+    /** Value of the radio button. */
+    get value(): any;
+    set value(newValue: any);
+    /** Whether the radio button is selected. */
+    get selected(): KbqRadioButton | null;
+    set selected(selected: KbqRadioButton | null);
+    /** Whether the radio group is disabled */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private readonly _disabled;
+    /** @docs-private */
+    readonly valueInput: _angular_core.InputSignal<{} | null | undefined>;
+    /** @docs-private */
+    readonly selectedInput: _angular_core.InputSignal<KbqRadioButton | null | undefined>;
+    /** @docs-private */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    ngOnChanges(changes: SimpleChanges): void;
+    /** Whether the radio group is required */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Error text projected into the group. */
+    private readonly error;
+    /** Ids the group last added to `aria-describedby` of the host, so the consumer's own survive an update. */
+    private ownDescribedByIds;
+    private readonly renderer;
+    private readonly isBrowser;
+    /**
+     * Event emitted when the group value changes.
+     * Change events are only emitted when the value changes due to user interaction with
+     * a radio button (the same behavior as `<input type-"radio">`).
+     */
+    readonly change: _angular_core.OutputEmitterRef<KbqRadioChange>;
+    private readonly radiosQuery;
+    private readonly radiosList;
+    /** Child radio buttons. */
+    get radios(): QueryList<KbqRadioButton>;
+    /**
+     * Selected value for group. Should equal the value of the selected radio button if there *is*
+     * a corresponding radio button with a matching value. If there is *not* such a corresponding
+     * radio button, this value persists to be applied in case a new radio button is added with a
+     * matching value.
+     */
+    private readonly _value;
+    /** The currently selected radio button. Should match value. */
+    private readonly _selected;
+    /** Whether the `value` has been set to its initial value. */
+    private isInitialized;
+    /**
+     * Called when the value changes. Needed to properly implement `ControlValueAccessor`.
+     *
+     * @docs-private
+     */
+    controlValueAccessorChangeFn: (value: any) => void;
+    /**
+     * onTouch function registered via registerOnTouch (ControlValueAccessor).
+     *
+     * @docs-private
+     */
+    onTouched: () => any;
+    checkSelectedRadioButton(): void;
+    constructor();
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    /** Updates the error state based on the error state matcher. */
+    updateErrorState(): void;
+    /** Writes the error and the hints of the group to `aria-describedby` of the host, after the consumer's own ids. */
+    private setDescribedByIds;
+    ngAfterContentInit(): void;
+    /**
+     * Initialize properties once content children are available.
+     * This allows us to propagate relevant attributes to associated buttons.
+     */
+    ngAfterContentChecked(): void;
+    /**
+     * Moves focus to the checked radio button, or to the first enabled one when nothing is checked —
+     * the same rule the browser follows when the group is reached with <kbd>Tab</kbd>.
+     */
+    focus(origin?: FocusOrigin): void;
+    /**
+     * Mark this group as being "touched" (for ngModel). Meant to be called by the contained
+     * radio buttons upon their blur.
+     */
+    touch(): void;
+    /** Dispatch change event with current selection and group value. */
+    emitChangeEvent(): void;
+    /**
+     * Marks every radio button of the group for a change-detection check.
+     *
+     * Kept for back-compatibility. A button derives `checked` and `disabled` from signals, its own and its
+     * group's, so it re-renders on its own and nothing in the library calls this any more.
+     */
+    markRadiosForCheck(): void;
+    /**
+     * Sets the model value. Implemented as part of ControlValueAccessor.
+     */
+    writeValue(value: any): void;
+    /**
+     * Registers a callback to be triggered when the model value changes.
+     * Implemented as part of ControlValueAccessor.
+     *
+     * @param fn Callback to be registered.
+     */
+    registerOnChange(fn: (value: any) => void): void;
+    /**
+     * Registers a callback to be triggered when the control is touched.
+     * Implemented as part of ControlValueAccessor.
+     *
+     * @param fn Callback to be registered.
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Sets the disabled state of the control. Implemented as a part of ControlValueAccessor.
+     *
+     * @param isDisabled Whether the control should be disabled.
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /** Updates the `selected` radio button from the internal _value state. */
+    private updateSelectedRadioFromValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqRadioGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqRadioGroup, "kbq-radio-group", ["kbqRadioGroup"], { "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; "big": { "alias": "big"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; "selectedInput": { "alias": "selected"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "change": "change"; }, ["error", "hints", "radiosQuery"], ["*", "kbq-error", "kbq-hint"], true, never>;
+}
+declare class KbqRadioButton extends KbqColorDirective implements OnChanges, OnInit, AfterViewInit, OnDestroy {
+    private readonly changeDetector;
+    private readonly focusMonitor;
+    private readonly radioDispatcher;
+    /** Whether this radio button is checked. */
+    get checked(): boolean;
+    set checked(value: boolean);
+    /** The value of this radio button. */
+    get value(): any;
+    set value(value: any);
+    /** Whether the radio button is disabled. A button inside a disabled group is disabled as well. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private readonly _disabled;
+    /** Tabindex of the native input. A disabled button is taken out of the tab order. */
+    get tabIndex(): number;
+    set tabIndex(value: number);
+    private readonly _tabIndex;
+    /** Whether the radio button is required. A button inside a required group is required as well. */
+    get required(): boolean;
+    set required(value: boolean);
+    /** Whether this radio is required. */
+    private readonly _required;
+    /** Whether the label should appear after or before the radio button. Defaults to 'after' */
+    get labelPosition(): 'before' | 'after';
+    /** @docs-private */
+    set labelPosition(value: 'before' | 'after' | undefined);
+    /**
+     * Analog to HTML 'name' attribute used to group radios for unique selection. Defaults to the
+     * parent group's name, or — outside a group — to an id unique to this button.
+     */
+    get name(): string;
+    set name(value: string | undefined);
+    /** The native `<input type=radio>` element */
+    readonly inputElement: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    /**
+     * Event emitted when the checked state of this radio button changes.
+     * Change events are only emitted when the value changes due to user interaction with
+     * the radio button (the same behavior as `<input type-"radio">`).
+     */
+    readonly change: _angular_core.OutputEmitterRef<KbqRadioChange>;
+    /** The parent radio group. `null` when the button is used outside one. */
+    radioGroup: KbqRadioGroup | null;
+    private readonly uniqueId;
+    /**
+     * A unique id for the radio button. If none is supplied — or `null` is bound explicitly — it is
+     * auto-generated, so a read always yields the id the element actually carries.
+     */
+    readonly id: _angular_core.InputSignalWithTransform<string, string | null | undefined>;
+    /** ID of the native input element inside `<kbq-radio-button>` */
+    readonly inputId: _angular_core.Signal<string>;
+    /**
+     * ID of the element holding the option text. The native input points its `aria-labelledby` at it,
+     * so the accessible name is the option text alone rather than everything the wrapping `<label>`
+     * contains — the projected hint included.
+     */
+    protected readonly labelId: _angular_core.Signal<string>;
+    /**
+     * The `value` attribute of the native input. An `<input type="radio">` with no `value` submits the
+     * literal string `"on"`, so only string-like values round-trip through native form submission.
+     */
+    protected get nativeValue(): string | null;
+    /** Hint projected into the button, referenced by the native input's `aria-describedby`. */
+    protected readonly hint: _angular_core.Signal<KbqHint | undefined>;
+    private readonly _labelPosition;
+    private readonly _name;
+    /** @docs-private */
+    readonly valueInput: _angular_core.InputSignal<{} | null | undefined>;
+    /** @docs-private */
+    readonly checkedInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @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 requiredInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly labelPositionInput: _angular_core.InputSignal<"before" | "after" | undefined>;
+    /** @docs-private */
+    readonly nameInput: _angular_core.InputSignal<string | undefined>;
+    ngOnChanges(changes: SimpleChanges): void;
+    /** Whether this radio is checked. */
+    private readonly _checked;
+    /** Value assigned to this radio. */
+    private readonly _value;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Focuses the radio button.
+     *
+     * Routed through the `FocusMonitor` so the origin is recorded: the focus ring is keyed off
+     * `.cdk-keyboard-focused`, which a bare `element.focus()` never produces.
+     */
+    focus(origin?: FocusOrigin): void;
+    /**
+     * Marks the radio button as needing checking for change detection.
+     *
+     * Kept for back-compatibility. A button derives its state from signals, its own and its group's, so it
+     * re-renders on its own and nothing in the library calls this any more.
+     */
+    markForCheck(): void;
+    onInputClick(event: Event): void;
+    onInputChange(event: Event): void;
+    /** Unregister function for _radioDispatcher */
+    private readonly removeUniqueSelectionListener;
+    /** Dispatch change event with current value. */
+    private emitChangeEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqRadioButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqRadioButton, "kbq-radio-button", ["kbqRadioButton"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; "checkedInput": { "alias": "checked"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "tabIndexInput": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "requiredInput": { "alias": "required"; "required": false; "isSignal": true; }; "labelPositionInput": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "nameInput": { "alias": "name"; "required": false; "isSignal": true; }; }, { "change": "change"; }, ["hint"], ["*", "kbq-hint"], true, never>;
+}
+
+declare class KbqRadioModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqRadioModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqRadioModule, never, [typeof i1.A11yModule, typeof KbqRadioGroup, typeof KbqRadioButton], [typeof KbqRadioGroup, typeof KbqRadioButton]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqRadioModule>;
+}
+
+export { KBQ_RADIO_GROUP_CONTROL_VALUE_ACCESSOR, KbqRadioButton, KbqRadioChange, KbqRadioGroup, KbqRadioModule };

package/{resizer/index.d.ts → types/koobiq-components-resizer.d.ts}

@@ -55,10 +55,33 @@ declare class KbqResizer {
     private y;
     private width;
     private height;
+    private readonly dragging;
+    private activePointerId;
+    /** Body cursor captured on pointer-down and restored when the drag finishes. `null` while not dragging. */
+    private previousBodyCursor;
+    private previousBodyCursorImportant;
     /**
      * Direction of element resizing.
      */
     readonly direction: i0.InputSignal<KbqResizerDirection>;
+    /**
+     * Overrides the cursor that is otherwise derived from the resizing direction.
+     */
+    readonly cursor: i0.InputSignal<string | null>;
+    /**
+     * Stops the directive from writing the new size onto the resizable element, leaving the host in
+     * control: {@link resizeStart} and {@link sizeChange} still report the size the drag asks for, and the
+     * host decides what to apply. Use it when the element's size is owned by a layout the directive must
+     * not fight — `KbqSplitter` sizes its panels through a grid template on their common parent.
+     *
+     * The reported size stays measured from where the drag started rather than from the element, so a host
+     * that clamps or ignores a move does not accumulate drift over the rest of the drag.
+     */
+    readonly disableSizeUpdate: i0.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Emits the element size when a pointer drag begins, after the directive has committed to the resize.
+     */
+    readonly resizeStart: i0.OutputEmitterRef<KbqResizerSizeChangeEvent>;
     /**
      * Emits the new size of the element after resizing.
      */
@@ -66,7 +89,7 @@ declare class KbqResizer {
     /**
      * @docs-private
      */
-    protected readonly cursor: i0.Signal<"default" | "ns-resize" | "ew-resize" | "nwse-resize" | "nesw-resize">;
+    protected readonly resolvedCursor: i0.Signal<string>;
     constructor();
     private handleElementPointerDown;
     /**
@@ -82,9 +105,21 @@ declare class KbqResizer {
     private getResizableSize;
     private handleDocumentPointerMove;
     private handleDocumentPointerUp;
+    private finishDrag;
+    private getPointerId;
+    private isActivePointer;
+    /**
+     * Forces the resize cursor onto `document.body` for the whole drag: when the handle stops at a size
+     * boundary the pointer can leave its hit-area, and only a document-level cursor keeps the feedback from
+     * flickering to whatever sits underneath. The consumer's own body cursor is saved for {@link restoreDocumentCursor}.
+     */
+    private applyDocumentCursor;
+    /** Reflects a mid-drag cursor change (e.g. the boundary switch to `e-resize`/`w-resize`) onto the document. */
+    private updateDocumentCursor;
+    private restoreDocumentCursor;
     private updateSize;
     static ɵfac: i0.ɵɵFactoryDeclaration<KbqResizer, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqResizer, "[kbqResizer]", ["kbqResizer"], { "direction": { "alias": "kbqResizer"; "required": true; "isSignal": true; }; }, { "sizeChange": "sizeChange"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqResizer, "[kbqResizer]", ["kbqResizer"], { "direction": { "alias": "kbqResizer"; "required": true; "isSignal": true; }; "cursor": { "alias": "cursor"; "required": false; "isSignal": true; }; "disableSizeUpdate": { "alias": "disableSizeUpdate"; "required": false; "isSignal": true; }; }, { "resizeStart": "resizeStart"; "sizeChange": "sizeChange"; }, never, never, true, never>;
 }
 
 declare class KbqResizerModule {

package/{scrollbar/index.d.ts → types/koobiq-components-scrollbar-deprecated.d.ts}

@@ -39,6 +39,12 @@ declare const KBQ_SCROLLBAR_OPTIONS_DEFAULT_CONFIG_PROVIDER: Provider;
 
 /**
  * The component-wrapper for `overlayscrollbars` library.
+ *
+ * @deprecated Wraps `overlayscrollbars`. Superseded by the dependency-free
+ * `@koobiq/components/scrollbar`. Will be removed in 22.0.0 — see
+ * `@koobiq/components/scrollbar/deprecated`'s migration path via `ng update`.
+ *
+ * @docs-private
  */
 declare class KbqScrollbar implements AfterViewInit, OnDestroy, KbqOverflowShadowSource {
     private ngZone;
@@ -93,7 +99,7 @@ declare class KbqScrollbar implements AfterViewInit, OnDestroy, KbqOverflowShado
     ngOnDestroy(): void;
     /** Wrapper function for native scroll */
     scrollTo(options?: ScrollToOptions): void;
-    /** @docs-private Implementation of `KbqOverflowShadowSource`. */
+    /** Implementation of `KbqOverflowShadowSource`. @docs-private */
     getScrollElement(): HTMLElement | null;
     mergeEvents(): KbqScrollbarEvents;
     private dispatchEventIfHasObservers;
@@ -103,6 +109,11 @@ declare class KbqScrollbar implements AfterViewInit, OnDestroy, KbqOverflowShado
 
 /**
  * A directive for adding `overlayscrollbars` to an element.
+ *
+ * @deprecated Wraps `overlayscrollbars`. Superseded by the dependency-free
+ * `@koobiq/components/scrollbar`. Will be removed in 22.0.0.
+ *
+ * @docs-private
  */
 declare class KbqScrollbarDirective implements OnDestroy {
     private ngZone;
@@ -126,6 +137,12 @@ declare class KbqScrollbarDirective implements OnDestroy {
     static ɵdir: i0.ɵɵDirectiveDeclaration<KbqScrollbarDirective, "[kbqScrollbar]", never, { "options": { "alias": "options"; "required": false; }; "events": { "alias": "events"; "required": false; }; "defer": { "alias": "defer"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkScrollable; inputs: {}; outputs: {}; }]>;
 }
 
+/**
+ * @deprecated Wraps `overlayscrollbars`. Superseded by the dependency-free
+ * `@koobiq/components/scrollbar`. Will be removed in 22.0.0 — an `ng update`
+ * migration rewrites `@koobiq/components/scrollbar` imports of this module to
+ * `@koobiq/components/scrollbar/deprecated` automatically.
+ */
 declare class KbqScrollbarModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<KbqScrollbarModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<KbqScrollbarModule, never, [typeof KbqScrollbar, typeof KbqScrollbarDirective], [typeof KbqScrollbar, typeof KbqScrollbarDirective]>;

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

@@ -0,0 +1,154 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Provider } from '@angular/core';
+import * as i1 from '@angular/cdk/scrolling';
+import { ExtendedScrollToOptions } from '@angular/cdk/scrolling';
+import { Observable } from 'rxjs';
+
+/**
+ * How the scrollbar is presented:
+ * - `hover` — track appears on pointer hover or while scrolling (default);
+ * - `always` — track is always visible while the content overflows;
+ * - `native` — the browser's native scrollbar is used;
+ * - `hidden` — no scrollbar is shown, but the content stays scrollable.
+ *
+ * `hover` and `always` draw a bar only for an axis the user can scroll: one whose computed `overflow` is
+ * `hidden`, `clip` or `visible` gets none, however far its content overflows.
+ */
+type KbqScrollbarMode = 'always' | 'hidden' | 'hover' | 'native';
+/** Configuration for {@link KbqScrollbar}. */
+type KbqScrollbarOptions = {
+    mode: KbqScrollbarMode;
+    /** How long the scroll-revealed track stays visible after scrolling stops, in milliseconds. */
+    hideDelay: number;
+};
+/** Injection token holding the current {@link KbqScrollbarOptions}. */
+declare const KBQ_SCROLLBAR_OPTIONS: InjectionToken<KbqScrollbarOptions>;
+/** Overrides the default scrollbar options within the given injector scope. */
+declare function kbqScrollbarOptionsProvider(options: Partial<KbqScrollbarOptions>): Provider;
+/** Configuration for {@link KbqNativeScrollbar}. */
+type KbqNativeScrollbarOptions = {
+    /** Whether browser-rendered scrollbars of descendant elements should also be customized. */
+    descendants: boolean;
+};
+/** Injection token holding the current {@link KbqNativeScrollbarOptions}. */
+declare const KBQ_NATIVE_SCROLLBAR_OPTIONS: InjectionToken<KbqNativeScrollbarOptions>;
+/** Overrides the default native scrollbar options within the given injector scope. */
+declare function kbqNativeScrollbarOptionsProvider(options: Partial<KbqNativeScrollbarOptions>): Provider;
+/** Customizes the browser-rendered scrollbar of its host without replacing native scrolling. */
+declare class KbqNativeScrollbar {
+    private readonly styleLoader;
+    private readonly options;
+    /**
+     * Whether browser-rendered scrollbars of descendant elements should also be customized.
+     * Defaults to {@link KBQ_NATIVE_SCROLLBAR_OPTIONS}.
+     */
+    readonly descendants: i0.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqNativeScrollbar, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqNativeScrollbar, "[kbqNativeScrollbar]", ["kbqNativeScrollbar"], { "descendants": { "alias": "kbqNativeScrollbarDescendants"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Options accepted by {@link KbqScrollbarViewport.scrollTo}/{@link KbqScrollbar.scrollTo} — RTL-normalized, see `CdkScrollable.scrollTo`. */
+type KbqScrollbarScrollToOptions = ExtendedScrollToOptions;
+/** Options accepted by {@link KbqScrollbarViewport.scrollToElement}/{@link KbqScrollbar.scrollToElement}. */
+type KbqScrollbarScrollToElementOptions = {
+    /** Extra gap to leave above the target, in px — e.g. so it doesn't end up under a sticky header. */
+    top?: number;
+    /** Extra gap to leave to the left of the target, in px. */
+    left?: number;
+    behavior?: ScrollBehavior;
+};
+/** Marks its host element as the custom scrollbar's scroll target, hiding its native scrollbar whenever a custom scrollbar track replaces it. */
+declare class KbqScrollbarViewport {
+    private readonly styleLoader;
+    private readonly scrollable;
+    private readonly appRef;
+    private readonly environmentInjector;
+    private readonly injector;
+    private readonly idGenerator;
+    private readonly options;
+    private readonly destroyRef;
+    private readonly scrollDispatcher;
+    private readonly generatedId;
+    protected get id(): string;
+    /** Visibility mode for this viewport's scrollbar. Defaults to the app-wide {@link KBQ_SCROLLBAR_OPTIONS}. */
+    readonly mode: i0.InputSignal<KbqScrollbarMode>;
+    /**
+     * How long the scroll-revealed `hover`-mode track stays visible after scrolling stops, in milliseconds.
+     * Defaults to the app-wide {@link KBQ_SCROLLBAR_OPTIONS}.
+     */
+    readonly hideDelay: i0.InputSignalWithTransform<number, unknown>;
+    private trackRef;
+    private readonly flashSubject;
+    /** Emits when {@link flashScrollIndicators} is called. */
+    readonly flashes: Observable<void>;
+    /** Emits on every native `scroll` event of the viewport. Emits outside Angular's zone — see `CdkScrollable.elementScrolled`. */
+    readonly scrollChanges: Observable<Event>;
+    constructor();
+    private dropDuplicateScrollableRegistration;
+    /** Briefly reveals an overflowing `hover`-mode scrollbar. */
+    flashScrollIndicators(): void;
+    /** Scrolls to the specified offsets. RTL-normalized — see `CdkScrollable.scrollTo`. */
+    scrollTo(options: KbqScrollbarScrollToOptions): void;
+    /** Scrolls to the start of the vertical axis. */
+    scrollToTop(behavior?: ScrollBehavior): void;
+    /** Scrolls to the end of the vertical axis. */
+    scrollToBottom(behavior?: ScrollBehavior): void;
+    /** Scrolls to the logical start of the horizontal axis — the right edge in RTL, left in LTR. */
+    scrollStart(behavior?: ScrollBehavior): void;
+    /** Scrolls to the logical end of the horizontal axis — the left edge in RTL, right in LTR. */
+    scrollEnd(behavior?: ScrollBehavior): void;
+    /** Scrolls `target` (an element, or a selector resolved against this viewport) into view. */
+    scrollToElement(target: HTMLElement | string, options?: KbqScrollbarScrollToElementOptions): void;
+    /** Scrolls `target` to the center of the viewport. */
+    scrollIntoView(target: HTMLElement, behavior?: ScrollBehavior): void;
+    private createTrack;
+    private destroyTrack;
+    /** The viewport's native scrollable element — the host this directive is applied to. */
+    getNativeElement(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqScrollbarViewport, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqScrollbarViewport, "[kbqScrollbarViewport]", never, { "mode": { "alias": "kbqScrollbarMode"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "kbqScrollbarHideDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkScrollable; inputs: {}; outputs: {}; }]>;
+}
+/** Custom scrollbar wrapper: projects content and overlays a scrollbar track over it (created by its {@link KbqScrollbarViewport} host directive). */
+declare class KbqScrollbar {
+    private readonly options;
+    private readonly viewport;
+    /** Visibility mode for the scrollbar. Defaults to the app-wide {@link KBQ_SCROLLBAR_OPTIONS}. */
+    readonly mode: i0.InputSignal<KbqScrollbarMode>;
+    /**
+     * How long the scroll-revealed `hover`-mode track stays visible after scrolling stops, in milliseconds.
+     * Defaults to the app-wide {@link KBQ_SCROLLBAR_OPTIONS}.
+     */
+    readonly hideDelay: i0.InputSignalWithTransform<number, unknown>;
+    /** Emits on every native `scroll` event of the viewport. Emits outside Angular's zone — see `CdkScrollable.elementScrolled`. */
+    readonly scrollChanges: Observable<Event>;
+    /** The scrollbar's native scrollable element. */
+    getNativeElement(): HTMLElement;
+    /** Scrolls to the specified offsets. RTL-normalized — see `CdkScrollable.scrollTo`. */
+    scrollTo(options: KbqScrollbarScrollToOptions): void;
+    /** Scrolls to the start of the vertical axis. */
+    scrollToTop(behavior?: ScrollBehavior): void;
+    /** Scrolls to the end of the vertical axis. */
+    scrollToBottom(behavior?: ScrollBehavior): void;
+    /** Scrolls to the logical start of the horizontal axis — the right edge in RTL, left in LTR. */
+    scrollStart(behavior?: ScrollBehavior): void;
+    /** Scrolls to the logical end of the horizontal axis — the left edge in RTL, right in LTR. */
+    scrollEnd(behavior?: ScrollBehavior): void;
+    /** Scrolls `target` (an element, or a selector resolved against this scrollbar) into view. */
+    scrollToElement(target: HTMLElement | string, options?: KbqScrollbarScrollToElementOptions): void;
+    /** Scrolls `target` to the center of the viewport. */
+    scrollIntoView(target: HTMLElement, behavior?: ScrollBehavior): void;
+    /** Briefly reveals the scrollbar track — see {@link KbqScrollbarViewport.flashScrollIndicators}. */
+    flashScrollIndicators(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqScrollbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqScrollbar, "kbq-scrollbar", ["kbqScrollbar"], { "mode": { "alias": "kbqScrollbarMode"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "kbqScrollbarHideDelay"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof KbqScrollbarViewport; inputs: { "kbqScrollbarMode": "kbqScrollbarMode"; "kbqScrollbarHideDelay": "kbqScrollbarHideDelay"; }; outputs: {}; }]>;
+}
+
+/** @docs-private */
+declare class KbqScrollbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqScrollbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqScrollbarModule, never, [typeof KbqNativeScrollbar, typeof KbqScrollbar, typeof KbqScrollbarViewport], [typeof KbqNativeScrollbar, typeof KbqScrollbar, typeof KbqScrollbarViewport]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqScrollbarModule>;
+}
+
+export { KBQ_NATIVE_SCROLLBAR_OPTIONS, KBQ_SCROLLBAR_OPTIONS, KbqNativeScrollbar, KbqScrollbar, KbqScrollbarModule, KbqScrollbarViewport, kbqNativeScrollbarOptionsProvider, kbqScrollbarOptionsProvider };
+export type { KbqNativeScrollbarOptions, KbqScrollbarMode, KbqScrollbarOptions, KbqScrollbarScrollToElementOptions, KbqScrollbarScrollToOptions };