@taiga-ui/legacy 4.0.0-rc.1

package/components/svg/content-processor.d.ts

@@ -0,0 +1,16 @@
+import type { TuiSafeHtml } from '@taiga-ui/cdk/types';
+/**
+ * @description:
+ * Any ‘linearGradient’ attributes which are defined on the referenced
+ * element which are not defined on this element are inherited by this element.
+ * If this element has no defined gradient stops, and the referenced element does
+ * (possibly due to its own ‘xlink:href’ attribute), then this element inherits
+ * the gradient stop from the referenced element. Inheritance can be indirect
+ * to an arbitrary level; thus, if the referenced element inherits attribute
+ * or gradient stops due to its own ‘xlink:href’ attribute, then the current
+ * element can inherit those attributes or gradient stops.
+ *
+ * Documentation: https://www.w3.org/TR/SVG11/pservers.html
+ *
+ */
+export declare function tuiSvgLinearGradientProcessor(svg: TuiSafeHtml, salt?: number | string): TuiSafeHtml;

package/components/svg/deprecated-icons.d.ts

@@ -0,0 +1 @@
+export declare const TUI_DEPRECATED_ICONS: Record<string, string>;

package/components/svg/index.d.ts

@@ -0,0 +1,5 @@
+export * from './content-processor';
+export * from './deprecated-icons';
+export * from './svg.component';
+export * from './svg.service';
+export * from './svg-options';

package/components/svg/svg-options.d.ts

@@ -0,0 +1,22 @@
+import type { FactoryProvider, Provider } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import type { TuiHandler, TuiSafeHtml, TuiStringHandler } from '@taiga-ui/cdk/types';
+export declare const TUI_DEFAULT_ICONS_PLACE = "assets/taiga-ui/icons";
+export interface TuiSvgOptions {
+    readonly contentProcessor: TuiHandler<TuiSafeHtml, TuiSafeHtml>;
+    readonly deprecated: TuiStringHandler<string>;
+    readonly iconsPlace: string;
+    readonly path: (name: string, baseHref?: string) => string;
+    readonly srcProcessor: TuiHandler<TuiSafeHtml, TuiSafeHtml>;
+}
+export type TuiSvgInterceptorHandler = ((src: TuiSafeHtml, options: TuiSvgOptions) => TuiSafeHtml) | ((src: TuiSafeHtml) => TuiSafeHtml);
+export declare const TUI_SVG_DEFAULT_OPTIONS: TuiSvgOptions;
+/**
+ * SVG component options
+ */
+export declare const TUI_SVG_OPTIONS: InjectionToken<TuiSvgOptions>;
+export declare const TUI_SVG_SRC_INTERCEPTORS: InjectionToken<TuiSvgInterceptorHandler>;
+export declare function tuiSvgSrcInterceptors(interceptor: TuiSvgInterceptorHandler): Provider;
+export declare const tuiSvgOptionsProvider: (options: Partial<Omit<TuiSvgOptions, 'path'>> & {
+    path?: TuiSvgOptions['path'] | string;
+}) => FactoryProvider;

package/components/svg/svg.component.d.ts

