@ng-doc/ui-kit 22.0.0-beta.2 → 22.1.0

package/types/ng-doc-ui-kit-components-tab-group.d.ts

@@ -1,31 +1,57 @@
+import * as _angular_core from '@angular/core';
+import { Signal, ElementRef } from '@angular/core';
 import { NgDocContent } from '@ng-doc/ui-kit/types';
-import * as i0 from '@angular/core';
-import { AfterContentInit, AfterViewInit, QueryList, ElementRef } from '@angular/core';
 
+/** One tab of an `ng-doc-tab-group`: its label, its id and the content of its panel. */
 declare class NgDocTabComponent<T> {
-    label: NgDocContent;
-    id: T | number;
-    /** Expander content */
-    content: NgDocContent;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocTabComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocTabComponent<any>, "ng-doc-tab, a[ng-doc-tab]", never, { "label": { "alias": "label"; "required": false; }; "id": { "alias": "id"; "required": false; }; "content": { "alias": "content"; "required": false; }; }, {}, never, never, true, never>;
+    /** Label of the tab: a string or a template. */
+    readonly label: _angular_core.InputSignal<NgDocContent>;
+    /** Id the group's `openedTab` refers to. */
+    readonly id: _angular_core.InputSignal<number | T>;
+    /** Content of the tab's panel. */
+    readonly content: _angular_core.InputSignal<NgDocContent>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocTabComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgDocTabComponent<any>, "ng-doc-tab, a[ng-doc-tab]", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class NgDocTabGroupComponent<T = number> implements AfterContentInit, AfterViewInit {
-    private readonly changeDetectorRef;
-    openedTab: T;
-    tabElements: QueryList<ElementRef>;
-    tabs: QueryList<NgDocTabComponent<T>>;
-    selectedTab?: NgDocTabComponent<T>;
-    private readonly destroyRef;
-    constructor();
-    ngAfterContentInit(): void;
-    ngAfterViewInit(): void;
-    get selectedIndex(): number;
-    get selectedHeaderTab(): ElementRef | null;
+/**
+ * Tabs as a segmented control over one panel. It follows the WAI-ARIA tabs pattern: the arrow keys,
+ * Home and End move between the tabs and select them. The highlight of the open tab slides to
+ * the newly opened one.
+ */
+declare class NgDocTabGroupComponent<T = number> {
+    /**
+     * `framed` draws the header bar and the panel as one surface; `plain` draws only the tabs over
+     * a line, and the panel takes no frame or background of its own, for content that has its own.
+     */
+    readonly appearance: _angular_core.InputSignal<"framed" | "plain">;
+    /** Id of the tab to open; the first tab opens when it is not set or matches no tab. */
+    readonly openedTab: _angular_core.InputSignal<T | undefined>;
+    /** The tabs of the group. */
+    readonly tabs: Signal<ReadonlyArray<NgDocTabComponent<T>>>;
+    /** Header buttons of the tabs, in order. */
+    readonly tabElements: Signal<ReadonlyArray<ElementRef<HTMLElement>>>;
+    /**
+     * The open tab. It follows `openedTab` and the tab list; a tab the user selects stays open as
+     * long as it is in the group and `openedTab` does not change.
+     */
+    readonly selectedTab: _angular_core.WritableSignal<NgDocTabComponent<T> | undefined>;
+    /** Index of the open tab, or -1. */
+    readonly selectedIndex: Signal<number>;
+    /** Prefix of the ids that tie the tabs to the panel. */
+    protected readonly idPrefix: string;
+    /**
+     * Opens a tab.
+     * @param tab - The tab to open.
+     */
     selectTab(tab: NgDocTabComponent<T>): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocTabGroupComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocTabGroupComponent<any>, "ng-doc-tab-group", never, { "openedTab": { "alias": "openedTab"; "required": false; }; }, {}, ["tabs"], never, true, never>;
+    /**
+     * Moves the selection with the keyboard and focuses the new tab.
+     * @param event - The key press on a tab.
+     */
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocTabGroupComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgDocTabGroupComponent<any>, "ng-doc-tab-group", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "openedTab": { "alias": "openedTab"; "required": false; "isSignal": true; }; }, {}, ["tabs"], never, true, never>;
 }
 
 export { NgDocTabComponent, NgDocTabGroupComponent };

package/types/ng-doc-ui-kit-components-tab-routes-group.d.ts

@@ -1,10 +1,12 @@
 import * as i0 from '@angular/core';
 import * as i1 from '@ng-doc/ui-kit/components/selection';
 
+/** A link of an `ng-doc-tab-routes-group`; the active one is underlined and marked current. */
 declare class NgDocTabRouteComponent {
-    isActive: boolean;
+    /** Whether the link's route is active. */
+    readonly isActive: i0.InputSignal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocTabRouteComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocTabRouteComponent, "a[ng-doc-tab-route]", never, { "isActive": { "alias": "isActive"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgDocSelectionOriginDirective; inputs: { "ngDocSelectionOrigin": "isActive"; }; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocTabRouteComponent, "a[ng-doc-tab-route]", never, { "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgDocSelectionOriginDirective; inputs: { "ngDocSelectionOrigin": "isActive"; }; outputs: {}; }]>;
 }
 
 declare class NgDocTabRoutesGroupComponent {

package/types/ng-doc-ui-kit-components-tag.d.ts

@@ -1,12 +1,19 @@
+import * as _angular_core from '@angular/core';
 import { NgDocColor, NgDocTagSize } from '@ng-doc/ui-kit/types';
-import * as i0 from '@angular/core';
 
+/**
+ * A small label. The `default` mod is a solid fill of the colour; the `light` mod is a soft chip
+ * whose text mixes the colour toward the heading colour, so it stays readable in every theme.
+ */
 declare class NgDocTagComponent {
-    color: NgDocColor;
-    size: NgDocTagSize;
-    mod: 'default' | 'light';
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocTagComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocTagComponent, "ng-doc-tag", never, { "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "mod": { "alias": "mod"; "required": false; }; }, {}, never, ["*"], true, never>;
+    /** Colour of the tag. */
+    readonly color: _angular_core.InputSignal<NgDocColor>;
+    /** Size of the tag. */
+    readonly size: _angular_core.InputSignal<NgDocTagSize>;
+    /** `default` fills the tag with the colour, `light` makes a soft chip of it. */
+    readonly mod: _angular_core.InputSignal<"default" | "light">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocTagComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgDocTagComponent, "ng-doc-tag", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "mod": { "alias": "mod"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 export { NgDocTagComponent };

package/types/ng-doc-ui-kit-components-text.d.ts

@@ -1,35 +1,37 @@
-import * as i0 from '@angular/core';
-import { AfterContentChecked } from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { NgDocSize, NgDocTextColor, NgDocTextAlign } from '@ng-doc/ui-kit/types';
 
 /** Using to display content on the left side */
 declare class NgDocTextLeftDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocTextLeftDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocTextLeftDirective, "[ngDocTextLeft]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocTextLeftDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgDocTextLeftDirective, "[ngDocTextLeft]", never, {}, {}, never, never, true, never>;
 }
 
 /** Using to display content on the right side */
 declare class NgDocTextRightDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocTextRightDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocTextRightDirective, "[ngDocTextRight]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocTextRightDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgDocTextRightDirective, "[ngDocTextRight]", never, {}, {}, never, never, true, never>;
 }
 
-declare class NgDocTextComponent implements AfterContentChecked {
-    private readonly changeDetectorRef;
+/**
+ * Text with the UI Kit typography, optionally with content on its left or right side
+ * (`ngDocTextLeft`, `ngDocTextRight`).
+ */
+declare class NgDocTextComponent {
     /** Text size */
-    size: NgDocSize;
+    readonly size: _angular_core.InputSignal<NgDocSize>;
     /** Text color */
-    color: NgDocTextColor;
+    readonly color: _angular_core.InputSignal<NgDocTextColor>;
     /** Text align */
-    align: NgDocTextAlign;
-    absoluteContent: boolean;
-    leftContent?: NgDocTextLeftDirective;
-    rightContent?: NgDocTextRightDirective;
-    readonly ngDocElement: boolean;
-    constructor();
-    ngAfterContentChecked(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocTextComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgDocTextComponent, "[ng-doc-text]", never, { "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; "align": { "alias": "align"; "required": false; }; "absoluteContent": { "alias": "absoluteContent"; "required": false; }; }, {}, ["leftContent", "rightContent"], ["[ngDocTextLeft]", "*", "[ngDocTextRight]"], true, never>;
+    readonly align: _angular_core.InputSignal<NgDocTextAlign>;
+    /** Positions the side content absolutely, so it does not take space from the text. */
+    readonly absoluteContent: _angular_core.InputSignal<boolean>;
+    /** Content projected with `ngDocTextLeft`. */
+    readonly leftContent: _angular_core.Signal<NgDocTextLeftDirective | undefined>;
+    /** Content projected with `ngDocTextRight`. */
+    readonly rightContent: _angular_core.Signal<NgDocTextRightDirective | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocTextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgDocTextComponent, "[ng-doc-text]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "absoluteContent": { "alias": "absoluteContent"; "required": false; "isSignal": true; }; }, {}, ["leftContent", "rightContent"], ["[ngDocTextLeft]", "*", "[ngDocTextRight]"], true, never>;
 }
 
 export { NgDocTextComponent, NgDocTextLeftDirective, NgDocTextRightDirective };

package/types/ng-doc-ui-kit-components-toggle.d.ts

@@ -1,18 +1,24 @@
 import * as i0 from '@angular/core';
-import { OnInit } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
 import { DIStateControl } from 'di-controls';
 
-declare class NgDocToggleComponent<T> extends DIStateControl<T> implements OnInit, ControlValueAccessor {
-    private wrapper?;
-    private circle?;
-    dragging: boolean;
+/**
+ * Switch control. It works with forms (`ngModel`, reactive forms, `[formField]`) and with host
+ * controls; the circle can be clicked or dragged.
+ */
+declare class NgDocToggleComponent<T> extends DIStateControl<T> implements ControlValueAccessor {
+    private readonly document;
+    private readonly toggleDestroyRef;
+    private readonly wrapper;
+    private readonly circle;
+    /** Whether the user is dragging the circle. */
+    protected readonly dragging: i0.WritableSignal<boolean>;
     private maxPixelValue;
     constructor();
-    ngOnInit(): void;
     updateModel(value: boolean | T | null): void;
+    protected onWrapperClick(): void;
     protected setState(isSelected: boolean): void;
-    private setDragging;
+    private listenToDrag;
     private detectByCoordinates;
     private changeCirclePosition;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocToggleComponent<any>, never>;

package/types/ng-doc-ui-kit-components-wrapper.d.ts

@@ -1,5 +1,8 @@
 import * as i0 from '@angular/core';
 
+/**
+ * Wraps an input and its controls; the border takes the focus color while it holds focus.
+ */
 declare class NgDocWrapperComponent {
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocWrapperComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgDocWrapperComponent, "ng-doc-wrapper", never, {}, {}, never, ["*"], true, never>;

package/types/ng-doc-ui-kit-directives-autofocus.d.ts

@@ -1,14 +1,16 @@
 import * as i0 from '@angular/core';
 import { OnInit } from '@angular/core';
 
+/**
+ * Focuses the host when it is created, if the host can take keyboard focus.
+ */
 declare class NgDocAutofocusDirective implements OnInit {
-    private elementRef;
-    selectAll: boolean;
-    /** Inserted by Angular inject() migration for backwards compatibility */
-    constructor(...args: unknown[]);
+    private readonly elementRef;
+    /** Selects the whole value of an `input` host after focusing it. */
+    readonly selectAll: i0.InputSignal<boolean>;
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocAutofocusDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocAutofocusDirective, "[ngDocAutofocus]", never, { "selectAll": { "alias": "selectAll"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocAutofocusDirective, "[ngDocAutofocus]", never, { "selectAll": { "alias": "selectAll"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { NgDocAutofocusDirective };

package/types/ng-doc-ui-kit-directives-checked-change.d.ts

@@ -1,16 +1,20 @@
-import * as i0 from '@angular/core';
-import { EventEmitter } from '@angular/core';
+import * as _angular_core from '@angular/core';
 
+/**
+ * Binds the checked state of a native checkbox: `true`, `false`, or `null` for the
+ * indeterminate state. Use `[ngDocChecked]` and `(ngDocCheckedChange)`, or both at once with
+ * `[(ngDocChecked)]`.
+ */
 declare class NgDocCheckedChangeDirective {
-    private readonly element;
-    private readonly renderer;
-    set ngDocChecked(checked: null | boolean);
-    readonly ngDocCheckedChange: EventEmitter<boolean>;
-    constructor();
-    onChange(target: EventTarget | null): void;
-    private updateProperty;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocCheckedChangeDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocCheckedChangeDirective, "input[ngDocChecked], input[ngDocCheckedChange]", never, { "ngDocChecked": { "alias": "ngDocChecked"; "required": false; }; }, { "ngDocCheckedChange": "ngDocCheckedChange"; }, never, never, true, never>;
+    /** Checked state; `null` shows the checkbox as indeterminate. */
+    readonly ngDocChecked: _angular_core.InputSignal<boolean | null>;
+    /** Emits the new checked state when the user changes it. */
+    readonly ngDocCheckedChange: _angular_core.OutputEmitterRef<boolean>;
+    /** What the checkbox shows: the bound state until the user changes it. */
+    protected readonly state: _angular_core.WritableSignal<boolean | null>;
+    protected onChange(target: EventTarget | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocCheckedChangeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgDocCheckedChangeDirective, "input[ngDocChecked], input[ngDocCheckedChange]", never, { "ngDocChecked": { "alias": "ngDocChecked"; "required": false; "isSignal": true; }; }, { "ngDocCheckedChange": "ngDocCheckedChange"; }, never, never, true, never>;
 }
 
 export { NgDocCheckedChangeDirective };

package/types/ng-doc-ui-kit-directives-data.d.ts

@@ -1,11 +1,13 @@
 import * as i0 from '@angular/core';
 import { TemplateRef, ViewContainerRef } from '@angular/core';
 
+/**
+ * Keeps its template unrendered, so that a parent can query it (with `read: TemplateRef`) and
+ * render it somewhere else, for example in a dropdown.
+ */
 declare class NgDocDataDirective {
-    protected template: TemplateRef<unknown>;
-    protected viewContainerRef: ViewContainerRef;
-    /** Inserted by Angular inject() migration for backwards compatibility */
-    constructor(...args: unknown[]);
+    protected readonly template: TemplateRef<unknown>;
+    protected readonly viewContainerRef: ViewContainerRef;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocDataDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocDataDirective, "[ngDocData]", never, {}, {}, never, never, true, never>;
 }

package/types/ng-doc-ui-kit-directives-dropdown-handler.d.ts

@@ -1,11 +1,13 @@
-import { NgDocDropdownComponent } from '@ng-doc/ui-kit/components/dropdown';
 import * as i0 from '@angular/core';
+import { NgDocDropdownComponent } from '@ng-doc/ui-kit/components/dropdown';
 
+/** Opens the dropdown on ArrowDown and closes it on Escape while the host has focus. */
 declare class NgDocDropdownHandlerDirective {
-    dropdown?: NgDocDropdownComponent;
+    /** The dropdown the host controls. */
+    readonly dropdown: i0.InputSignal<NgDocDropdownComponent | undefined>;
     keyboardEvent(event: KeyboardEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocDropdownHandlerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocDropdownHandlerDirective, "[ngDocDropdownHandler]", never, { "dropdown": { "alias": "ngDocDropdownHandler"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocDropdownHandlerDirective, "[ngDocDropdownHandler]", never, { "dropdown": { "alias": "ngDocDropdownHandler"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { NgDocDropdownHandlerDirective };

package/types/ng-doc-ui-kit-directives-event-switcher.d.ts

@@ -1,18 +1,23 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { OnInit } from '@angular/core';
 import { BaseElement } from '@ng-doc/ui-kit/types';
 
+/**
+ * Re-dispatches the given events of the host on another element, for example the events of an
+ * overlay on its origin.
+ */
 declare class NgDocEventSwitcherDirective implements OnInit {
     private elementRef;
     private ngZone;
-    switchTo: BaseElement<HTMLElement> | null;
-    events: string | string[];
     private readonly destroyRef;
-    constructor();
+    /** The element that receives the events. */
+    readonly switchTo: _angular_core.InputSignal<BaseElement<HTMLElement> | null>;
+    /** The names of the events to re-dispatch. They are read once, when the directive starts. */
+    readonly events: _angular_core.InputSignal<string | string[]>;
     ngOnInit(): void;
     private makeEvent;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocEventSwitcherDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocEventSwitcherDirective, "[ngDocEventSwitcher]", never, { "switchTo": { "alias": "ngDocEventSwitcher"; "required": false; }; "events": { "alias": "events"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocEventSwitcherDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgDocEventSwitcherDirective, "[ngDocEventSwitcher]", never, { "switchTo": { "alias": "ngDocEventSwitcher"; "required": false; "isSignal": true; }; "events": { "alias": "events"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { NgDocEventSwitcherDirective };

package/types/ng-doc-ui-kit-directives-focus-catcher.d.ts

@@ -1,18 +1,21 @@
-import * as i0 from '@angular/core';
-import { EventEmitter } from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { Observable } from 'rxjs';
 
+/** Tracks whether focus is inside the host element. */
 declare class NgDocFocusCatcherDirective {
     private elementRef;
     private ngZone;
-    private changeDetectorRef;
-    focusEvent: EventEmitter<Event>;
-    blurEvent: EventEmitter<Event>;
-    focused: boolean;
+    /** Emits when focus moves into the host. */
+    readonly focusEvent: _angular_core.OutputEmitterRef<Event>;
+    /** Emits when focus leaves the host. */
+    readonly blurEvent: _angular_core.OutputEmitterRef<Event>;
+    protected readonly focusedState: _angular_core.WritableSignal<boolean>;
     constructor();
+    /** Whether focus is inside the host. */
+    get focused(): boolean;
     static observeFocus(element: HTMLElement): Observable<FocusEvent>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocFocusCatcherDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocFocusCatcherDirective, "[ngDocFocusCatcher]", ["ngDocFocusCatcher"], {}, { "focusEvent": "focusEvent"; "blurEvent": "blurEvent"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocFocusCatcherDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgDocFocusCatcherDirective, "[ngDocFocusCatcher]", ["ngDocFocusCatcher"], {}, { "focusEvent": "focusEvent"; "blurEvent": "blurEvent"; }, never, never, true, never>;
 }
 
 export { NgDocFocusCatcherDirective };

package/types/ng-doc-ui-kit-directives-focusable.d.ts

@@ -1,10 +1,13 @@
 import * as i0 from '@angular/core';
 
+/**
+ * Puts the host into the tab order (`tabindex="0"`) or takes it out (`tabindex="-1"`).
+ */
 declare class NgDocFocusableDirective {
-    focusable: boolean;
-    get tabIndex(): number;
+    /** Whether the host can be focused with the keyboard. */
+    readonly focusable: i0.InputSignal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocFocusableDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocFocusableDirective, "[ngDocFocusable]", ["ngDocFocusable"], { "focusable": { "alias": "ngDocFocusable"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocFocusableDirective, "[ngDocFocusable]", ["ngDocFocusable"], { "focusable": { "alias": "ngDocFocusable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { NgDocFocusableDirective };

package/types/ng-doc-ui-kit-directives-fullscreen.d.ts

@@ -0,0 +1,39 @@
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+
+/**
+ * Shows its host element fullscreen with the browser Fullscreen API.
+ *
+ * `supported()` stays `false` on the server and in browsers that do not allow fullscreen
+ * (`document.fullscreenEnabled`), so a control that uses the directive can hide itself there.
+ * `active()` follows the browser's fullscreen state, including an exit with Esc, and the host
+ * gets `data-ng-doc-fullscreen="true"` while it is fullscreen.
+ * @example
+ * <div ngDocFullscreen #stage="ngDocFullscreen">
+ *   <button (click)="stage.toggle()">{{ stage.active() ? 'Exit fullscreen' : 'Fullscreen' }}</button>
+ * </div>
+ */
+declare class NgDocFullscreenDirective {
+    private readonly document;
+    private readonly host;
+    private readonly supportedState;
+    private readonly activeState;
+    /** Whether the browser can show the host fullscreen. Always `false` on the server. */
+    readonly supported: Signal<boolean>;
+    /** Whether the host is shown fullscreen. */
+    readonly active: Signal<boolean>;
+    constructor();
+    /**
+     * Shows the host fullscreen. Does nothing where fullscreen is not supported, and a request the
+     * browser refuses leaves the page as it is.
+     */
+    enter(): Promise<void>;
+    /** Leaves fullscreen when the host is the fullscreen element. */
+    exit(): Promise<void>;
+    /** Enters fullscreen, or leaves it when the host is already fullscreen. */
+    toggle(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocFullscreenDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocFullscreenDirective, "[ngDocFullscreen]", ["ngDocFullscreen"], {}, {}, never, never, true, never>;
+}
+
+export { NgDocFullscreenDirective };

package/types/ng-doc-ui-kit-directives-hotkey.d.ts

@@ -1,13 +1,20 @@
-import * as i0 from '@angular/core';
-import { EventEmitter } from '@angular/core';
+import * as _angular_core from '@angular/core';
 
+/**
+ * Emits when a key that matches the given keyboard event properties is released anywhere in the
+ * document, except while the reader types in a field.
+ * @example
+ * <button [ngDocHotkey]="{ key: 'k', ctrlKey: true }" (ngDocHotkey)="open()">Open</button>
+ */
 declare class NgDocHotkeyDirective {
-    private readonly ngZone;
-    hotkey?: Partial<KeyboardEvent>;
-    callback: EventEmitter<void>;
+    /** The keyboard event properties to match, for example the key and the modifier keys. */
+    readonly hotkey: _angular_core.InputSignal<Partial<KeyboardEvent> | undefined>;
+    /** Emits when the hotkey is released. */
+    readonly callback: _angular_core.OutputEmitterRef<void>;
     constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocHotkeyDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocHotkeyDirective, "[ngDocHotkey]", never, { "hotkey": { "alias": "ngDocHotkey"; "required": false; }; }, { "callback": "ngDocHotkey"; }, never, never, true, never>;
+    private matches;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocHotkeyDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgDocHotkeyDirective, "[ngDocHotkey]", never, { "hotkey": { "alias": "ngDocHotkey"; "required": false; "isSignal": true; }; }, { "callback": "ngDocHotkey"; }, never, never, true, never>;
 }
 
 export { NgDocHotkeyDirective };

package/types/ng-doc-ui-kit-directives-input-number.d.ts

@@ -1,10 +1,11 @@
 import { NgDocBaseInput } from '@ng-doc/ui-kit/classes/base-input';
 import * as i0 from '@angular/core';
 
+/** Directive turns a native input into a control whose model is a number */
 declare class NgDocInputNumberDirective extends NgDocBaseInput<number> {
     constructor();
-    blurEvent(): void;
-    inputEvent(): void;
+    protected blurEvent(): void;
+    protected inputEvent(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocInputNumberDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocInputNumberDirective, "input[ngDocInputNumber]", never, {}, {}, never, never, true, never>;
 }

package/types/ng-doc-ui-kit-directives-input-string.d.ts

@@ -4,8 +4,8 @@ import * as i0 from '@angular/core';
 /** Directive converts any input data or model to text */
 declare class NgDocInputStringDirective extends NgDocBaseInput<string> {
     constructor();
-    blurEvent(): void;
-    inputEvent(): void;
+    protected blurEvent(): void;
+    protected inputEvent(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocInputStringDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocInputStringDirective, "input[ngDocInputString]", never, {}, {}, never, never, true, never>;
 }

package/types/ng-doc-ui-kit-directives-radio-group.d.ts

@@ -1,6 +1,10 @@
 import { DIControl } from 'di-controls';
 import * as i0 from '@angular/core';
 
+/**
+ * Host control for a group of state controls (for example `ng-doc-button-toggle`): the group's
+ * model is the value of the checked control, so only one control is checked at a time.
+ */
 declare class NgDocRadioGroupDirective<T> extends DIControl<T> {
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgDocRadioGroupDirective<any>, never>;

package/types/ng-doc-ui-kit-directives-rotator.d.ts

@@ -1,18 +1,18 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 
 /**
  * Directive rotates host with transition
  */
 declare class NgDocRotatorDirective {
     /** Rotator state */
-    rotated: boolean;
+    readonly rotated: _angular_core.InputSignal<boolean>;
     /** Start position angle */
-    from: number;
-    /** End position anle */
-    to: number;
-    get transform(): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgDocRotatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgDocRotatorDirective, "[ngDocRotator]", never, { "rotated": { "alias": "ngDocRotator"; "required": false; }; "from": { "alias": "from"; "required": false; }; "to": { "alias": "to"; "required": false; }; }, {}, never, never, true, never>;
+    readonly from: _angular_core.InputSignal<number>;
+    /** End position angle */
+    readonly to: _angular_core.InputSignal<number>;
+    protected transform(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgDocRotatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgDocRotatorDirective, "[ngDocRotator]", never, { "rotated": { "alias": "ngDocRotator"; "required": false; "isSignal": true; }; "from": { "alias": "from"; "required": false; "isSignal": true; }; "to": { "alias": "to"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { NgDocRotatorDirective };