@taiga-ui/core 4.68.0 → 5.0.0-canary.0dce162

package/pipes/index.d.ts

@@ -1,9 +1 @@
-export * from '@taiga-ui/core/pipes/auto-color';
-export * from '@taiga-ui/core/pipes/calendar-sheet';
-export * from '@taiga-ui/core/pipes/fallback-src';
-export * from '@taiga-ui/core/pipes/flag';
-export * from '@taiga-ui/core/pipes/format-date';
 export * from '@taiga-ui/core/pipes/format-number';
-export * from '@taiga-ui/core/pipes/initials';
-export * from '@taiga-ui/core/pipes/month';
-export * from '@taiga-ui/core/pipes/order-week-days';

package/portals/alert/alert.directive.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export interface TuiPositionOptions {
+    readonly block: 'end' | 'start';
+    readonly inline: 'center' | 'end' | 'start';
+}
+export declare class TuiAlertDirective {
+    protected readonly nothing: undefined;
+    protected readonly context: TuiPositionOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiAlertDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAlertDirective, never, never, {}, {}, never, never, true, never>;
+}

package/portals/alert/alert.service.d.ts

@@ -0,0 +1,12 @@
+import { TuiPortal } from '@taiga-ui/cdk/portals';
+import { type PolymorpheusComponent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare abstract class TuiAlertService<T, K = void> extends TuiPortal<T, K> {
+    private readonly concurrency;
+    private readonly current;
+    private readonly queue;
+    constructor(concurrency: number);
+    protected add(component: PolymorpheusComponent<unknown>): () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiAlertService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TuiAlertService<any, any>>;
+}

package/portals/alert/index.d.ts

@@ -0,0 +1,2 @@
+export * from './alert.directive';
+export * from './alert.service';

package/portals/dialog/dialog.component.d.ts

@@ -0,0 +1,14 @@
+import { Subject } from 'rxjs';
+import { type TuiDialogContext } from './dialog.options';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/cdk/directives/animated";
+export declare class TuiDialogComponent<O, I> {
+    protected readonly close$: Subject<void>;
+    protected readonly close: import("@angular/core").Signal<string>;
+    protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
+    protected readonly context: TuiDialogContext<I, O>;
+    protected readonly primitive: boolean;
+    protected readonly sub: import("rxjs").Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDialogComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiDialogComponent<any, any>, "tui-dialog", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
+}

package/portals/dialog/dialog.directive.d.ts

@@ -0,0 +1,8 @@
+import { type TuiDialogOptions } from './dialog.options';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/cdk/portals";
+export declare class TuiDialog<T> {
+    readonly tuiDialogOptions: import("@angular/core").InputSignal<Partial<TuiDialogOptions<T>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDialog<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDialog<any>, "ng-template[tuiDialog]", never, { "tuiDialogOptions": { "alias": "tuiDialogOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiPortalDirective; inputs: { "options": "tuiDialogOptions"; "open": "tuiDialog"; }; outputs: { "openChange": "tuiDialogChange"; }; }]>;
+}

package/{components → portals}/dialog/dialog.factory.d.ts

@@ -1,6 +1,6 @@
 import { type Injector } from '@angular/core';
 import { type Observable } from 'rxjs';
-import { type TuiDialogContext, type TuiDialogOptions } from './dialog.interfaces';
+import { type TuiDialogContext, type TuiDialogOptions } from './dialog.options';
 type SingleUnionOrNever<T, U = T> = [T] extends [never] ? never : T extends U ? [U] extends [T] ? T : never : never;
 type ReplaceAny<T> = 0 extends T & 1 ? void : T;
 type ContextKeys<T> = {

package/portals/dialog/dialog.options.d.ts

@@ -0,0 +1,25 @@
+import { type TuiPortalContext } from '@taiga-ui/cdk/portals';
+import { type TuiSizeL, type TuiSizeS } from '@taiga-ui/core/types';
+import { type Observable } from 'rxjs';
+/**
+ * Options for a dialog
+ *
+ * appearance - data-appearance attribute of the dialog ('taiga' by default)
+ * closable - show close button (true by default)
+ * data - arbitrary data for dialog
+ * dismissible - close dialog by Esc button or click on overlay (true by default)
+ * label - string title for the dialog ('' by default)
+ * required - dismissing or closing dialog by X button throws (false by default)
+ * size - size of the dialog ('m' by default)
+ */
+export interface TuiDialogOptions<I> {
+    readonly appearance: string;
+    readonly closable: Observable<boolean> | boolean;
+    readonly data: I extends void ? undefined : I;
+    readonly dismissible: Observable<boolean> | boolean;
+    readonly label: string;
+    readonly required: boolean;
+    readonly size: TuiSizeL | TuiSizeS;
+}
+export type TuiDialogContext<O = void, I = undefined> = TuiPortalContext<TuiDialogOptions<I>, O>;
+export declare const TUI_DIALOG_OPTIONS: import("@angular/core").InjectionToken<TuiDialogOptions<void>>, tuiDialogOptionsProvider: (item: Partial<TuiDialogOptions<void>> | (() => Partial<TuiDialogOptions<void>>)) => import("@angular/core").FactoryProvider;

package/{components/dialog/dialog-close.service.d.ts → portals/dialog/dialog.providers.d.ts}

@@ -1,5 +1,7 @@
+import { InjectionToken } from '@angular/core';
 import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
+export declare const TUI_DIALOGS_CLOSE: InjectionToken<Observable<unknown>>;
 export declare class TuiDialogCloseService extends Observable<unknown> {
     private readonly win;
     private readonly doc;

package/portals/dialog/dialog.service.d.ts

@@ -0,0 +1,10 @@
+import { TuiModalService } from '@taiga-ui/core/portals/modal';
+import { TuiDialogComponent } from './dialog.component';
+import { type TuiDialogOptions } from './dialog.options';
+import * as i0 from "@angular/core";
+export declare class TuiDialogService extends TuiModalService<TuiDialogOptions<any>> {
+    protected readonly options: TuiDialogOptions<void>;
+    protected readonly content: typeof TuiDialogComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TuiDialogService>;
+}

package/portals/dialog/index.d.ts

@@ -0,0 +1,6 @@
+export * from './dialog.component';
+export * from './dialog.directive';
+export * from './dialog.factory';
+export * from './dialog.options';
+export * from './dialog.providers';
+export * from './dialog.service';

package/portals/dropdown/dropdown-close.directive.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+export declare class TuiDropdownClose {
+    private readonly el;
+    private readonly ref;
+    private readonly open;
+    private readonly obscured;
+    private readonly activeZone;
+    protected readonly tuiDropdownClose: import("@angular/core").OutputRef<boolean | void | (KeyboardEvent & {
+        readonly currentTarget: Document;
+    }) | (FocusEvent & {
+        readonly currentTarget: HTMLElement;
+    })>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownClose, never, never, {}, { "tuiDropdownClose": "tuiDropdownClose"; }, never, never, true, never>;
+}

package/portals/dropdown/dropdown-content.directive.d.ts

@@ -0,0 +1,9 @@
+import { type OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TuiDropdownContent implements OnDestroy {
+    private readonly directive;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownContent, "ng-template[tuiDropdown]", never, {}, {}, never, never, true, never>;
+}

package/{directives → portals}/dropdown/dropdown-context.directive.d.ts

@@ -12,7 +12,6 @@ export declare class TuiDropdownContext extends TuiRectAccessor {
     protected readonly sub: import("rxjs").Subscription;
     readonly type = "dropdown";
     getClientRect(): DOMRect;
-    protected closeDropdown(_event?: Event): void;
     protected onContextMenu(x: number, y: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownContext, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownContext, "[tuiDropdownContext]", never, {}, {}, never, never, true, never>;

package/{directives → portals}/dropdown/dropdown-hover.directive.d.ts

@@ -1,25 +1,20 @@
 import { TuiDriver } from '@taiga-ui/core/classes';
 import * as i0 from "@angular/core";
 export declare class TuiDropdownHover extends TuiDriver {
-    private readonly dropdownHost?;
+    private readonly dropdownHost;
+    private hovered;
     private readonly el;
     private readonly doc;
     private readonly options;
     private readonly activeZone;
     private readonly open;
-    /**
-     * Dropdown can be removed not only via click/touch –
-     * swipe on mobile devices removes dropdown sheet without triggering new mouseover / mouseout events.
-     */
-    private readonly dropdownExternalRemoval$;
     private readonly stream$;
-    showDelay: number;
-    hideDelay: number;
-    hovered: boolean;
+    readonly tuiDropdownShowDelay: import("@angular/core").InputSignal<number>;
+    readonly tuiDropdownHideDelay: import("@angular/core").InputSignal<number>;
     readonly type = "dropdown";
     constructor();
     protected onClick(event: MouseEvent): void;
     private isHovered;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownHover, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownHover, "[tuiDropdownHover]", never, { "showDelay": { "alias": "tuiDropdownShowDelay"; "required": false; }; "hideDelay": { "alias": "tuiDropdownHideDelay"; "required": false; }; }, {}, ["dropdownHost"], never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownHover, "[tuiDropdownHover]", never, { "tuiDropdownShowDelay": { "alias": "tuiDropdownShowDelay"; "required": false; "isSignal": true; }; "tuiDropdownHideDelay": { "alias": "tuiDropdownHideDelay"; "required": false; "isSignal": true; }; }, {}, ["dropdownHost"], never, true, never>;
 }

package/{directives → portals}/dropdown/dropdown-hover.options.d.ts

@@ -1,4 +1,3 @@
-import { InjectionToken, type Provider } from '@angular/core';
 export interface TuiDropdownHoverOptions {
     readonly hideDelay: number;
     readonly showDelay: number;
@@ -8,5 +7,4 @@ export declare const TUI_DROPDOWN_HOVER_DEFAULT_OPTIONS: TuiDropdownHoverOptions
 /**
  * Default parameters for dropdown hover directive
  */
-export declare const TUI_DROPDOWN_HOVER_OPTIONS: InjectionToken<TuiDropdownHoverOptions>;
-export declare function tuiDropdownHoverOptionsProvider(options: Partial<TuiDropdownHoverOptions>): Provider;
+export declare const TUI_DROPDOWN_HOVER_OPTIONS: import("@angular/core").InjectionToken<TuiDropdownHoverOptions>, tuiDropdownHoverOptionsProvider: (item: Partial<TuiDropdownHoverOptions> | (() => Partial<TuiDropdownHoverOptions>)) => import("@angular/core").FactoryProvider;

package/{directives → portals}/dropdown/dropdown-manual.directive.d.ts

@@ -2,8 +2,8 @@ import { type OnChanges } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class TuiDropdownManual implements OnChanges {
     private readonly driver;
-    tuiDropdownManual: boolean | '';
+    readonly tuiDropdownManual: import("@angular/core").InputSignal<boolean | "">;
     ngOnChanges(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownManual, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownManual, "[tuiDropdownManual]", never, { "tuiDropdownManual": { "alias": "tuiDropdownManual"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownManual, "[tuiDropdownManual]", never, { "tuiDropdownManual": { "alias": "tuiDropdownManual"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/portals/dropdown/dropdown-open.directive.d.ts

@@ -0,0 +1,29 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/cdk/directives/obscured";
+import * as i2 from "./dropdown-close.directive";
+import * as i3 from "@taiga-ui/cdk/directives/active-zone";
+export declare class TuiDropdownOpen {
+    private readonly dropdownHost;
+    private readonly directive;
+    private readonly el;
+    private readonly obscured;
+    private readonly driver;
+    private readonly dropdown;
+    readonly enabled: import("@angular/core").InputSignal<boolean>;
+    readonly open: import("@angular/core").ModelSignal<boolean>;
+    protected readonly driveEffect: import("@angular/core").EffectRef;
+    protected readonly syncSub: import("rxjs").Subscription;
+    protected readonly keydownSub: import("rxjs").Subscription;
+    get host(): HTMLElement;
+    toggle(open: boolean): void;
+    protected onClick(target: HTMLElement): void;
+    protected onArrow(event: KeyboardEvent, up: boolean): void;
+    private get editable();
+    private get focused();
+    private onKeydown;
+    private update;
+    private drive;
+    private focusDropdown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownOpen, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownOpen, "[tuiDropdown][tuiDropdownAuto],[tuiDropdown][tuiDropdownOpen],[tuiDropdown][tuiDropdownOpenChange]", never, { "enabled": { "alias": "tuiDropdownEnabled"; "required": false; "isSignal": true; }; "open": { "alias": "tuiDropdownOpen"; "required": false; "isSignal": true; }; }, { "open": "tuiDropdownOpenChange"; }, ["dropdownHost"], never, true, [{ directive: typeof i1.TuiObscured; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiDropdownClose; inputs: {}; outputs: { "tuiDropdownClose": "tuiDropdownClose"; }; }, { directive: typeof i3.TuiActiveZone; inputs: { "tuiActiveZoneParent": "tuiActiveZoneParent"; }; outputs: { "tuiActiveZoneChange": "tuiActiveZoneChange"; }; }]>;
+}

package/{directives → portals}/dropdown/dropdown-options.directive.d.ts

@@ -1,7 +1,7 @@
 import { type FactoryProvider, InjectionToken } from '@angular/core';
 import { type TuiVerticalDirection } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
-export type TuiDropdownAlign = 'center' | 'left' | 'right';
+export type TuiDropdownAlign = 'center' | 'end' | 'start';
 export type TuiDropdownWidth = 'auto' | 'fixed' | 'min';
 export interface TuiDropdownOptions {
     readonly align: TuiDropdownAlign;
@@ -12,11 +12,7 @@ export interface TuiDropdownOptions {
     readonly minHeight: number;
     readonly offset: number;
 }
-/** Default values for dropdown options */
 export declare const TUI_DROPDOWN_DEFAULT_OPTIONS: TuiDropdownOptions;
-/**
- * Default parameters for dropdown directive
- */
 export declare const TUI_DROPDOWN_OPTIONS: InjectionToken<TuiDropdownOptions>;
 export declare const tuiDropdownOptionsProvider: (options: Partial<TuiDropdownOptions>) => FactoryProvider;
 export declare class TuiDropdownOptionsDirective implements TuiDropdownOptions {

package/{directives → portals}/dropdown/dropdown-position-sided.directive.d.ts

@@ -6,10 +6,10 @@ export declare class TuiDropdownPositionSided extends TuiPositionAccessor {
     private readonly viewport;
     private readonly vertical;
     private previous;
-    tuiDropdownSided: boolean | string;
-    tuiDropdownSidedOffset: number;
+    readonly tuiDropdownSided: import("@angular/core").InputSignal<string | boolean>;
+    readonly tuiDropdownSidedOffset: import("@angular/core").InputSignal<number>;
     readonly type = "dropdown";
     getPosition(rect: DOMRect): TuiPoint;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownPositionSided, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownPositionSided, "[tuiDropdownSided]", never, { "tuiDropdownSided": { "alias": "tuiDropdownSided"; "required": false; }; "tuiDropdownSidedOffset": { "alias": "tuiDropdownSidedOffset"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownPositionSided, "[tuiDropdownSided]", never, { "tuiDropdownSided": { "alias": "tuiDropdownSided"; "required": false; "isSignal": true; }; "tuiDropdownSidedOffset": { "alias": "tuiDropdownSidedOffset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/{directives → portals}/dropdown/dropdown-position.directive.d.ts

@@ -1,6 +1,6 @@
-import { EventEmitter } from '@angular/core';
 import { TuiPositionAccessor, TuiRectAccessor } from '@taiga-ui/core/classes';
 import { type TuiPoint, type TuiVerticalDirection } from '@taiga-ui/core/types';
+import { Subject } from 'rxjs';
 import { type TuiDropdownAlign } from './dropdown-options.directive';
 import * as i0 from "@angular/core";
 export declare class TuiDropdownPosition extends TuiPositionAccessor {
@@ -8,12 +8,12 @@ export declare class TuiDropdownPosition extends TuiPositionAccessor {
     private readonly options;
     private readonly viewport;
     private previous?;
-    readonly directionChange: EventEmitter<TuiVerticalDirection>;
+    readonly direction: Subject<TuiVerticalDirection>;
     readonly type = "dropdown";
-    readonly accessor: TuiRectAccessor | null;
-    emitDirection(direction: TuiVerticalDirection): void;
+    readonly accessor: TuiRectAccessor;
+    readonly tuiDropdownDirectionChange: import("@angular/core").OutputRef<TuiVerticalDirection>;
     getPosition({ width, height }: DOMRect): TuiPoint;
-    getAlign(align: TuiDropdownAlign): TuiDropdownAlign;
+    getAlign(align: TuiDropdownAlign): 'center' | 'left' | 'right';
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownPosition, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownPosition, never, never, {}, { "directionChange": "tuiDropdownDirectionChange"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownPosition, never, never, {}, { "tuiDropdownDirectionChange": "tuiDropdownDirectionChange"; }, never, never, true, never>;
 }

package/{directives → portals}/dropdown/dropdown-selection.directive.d.ts

@@ -1,7 +1,6 @@
 import { type OnDestroy, ViewContainerRef } from '@angular/core';
 import { type TuiBooleanHandler } from '@taiga-ui/cdk/types';
 import { TuiDriver, type TuiRectAccessor } from '@taiga-ui/core/classes';
-import { BehaviorSubject } from 'rxjs';
 import { TuiDropdownDirective } from './dropdown.directive';
 import * as i0 from "@angular/core";
 export declare class TuiDropdownSelection extends TuiDriver implements TuiRectAccessor, OnDestroy {
@@ -10,13 +9,13 @@ export declare class TuiDropdownSelection extends TuiDriver implements TuiRectAc
     protected readonly vcr: ViewContainerRef;
     protected readonly dropdown: TuiDropdownDirective;
     protected readonly el: HTMLElement;
-    protected readonly handler$: BehaviorSubject<TuiBooleanHandler<Range>>;
+    protected readonly handler: import("@angular/core").Signal<TuiBooleanHandler<Range>>;
     protected readonly stream$: import("rxjs").Observable<boolean>;
     protected range: Range;
-    position: 'selection' | 'tag' | 'word';
     readonly type = "dropdown";
+    readonly tuiDropdownSelection: import("@angular/core").InputSignal<string | TuiBooleanHandler<Range>>;
+    readonly tuiDropdownSelectionPosition: import("@angular/core").InputSignal<"selection" | "tag" | "word">;
     constructor();
-    set tuiDropdownSelection(visible: TuiBooleanHandler<Range> | string);
     getClientRect(): DOMRect;
     ngOnDestroy(): void;
     private get ghostHost();
@@ -39,5 +38,5 @@ export declare class TuiDropdownSelection extends TuiDriver implements TuiRectAc
      */
     private initGhost;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownSelection, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownSelection, "[tuiDropdownSelection]", never, { "position": { "alias": "tuiDropdownSelectionPosition"; "required": false; }; "tuiDropdownSelection": { "alias": "tuiDropdownSelection"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownSelection, "[tuiDropdownSelection]", never, { "tuiDropdownSelection": { "alias": "tuiDropdownSelection"; "required": false; "isSignal": true; }; "tuiDropdownSelectionPosition": { "alias": "tuiDropdownSelectionPosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/{directives → portals}/dropdown/dropdown.bindings.d.ts

@@ -5,5 +5,4 @@ export declare function tuiDropdown(value: C | WritableSignal<C>): WritableSigna
 export declare function tuiDropdown(value: Signal<C>): Signal<C>;
 export declare function tuiDropdownEnabled(value: WritableSignal<boolean> | boolean): WritableSignal<boolean>;
 export declare function tuiDropdownEnabled(value: Signal<boolean>): Signal<boolean>;
-export declare function tuiDropdownOpen(): WritableSignal<boolean>;
 export {};

package/{directives → portals}/dropdown/dropdown.d.ts

@@ -1,14 +1,13 @@
 import { TuiDropdownComponent } from './dropdown.component';
 import { TuiDropdownDirective } from './dropdown.directive';
 import { TuiDropdownDriverDirective } from './dropdown.driver';
+import { TuiDropdownContent } from './dropdown-content.directive';
 import { TuiDropdownContext } from './dropdown-context.directive';
 import { TuiDropdownHover } from './dropdown-hover.directive';
 import { TuiDropdownManual } from './dropdown-manual.directive';
 import { TuiDropdownOpen } from './dropdown-open.directive';
-import { TuiDropdownOpenLegacy } from './dropdown-open-legacy.directive';
 import { TuiDropdownOptionsDirective } from './dropdown-options.directive';
-import { TuiDropdownPortal } from './dropdown-portal.directive';
 import { TuiDropdownPosition } from './dropdown-position.directive';
 import { TuiDropdownPositionSided } from './dropdown-position-sided.directive';
 import { TuiDropdownSelection } from './dropdown-selection.directive';
-export declare const TuiDropdown: readonly [typeof TuiDropdownOptionsDirective, typeof TuiDropdownDriverDirective, typeof TuiDropdownDirective, typeof TuiDropdownComponent, typeof TuiDropdownOpen, typeof TuiDropdownOpenLegacy, typeof TuiDropdownPortal, typeof TuiDropdownManual, typeof TuiDropdownHover, typeof TuiDropdownContext, typeof TuiDropdownPosition, typeof TuiDropdownPositionSided, typeof TuiDropdownSelection];
+export declare const TuiDropdown: readonly [typeof TuiDropdownOptionsDirective, typeof TuiDropdownDriverDirective, typeof TuiDropdownDirective, typeof TuiDropdownComponent, typeof TuiDropdownOpen, typeof TuiDropdownManual, typeof TuiDropdownHover, typeof TuiDropdownContent, typeof TuiDropdownContext, typeof TuiDropdownPosition, typeof TuiDropdownPositionSided, typeof TuiDropdownSelection];

package/{directives → portals}/dropdown/dropdown.directive.d.ts

@@ -1,30 +1,28 @@
 import { type AfterViewChecked, type ComponentRef, type OnDestroy } from '@angular/core';
 import { type TuiContext } from '@taiga-ui/cdk/types';
 import { type TuiRectAccessor, type TuiVehicle } from '@taiga-ui/core/classes';
-import { type TuiPortalItem } from '@taiga-ui/core/types';
 import { PolymorpheusComponent, type PolymorpheusContent } from '@taiga-ui/polymorpheus';
 import * as i0 from "@angular/core";
 import * as i1 from "./dropdown.driver";
 import * as i2 from "./dropdown-position.directive";
-export declare class TuiDropdownDirective implements AfterViewChecked, OnDestroy, TuiPortalItem, TuiRectAccessor, TuiVehicle {
+export declare class TuiDropdownDirective implements AfterViewChecked, OnDestroy, TuiRectAccessor, TuiVehicle {
     private readonly refresh$;
     private readonly service;
     private readonly cdr;
     private readonly drivers;
     protected readonly sub: import("rxjs").Subscription;
+    protected readonly autoClose: import("@angular/core").EffectRef;
+    readonly ref: import("@angular/core").WritableSignal<ComponentRef<unknown> | null>;
     readonly el: HTMLElement;
     readonly type = "dropdown";
     readonly component: PolymorpheusComponent<any>;
-    ref: import("@angular/core").WritableSignal<ComponentRef<unknown> | null>;
-    readonly _content: import("@angular/core").WritableSignal<PolymorpheusContent<TuiContext<() => void>>>;
-    set tuiDropdown(content: PolymorpheusContent<TuiContext<() => void>>);
+    readonly tuiDropdown: import("@angular/core").InputSignal<PolymorpheusContent<TuiContext<() => void>>>;
+    readonly content: import("@angular/core").Signal<PolymorpheusContent<TuiContext<() => void>>>;
     get position(): 'absolute' | 'fixed';
-    get content(): PolymorpheusContent<TuiContext<() => void>>;
-    set content(x: PolymorpheusContent<TuiContext<() => void>>);
     ngAfterViewChecked(): void;
     ngOnDestroy(): void;
     getClientRect(): DOMRect;
     toggle(show: boolean): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownDirective, "[tuiDropdown]:not(ng-container):not(ng-template)", ["tuiDropdown"], { "tuiDropdown": { "alias": "tuiDropdown"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiDropdownDriverDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiDropdownPosition; inputs: {}; outputs: { "tuiDropdownDirectionChange": "tuiDropdownDirectionChange"; }; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownDirective, "[tuiDropdown]:not(ng-container):not(ng-template)", ["tuiDropdown"], { "tuiDropdown": { "alias": "tuiDropdown"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiDropdownDriverDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiDropdownPosition; inputs: {}; outputs: { "tuiDropdownDirectionChange": "tuiDropdownDirectionChange"; }; }]>;
 }

package/{directives → portals}/dropdown/index.d.ts

@@ -4,18 +4,16 @@ export * from './dropdown.component';
 export * from './dropdown.directive';
 export * from './dropdown.driver';
 export * from './dropdown.providers';
-export * from './dropdown.service';
+export * from './dropdown-close.directive';
+export * from './dropdown-content.directive';
 export * from './dropdown-context.directive';
 export * from './dropdown-hover.directive';
 export * from './dropdown-hover.options';
 export * from './dropdown-limit-width';
 export * from './dropdown-manual.directive';
 export * from './dropdown-open.directive';
-export * from './dropdown-open-legacy.directive';
 export * from './dropdown-options.directive';
-export * from './dropdown-portal.directive';
 export * from './dropdown-position.directive';
 export * from './dropdown-position-sided.directive';
 export * from './dropdown-selection.directive';
-export * from './dropdowns.component';
 export * from './with-dropdown-open.directive';

package/{directives → portals}/hint/hint-describe.directive.d.ts

@@ -3,14 +3,12 @@ import * as i0 from "@angular/core";
 export declare class TuiHintDescribe extends TuiDriver {
     private readonly doc;
     private readonly el;
-    private readonly zone;
-    private readonly id$;
-    private readonly stream$;
+    protected readonly element: import("@angular/core").Signal<Element>;
+    readonly id: import("@angular/core").InputSignal<string | null | undefined>;
     readonly type = "hint";
+    protected readonly stream$: import("rxjs").Observable<boolean>;
     constructor();
-    set tuiHintDescribe(id: string | null | undefined);
-    private get element();
     private get focused();
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintDescribe, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintDescribe, "[tuiHintDescribe]", never, { "tuiHintDescribe": { "alias": "tuiHintDescribe"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintDescribe, "[tuiHintDescribe]", never, { "id": { "alias": "tuiHintDescribe"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/{directives → portals}/hint/hint-host.directive.d.ts

@@ -1,9 +1,9 @@
 import { TuiRectAccessor } from '@taiga-ui/core/classes';
 import * as i0 from "@angular/core";
 export declare class TuiHintHost extends TuiRectAccessor {
-    tuiHintHost?: HTMLElement;
+    readonly tuiHintHost: import("@angular/core").InputSignal<HTMLElement | undefined>;
     readonly type = "hint";
     getClientRect(): DOMRect;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintHost, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintHost, "[tuiHint][tuiHintHost]", never, { "tuiHintHost": { "alias": "tuiHintHost"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintHost, "[tuiHint][tuiHintHost]", never, { "tuiHintHost": { "alias": "tuiHintHost"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/{directives → portals}/hint/hint-hover.directive.d.ts

@@ -1,5 +1,4 @@
 import { TuiDriver } from '@taiga-ui/core/classes';
-import { type TuiHintOptions } from './hint-options.directive';
 import * as i0 from "@angular/core";
 export declare class TuiHintHover extends TuiDriver {
     private readonly isMobile;
@@ -10,13 +9,13 @@ export declare class TuiHintHover extends TuiDriver {
     private readonly toggle$;
     private readonly stream$;
     private readonly parent;
-    tuiHintShowDelay: TuiHintOptions['showDelay'];
-    tuiHintHideDelay: TuiHintOptions['hideDelay'];
+    readonly showDelay: import("@angular/core").InputSignal<number>;
+    readonly hideDelay: import("@angular/core").InputSignal<number>;
     readonly type = "hint";
     enabled: boolean;
     constructor();
     toggle(visible?: boolean): void;
     close(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintHover, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintHover, never, ["tuiHintHover"], { "tuiHintShowDelay": { "alias": "tuiHintShowDelay"; "required": false; }; "tuiHintHideDelay": { "alias": "tuiHintHideDelay"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintHover, never, ["tuiHintHover"], { "showDelay": { "alias": "tuiHintShowDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "tuiHintHideDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/{directives → portals}/hint/hint-manual.directive.d.ts

@@ -4,10 +4,10 @@ import * as i0 from "@angular/core";
 export declare class TuiHintManual extends TuiDriver implements OnChanges {
     private readonly hover;
     private readonly stream$;
-    tuiHintManual: boolean | null;
+    readonly visible: import("@angular/core").InputSignal<boolean | null>;
     readonly type = "hint";
     constructor();
     ngOnChanges(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintManual, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintManual, "[tuiHint][tuiHintManual]", never, { "tuiHintManual": { "alias": "tuiHintManual"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintManual, "[tuiHint][tuiHintManual]", never, { "visible": { "alias": "tuiHintManual"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/portals/hint/hint-options.directive.d.ts

@@ -0,0 +1,17 @@
+import { type FactoryProvider, InjectionToken } from '@angular/core';
+import { type TuiAppearanceOptions } from '@taiga-ui/core/directives/appearance';
+export type TuiHintDirection = 'bottom-end' | 'bottom-start' | 'bottom' | 'end-bottom' | 'end-top' | 'end' | 'start-bottom' | 'start-top' | 'start' | 'top-end' | 'top-start' | 'top';
+export declare const TUI_HINT_DIRECTIONS: readonly TuiHintDirection[];
+export interface TuiHintOptions extends TuiAppearanceOptions {
+    readonly direction: TuiHintDirection | TuiHintDirection[];
+    readonly hideDelay: number;
+    readonly icon: string;
+    readonly showDelay: number;
+}
+/** Default values for hint options */
+export declare const TUI_HINT_DEFAULT_OPTIONS: TuiHintOptions;
+/**
+ * Default parameters for hint directive
+ */
+export declare const TUI_HINT_OPTIONS: InjectionToken<TuiHintOptions>;
+export declare const tuiHintOptionsProvider: (options: Partial<TuiHintOptions>) => FactoryProvider;

package/{directives → portals}/hint/hint-overflow.directive.d.ts

@@ -2,8 +2,8 @@ import * as i0 from "@angular/core";
 import * as i1 from "./hint.directive";
 export declare class TuiHintOverflow {
     private readonly hint;
-    tuiHintOverflow: string | null;
+    readonly content: import("@angular/core").InputSignal<string | null>;
     protected onMouseEnter({ scrollWidth, clientWidth, textContent }: Element): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintOverflow, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintOverflow, "[tuiHintOverflow]", never, { "tuiHintOverflow": { "alias": "tuiHintOverflow"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiHintDirective; inputs: { "tuiHintAppearance": "tuiHintAppearance"; }; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintOverflow, "[tuiHintOverflow]", never, { "content": { "alias": "tuiHintOverflow"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiHintDirective; inputs: { "tuiHintAppearance": "tuiHintAppearance"; }; outputs: {}; }]>;
 }

package/{directives → portals}/hint/hint-position.directive.d.ts

@@ -1,21 +1,20 @@
-import { EventEmitter } from '@angular/core';
 import { TuiPositionAccessor } from '@taiga-ui/core/classes';
 import { type TuiPoint } from '@taiga-ui/core/types';
-import { type TuiHintDirection, type TuiHintOptions } from './hint-options.directive';
+import { type TuiHintDirection } from './hint-options.directive';
 import * as i0 from "@angular/core";
 export declare class TuiHintPosition extends TuiPositionAccessor {
     private readonly el;
     private readonly viewport;
+    private readonly directionChange;
     private readonly accessor;
     private readonly points;
-    direction: TuiHintOptions['direction'];
-    offset: number;
-    readonly directionChange: EventEmitter<TuiHintDirection>;
+    readonly direction: import("@angular/core").InputSignal<TuiHintDirection | TuiHintDirection[]>;
+    readonly offset: import("@angular/core").InputSignal<number>;
+    readonly tuiHintDirectionChange: import("@angular/core").OutputRef<TuiHintDirection>;
     readonly type = "hint";
-    emitDirection(direction: TuiHintDirection): void;
-    getPosition(rect: DOMRect, el?: HTMLElement): TuiPoint;
+    getPosition({ width, height }: DOMRect): TuiPoint;
     private get fallback();
     private checkPosition;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintPosition, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintPosition, never, never, { "direction": { "alias": "tuiHintDirection"; "required": false; }; "offset": { "alias": "tuiHintOffset"; "required": false; }; }, { "directionChange": "tuiHintDirectionChange"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintPosition, never, never, { "direction": { "alias": "tuiHintDirection"; "required": false; "isSignal": true; }; "offset": { "alias": "tuiHintOffset"; "required": false; "isSignal": true; }; }, { "tuiHintDirectionChange": "tuiHintDirectionChange"; }, never, never, true, never>;
 }

package/{directives → portals}/hint/hint-unstyled.component.d.ts

@@ -1,12 +1,7 @@
-import { type WritableSignal } from '@angular/core';
-import { type TuiContext } from '@taiga-ui/cdk/types';
-import { type TuiPortalItem } from '@taiga-ui/core/types';
-import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import { TuiHintDirective } from './hint.directive';
 import * as i0 from "@angular/core";
 export declare class TuiHintUnstyledComponent {
-    protected readonly context: TuiContext<TuiPortalItem<any> & {
-        content: WritableSignal<PolymorpheusContent>;
-    }>;
+    protected readonly hint: TuiHintDirective<any>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintUnstyledComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TuiHintUnstyledComponent, "ng-component", never, {}, {}, never, never, true, never>;
 }