@@ -0,0 +1,43 @@
+import type { SafeHtml } from '@angular/platform-browser';
+import type { TuiSafeHtml } from '@taiga-ui/cdk/types';
+import type { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface TuiIconError {
+    readonly icon: string;
+    readonly message: string;
+}
+export declare class TuiSvgComponent {
+    private icon;
+    private readonly doc;
+    private readonly win;
+    private readonly options;
+    private readonly tuiSanitizer;
+    private readonly svgService;
+    private readonly staticRequestService;
+    private readonly sanitizer;
+    private readonly el;
+    private readonly baseHref;
+    private readonly src$;
+    private readonly srcInterceptors;
+    protected readonly innerHTML$: Observable<SafeHtml>;
+    constructor();
+    set src(src: TuiSafeHtml | null | undefined);
+    get src(): TuiSafeHtml;
+    get use(): string;
+    get isInnerHTML(): boolean;
+    protected onError(message?: string): void;
+    private get isShadowDOM();
+    private get isUse();
+    private get isExternal();
+    private get isUrl();
+    private get isSrc();
+    private get isName();
+    private get isCrossDomain();
+    private resolveName;
+    private getSafeHtml;
+    private process;
+    private sanitize;
+    private getExternalIcon;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiSvgComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiSvgComponent, "tui-svg", never, { "src": { "alias": "src"; "required": false; }; }, {}, never, never, true, never>;
+}

package/components/svg/svg.service.d.ts

@@ -0,0 +1,21 @@
+import type { SafeHtml } from '@angular/platform-browser';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Service for reusing SVGs without inlining each instance
+ * @deprecated
+ */
+export declare class TuiSvgService {
+    private readonly tuiSanitizer;
+    private readonly sanitizer;
+    private originals;
+    readonly items$: BehaviorSubject<Map<string, SafeHtml>>;
+    constructor();
+    define(icons: Record<string, string>): void;
+    getOriginal(name: string): string | null;
+    private defineIcon;
+    private parseSrc;
+    private sanitize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiSvgService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TuiSvgService>;
+}

package/components/table-bar/index.d.ts

@@ -0,0 +1,5 @@
+export * from './table-bar.directive';
+export * from './table-bar.options';
+export * from './table-bars.service';
+export * from './table-bars-host.component';
+export * from './table-bars-host.component';

package/components/table-bar/table-bar.component.d.ts

@@ -0,0 +1,13 @@
+import type { TuiPopover } from '@taiga-ui/cdk/services';
+import type { TuiTableBarOptions } from './table-bar.options';
+import * as i0 from "@angular/core";
+export declare class TuiTableBarComponent {
+    protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
+    protected readonly closeWord$: import("rxjs").Observable<string>;
+    protected readonly context: TuiPopover<TuiTableBarOptions, void>;
+    protected readonly animation: import("@angular/animations").AnimationOptions;
+    protected getTheme(appearance: string): string | null;
+    protected close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTableBarComponent, "tui-table-bar", never, {}, {}, never, never, true, never>;
+}

package/components/table-bar/table-bar.directive.d.ts

@@ -0,0 +1,7 @@
+import { TuiPopoverDirective } from '@taiga-ui/cdk/directives/popover';
+import type { TuiTableBarOptions } from './table-bar.options';
+import * as i0 from "@angular/core";
+export declare class TuiTableBarDirective extends TuiPopoverDirective<TuiTableBarOptions> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableBarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableBarDirective, "ng-template[tuiTableBar]", never, { "open": { "alias": "tuiTableBar"; "required": false; }; "options": { "alias": "tuiTableBarOptions"; "required": false; }; }, { "openChange": "tuiTableBarChange"; }, never, never, true, never>;
+}

package/components/table-bar/table-bar.options.d.ts

@@ -0,0 +1,14 @@
+import type { Provider } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+export interface TuiTableBarOptions {
+    readonly adaptive?: boolean;
+    readonly hasCloseButton?: boolean;
+    readonly mode?: 'onDark' | 'onLight';
+}
+export declare const TUI_TABLE_BARS: import("@angular/core").InjectionToken<BehaviorSubject<readonly any[]>>;
+export declare const TUI_TABLE_BAR_DEFAULT_OPTIONS: TuiTableBarOptions;
+/**
+ * Default parameters for table bars component
+ */
+export declare const TUI_TABLE_BAR_OPTIONS: import("@angular/core").InjectionToken<TuiTableBarOptions>;
+export declare function tuiTableBarOptionsProvider(options: Partial<TuiTableBarOptions>): Provider;

package/components/table-bar/table-bars-host.component.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class TuiTableBarsHostComponent {
+    protected bars$: import("rxjs").BehaviorSubject<readonly any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableBarsHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTableBarsHostComponent, "tui-table-bars-host", never, {}, {}, never, never, true, never>;
+}

package/components/table-bar/table-bars.service.d.ts

