@koobiq/components 20.4.2 → 21.0.1

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

@@ -0,0 +1,477 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnDestroy, Provider, DoCheck, ElementRef, WritableSignal, OnChanges, SimpleChanges } from '@angular/core';
+import * as i2 from '@angular/forms';
+import { ControlValueAccessor, NgControl, NgForm, FormGroupDirective, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import * as i1 from '@koobiq/components/core';
+import { KbqInputLocaleConfiguration, KbqInputNumberLocaleConfiguration, KbqDeepPartial, CanUpdateErrorState, ErrorStateMatcher } from '@koobiq/components/core';
+import * as i8 from '@koobiq/components/form-field';
+import { KbqFormFieldControl } from '@koobiq/components/form-field';
+import { NumberInput } from '@angular/cdk/coercion';
+import { Subject } from 'rxjs';
+import * as i1$1 from '@angular/cdk/a11y';
+import * as i3 from '@koobiq/components/icon';
+
+/**
+ * @deprecated Use {@link KBQ_INPUT_DEFAULT_LOCALE_CONFIGURATION}, which carries the whole `input`
+ * locale section rather than just its `number` slice. Will be removed in 22.0.0.
+ */
+declare const KBQ_INPUT_NUMBER_DEFAULT_CONFIGURATION: {
+    groupSeparator: string[];
+    fractionSeparator: string;
+    startFormattingFrom: number;
+    viewGroupSeparator: string;
+};
+/**
+ * Default configuration of `KbqNumberInput`: the whole `input` locale section, of which the number input
+ * reads `number`.
+ */
+declare const KBQ_INPUT_DEFAULT_LOCALE_CONFIGURATION: KbqInputLocaleConfiguration;
+/** Injection token for providing the default configuration of `KbqNumberInput`. */
+declare const KBQ_INPUT_LOCALE_CONFIGURATION: InjectionToken<KbqInputLocaleConfiguration>;
+/**
+ * Utility provider for `KBQ_INPUT_LOCALE_CONFIGURATION`. Only the values you pass are overridden; the rest
+ * keep following the active locale.
+ */
+declare const kbqInputLocaleConfigurationProvider: (configuration: KbqDeepPartial<KbqInputLocaleConfiguration>) => Provider;
+/**
+ * Default of `bigStep`.
+ *
+ * @docs-private
+ */
+declare const BIG_STEP = 10;
+/**
+ * Default of `step`.
+ *
+ * @docs-private
+ */
+declare const SMALL_STEP = 1;
+/** @docs-private */
+declare function isFloat(value: string): boolean;
+/**
+ * Decimal scale of `value`: `10 ** <number of fraction digits>`.
+ *
+ * @docs-private
+ */
+declare function getPrecision(value: number): number;
+/**
+ * Adds two decimal numbers without IEEE-754 drift: both operands are rounded into integer space at
+ * the larger of the two scales, added there, and scaled back.
+ *
+ * @docs-private
+ */
+declare function add(value1: number, value2: number): number;
+declare const KBQ_NUMBER_INPUT_VALUE_ACCESSOR: any;
+declare class KbqNumberInput implements ControlValueAccessor, OnDestroy {
+    private elementRef;
+    private readonly renderer;
+    private readonly ngZone;
+    private readonly destroyRef;
+    private localeService;
+    /** Emits when the value changes (either due to user input or programmatic change). */
+    readonly valueChange: Subject<number | null>;
+    /** Emits when the disabled state has changed */
+    readonly disabledChange: Subject<boolean>;
+    /** Emits whenever the focused or disabled state of the directive changes. */
+    readonly stateChanges: Subject<void>;
+    /**
+     * Discriminator read by `kbq-stepper` to find the control it drives.
+     *
+     * @docs-private
+     */
+    controlType: string;
+    /**
+     * Allows input and pasting of integers only.
+     */
+    readonly integer: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Step applied when `Shift` is held. */
+    readonly bigStep: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /** Step applied by the arrow keys and by `kbq-stepper`. */
+    readonly step: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /** Lower bound the value is clamped to when stepping. */
+    readonly min: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /** Upper bound the value is clamped to when stepping. */
+    readonly max: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly withThousandSeparator: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Adds the thousand separator only from this power of ten. For example, `4` keeps `1234`
+     * un-grouped and groups `12345`. Defaults to the active locale's own value.
+     */
+    readonly startFormattingFrom: _angular_core.InputSignal<number | undefined>;
+    /** @docs-private */
+    readonly valueInput: _angular_core.InputSignal<number | null | undefined>;
+    /** The numeric value of the field, bound with `[value]` or written by a form control. */
+    get value(): number | null;
+    private readonly valueState;
+    /** @docs-private */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | null | undefined>;
+    /** Whether the field is disabled, bound with `[disabled]` or set by a form control. */
+    get disabled(): boolean;
+    private readonly disabledState;
+    focused: boolean;
+    get nativeElement(): HTMLInputElement;
+    get viewValue(): string;
+    /**
+     * Locale-aware numeric read of the field: parsed straight from `nativeElement.value`, so `"1 234,5"`
+     * reads back as `1234.5` where the native `valueAsNumber` of a `type="text"` input reports `NaN`.
+     * Computed on every read rather than cached off the committed model, so it never lags behind a
+     * keystroke the way `value` can while `onInput`'s reformat is still pending in its `setTimeout(0)` —
+     * safe to read from a consumer's own `(input)` handler. An in-progress `"-"` reads as `null`, same as
+     * an empty field, rather than the last committed number.
+     */
+    get valueAsNumber(): number | null;
+    /**
+     * An unbounded end reports no `aria-value*`: `Infinity` is not a valid ARIA attribute value.
+     * A `computed()` rather than a getter so the value is cached between checks — the host binding
+     * itself lives in the declaring view and repaints either way.
+     */
+    protected readonly ariaValueMin: _angular_core.Signal<number | null>;
+    /** The upper bound, reported the way `ariaValueMin` reports the lower one. */
+    protected readonly ariaValueMax: _angular_core.Signal<number | null>;
+    protected get fractionSeparator(): KbqInputNumberLocaleConfiguration['fractionSeparator'];
+    protected get groupSeparator(): KbqInputNumberLocaleConfiguration['groupSeparator'];
+    private get config();
+    private readonly localeConfiguration;
+    private valueFromPaste;
+    /** Pending `onInput` reformats by timer handle: cancelled on destroy, run at once before a step. */
+    private readonly pendingReformats;
+    constructor();
+    ngOnDestroy(): void;
+    onContainerClick(): void;
+    focus(): void;
+    writeValue(value: number | null): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    focusChanged(isFocused: boolean): void;
+    /**
+     * Called when the control is blurred. Needed to properly implement `ControlValueAccessor`.
+     *
+     * @docs-private
+     */
+    onTouched: () => void;
+    onKeyDown(event: KeyboardEvent): void;
+    onInput(event: InputEvent): void;
+    onPaste(event: ClipboardEvent): void;
+    stepUp(step: number): void;
+    stepDown(step: number): void;
+    private isCtrlV;
+    private isCtrlX;
+    private isCtrlZ;
+    private isPeriod;
+    private cvaOnChange;
+    /**
+     * Commits a keystroke whose reformat is still pending, so a step pressed right after typing starts from
+     * the typed value rather than the last committed one. The caret correction is skipped: the step rewrites
+     * the value it would apply to.
+     */
+    private commitPendingReformats;
+    /**
+     * Moves the caret one position when a group separator was inserted or removed by the reformat, so it
+     * stays next to the same digit. Runs outside the zone: it only writes the selection, which no view or
+     * model reads back, and each keystroke would otherwise cost an extra application-wide check.
+     */
+    private correctCaretForSeparator;
+    private setViewValue;
+    /** Writes a value from outside the field: reformats it and reports the change. */
+    private setValue;
+    private setDisabled;
+    private viewToModelUpdate;
+    private formatViewValue;
+    private formatNumber;
+    private createLocalizedNumberFromParts;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqNumberInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqNumberInput, "input[kbqNumberInput]", ["kbqNumberInput", "kbqNumericalInput"], { "integer": { "alias": "integer"; "required": false; "isSignal": true; }; "bigStep": { "alias": "bigStep"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "withThousandSeparator": { "alias": "withThousandSeparator"; "required": false; "isSignal": true; }; "startFormattingFrom": { "alias": "startFormattingFrom"; "required": false; "isSignal": true; }; "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.KbqLocaleOverridesDirective; inputs: { "kbqLocaleOverrides": "localeOverrides"; }; outputs: {}; }]>;
+}
+
+declare class KbqInput implements KbqFormFieldControl<any>, DoCheck, CanUpdateErrorState {
+    protected elementRef: ElementRef<HTMLInputElement>;
+    ngControl: NgControl | null;
+    numberInput: KbqNumberInput | null;
+    parentForm: NgForm | null;
+    parentFormGroup: FormGroupDirective | null;
+    defaultErrorStateMatcher: ErrorStateMatcher;
+    private readonly errorStateTracker;
+    /** Whether the component is in an error state. */
+    readonly errorState: _angular_core.Signal<boolean>;
+    /** An object used to control when error messages are shown. */
+    readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
+    private readonly focusedValue;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly focused: _angular_core.Signal<boolean>;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly autofilled: _angular_core.Signal<boolean>;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    controlType: string;
+    /** @docs-private */
+    readonly placeholderInput: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Implemented as part of KbqFormFieldControl. Writable, so that a select search can supply one.
+     *
+     * @docs-private
+     */
+    readonly placeholder: WritableSignal<string | undefined>;
+    protected uid: string;
+    protected neverEmptyInputTypes: string[];
+    /** @docs-private */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, string | boolean | null | undefined>;
+    /** `disabled` of the bound form control, which takes precedence over the input. */
+    private readonly formDisabled;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly disabled: _angular_core.Signal<boolean>;
+    /** @docs-private */
+    readonly idInput: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly id: _angular_core.Signal<string>;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, string | boolean | null | undefined>;
+    /** @docs-private */
+    readonly typeInput: _angular_core.InputSignal<string | undefined>;
+    /** Input type of the element. */
+    get type(): string;
+    private readonly resolvedType;
+    private inputValueAccessor;
+    /** @docs-private */
+    readonly valueInput: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Implemented as part of KbqFormFieldControl. Follows what the user types; a value bound with `[value]` or set
+     * here is written to the element.
+     *
+     * @docs-private
+     */
+    readonly value: WritableSignal<string>;
+    private readonly emptyValue;
+    /** The value the element and `value` last agreed on, and the text the element showed then. */
+    private syncedValue;
+    private syncedText;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly empty: _angular_core.Signal<boolean>;
+    constructor();
+    ngDoCheck(): void;
+    updateErrorState(): void;
+    /** Focuses the input. */
+    focus(): void;
+    onBlur(): void;
+    /** Callback for the cases where the focused state of the input changes. */
+    focusChanged(isFocused: boolean): void;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    onContainerClick(): void;
+    /**
+     * Reads the native value back, since it changes without notice: through the forms API, which writes the
+     * element directly, or by the user typing into an input that no form listens to.
+     *
+     * @docs-private
+     */
+    dirtyCheckNativeValue(): void;
+    /** Make sure the input is a supported type. */
+    protected validateType(): void;
+    /** Checks whether the input type is one of the types that are never empty. */
+    protected isNeverEmpty(): boolean;
+    /** Checks whether the input is invalid based on the native validation. */
+    protected isBadInput(): boolean;
+    private isEmpty;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqInput, "input[kbqInput],input[kbqNumberInput]", ["kbqInput"], { "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; "placeholderInput": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "typeInput": { "alias": "type"; "required": false; "isSignal": true; }; "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class KbqInputMono {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqInputMono, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqInputMono, "input[kbqInputMonospace]", ["kbqInputMonospace", "KbqInputMonospace"], {}, {}, never, never, true, never>;
+}
+
+declare const KBQ_MIN_VALIDATOR: Provider;
+/**
+ * A directive which installs the `KbqMinValidator` for any `formControlName`,
+ * `formControl`, or control with `ngModel` that also has a `min` attribute.
+ */
+declare class KbqMinValidator implements Validator, OnChanges {
+    /** Lower bound installed as `Validators.min`. A non-numeric bound reads back as `NaN`. */
+    readonly min: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    private validator;
+    private onChange;
+    /** `min()` unless it is `NaN`, which has no DOM representation. */
+    protected readonly coercedMin: _angular_core.Signal<number | null>;
+    ngOnChanges(changes: SimpleChanges): void;
+    validate(c: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    private createValidator;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqMinValidator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqMinValidator, "[min][formControlName],[min][formControl],[min][ngModel]", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare const KBQ_MAX_VALIDATOR: Provider;
+/**
+ * A directive which installs the `KbqMaxValidator` for any `formControlName`,
+ * `formControl`, or control with `ngModel` that also has a `max` attribute.
+ */
+declare class KbqMaxValidator implements Validator, OnChanges {
+    /** Upper bound installed as `Validators.max`. A non-numeric bound reads back as `NaN`. */
+    readonly max: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    private validator;
+    private onChange;
+    /** `max()` unless it is `NaN`, which has no DOM representation. */
+    protected readonly coercedMax: _angular_core.Signal<number | null>;
+    ngOnChanges(changes: SimpleChanges): void;
+    validate(c: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    private createValidator;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqMaxValidator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqMaxValidator, "[max][formControlName],[max][formControl],[max][ngModel]", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class KbqInputPassword implements KbqFormFieldControl<any>, DoCheck, CanUpdateErrorState {
+    protected elementRef: ElementRef<HTMLInputElement>;
+    ngControl: NgControl | null;
+    parentForm: NgForm | null;
+    parentFormGroup: FormGroupDirective | null;
+    defaultErrorStateMatcher: ErrorStateMatcher;
+    private readonly errorStateTracker;
+    /** Whether the component is in an error state. */
+    readonly errorState: _angular_core.Signal<boolean>;
+    /** An object used to control when error messages are shown. */
+    readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
+    private readonly focusedValue;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly focused: _angular_core.Signal<boolean>;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly autofilled: _angular_core.Signal<boolean>;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    controlType: string;
+    private readonly elementTypeValue;
+    /** Type of the native input: `password` while the password is hidden, `text` while it is shown. */
+    readonly elementType: _angular_core.Signal<"text" | "password">;
+    /** @docs-private */
+    readonly placeholderInput: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly placeholder: WritableSignal<string | undefined>;
+    protected uid: string;
+    /** @docs-private */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, string | boolean | null | undefined>;
+    /** `disabled` of the bound form control, which takes precedence over the input. */
+    private readonly formDisabled;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly disabled: _angular_core.Signal<boolean>;
+    /** @docs-private */
+    readonly idInput: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly id: _angular_core.Signal<string>;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, string | boolean | null | undefined>;
+    private inputValueAccessor;
+    /** @docs-private */
+    readonly valueInput: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Implemented as part of KbqFormFieldControl. Follows what the user types; a value bound with `[value]` or set
+     * here is written to the element.
+     *
+     * @docs-private
+     */
+    readonly value: WritableSignal<string>;
+    private readonly emptyValue;
+    /** The value the element and `value` last agreed on, and the text the element showed then. */
+    private syncedValue;
+    private syncedText;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly empty: _angular_core.Signal<boolean>;
+    constructor();
+    ngDoCheck(): void;
+    updateErrorState(): void;
+    /** Toggles the native input type between password and text. */
+    toggleType(): void;
+    /** Focuses the input. */
+    focus(): void;
+    onBlur(): void;
+    /** Callback for the cases where the focused state of the input changes. */
+    focusChanged(isFocused: boolean): void;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    onContainerClick(): void;
+    /**
+     * Reads the native value back, since it changes without notice: through the forms API, which writes the
+     * element directly, or by the user typing into an input that no form listens to.
+     *
+     * @docs-private
+     */
+    dirtyCheckNativeValue(): void;
+    /** Checks whether the input is invalid based on the native validation. */
+    protected isBadInput(): boolean;
+    private isEmpty;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqInputPassword, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqInputPassword, "input[kbqInputPassword]", ["kbqInputPassword"], { "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; "placeholderInput": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const KBQ_INPUT_VALUE_ACCESSOR: InjectionToken<{
+    value: any;
+}>;
+
+declare class KbqInputModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqInputModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqInputModule, never, [typeof i1$1.A11yModule, typeof i2.FormsModule, typeof i3.KbqIconModule, typeof KbqInput, typeof KbqNumberInput, typeof KbqInputPassword, typeof KbqInputMono, typeof KbqMinValidator, typeof KbqMaxValidator], [typeof KbqInput, typeof KbqNumberInput, typeof KbqInputPassword, typeof KbqInputMono, typeof KbqMinValidator, typeof KbqMaxValidator, typeof i8.KbqFormFieldModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqInputModule>;
+}
+
+export { BIG_STEP, KBQ_INPUT_DEFAULT_LOCALE_CONFIGURATION, KBQ_INPUT_LOCALE_CONFIGURATION, KBQ_INPUT_NUMBER_DEFAULT_CONFIGURATION, KBQ_INPUT_VALUE_ACCESSOR, KBQ_MAX_VALIDATOR, KBQ_MIN_VALIDATOR, KBQ_NUMBER_INPUT_VALUE_ACCESSOR, KbqInput, KbqInputModule, KbqInputMono, KbqInputPassword, KbqMaxValidator, KbqMinValidator, KbqNumberInput, SMALL_STEP, add, getPrecision, isFloat, kbqInputLocaleConfigurationProvider };

package/types/koobiq-components-link-deprecated.d.ts

@@ -0,0 +1,101 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, AfterViewChecked, OnDestroy, Renderer2 } from '@angular/core';
+import * as i1 from '@angular/cdk/a11y';
+
+/**
+ * Directive that styles an anchor as a link.
+ *
+ * @deprecated The directive whose markup has to know its internals: the `kbq-link__text` wrapper, the
+ * `kbq-link_external` and `kbq-text-with-dot` classes. Superseded by the `KbqLink` component of
+ * `@koobiq/components/link` (`[kbqLink]`), which renders that structure itself and adds
+ * `kbqLinkPrefix`/`kbqLinkSuffix` slots, the `external` and `size` inputs and keyboard support for pseudo
+ * links. Will be removed in a future major version - an `ng update` migration rewrites
+ * `@koobiq/components/link` imports of this API to `@koobiq/components/link/deprecated` automatically.
+ */
+declare class KbqLink implements AfterViewInit, AfterViewChecked, OnDestroy {
+    private readonly focusMonitor;
+    private readonly contentObserver;
+    private readonly nativeElement;
+    /**
+     * `[kbq-link]` styles an `<a>` or a `<span>`, where `disabled` is not a valid attribute and means
+     * nothing to assistive tech, so the state is exposed through ARIA instead. The check is on the tag
+     * rather than hardcoded, because the selector does not restrict the host.
+     */
+    private readonly hostSupportsNativeDisabled;
+    protected readonly renderer: Renderer2;
+    private readonly icons;
+    /** Whether the link is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Effective disabled state, mirroring the `disabled` input. It stays writable because `kbqTooltip`
+     * accepts a link through `forDisabledComponent` and reads this signal to keep a tooltip reachable on a
+     * disabled link; the host bindings read it rather than the input so such a write still shows.
+     *
+     * @docs-private
+     */
+    readonly disabledSignal: _angular_core.WritableSignal<boolean>;
+    /** Tab order of the link. A disabled link is taken out of the tab order regardless of this value. */
+    readonly tabIndex: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Whether the link is rendered without a `href`, as a control that looks like a link. */
+    readonly pseudo: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the link is rendered without an underline. */
+    readonly noUnderline: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the link uses the big typography. */
+    readonly big: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the link uses the compact typography. */
+    readonly compact: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the link has an increased hit area for multiline usage. */
+    readonly multiline: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether a visited link is styled differently. */
+    readonly useVisited: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * URL printed next to the link text when the page is printed. Defaults to the `href` without its
+     * protocol, which is what a valueless `print` attribute and an empty string ask for; bind it to print
+     * something else, or bind `null` to opt out.
+     */
+    readonly print: _angular_core.InputSignal<string | null | undefined>;
+    /** @docs-private */
+    protected readonly hasIcon: _angular_core.Signal<boolean>;
+    /** @docs-private */
+    protected readonly printMode: _angular_core.Signal<boolean>;
+    /** @docs-private */
+    protected readonly nativeDisabledAttribute: _angular_core.Signal<true | null>;
+    /** @docs-private */
+    protected readonly ariaDisabledAttribute: _angular_core.Signal<true | null>;
+    /** @docs-private */
+    protected readonly hostTabIndex: _angular_core.Signal<number>;
+    constructor();
+    /** The URL last written to the `print` attribute. */
+    private printedUrl;
+    ngAfterViewInit(): void;
+    /**
+     * Writes the URL printed next to the link text. `href` is DOM state rather than a signal, and a `routerLink` on
+     * the same element sets it from a host binding of its own that may run after this directive's, so it is read
+     * once the view is checked: a binding would print the previous `href` until something re-checked the view.
+     */
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    /** Focuses the link. */
+    focus(): void;
+    /** The anchor the directive is applied to. */
+    getHostElement(): HTMLAnchorElement;
+    private updateClassModifierForIcons;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqLink, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqLink, "[kbq-link]", ["kbqLink"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "pseudo": { "alias": "pseudo"; "required": false; "isSignal": true; }; "noUnderline": { "alias": "noUnderline"; "required": false; "isSignal": true; }; "big": { "alias": "big"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "multiline": { "alias": "multiline"; "required": false; "isSignal": true; }; "useVisited": { "alias": "useVisited"; "required": false; "isSignal": true; }; "print": { "alias": "print"; "required": false; "isSignal": true; }; }, {}, ["icons"], never, true, never>;
+}
+
+/**
+ * @deprecated The directive whose markup has to know its internals: the `kbq-link__text` wrapper, the
+ * `kbq-link_external` and `kbq-text-with-dot` classes. Superseded by the `KbqLink` component of
+ * `@koobiq/components/link` (`[kbqLink]`), which renders that structure itself and adds
+ * `kbqLinkPrefix`/`kbqLinkSuffix` slots, the `external` and `size` inputs and keyboard support for pseudo
+ * links. Will be removed in a future major version - an `ng update` migration rewrites
+ * `@koobiq/components/link` imports of this API to `@koobiq/components/link/deprecated` automatically.
+ */
+declare class KbqLinkModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqLinkModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqLinkModule, never, [typeof i1.A11yModule, typeof KbqLink], [typeof KbqLink]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqLinkModule>;
+}
+
+export { KbqLink, KbqLinkModule };