@koobiq/components 19.8.0 → 20.0.0

package/tags/index.d.ts

@@ -1 +1,706 @@
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { OnDestroy, AfterContentInit, AfterViewInit, ChangeDetectorRef, ElementRef, DoCheck, QueryList, OnChanges, InjectionToken } from '@angular/core';
+import { NgControl, ControlValueAccessor, NgForm, FormGroupDirective } from '@angular/forms';
+import { KbqAutocompleteTrigger } from '@koobiq/components/autocomplete';
+import * as i2 from '@angular/cdk/drag-drop';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import * as i1 from '@koobiq/components/core';
+import { KbqColorDirective, IFocusableOption, KbqTitleTextRef, CanUpdateErrorState, ErrorStateMatcher, FocusKeyManager } from '@koobiq/components/core';
+import { KbqFormFieldControl, KbqCleaner } from '@koobiq/components/form-field';
+import { Subject, Observable } from 'rxjs';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { KbqIcon } from '@koobiq/components/icon';
+import * as i1$1 from '@angular/cdk/platform';
+
+/** Interface for a text control that is used to drive interaction with a kbq-tag-list. */
+
+interface KbqTagTextControl {
+    id: string;
+    placeholder: string;
+    focused: boolean;
+    empty: boolean;
+    ngControl?: NgControl;
+    focus(): void;
+}
+
+/**
+ * Event object emitted by KbqTag.
+ */
+type KbqTagEvent = {
+    tag: KbqTag;
+};
+/**
+ * Event object emitted by KbqTag when the tag is edited.
+ */
+declare class KbqTagEditChange {
+    readonly tag: KbqTag;
+    readonly type: 'start' | 'submit' | 'cancel';
+    readonly reason: string;
+    constructor(tag: KbqTag, type: 'start' | 'submit' | 'cancel', reason: string);
+}
+/** Event object emitted by KbqTag when selected or deselected. */
+declare class KbqTagSelectionChange {
+    source: KbqTag;
+    selected: boolean;
+    isUserInput: boolean;
+    constructor(source: KbqTag, selected: boolean, isUserInput?: boolean);
+}
+/**
+ * Event object emitted when the KbqTag is focused.
+ */
+type KbqTagFocusEvent = KbqTagEvent & {
+    origin: FocusOrigin;
+};
+/**
+ * Object passed to the drag data event when a tag is being dragged.
+ *
+ * @docs-private
+ */
+type KbqTagDragData = KbqTagEvent;
+/**
+ * Dummy directive to add CSS class to tag avatar.
+ * @docs-private
+ */
+declare class KbqTagAvatar {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTagAvatar, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTagAvatar, "kbq-tag-avatar, [kbqTagAvatar]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Dummy directive to add CSS class to tag trailing icon.
+ * @docs-private
+ */
+declare class KbqTagTrailingIcon {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTagTrailingIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTagTrailingIcon, "kbq-tag-trailing-icon, [kbqTagTrailingIcon]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to add submit behavior for the editable tag.
+ */
+declare class KbqTagEditSubmit {
+    /** @docs-private */
+    protected readonly tag: KbqTag;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTagEditSubmit, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTagEditSubmit, "[kbqTagEditSubmit]", ["kbqTagEditSubmit"], {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to add input behavior for the editable tag.
+ */
+declare class KbqTagEditInput {
+    private readonly tag;
+    /** @docs-private */
+    protected handleClick(event: MouseEvent): void;
+    /** @docs-private */
+    protected handleKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTagEditInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTagEditInput, "[kbqTagEditInput]", ["kbqTagEditInput"], {}, {}, never, never, true, [{ directive: typeof i1.KbqFieldSizingContent; inputs: {}; outputs: {}; }]>;
+}
+declare class KbqTag extends KbqColorDirective implements IFocusableOption, OnDestroy, KbqTitleTextRef, AfterContentInit, AfterViewInit {
+    changeDetectorRef: ChangeDetectorRef;
+    private readonly focusMonitor;
+    private readonly tagList;
+    private readonly drag;
+    private readonly destroyRef;
+    /** @docs-private */
+    readonly elementRef: ElementRef<HTMLElement>;
+    /**
+     * Emits when the tag is focused.
+     *
+     * @docs-private
+     */
+    readonly onFocus: Subject<KbqTagFocusEvent>;
+    /**
+     * Emits when the tag is blurred.
+     *
+     * @docs-private
+     */
+    readonly onBlur: Subject<KbqTagEvent>;
+    /** @docs-private */
+    readonly nativeElement: HTMLElement;
+    /**
+     * Whether the tag has focus.
+     *
+     * @docs-private
+     */
+    hasFocus: boolean;
+    /** Whether the tag is editable. */
+    get editable(): boolean;
+    set editable(value: boolean);
+    private _editable;
+    /** Whether the tag edits can't be submitted. */
+    readonly preventEditSubmit: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly editInputElementRef;
+    /**
+     * Emits event when the tag is edited.
+     */
+    readonly editChange: _angular_core.OutputEmitterRef<KbqTagEditChange>;
+    /**
+     * @docs-private
+     */
+    protected readonly editing: _angular_core.WritableSignal<boolean>;
+    /**
+     * @docs-private
+     */
+    readonly textElement: ElementRef<HTMLSpanElement>;
+    readonly contentChildren: _angular_core.Signal<readonly KbqIcon[]>;
+    /** The tag avatar */
+    readonly avatar: _angular_core.Signal<KbqTagAvatar | undefined>;
+    /** The tag's trailing icon. */
+    readonly trailingIcon: _angular_core.Signal<KbqTagTrailingIcon | undefined>;
+    /** The tag's remove toggler. */
+    readonly removeIcon: _angular_core.Signal<any>;
+    /** Emitted when the tag is selected or deselected. */
+    readonly selectionChange: _angular_core.OutputEmitterRef<KbqTagSelectionChange>;
+    /** Emitted when the tag is destroyed and leaving the DOM. */
+    readonly destroyed: _angular_core.OutputEmitterRef<KbqTagEvent>;
+    /**
+     * Emitted when a tag is to be removed.
+     * Fires on programmatic and UI removal (click or keyboard).
+     */
+    readonly removed: _angular_core.OutputEmitterRef<KbqTagEvent>;
+    /** Whether the tag is selected. */
+    get selected(): boolean;
+    set selected(value: boolean);
+    private _selected;
+    /** The value of the tag. Defaults to the content inside `<kbq-tag>` tags. */
+    get value(): any;
+    set value(value: any);
+    private _value;
+    /**
+     * Whether the tag is selectable.
+     */
+    get selectable(): boolean;
+    set selectable(value: boolean);
+    private _selectable;
+    /**
+     * Determines whether the tag is removable.
+     */
+    get removable(): boolean;
+    set removable(value: boolean);
+    private _removable;
+    get tabindex(): any;
+    set tabindex(value: any);
+    private _tabindex;
+    /**
+     * Whether the tag is disabled.
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /**
+     * Whether the tag is draggable.
+     *
+     * @docs-private
+     */
+    protected get draggable(): boolean;
+    constructor();
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** @docs-private */
+    addClassModificatorForIcons(): void;
+    /** @docs-private */
+    addHostClassName(): void;
+    /**
+     * Selects the tag.
+     */
+    select(): void;
+    /**
+     * Deselects the tag.
+     */
+    deselect(): void;
+    /**
+     * Selects the tag and emits event with isUserInput flag.
+     *
+     * @docs-private
+     */
+    selectViaInteraction(): void;
+    /**
+     * Toggles the current selected state of the tag.
+     */
+    toggleSelected(isUserInput?: boolean): boolean;
+    /** Focuses the tag. */
+    focus(): void;
+    /**
+     * Allows for programmatic removal of the tag. Called by the KbqTagList when the DELETE or
+     * BACKSPACE keys are pressed.
+     *
+     * Informs any listeners of the removal request. Does not remove the tag from the DOM.
+     */
+    remove(): void;
+    /** @docs-private */
+    handleClick(event: MouseEvent): void;
+    /** @docs-private */
+    handleKeydown(event: KeyboardEvent): void;
+    /** @docs-private */
+    blur(): void;
+    /** @docs-private */
+    protected handleDblClick(event: MouseEvent): void;
+    private startEditing;
+    /** @docs-private */
+    cancelEditing(reason: string): void;
+    /** @docs-private */
+    submitEditing(reason: string): void;
+    /**
+     * Sets the selected state of the tag.
+     *
+     * @docs-private
+     */
+    setSelectedState(selected: boolean, options?: Partial<{
+        isUserInput: boolean;
+        emitEvent: boolean;
+    }>): void;
+    private setupDragInitialProperties;
+    private syncDragDisabledState;
+    private setupFocusMonitor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTag, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqTag, "kbq-tag, [kbq-tag], kbq-basic-tag, [kbq-basic-tag]", ["kbqTag"], { "editable": { "alias": "editable"; "required": false; }; "preventEditSubmit": { "alias": "preventEditSubmit"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; }; "value": { "alias": "value"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "editChange": "editChange"; "selectionChange": "selectionChange"; "destroyed": "destroyed"; "removed": "removed"; }, ["editInputElementRef", "contentChildren", "avatar", "trailingIcon", "removeIcon"], ["[kbq-icon]:not([kbqTagRemove]):not([kbqTagEditSubmit])", "[kbqTagEditInput]", "*", "[kbqTagEditSubmit]", "[kbqTagRemove]"], true, [{ directive: typeof i2.CdkDrag; inputs: {}; outputs: {}; }]>;
+    static ngAcceptInputType_editable: unknown;
+    static ngAcceptInputType_selected: unknown;
+    static ngAcceptInputType_selectable: unknown;
+    static ngAcceptInputType_removable: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+/**
+ *
+ * Example:
+ *
+ *     `<kbq-tag>
+ *       <kbq-icon kbqTagRemove>cancel</kbq-icon>
+ *     </kbq-tag>`
+ *
+ * You *may* use a custom icon, but you may need to override the `kbq-tag-remove` positioning
+ * styles to properly center the icon within the tag.
+ */
+declare class KbqTagRemove {
+    protected parentTag: KbqTag;
+    /** @docs-private */
+    focus(event: FocusEvent): void;
+    /**
+     * Calls the parent tag's public `remove()` method if applicable.
+     *
+     * @docs-private
+     */
+    handleClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTagRemove, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTagRemove, "[kbqTagRemove]", never, {}, {}, never, never, true, never>;
+}
+
+/** Change event object that is emitted when the tag list value has changed. */
+declare class KbqTagListChange {
+    source: KbqTagList;
+    value: any;
+    constructor(source: KbqTagList, value: any);
+}
+type KbqTagListDroppedEvent = Pick<CdkDragDrop<unknown>, 'event' | 'previousIndex' | 'currentIndex'> & {
+    tag: KbqTag;
+};
+declare class KbqTagList implements KbqFormFieldControl<any>, ControlValueAccessor, AfterContentInit, DoCheck, OnDestroy, CanUpdateErrorState, AfterViewInit {
+    protected elementRef: ElementRef<HTMLElement>;
+    private changeDetectorRef;
+    defaultErrorStateMatcher: ErrorStateMatcher;
+    private dir;
+    parentForm: NgForm | null;
+    parentFormGroup: FormGroupDirective | null;
+    ngControl: NgControl;
+    private readonly dropList;
+    private readonly destroyRef;
+    private readonly focusMonitor;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly controlType: string;
+    /**
+     * Emits whenever the component state changes and should cause the parent
+     * form-field to update. Implemented as part of `KbqFormFieldControl`.
+     * @docs-private
+     */
+    readonly stateChanges: Subject<void>;
+    /**
+     * Combined stream of all of the child tags' selection change events.
+     *
+     * @docs-private
+     */
+    get tagSelectionChanges(): Observable<KbqTagSelectionChange>;
+    /**
+     * Combined stream of all of the child tags' focus change events.
+     *
+     * @docs-private
+     */
+    get tagFocusChanges(): Observable<KbqTagFocusEvent>;
+    /**
+     * Combined stream of all of the child tags' blur change events.
+     *
+     * @docs-private
+     */
+    get tagBlurChanges(): Observable<KbqTagEvent>;
+    /**
+     * Combined stream of all of the child tags' destroyed events.
+     *
+     * @docs-private
+     */
+    get tagRemoveChanges(): Observable<KbqTagEvent>;
+    /**
+     * Combined stream of all of the child tags' removal request events.
+     *
+     * @docs-private
+     */
+    protected get tagBeforeRemoveChanges(): Observable<KbqTagEvent>;
+    /**
+     * Combined stream of all of the child tags' edit change events.
+     *
+     * @docs-private
+     */
+    get tagEditChanges(): Observable<KbqTagEditChange>;
+    /**
+     * The array of selected tags inside tag list.
+     *
+     * @docs-private
+     */
+    get selected(): KbqTag[];
+    /** @docs-private */
+    get canShowCleaner(): boolean;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     * @docs-private
+     */
+    get value(): any;
+    set value(value: any);
+    private _value;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     * @docs-private
+     */
+    get id(): string;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     * @docs-private
+     */
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     * @docs-private
+     */
+    get placeholder(): string;
+    set placeholder(value: string);
+    private _placeholder;
+    /** Whether any tags or the kbqTagInput inside of this tag-list has focus. */
+    get focused(): boolean;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     * @docs-private
+     */
+    get empty(): boolean;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     * @docs-private
+     */
+    get shouldLabelFloat(): boolean;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     * @docs-private
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    get draggable(): boolean;
+    set draggable(value: boolean);
+    private _draggable;
+    /**
+     * Emits when the user drops tag inside tag list container.
+     */
+    readonly dropped: _angular_core.OutputEmitterRef<KbqTagListDroppedEvent>;
+    /**
+     * Whether or not this tag list is selectable. When a tag list is not selectable,
+     * the selected states for all the tags inside the tag list are always ignored.
+     */
+    readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the tags in the list are editable. */
+    readonly editable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the tags in the list are removable. */
+    get removable(): boolean;
+    set removable(value: boolean);
+    private _removable;
+    /**
+     * Tab index of the tag list. This property is ignored when the tag list contains a tag input or is disabled.
+     *
+     * @docs-private
+     */
+    get tabIndex(): number | null;
+    set tabIndex(value: number);
+    private _tabIndex;
+    /**
+     * Event that emits whenever the raw value of the tag-list changes. This is here primarily
+     * to facilitate the two-way binding for the `value` input.
+     * @docs-private
+     */
+    readonly valueChange: _angular_core.OutputEmitterRef<any>;
+    /** @docs-private */
+    uid: string;
+    /**
+     * User defined tab index.
+     * When it is not null, use user defined tab index. Otherwise use tabIndex
+     *
+     * @docs-private
+     */
+    userTabIndex: number | null;
+    /** @docs-private */
+    keyManager: FocusKeyManager<KbqTag>;
+    /** An object used to control when error messages are shown. */
+    errorStateMatcher: ErrorStateMatcher;
+    /** Event emitted when the selected tag list value has been changed by the user. */
+    readonly change: _angular_core.OutputEmitterRef<KbqTagListChange>;
+    /** @docs-private */
+    readonly cleaner: _angular_core.Signal<KbqCleaner | undefined>;
+    /**
+     * The tag components contained within this tag list.
+     *
+     * @docs-private
+     */
+    tags: QueryList<KbqTag>;
+    /**
+     * Whether the component is in an error state.
+     *
+     * @docs-private
+     */
+    errorState: boolean;
+    /** The tag input to add more tags */
+    private tagInput;
+    /** True when the next `tags.changes` emission is triggered by a UI action, not programmatic update. */
+    private pendingUIChange;
+    /**
+     * When a tag is destroyed, we store the index of the destroyed tag until the tags
+     * query list notifies about the update. This is necessary because we cannot determine an
+     * appropriate tag that should receive focus until the array of tags updated completely.
+     */
+    private lastDestroyedTagIndex;
+    /** Triggers unsubscription from all per-tags streams when tags are reset. */
+    private readonly tagsSubscriptions$;
+    constructor();
+    ngDoCheck(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** @docs-private */
+    updateErrorState(): void;
+    /** @docs-private */
+    onTouched: () => void;
+    /** @docs-private */
+    onChange: (value: any) => void;
+    /** Notifies that the next `tags.changes` emission is UI-initiated. */
+    notifyPendingTagChange(): void;
+    /**
+     * Associates an HTML input element with this tag list.
+     *
+     * @docs-private
+     */
+    registerInput(inputElement: KbqTagTextControl): void;
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    writeValue(value: any): void;
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    registerOnChange(fn: (value: any) => void): void;
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    registerOnTouched(fn: () => void): void;
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    onContainerClick(): void;
+    /**
+     * Focuses the tag list. If there is a tag input, focuses that instead.
+     */
+    focus(): void;
+    /**
+     * Focuses the tag input inside the tag list.
+     *
+     * @docs-private
+     */
+    focusInput(): void;
+    /**
+     * Pass events to the keyboard manager. Available here for tests.
+     *
+     * @docs-private
+     */
+    keydown(event: KeyboardEvent): void;
+    /** When blurred, mark the field as touched when focus moved outside the tag list. */
+    blur(): void;
+    /** Mark the field as touched */
+    markAsTouched(): void;
+    /**
+     * Check the tab index as you should not be allowed to focus an empty list.
+     *
+     * @docs-private
+     */
+    protected updateTabIndex(): void;
+    /**
+     * If the amount of tags changed, we need to update the
+     * key manager state and focus the next closest tag.
+     *
+     * @docs-private
+     */
+    protected updateFocusForDestroyedTags(): void;
+    /**
+     * Utility to ensure all indexes are valid.
+     *
+     * @param index The index to be checked.
+     * @returns True if the index is valid for our list of tags.
+     */
+    private isValidIndex;
+    private isInputElement;
+    private isInputEmpty;
+    private isTagElement;
+    private selectAll;
+    /**
+     * Unselects all tags in the list.
+     *
+     * @docs-private
+     */
+    unselectAll(): void;
+    /**
+     * Removes all selected tags from the list.
+     *
+     * @docs-private
+     */
+    removeSelected(): void;
+    private propagateTagsChanges;
+    private resetTags;
+    /** Listens to user-generated selection events on each tag. */
+    private listenToTagsFocus;
+    private listenToTagsRemoved;
+    private listenToTagsEdit;
+    /** Checks whether any of the tags is focused. */
+    private hasFocusedTag;
+    private syncTagsRemovableState;
+    private setupDropListInitialProperties;
+    private syncDropListDisabledState;
+    private setupFocusMonitor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTagList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqTagList, "kbq-tag-list", ["kbqTagList"], { "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; }, { "dropped": "dropped"; "valueChange": "valueChange"; "change": "change"; }, ["cleaner", "tags"], ["*", "kbq-cleaner"], true, [{ directive: typeof i2.CdkDropList; inputs: {}; outputs: {}; }]>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_draggable: unknown;
+    static ngAcceptInputType_removable: unknown;
+}
+
+/** Represents an input event on a `kbqTagInput`. */
+interface KbqTagInputEvent {
+    /** The native `<input>` element that the event is being fired for. */
+    input: HTMLInputElement;
+    /** The value of the input. */
+    value: string;
+}
+interface KbqTagSeparator {
+    symbol: RegExp;
+    key: string;
+}
+/**
+ * Directive that adds tag-specific behaviors to an input element inside `<kbq-form-field>`.
+ * May be placed inside or outside of an `<kbq-tag-list>`.
+ */
+declare class KbqTagInput implements KbqTagTextControl, OnChanges {
+    private elementRef;
+    private defaultOptions;
+    private trimDirective;
+    ngControl: NgControl;
+    autocompleteTrigger?: KbqAutocompleteTrigger | null | undefined;
+    /** Whether the control is focused. */
+    focused: boolean;
+    /**
+     * The list of key codes that will trigger a tagEnd event.
+     *
+     * Defaults to `[ENTER]`.
+     */
+    set separatorKeyCodes(value: number[]);
+    private _separatorKeyCodes;
+    /** @docs-private */
+    get separators(): KbqTagSeparator[];
+    private _separators;
+    /** Emitted when a tag is to be added. */
+    readonly tagEnd: _angular_core.OutputEmitterRef<KbqTagInputEvent>;
+    /** A value indicating whether allow/prevent tags duplication  */
+    readonly distinct: _angular_core.InputSignal<boolean>;
+    /** The input's placeholder text. */
+    placeholder: string;
+    /** Unique id for the input. */
+    id: string;
+    /** Register input for tag list */
+    set tagList(value: KbqTagList);
+    private _tagList;
+    /**
+     * Whether or not the tagEnd event will be emitted when the input is blurred.
+     */
+    get addOnBlur(): boolean;
+    set addOnBlur(value: boolean);
+    private _addOnBlur;
+    /**
+     * Whether the tagEnd event will be emitted when the text pasted.
+     * @default true
+     */
+    readonly addOnPaste: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the input is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /** Whether the input is empty. */
+    get empty(): boolean;
+    /** The native input element to which this directive is attached. */
+    private inputElement;
+    constructor();
+    ngOnChanges(): void;
+    /** @docs-private */
+    onKeydown(event: KeyboardEvent): void;
+    /** Checks to see if the blur should emit the (tagEnd) event. */
+    blur(event: FocusEvent): void;
+    triggerValidation(): void;
+    /** Checks to see if the (tagEnd) event needs to be emitted. */
+    emitTagEnd(): void;
+    get hasDuplicates(): boolean;
+    onInput(): void;
+    onPaste($event: ClipboardEvent): void;
+    /** @docs-private */
+    onFocus(): void;
+    /** Focuses the input. */
+    focus(): void;
+    private getSeparatorsForString;
+    private trimValue;
+    private getSeparatorByKeyCode;
+    private hasControl;
+    /** Checks whether a keycode is one of the configured separators. */
+    private isSeparatorKey;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTagInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTagInput, "input[kbqTagInputFor]", ["kbqTagInput", "kbqTagInputFor"], { "separatorKeyCodes": { "alias": "kbqTagInputSeparatorKeyCodes"; "required": false; }; "distinct": { "alias": "distinct"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; }; "id": { "alias": "id"; "required": false; }; "tagList": { "alias": "kbqTagInputFor"; "required": false; }; "addOnBlur": { "alias": "kbqTagInputAddOnBlur"; "required": false; }; "addOnPaste": { "alias": "kbqTagInputAddOnPaste"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "tagEnd": "kbqTagInputTokenEnd"; }, never, never, true, [{ directive: typeof i1.KbqFieldSizingContent; inputs: {}; outputs: {}; }]>;
+}
+
+/** Default options, for the chips module, that can be overridden. */
+interface KbqTagsDefaultOptions {
+    /** The list of key codes that will trigger a chipEnd event. */
+    separatorKeyCodes: number[];
+    separators?: {
+        [key: number]: KbqTagSeparator;
+    };
+    addOnPaste?: boolean;
+}
+/** Injection token to be used to override the default options for the chips module. */
+declare const KBQ_TAGS_DEFAULT_OPTIONS: InjectionToken<KbqTagsDefaultOptions>;
+
+declare class KbqTagsModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTagsModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqTagsModule, never, [typeof i1$1.PlatformModule, typeof KbqTagEditSubmit, typeof KbqTagEditInput, typeof KbqTagList, typeof KbqTag, typeof KbqTagInput, typeof KbqTagTrailingIcon, typeof KbqTagAvatar, typeof KbqTagRemove], [typeof KbqTagList, typeof KbqTag, typeof KbqTagInput, typeof KbqTagTrailingIcon, typeof KbqTagAvatar, typeof KbqTagRemove, typeof KbqTagEditSubmit, typeof KbqTagEditInput]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqTagsModule>;
+}
+
+export { KBQ_TAGS_DEFAULT_OPTIONS, KbqTag, KbqTagAvatar, KbqTagEditChange, KbqTagEditInput, KbqTagEditSubmit, KbqTagInput, KbqTagList, KbqTagListChange, KbqTagRemove, KbqTagSelectionChange, KbqTagTrailingIcon, KbqTagsModule };
+export type { KbqTagDragData, KbqTagEvent, KbqTagFocusEvent, KbqTagInputEvent, KbqTagListDroppedEvent, KbqTagSeparator, KbqTagsDefaultOptions };