@@ -0,0 +1,10 @@
+import { TuiPopoverService } from '@taiga-ui/cdk/services';
+import type { TuiTableBarOptions } from './table-bar.options';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated Use {@link TuiFilterByInputPipe} instead
+ */
+export declare class TuiTableBarsService extends TuiPopoverService<TuiTableBarOptions> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableBarsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TuiTableBarsService>;
+}

package/components/tag/index.d.ts

@@ -0,0 +1,3 @@
+export * from './tag.component';
+export * from './tag.module';
+export * from './tag.options';

package/components/tag/tag.component.d.ts

@@ -0,0 +1,40 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import type { TuiSizeL, TuiSizeS, TuiSizeXS } from '@taiga-ui/core/types';
+import type { TuiStatus } from '@taiga-ui/legacy/utils';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare class TuiTagComponent {
+    private readonly el;
+    private readonly options;
+    protected editing: boolean;
+    protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
+    protected editedText: string | null;
+    value: string;
+    editable: boolean;
+    separator: RegExp | string;
+    maxLength: number | null;
+    size: TuiSizeL | TuiSizeS;
+    showLoader: boolean;
+    status: TuiStatus;
+    hoverable: boolean;
+    removable: boolean;
+    disabled: boolean;
+    autoColor: boolean;
+    leftContent: PolymorpheusContent;
+    readonly edited: EventEmitter<string>;
+    protected set input(input: ElementRef<HTMLInputElement>);
+    protected get backgroundColor(): string | null;
+    protected get canRemove(): boolean;
+    protected get displayText(): string;
+    protected get loaderSize(): TuiSizeXS;
+    protected edit(event: Event): void;
+    protected remove(event: Event): void;
+    protected onInput(value: string): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onBlur(): void;
+    private get canEdit();
+    private stopEditing;
+    private save;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTagComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTagComponent, "tui-tag, a[tuiTag], button[tuiTag]", never, { "value": { "alias": "value"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "separator": { "alias": "separator"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "size": { "alias": "size"; "required": false; }; "showLoader": { "alias": "showLoader"; "required": false; }; "status": { "alias": "status"; "required": false; }; "hoverable": { "alias": "hoverable"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "autoColor": { "alias": "autoColor"; "required": false; }; "leftContent": { "alias": "leftContent"; "required": false; }; }, { "edited": "edited"; }, never, never, false, never>;
+}

package/components/tag/tag.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tag.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@taiga-ui/core/components/icon";
+import * as i5 from "@taiga-ui/core/components/loader";
+import * as i6 from "@taiga-ui/polymorpheus";
+export declare class TuiTagModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTagModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiTagModule, [typeof i1.TuiTagComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.TuiIcon, typeof i5.TuiLoader, typeof i6.PolymorpheusOutlet, typeof i6.PolymorpheusTemplate], [typeof i1.TuiTagComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiTagModule>;
+}

package/components/tag/tag.options.d.ts

@@ -0,0 +1,15 @@
+import type { Provider } from '@angular/core';
+import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
+import type { TuiStatus } from '@taiga-ui/legacy/utils';
+export interface TuiTagOptions {
+    readonly autoColor: boolean;
+    readonly size: TuiSizeL | TuiSizeS;
+    readonly status: TuiStatus;
+}
+/** Default values for the tag options. */
+export declare const TUI_TAG_DEFAULT_OPTIONS: TuiTagOptions;
+/**
+ * Default parameters for Tag component
+ */
+export declare const TUI_TAG_OPTIONS: import("@angular/core").InjectionToken<TuiTagOptions>;
+export declare function tuiTagOptionsProvider(options: Partial<TuiTagOptions>): Provider;

package/components/textarea/index.d.ts

@@ -0,0 +1,3 @@
+export * from './textarea.component';
+export * from './textarea.directive';
+export * from './textarea.module';

package/components/textarea/textarea.component.d.ts

@@ -0,0 +1,50 @@
+import type { TuiContext } from '@taiga-ui/cdk/types';
+import { TuiHintOptionsDirective } from '@taiga-ui/core/directives/hint';
+import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
+import { AbstractTuiControl } from '@taiga-ui/legacy/classes';
+import type { TuiFocusableElementAccessor } from '@taiga-ui/legacy/tokens';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare const DEFAULT_ROWS = 20;
+export declare const LINE_HEIGHT_M = 20;
+export declare const LINE_HEIGHT_L = 24;
+export declare class TuiTextareaComponent extends AbstractTuiControl<string> implements TuiFocusableElementAccessor {
+    private readonly focusableElement?;
+    private readonly textfield?;
+    private readonly options;
+    protected readonly isIOS: boolean;
+    protected readonly controller: import("@taiga-ui/legacy/directives").TuiTextfieldController;
+    protected readonly hintOptions: TuiHintOptionsDirective | null;
+    rows: number;
+    maxLength: number | null;
+    expandable: boolean;
+    get nativeFocusableElement(): HTMLTextAreaElement | null;
+    get focused(): boolean;
+    get computeMaxHeight(): number | null;
+    onValueChange(value: string): void;
+    protected get labelOutside(): boolean;
+    protected get size(): TuiSizeL | TuiSizeS;
+    protected get borderStart(): number;
+    protected get borderEnd(): number;
+    protected get hasTooltip(): boolean;
+    protected get hasValue(): boolean;
+    protected get hasCounter(): boolean;
+    protected get appearance(): string;
+    protected get hasCleaner(): boolean;
+    protected get hasPlaceholder(): boolean;
+    protected get hasCustomContent(): boolean;
+    protected get iconLeftContent(): PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+    protected get iconContent(): PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+    protected get iconCleaner(): PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+    protected get hasExampleText(): boolean;
+    protected get placeholderRaised(): boolean;
+    protected get fittedContent(): string;
+    protected get extraContent(): string;
+    protected onFocused(focused: boolean): void;
+    protected onMouseDown(event: MouseEvent): void;
+    protected getFallbackValue(): string;
+    private get lineHeight();
+    private get placeholderRaisable();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextareaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTextareaComponent, "tui-textarea", never, { "rows": { "alias": "rows"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "expandable": { "alias": "expandable"; "required": false; }; }, {}, ["textfield"], ["*", "textarea"], false, never>;
+}

package/components/textarea/textarea.directive.d.ts

@@ -0,0 +1,8 @@
+import { AbstractTuiTextfieldHost } from '@taiga-ui/legacy/classes';
+import type { TuiTextareaComponent } from './textarea.component';
+import * as i0 from "@angular/core";
+export declare class TuiTextareaDirective extends AbstractTuiTextfieldHost<TuiTextareaComponent> {
+    onValueChange(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextareaDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextareaDirective, "tui-textarea", never, {}, {}, never, never, false, never>;
+}

package/components/textarea/textarea.module.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./textarea.component";
+import * as i2 from "./textarea.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/forms";
+import * as i5 from "@taiga-ui/core/components/scrollbar";
+import * as i6 from "@taiga-ui/legacy/components/tooltip";
+import * as i7 from "@taiga-ui/legacy/directives";
+import * as i8 from "@taiga-ui/legacy/components/primitive-textfield";
+import * as i9 from "@taiga-ui/polymorpheus";
+import * as i10 from "@taiga-ui/core/components/icon";
+import * as i11 from "@taiga-ui/core/directives/appearance";
+export declare class TuiTextareaModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextareaModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiTextareaModule, [typeof i1.TuiTextareaComponent, typeof i2.TuiTextareaDirective], [typeof i3.CommonModule, typeof i4.FormsModule, typeof i5.TuiScrollbar, typeof i6.TuiTooltip, typeof i7.TuiWrapperModule, typeof i8.TuiPrimitiveTextfieldModule, typeof i9.PolymorpheusOutlet, typeof i9.PolymorpheusTemplate, typeof i10.TuiIcon, typeof i11.TuiAppearance], [typeof i1.TuiTextareaComponent, typeof i2.TuiTextareaDirective, typeof i8.TuiTextfieldComponent, typeof i9.PolymorpheusOutlet, typeof i9.PolymorpheusTemplate]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiTextareaModule>;
+}

package/components/tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export * from './tooltip.component';
+export * from './tooltip.module';

package/components/tooltip/tooltip.component.d.ts

@@ -0,0 +1,12 @@
+import { TuiHintHover, TuiHintOptionsDirective } from '@taiga-ui/core/directives/hint';
+import * as i0 from "@angular/core";
+export declare class TuiTooltipComponent<C = any> extends TuiHintOptionsDirective {
+    private readonly isMobile;
+    protected readonly driver$?: TuiHintHover;
+    describeId: string;
+    context?: C;
+    protected get computedAppearance(): string;
+    protected stopOnMobile(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTooltipComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTooltipComponent<any>, "tui-tooltip", never, { "content": { "alias": "content"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "showDelay": { "alias": "showDelay"; "required": false; }; "hideDelay": { "alias": "hideDelay"; "required": false; }; "describeId": { "alias": "describeId"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, {}, never, never, false, never>;
+}

package/components/tooltip/tooltip.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tooltip.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@taiga-ui/core/components/icon";
+import * as i4 from "@taiga-ui/polymorpheus";
+import * as i5 from "@taiga-ui/core/directives/appearance";
+import * as i6 from "@taiga-ui/core/directives/hint";
+export declare class TuiTooltip {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTooltip, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiTooltip, [typeof i1.TuiTooltipComponent], [typeof i2.CommonModule, typeof i3.TuiIcon, typeof i4.PolymorpheusOutlet, typeof i5.TuiAppearance, typeof i6.TuiHintComponent, typeof i6.TuiHintDirective, typeof i6.TuiHintOptionsDirective, typeof i6.TuiHintUnstyled, typeof i6.TuiHintDriver, typeof i6.TuiHintPosition, typeof i6.TuiHintHover, typeof i6.TuiHintDescribe, typeof i6.TuiHintHost, typeof i6.TuiHintManual, typeof i6.TuiHintPointer], [typeof i1.TuiTooltipComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiTooltip>;
+}

package/directives/index.d.ts

@@ -0,0 +1,5 @@
+export * from '@taiga-ui/legacy/directives/legacy-dropdown-open-monitor';
+export * from '@taiga-ui/legacy/directives/textfield-controller';
+export * from '@taiga-ui/legacy/directives/unfinished-validator';
+export * from '@taiga-ui/legacy/directives/value-accessor';
+export * from '@taiga-ui/legacy/directives/wrapper';

package/directives/legacy-dropdown-open-monitor/index.d.ts

@@ -0,0 +1 @@
+export * from './legacy-dropdown-open-monitor';

package/directives/legacy-dropdown-open-monitor/legacy-dropdown-open-monitor.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class TuiLegacyDropdownOpenMonitorDirective {
+    private readonly el;
+    private readonly host;
+    private readonly external;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiLegacyDropdownOpenMonitorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiLegacyDropdownOpenMonitorDirective, "[tuiDropdownOpenMonitor]", never, {}, {}, never, never, true, never>;
+}

package/directives/textfield-controller/index.d.ts

@@ -0,0 +1,14 @@
+export * from './textfield.controller';
+export * from './textfield.options';
+export * from './textfield-appearance.directive';
+export * from './textfield-cleaner.directive';
+export * from './textfield-controller.module';
+export * from './textfield-controller.provider';
+export * from './textfield-custom-content.directive';
+export * from './textfield-filler.directive';
+export * from './textfield-icon.directive';
+export * from './textfield-icon-left.directive';
+export * from './textfield-label-outside.directive';
+export * from './textfield-postfix.directive';
+export * from './textfield-prefix.directive';
+export * from './textfield-size.directive';

package/directives/textfield-controller/textfield-appearance.directive.d.ts

@@ -0,0 +1,8 @@
+import { AbstractTuiController } from '@taiga-ui/cdk/classes';
+import * as i0 from "@angular/core";
+export declare const TUI_TEXTFIELD_APPEARANCE_DIRECTIVE: import("@angular/core").InjectionToken<TuiTextfieldAppearanceDirective>;
+export declare class TuiTextfieldAppearanceDirective extends AbstractTuiController {
+    appearance: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldAppearanceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldAppearanceDirective, "[tuiTextfieldAppearance]", never, { "appearance": { "alias": "tuiTextfieldAppearance"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/textfield-controller/textfield-cleaner.directive.d.ts

@@ -0,0 +1,8 @@
+import { AbstractTuiController } from '@taiga-ui/cdk/classes';
+import * as i0 from "@angular/core";
+export declare const TUI_TEXTFIELD_CLEANER: import("@angular/core").InjectionToken<TuiTextfieldCleanerDirective>;
+export declare class TuiTextfieldCleanerDirective extends AbstractTuiController {
+    cleaner: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldCleanerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldCleanerDirective, "[tuiTextfieldCleaner]", never, { "cleaner": { "alias": "tuiTextfieldCleaner"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/textfield-controller/textfield-controller.module.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./textfield-appearance.directive";
+import * as i2 from "./textfield-cleaner.directive";
+import * as i3 from "./textfield-custom-content.directive";
+import * as i4 from "./textfield-label-outside.directive";
+import * as i5 from "./textfield-size.directive";
+import * as i6 from "./textfield-icon.directive";
+import * as i7 from "./textfield-icon-left.directive";
+import * as i8 from "./textfield-prefix.directive";
+import * as i9 from "./textfield-postfix.directive";
+import * as i10 from "./textfield-filler.directive";
+import * as i11 from "@taiga-ui/polymorpheus";
+export declare class TuiTextfieldControllerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldControllerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiTextfieldControllerModule, [typeof i1.TuiTextfieldAppearanceDirective, typeof i2.TuiTextfieldCleanerDirective, typeof i3.TuiTextfieldCustomContentDirective, typeof i4.TuiTextfieldLabelOutsideDirective, typeof i5.TuiTextfieldSizeDirective, typeof i6.TuiTextfieldIconDirective, typeof i7.TuiTextfieldIconLeftDirective, typeof i8.TuiTextfieldPrefixDirective, typeof i9.TuiTextfieldPostfixDirective, typeof i10.TuiTextfieldFillerDirective], [typeof i11.PolymorpheusOutlet, typeof i11.PolymorpheusTemplate], [typeof i1.TuiTextfieldAppearanceDirective, typeof i2.TuiTextfieldCleanerDirective, typeof i3.TuiTextfieldCustomContentDirective, typeof i4.TuiTextfieldLabelOutsideDirective, typeof i5.TuiTextfieldSizeDirective, typeof i6.TuiTextfieldIconDirective, typeof i7.TuiTextfieldIconLeftDirective, typeof i8.TuiTextfieldPrefixDirective, typeof i9.TuiTextfieldPostfixDirective, typeof i10.TuiTextfieldFillerDirective, typeof i11.PolymorpheusOutlet, typeof i11.PolymorpheusTemplate]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiTextfieldControllerModule>;
+}

package/directives/textfield-controller/textfield-controller.provider.d.ts

@@ -0,0 +1,5 @@
+import type { Provider } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { TuiTextfieldController } from './textfield.controller';
+export declare const TUI_TEXTFIELD_WATCHED_CONTROLLER: InjectionToken<TuiTextfieldController>;
+export declare const TEXTFIELD_CONTROLLER_PROVIDER: Provider;

package/directives/textfield-controller/textfield-custom-content.directive.d.ts

@@ -0,0 +1,9 @@
+import { AbstractTuiController } from '@taiga-ui/cdk/classes';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare const TUI_TEXTFIELD_CUSTOM_CONTENT: import("@angular/core").InjectionToken<TuiTextfieldCustomContentDirective>;
+export declare class TuiTextfieldCustomContentDirective extends AbstractTuiController {
+    customContent: PolymorpheusContent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldCustomContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldCustomContentDirective, "[tuiTextfieldCustomContent]", never, { "customContent": { "alias": "tuiTextfieldCustomContent"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/textfield-controller/textfield-filler.directive.d.ts

@@ -0,0 +1,8 @@
+import { AbstractTuiController } from '@taiga-ui/cdk/classes';
+import * as i0 from "@angular/core";
+export declare const TUI_TEXTFIELD_FILLER: import("@angular/core").InjectionToken<TuiTextfieldFillerDirective>;
+export declare class TuiTextfieldFillerDirective extends AbstractTuiController {
+    filler: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldFillerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldFillerDirective, "[tuiTextfieldFiller]", never, { "filler": { "alias": "tuiTextfieldFiller"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/textfield-controller/textfield-icon-left.directive.d.ts

@@ -0,0 +1,11 @@
+import { AbstractTuiController } from '@taiga-ui/cdk/classes';
+import type { TuiContext } from '@taiga-ui/cdk/types';
+import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare const TUI_TEXTFIELD_ICON_LEFT: import("@angular/core").InjectionToken<TuiTextfieldIconLeftDirective>;
+export declare class TuiTextfieldIconLeftDirective extends AbstractTuiController {
+    iconLeft: PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldIconLeftDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldIconLeftDirective, "[tuiTextfieldIconLeft]", never, { "iconLeft": { "alias": "tuiTextfieldIconLeft"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/textfield-controller/textfield-icon.directive.d.ts

@@ -0,0 +1,11 @@
+import { AbstractTuiController } from '@taiga-ui/cdk/classes';
+import type { TuiContext } from '@taiga-ui/cdk/types';
+import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare const TUI_TEXTFIELD_ICON: import("@angular/core").InjectionToken<TuiTextfieldIconDirective>;
+export declare class TuiTextfieldIconDirective extends AbstractTuiController {
+    icon: PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldIconDirective, "[tuiTextfieldIcon]", never, { "icon": { "alias": "tuiTextfieldIcon"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/textfield-controller/textfield-label-outside.directive.d.ts

@@ -0,0 +1,8 @@
+import { AbstractTuiController } from '@taiga-ui/cdk/classes';
+import * as i0 from "@angular/core";
+export declare const TUI_TEXTFIELD_LABEL_OUTSIDE: import("@angular/core").InjectionToken<TuiTextfieldLabelOutsideDirective>;
+export declare class TuiTextfieldLabelOutsideDirective extends AbstractTuiController {
+    labelOutside: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldLabelOutsideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldLabelOutsideDirective, "[tuiTextfieldLabelOutside]", never, { "labelOutside": { "alias": "tuiTextfieldLabelOutside"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/textfield-controller/textfield-postfix.directive.d.ts

@@ -0,0 +1,8 @@
+import { AbstractTuiController } from '@taiga-ui/cdk/classes';
+import * as i0 from "@angular/core";
+export declare const TUI_TEXTFIELD_POSTFIX: import("@angular/core").InjectionToken<TuiTextfieldPostfixDirective>;
+export declare class TuiTextfieldPostfixDirective extends AbstractTuiController {
+    postfix: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldPostfixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldPostfixDirective, "[tuiTextfieldPostfix]", never, { "postfix": { "alias": "tuiTextfieldPostfix"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/textfield-controller/textfield-prefix.directive.d.ts

@@ -0,0 +1,8 @@
+import { AbstractTuiController } from '@taiga-ui/cdk/classes';
+import * as i0 from "@angular/core";
+export declare const TUI_TEXTFIELD_PREFIX: import("@angular/core").InjectionToken<TuiTextfieldPrefixDirective>;
+export declare class TuiTextfieldPrefixDirective extends AbstractTuiController {
+    prefix: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldPrefixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldPrefixDirective, "[tuiTextfieldPrefix]", never, { "prefix": { "alias": "tuiTextfieldPrefix"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/textfield-controller/textfield-size.directive.d.ts

@@ -0,0 +1,9 @@
+import { AbstractTuiController } from '@taiga-ui/cdk/classes';
+import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
+import * as i0 from "@angular/core";
+export declare const TUI_TEXTFIELD_SIZE: import("@angular/core").InjectionToken<TuiTextfieldSizeDirective>;
+export declare class TuiTextfieldSizeDirective extends AbstractTuiController {
+    size: TuiSizeL | TuiSizeS;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldSizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldSizeDirective, "[tuiTextfieldSize]", never, { "size": { "alias": "tuiTextfieldSize"; "required": false; }; }, {}, never, never, false, never>;
+}

package/directives/textfield-controller/textfield.controller.d.ts

@@ -0,0 +1,41 @@
+import type { TuiContext } from '@taiga-ui/cdk/types';
+import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import type { Observable } from 'rxjs';
+import type { TuiTextfieldOptions } from './textfield.options';
+import type { TuiTextfieldAppearanceDirective } from './textfield-appearance.directive';
+import type { TuiTextfieldCleanerDirective } from './textfield-cleaner.directive';
+import type { TuiTextfieldCustomContentDirective } from './textfield-custom-content.directive';
+import type { TuiTextfieldFillerDirective } from './textfield-filler.directive';
+import type { TuiTextfieldIconDirective } from './textfield-icon.directive';
+import type { TuiTextfieldIconLeftDirective } from './textfield-icon-left.directive';
+import type { TuiTextfieldLabelOutsideDirective } from './textfield-label-outside.directive';
+import type { TuiTextfieldPostfixDirective } from './textfield-postfix.directive';
+import type { TuiTextfieldPrefixDirective } from './textfield-prefix.directive';
+import type { TuiTextfieldSizeDirective } from './textfield-size.directive';
+export declare class TuiTextfieldController {
+    readonly change$: Observable<void>;
+    readonly options: TuiTextfieldOptions;
+    private readonly legacyAppearance;
+    private readonly appearanceDirective;
+    private readonly cleanerDirective;
+    private readonly customContentDirective;
+    private readonly iconDirective;
+    private readonly iconLeftDirective;
+    private readonly labelOutsideDirective;
+    private readonly sizeDirective;
+    private readonly prefixDirective;
+    private readonly postfixDirective;
+    private readonly fillerDirective;
+    constructor(change$: Observable<void>, options: TuiTextfieldOptions, legacyAppearance: string, appearanceDirective: TuiTextfieldAppearanceDirective, cleanerDirective: TuiTextfieldCleanerDirective, customContentDirective: TuiTextfieldCustomContentDirective, iconDirective: TuiTextfieldIconDirective, iconLeftDirective: TuiTextfieldIconLeftDirective, labelOutsideDirective: TuiTextfieldLabelOutsideDirective, sizeDirective: TuiTextfieldSizeDirective, prefixDirective: TuiTextfieldPrefixDirective, postfixDirective: TuiTextfieldPostfixDirective, fillerDirective: TuiTextfieldFillerDirective);
+    get appearance(): string;
+    get cleaner(): boolean;
+    get customContent(): PolymorpheusContent;
+    get icon(): PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+    get iconLeft(): PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+    get labelOutside(): boolean;
+    get size(): TuiSizeL | TuiSizeS;
+    get prefix(): string;
+    get postfix(): string;
+    get filler(): string;
+}

package/directives/textfield-controller/textfield.options.d.ts

@@ -0,0 +1,15 @@
+import type { Provider } from '@angular/core';
+import type { TuiContext } from '@taiga-ui/cdk/types';
+import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+export interface TuiTextfieldOptions {
+    readonly hintOnDisabled: boolean;
+    readonly iconCleaner: PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+}
+/** Default values for primitive textfield options */
+export declare const TUI_TEXTFIELD_DEFAULT_OPTIONS: TuiTextfieldOptions;
+/**
+ * Default parameters for textfield
+ */
+export declare const TUI_TEXTFIELD_OPTIONS: import("@angular/core").InjectionToken<TuiTextfieldOptions>;
+export declare function tuiTextfieldOptionsProvider(options: Partial<TuiTextfieldOptions>): Provider;

package/directives/unfinished-validator/index.d.ts

@@ -0,0 +1,2 @@
+export * from './unfinished.validator';
+export * from './unfinished-validator.directive';