@cuby-ui/core 0.0.180 → 0.0.190

package/animations/animations.d.ts

@@ -0,0 +1,36 @@
+export interface CuiDurationOptions {
+    params: {
+        duration: number;
+    };
+    value: string;
+}
+/**
+ * Add to enable child :leave animation (fixes https://github.com/angular/angular/issues/15753)
+ */
+export declare const cuiParentAnimation: import("@angular/animations").AnimationTriggerMetadata;
+/**
+ * Add on parent to stop initial :enter animation for children
+ */
+export declare const cuiParentStop: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiHost: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiHeightCollapse: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiHeightCollapseList: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiWidthCollapse: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiWidthCollapseList: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiFadeIn: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiFadeInList: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiFadeInTop: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiFadeInBottom: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiDropdownAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiScaleIn: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiPop: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiScaleInList: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideIn: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInLeft: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInLeftList: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInRight: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInRightList: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInTop: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInTopList: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInBottom: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cuiSlideInBottomList: import("@angular/animations").AnimationTriggerMetadata;

package/animations/index.d.ts

@@ -0,0 +1 @@
+export * from './animations';

package/classes/accessors.d.ts

@@ -0,0 +1,17 @@
+import type { AbstractType, ExistingProvider, FactoryProvider, Type } from '@angular/core';
+import type { CuiPoint } from '../types';
+export declare abstract class CuiAccessor {
+    abstract readonly type: string;
+}
+export declare abstract class CuiPositionAccessor extends CuiAccessor {
+    abstract getPosition(rect: DOMRect, element?: HTMLElement): CuiPoint;
+}
+export declare abstract class CuiRectAccessor extends CuiAccessor {
+    abstract getClientRect(): DOMRect;
+}
+export declare function cuiProvideAccessor<T extends CuiAccessor>(provide: AbstractType<T>, type: string, fallback: Type<T>): FactoryProvider;
+export declare function cuiFallbackAccessor<T extends CuiAccessor>(type: string): (accessors: readonly T[] | null, fallback: T) => T;
+export declare function cuiPositionAccessorFor(type: string, fallback: Type<CuiPositionAccessor>): FactoryProvider;
+export declare function cuiRectAccessorFor(type: string, fallback: Type<CuiRectAccessor>): FactoryProvider;
+export declare function cuiAsPositionAccessor(accessor: Type<CuiPositionAccessor>): ExistingProvider;
+export declare function cuiAsRectAccessor(accessor: Type<CuiRectAccessor>): ExistingProvider;

package/classes/driver.d.ts

@@ -0,0 +1,16 @@
+import type { AfterViewInit, ExistingProvider, Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare abstract class CuiDriver extends Observable<boolean> {
+    abstract readonly type: string;
+}
+export declare function cuiAsDriver(driver: Type<CuiDriver>): ExistingProvider;
+export declare abstract class CuiDriverDirective implements AfterViewInit {
+    abstract type: string;
+    private readonly destroyRef;
+    private readonly drivers;
+    private readonly vehicles;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiDriverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiDriverDirective, never, never, {}, {}, never, never, false, never>;
+}

package/classes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './accessors';
+export * from './driver';
+export * from './vehicle';

package/classes/vehicle.d.ts

@@ -0,0 +1,6 @@
+import type { ExistingProvider, Type } from '@angular/core';
+export declare abstract class CuiVehicle {
+    abstract readonly type: string;
+    abstract toggle(value: boolean): void;
+}
+export declare function cuiAsVehicle(vehicle: Type<CuiVehicle>): ExistingProvider;

package/components/accordion/accordion-item/accordion-item.component.d.ts

@@ -7,5 +7,5 @@ export declare class CuiAccordionItemComponent {
     protected get buttonIcon(): CuiIcon;
     protected onRowToggle(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiAccordionItemComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiAccordionItemComponent, "cui-accordion-item", never, { "isOpen": "isOpen"; }, { "isOpenChange": "isOpenChange"; }, never, ["*", "[cuiAccordionItemContent]"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiAccordionItemComponent, "cui-accordion-item", never, { "isOpen": { "alias": "isOpen"; "required": false; }; }, { "isOpenChange": "isOpenChange"; }, never, ["*", "[cuiAccordionItemContent]"], false, never>;
 }

package/components/alert/alert.tokens.d.ts

@@ -6,11 +6,11 @@ export declare const CUI_ALERTS: InjectionToken<BehaviorSubject<readonly CuiPopo
 export declare const CUI_ALERT_DEFAULT_OPTIONS: Omit<CuiAlertOptions, 'status'>;
 export declare const CUI_ALERT_OPTIONS: InjectionToken<{
     status: import("@cuby-ui/core").CuiStatus;
-    mode: "default" | "light";
-    position: import("@cuby-ui/core").CuiAlertPosition;
+    mode: "light" | "default";
     label: string;
     needAutoClose: boolean;
     isCloseable: boolean;
+    position: import("@cuby-ui/core").CuiAlertPosition;
     resizing: import("@cuby-ui/core").CuiAlertResizing;
 }>;
 export declare const CUI_ALERT_CONTEXT: InjectionToken<CuiPopover<CuiAlertOptions>>;

package/components/badge/badge.component.d.ts

@@ -6,5 +6,5 @@ export declare class CuiBadgeComponent implements CuiBadgeOptions {
     size: "sm" | "md";
     isWithDot: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiBadgeComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiBadgeComponent, "cui-badge", never, { "color": "color"; "size": "size"; "isWithDot": "isWithDot"; }, {}, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiBadgeComponent, "cui-badge", never, { "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "isWithDot": { "alias": "isWithDot"; "required": false; }; }, {}, never, ["*"], false, never>;
 }

package/components/banner/banner.component.d.ts

@@ -17,5 +17,5 @@ export declare class CuiBannerComponent implements CuiBannerOptions {
     protected onAction(): void;
     protected onClose(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiBannerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiBannerComponent, "cui-banner", never, { "status": "status"; "isCloseable": "isCloseable"; "label": "label"; "actionButtonText": "actionButtonText"; }, { "actionButtonClicked": "actionButtonClicked"; "closed": "closed"; }, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiBannerComponent, "cui-banner", never, { "status": { "alias": "status"; "required": false; }; "isCloseable": { "alias": "isCloseable"; "required": false; }; "label": { "alias": "label"; "required": false; }; "actionButtonText": { "alias": "actionButtonText"; "required": false; }; }, { "actionButtonClicked": "actionButtonClicked"; "closed": "closed"; }, never, ["*"], false, never>;
 }

package/components/breadcrumbs/breadcrumb/breadcrumb.component.d.ts

@@ -2,5 +2,5 @@ import * as i0 from "@angular/core";
 export declare class CuiBreadcrumbComponent {
     isLast: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiBreadcrumbComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiBreadcrumbComponent, "[cuiBreadcrumb]", never, { "isLast": "isLast"; }, {}, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiBreadcrumbComponent, "[cuiBreadcrumb]", never, { "isLast": { "alias": "isLast"; "required": false; }; }, {}, never, ["*"], false, never>;
 }

package/components/button/button.component.d.ts

@@ -10,9 +10,9 @@ export declare class CuiButtonComponent implements CuiButtonOptions, OnInit {
     protected readonly AppearanceIconColors: Record<CuiButtonOptions['appearance'], string>;
     protected readonly COLOR_BASE_500 = "var(--cui-base-500)";
     protected readonly BUTTON_ICONS_COLOR_BASE_500: CuiButtonOptions['appearance'][];
-    protected _appearance: "link" | "flat" | "action" | "secondary" | "outlined" | "outlined-gray" | "ghost" | "destructive";
+    protected _appearance: "flat" | "link" | "action" | "secondary" | "outlined" | "outlined-gray" | "ghost" | "destructive";
     protected iconColor: string;
-    protected _size: "xxs" | "xs" | "sm" | "md";
+    protected _size: "sm" | "md" | "xxs" | "xs";
     protected iconDimensions: {
         width: number;
         height: number;
@@ -34,5 +34,5 @@ export declare class CuiButtonComponent implements CuiButtonOptions, OnInit {
     private changeIconColor;
     private getIconColor;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiButtonComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiButtonComponent, "button[cuiButton], a[cuiButton]", never, { "shape": "shape"; "disabled": "disabled"; "isLoaderShown": "isLoaderShown"; "icon": "icon"; "iconRight": "iconRight"; "appearance": "appearance"; "size": "size"; }, {}, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiButtonComponent, "button[cuiButton], a[cuiButton]", never, { "shape": { "alias": "shape"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isLoaderShown": { "alias": "isLoaderShown"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconRight": { "alias": "iconRight"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], false, never>;
 }

package/components/context-menu/context-menu.component.d.ts

@@ -35,5 +35,5 @@ export declare class CuiContextMenuComponent implements OnInit, AfterViewInit, O
     private changePosition;
     private clearViewContainerRef;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiContextMenuComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiContextMenuComponent, "cui-context-menu[items][target]", never, { "items": "items"; "target": "target"; }, {}, never, never, false, [{ directive: typeof i1.CuiClickOutsideDirective; inputs: {}; outputs: {}; }, { directive: typeof i1.CuiTargetDirective; inputs: { "ccTarget": "target"; }; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiContextMenuComponent, "cui-context-menu[items][target]", never, { "items": { "alias": "items"; "required": false; }; "target": { "alias": "target"; "required": false; }; }, {}, never, never, false, [{ directive: typeof i1.CuiClickOutsideDirective; inputs: {}; outputs: {}; }, { directive: typeof i1.CuiTargetDirective; inputs: { "ccTarget": "target"; }; outputs: {}; }]>;
 }

package/components/dialog/dialog-header/dialog-header.component.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from '@angular/core';
-import type { PolymorpheusContent } from '@tinkoff/ng-polymorpheus';
-import { PolymorpheusContext } from '@tinkoff/ng-polymorpheus/classes/context';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import { PolymorpheusContext } from '@taiga-ui/polymorpheus/classes/context';
 import * as i0 from "@angular/core";
 export declare class CuiDialogHeaderComponent {
     heading: PolymorpheusContent;
@@ -9,5 +9,5 @@ export declare class CuiDialogHeaderComponent {
     readonly closed: EventEmitter<MouseEvent>;
     protected onClose(event: MouseEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiDialogHeaderComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiDialogHeaderComponent, "header[cuiDialogHeader][heading]", never, { "heading": "heading"; "headingContext": "headingContext"; "subheading": "subheading"; }, { "closed": "closed"; }, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiDialogHeaderComponent, "header[cuiDialogHeader][heading]", never, { "heading": { "alias": "heading"; "required": false; }; "headingContext": { "alias": "headingContext"; "required": false; }; "subheading": { "alias": "subheading"; "required": false; }; }, { "closed": "closed"; }, never, ["*"], false, never>;
 }

package/components/dialog/dialog.interfaces.d.ts

@@ -1,6 +1,6 @@
 import type { Injector } from '@angular/core';
 import type { CuiPopoverContext } from '@cuby-ui/cdk';
-export type CuiDialogSize = 'xl' | 'auto';
+export type CuiDialogSize = 'xl' | 'sm' | 'auto';
 export interface CuiDialogOptions<I = any> {
     readonly size: CuiDialogSize;
     readonly data: I;

package/components/dialog/dialog.module.d.ts

@@ -4,11 +4,11 @@ import * as i2 from "./dialogs.component";
 import * as i3 from "./dialog-actions/dialog-actions.component";
 import * as i4 from "./dialog-header/dialog-header.component";
 import * as i5 from "@angular/common";
-import * as i6 from "@tinkoff/ng-polymorpheus";
+import * as i6 from "@taiga-ui/polymorpheus";
 import * as i7 from "@cuby-ui/cdk";
 import * as i8 from "../button/button.module";
 export declare class CuiDialogModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiDialogModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CuiDialogModule, [typeof i1.CuiDialogComponent, typeof i2.CuiDialogsComponent, typeof i3.CuiDialogActionsComponent, typeof i4.CuiDialogHeaderComponent], [typeof i5.CommonModule, typeof i6.PolymorpheusModule, typeof i7.CuiLetDirective, typeof i8.CuiButtonModule], [typeof i1.CuiDialogComponent, typeof i2.CuiDialogsComponent, typeof i3.CuiDialogActionsComponent, typeof i4.CuiDialogHeaderComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuiDialogModule, [typeof i1.CuiDialogComponent, typeof i2.CuiDialogsComponent, typeof i3.CuiDialogActionsComponent, typeof i4.CuiDialogHeaderComponent], [typeof i5.CommonModule, typeof i6.PolymorpheusOutlet, typeof i7.CuiLetDirective, typeof i8.CuiButtonModule], [typeof i1.CuiDialogComponent, typeof i2.CuiDialogsComponent, typeof i3.CuiDialogActionsComponent, typeof i4.CuiDialogHeaderComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<CuiDialogModule>;
 }

package/components/hint/hint.component.d.ts

@@ -3,5 +3,5 @@ import * as i0 from "@angular/core";
 export declare class CuiHintComponent {
     hintType: CuiHintType;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiHintComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiHintComponent, "cui-hint", never, { "hintType": "hintType"; }, {}, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiHintComponent, "cui-hint", never, { "hintType": { "alias": "hintType"; "required": false; }; }, {}, never, ["*"], false, never>;
 }

package/components/icon-button/icon-button.component.d.ts

@@ -9,5 +9,5 @@ export declare class CuiIconButtonComponent {
     hoverColor?: string;
     protected get isWithHoverColor(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiIconButtonComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiIconButtonComponent, "button[cuiIconButton][icon], a[cuiIconButton][icon]", never, { "icon": "icon"; "color": "color"; "hoverColor": "hoverColor"; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiIconButtonComponent, "button[cuiIconButton][icon], a[cuiIconButton][icon]", never, { "icon": { "alias": "icon"; "required": false; }; "color": { "alias": "color"; "required": false; }; "hoverColor": { "alias": "hoverColor"; "required": false; }; }, {}, never, never, false, never>;
 }

package/components/input-number/input-number.component.d.ts

@@ -34,5 +34,5 @@ export declare class CuiInputNumberComponent implements ControlValueAccessor {
     private changeModel;
     private generateMask;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiInputNumberComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiInputNumberComponent, "cui-input-number", never, { "precision": "precision"; "min": "min"; "max": "max"; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiInputNumberComponent, "cui-input-number", never, { "precision": { "alias": "precision"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; }, {}, never, never, false, never>;
 }

package/components/input-time/input-time.component.d.ts

@@ -32,5 +32,5 @@ export declare class CuiInputTimeComponent implements CuiInputTimeOptions, Contr
     protected onFocus(): void;
     private generateMask;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiInputTimeComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiInputTimeComponent, "cui-input-time", never, { "mode": "mode"; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiInputTimeComponent, "cui-input-time", never, { "mode": { "alias": "mode"; "required": false; }; }, {}, never, never, false, never>;
 }

package/components/label/label.component.d.ts

@@ -2,5 +2,5 @@ import * as i0 from "@angular/core";
 export declare class CuiLabelComponent {
     isRequired: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiLabelComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiLabelComponent, "label[cuiLabel]", never, { "isRequired": "isRequired"; }, {}, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiLabelComponent, "label[cuiLabel]", never, { "isRequired": { "alias": "isRequired"; "required": false; }; }, {}, never, ["*"], false, never>;
 }

package/components/notification/notification.component.d.ts

@@ -4,15 +4,15 @@ import * as i0 from "@angular/core";
 export declare class CuiNotificationComponent implements CuiNotificationOptions, OnInit {
     private readonly cuiNotificationOptions;
     protected readonly ICONS: import("./notification.options").CuiNotificationIcons;
-    protected readonly ICON_OPTIONS: Record<"default" | "light", CuiNotificationIconOptions>;
+    protected readonly ICON_OPTIONS: Record<"light" | "default", CuiNotificationIconOptions>;
     protected iconOptions: CuiNotificationIconOptions;
     status: import("@cuby-ui/core").CuiStatus;
-    mode: "default" | "light";
+    mode: "light" | "default";
     isCloseable: boolean;
     readonly closed: EventEmitter<void>;
     ngOnInit(): void;
     protected onClose(): void;
     private initIconOptions;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiNotificationComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiNotificationComponent, "cui-notification", never, { "status": "status"; "mode": "mode"; "isCloseable": "isCloseable"; }, { "closed": "closed"; }, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiNotificationComponent, "cui-notification", never, { "status": { "alias": "status"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "isCloseable": { "alias": "isCloseable"; "required": false; }; }, { "closed": "closed"; }, never, ["*"], false, never>;
 }

package/components/root/root.module.d.ts

@@ -3,8 +3,9 @@ import * as i1 from "./root.component";
 import * as i2 from "@angular/common";
 import * as i3 from "../dialog/dialog.module";
 import * as i4 from "../alert/alert.module";
+import * as i5 from "../../directives/tooltip/tooltips.component";
 export declare class CuiRootModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiRootModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CuiRootModule, [typeof i1.CuiRootComponent], [typeof i2.CommonModule, typeof i3.CuiDialogModule, typeof i4.CuiAlertModule], [typeof i1.CuiRootComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuiRootModule, [typeof i1.CuiRootComponent], [typeof i2.CommonModule, typeof i3.CuiDialogModule, typeof i4.CuiAlertModule, typeof i5.CuiTooltips], [typeof i1.CuiRootComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<CuiRootModule>;
 }

package/components/select/select.component.d.ts

@@ -49,5 +49,5 @@ export declare class CuiSelectComponent implements ControlValueAccessor, OnInit,
     private close;
     private clearViewContainerRef;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiSelectComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiSelectComponent, "cui-select[options]", never, { "options": "options"; "defaultOptionText": "defaultOptionText"; }, {}, never, never, false, [{ directive: typeof i1.CuiClickOutsideDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiSelectComponent, "cui-select[options]", never, { "options": { "alias": "options"; "required": false; }; "defaultOptionText": { "alias": "defaultOptionText"; "required": false; }; }, {}, never, never, false, [{ directive: typeof i1.CuiClickOutsideDirective; inputs: {}; outputs: {}; }]>;
 }

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

@@ -12,5 +12,5 @@ export declare class CuiSvgComponent {
     get isWithStrokeWidth(): boolean;
     get isWithColor(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiSvgComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiSvgComponent, "cui-svg[icon]", never, { "width": "width"; "height": "height"; "strokeWidth": "strokeWidth"; "color": "color"; "icon": "icon"; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiSvgComponent, "cui-svg[icon]", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "color": { "alias": "color"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, {}, never, never, false, never>;
 }

package/components/tabs/tabs.component.d.ts

@@ -12,5 +12,5 @@ export declare class CuiTabsComponent implements AfterViewChecked {
     protected onActivate(event: CustomEvent): void;
     private changeActiveItem;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiTabsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiTabsComponent, "cui-tabs", never, { "activeItemIndex": "activeItemIndex"; }, { "activeItemIndexChange": "activeItemIndexChange"; }, never, ["[cuiTab]"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiTabsComponent, "cui-tabs", never, { "activeItemIndex": { "alias": "activeItemIndex"; "required": false; }; }, { "activeItemIndexChange": "activeItemIndexChange"; }, never, ["[cuiTab]"], false, never>;
 }

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

@@ -6,5 +6,5 @@ export declare class CuiTextareaComponent {
     noBordersAndPaddings: boolean;
     protected get isError(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextareaComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CuiTextareaComponent, "textarea[cuiTextarea]", never, { "rows": "rows"; "noBordersAndPaddings": "noBordersAndPaddings"; }, {}, never, never, false, [{ directive: typeof i1.CuiAutoResizingDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiTextareaComponent, "textarea[cuiTextarea]", never, { "rows": { "alias": "rows"; "required": false; }; "noBordersAndPaddings": { "alias": "noBordersAndPaddings"; "required": false; }; }, {}, never, never, false, [{ directive: typeof i1.CuiAutoResizingDirective; inputs: {}; outputs: {}; }]>;
 }

package/directives/index.d.ts

@@ -1 +1,2 @@
 export * from './text-field-controller';
+export * from './tooltip';

package/directives/text-field-controller/text-field-icon-left.directive.d.ts

@@ -5,5 +5,5 @@ export declare const CUI_TEXT_FIELD_ICON_LEFT: InjectionToken<CuiTextFieldIconLe
 export declare class CuiTextFieldIconLeftDirective {
     iconLeft?: CuiIcon | string;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldIconLeftDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldIconLeftDirective, "[cuiTextFieldIconLeft]", never, { "iconLeft": "cuiTextFieldIconLeft"; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldIconLeftDirective, "[cuiTextFieldIconLeft]", never, { "iconLeft": { "alias": "cuiTextFieldIconLeft"; "required": false; }; }, {}, never, never, false, never>;
 }

package/directives/text-field-controller/text-field-id.directive.d.ts

@@ -4,5 +4,5 @@ export declare const CUI_TEXT_FIELD_ID: InjectionToken<CuiTextFieldIdDirective>;
 export declare class CuiTextFieldIdDirective {
     id?: string;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldIdDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldIdDirective, "[cuiTextFieldId]", never, { "id": "cuiTextFieldId"; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldIdDirective, "[cuiTextFieldId]", never, { "id": { "alias": "cuiTextFieldId"; "required": false; }; }, {}, never, never, false, never>;
 }

package/directives/text-field-controller/text-field-is-error.directive.d.ts

@@ -4,5 +4,5 @@ export declare const CUI_TEXT_FIELD_IS_ERROR: InjectionToken<CuiTextFieldIsError
 export declare class CuiTextFieldIsErrorDirective {
     isError: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldIsErrorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldIsErrorDirective, "[cuiTextFieldIsError]", never, { "isError": "cuiTextFieldIsError"; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldIsErrorDirective, "[cuiTextFieldIsError]", never, { "isError": { "alias": "cuiTextFieldIsError"; "required": false; }; }, {}, never, never, false, never>;
 }

package/directives/text-field-controller/text-field-placeholder.directive.d.ts

@@ -4,5 +4,5 @@ export declare const CUI_TEXT_FIELD_PLACEHOLDER: InjectionToken<CuiTextFieldPlac
 export declare class CuiTextFieldPlaceholderDirective {
     placeholder?: string;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldPlaceholderDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldPlaceholderDirective, "[cuiTextFieldPlaceholder]", never, { "placeholder": "cuiTextFieldPlaceholder"; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldPlaceholderDirective, "[cuiTextFieldPlaceholder]", never, { "placeholder": { "alias": "cuiTextFieldPlaceholder"; "required": false; }; }, {}, never, never, false, never>;
 }

package/directives/text-field-controller/text-field-size.directive.d.ts

@@ -5,5 +5,5 @@ export declare const CUI_TEXT_FIELD_SIZE: InjectionToken<CuiTextFieldSizeDirecti
 export declare class CuiTextFieldSizeDirective {
     size: CuiSizeSm | CuiSizeMd;
     static ɵfac: i0.ɵɵFactoryDeclaration<CuiTextFieldSizeDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldSizeDirective, "[cuiTextFieldSize]", never, { "size": "cuiTextFieldSize"; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTextFieldSizeDirective, "[cuiTextFieldSize]", never, { "size": { "alias": "cuiTextFieldSize"; "required": false; }; }, {}, never, never, false, never>;
 }

package/directives/tooltip/index.d.ts

@@ -0,0 +1,16 @@
+export * from './tooltip';
+export * from './tooltip.component';
+export * from './tooltip.directive';
+export * from './tooltip.providers';
+export * from './tooltip.service';
+export * from './tooltip-describe.directive';
+export * from './tooltip-driver.directive';
+export * from './tooltip-host.directive';
+export * from './tooltip-hover.directive';
+export * from './tooltip-manual.directive';
+export * from './tooltip-options.directive';
+export * from './tooltip-overflow.directive';
+export * from './tooltip-pointer.directive';
+export * from './tooltip-position.directive';
+export * from './tooltip-unstyled.component';
+export * from './tooltips.component';

package/directives/tooltip/tooltip-describe.directive.d.ts

@@ -0,0 +1,16 @@
+import { CuiDriver } from '../../classes';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipDescribe extends CuiDriver {
+    private readonly doc;
+    private readonly el;
+    private readonly zone;
+    private readonly id$;
+    private readonly stream$;
+    readonly type = "hint";
+    constructor();
+    set cuiTooltipDescribe(id: string | null | undefined);
+    private get element();
+    private get focused();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipDescribe, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipDescribe, "[cuiTooltipDescribe]", never, { "cuiTooltipDescribe": { "alias": "cuiTooltipDescribe"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip-driver.directive.d.ts

@@ -0,0 +1,7 @@
+import { CuiDriverDirective } from '../../classes';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipDriver extends CuiDriverDirective {
+    readonly type = "hint";
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipDriver, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipDriver, never, never, {}, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip-host.directive.d.ts

@@ -0,0 +1,9 @@
+import { CuiRectAccessor } from '../../classes';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipHost extends CuiRectAccessor {
+    cuiTooltipHost?: HTMLElement;
+    readonly type = "hint";
+    getClientRect(): DOMRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipHost, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipHost, "[cuiTooltip][cuiTooltipHost]", never, { "cuiTooltipHost": { "alias": "cuiTooltipHost"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip-hover.directive.d.ts

@@ -0,0 +1,21 @@
+import { CuiDriver } from '../../classes';
+import type { CuiTooltipOptions } from './tooltip-options.directive';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipHover extends CuiDriver {
+    private readonly isMobile;
+    private readonly el;
+    private readonly hovered$;
+    private readonly options;
+    private visible;
+    private readonly toggle$;
+    private readonly stream$;
+    private readonly parent;
+    cuiTooltipShowDelay: CuiTooltipOptions['showDelay'];
+    cuiTooltipHideDelay: CuiTooltipOptions['hideDelay'];
+    readonly type = "hint";
+    enabled: boolean;
+    constructor();
+    toggle(visible?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipHover, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipHover, never, ["cuiTooltipHover"], { "cuiTooltipShowDelay": { "alias": "cuiTooltipShowDelay"; "required": false; }; "cuiTooltipHideDelay": { "alias": "cuiTooltipHideDelay"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip-manual.directive.d.ts

@@ -0,0 +1,13 @@
+import type { OnChanges } from '@angular/core';
+import { CuiDriver } from '../../classes';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipManual extends CuiDriver implements OnChanges {
+    private readonly hover;
+    private readonly stream$;
+    cuiTooltipManual: boolean;
+    readonly type = "hint";
+    constructor();
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipManual, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipManual, "[cuiTooltip][cuiTooltipManual]", never, { "cuiTooltipManual": { "alias": "cuiTooltipManual"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip-options.directive.d.ts

@@ -0,0 +1,36 @@
+import type { FactoryProvider, OnChanges } from '@angular/core';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export type CuiTooltipDirection = 'bottom-left' | 'bottom-right' | 'bottom' | 'left-bottom' | 'left-top' | 'left' | 'right-bottom' | 'right-top' | 'right' | 'top-left' | 'top-right' | 'top';
+export declare const CUI_TOOLTIP_DIRECTIONS: readonly CuiTooltipDirection[];
+export interface CuiTooltipOptions {
+    readonly appearance: string;
+    readonly direction: CuiTooltipDirection | CuiTooltipDirection[];
+    readonly hideDelay: number;
+    readonly icon: string;
+    readonly showDelay: number;
+}
+/** Default values for tooltip options */
+export declare const CUI_TOOLTIP_DEFAULT_OPTIONS: CuiTooltipOptions;
+/**
+ * Default parameters for tooltip directive
+ */
+export declare const CUI_TOOLTIP_OPTIONS: import("@angular/core").InjectionToken<CuiTooltipOptions>;
+export declare const cuiTooltipOptionsProvider: (options: Partial<CuiTooltipOptions>) => FactoryProvider;
+/**
+ * @deprecated: drop in 5.0
+ */
+export declare class CuiTooltipOptionsDirective implements CuiTooltipOptions, OnChanges {
+    private readonly options;
+    content: PolymorpheusContent;
+    direction: CuiTooltipDirection | CuiTooltipDirection[];
+    appearance: string;
+    showDelay: number;
+    hideDelay: number;
+    icon: string;
+    readonly change$: Subject<void>;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipOptionsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipOptionsDirective, "[cuiTooltipContent]", never, { "content": { "alias": "cuiTooltipContent"; "required": false; }; "direction": { "alias": "cuiTooltipDirection"; "required": false; }; "appearance": { "alias": "cuiTooltipAppearance"; "required": false; }; "showDelay": { "alias": "cuiTooltipShowDelay"; "required": false; }; "hideDelay": { "alias": "cuiTooltipHideDelay"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip-overflow.directive.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tooltip.directive";
+export declare class CuiTooltipOverflow {
+    private readonly hint;
+    protected onMouseEnter({ scrollWidth, clientWidth, textContent }: Element): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipOverflow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipOverflow, "[cuiTooltipOverflow]", never, {}, {}, never, never, true, [{ directive: typeof i1.CuiTooltipDirective; inputs: { "cuiTooltipAppearance": "cuiTooltipAppearance"; }; outputs: {}; }]>;
+}

package/directives/tooltip/tooltip-pointer.directive.d.ts

@@ -0,0 +1,10 @@
+import type { CuiRectAccessor } from '../../classes';
+import { CuiTooltipHover } from './tooltip-hover.directive';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipPointer extends CuiTooltipHover implements CuiRectAccessor {
+    private currentRect;
+    getClientRect(): DOMRect;
+    protected onMove({ clientX, clientY }: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipPointer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipPointer, "[cuiTooltip][cuiTooltipPointer]", never, {}, {}, never, never, true, never>;
+}

package/directives/tooltip/tooltip-position.directive.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from '@angular/core';
+import { CuiPositionAccessor } from '../../classes';
+import type { CuiPoint } from '../../types';
+import type { CuiTooltipDirection, CuiTooltipOptions } from './tooltip-options.directive';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipPosition extends CuiPositionAccessor {
+    private readonly offset;
+    private readonly viewport;
+    private readonly accessor;
+    private readonly points;
+    direction: CuiTooltipOptions['direction'];
+    readonly directionChange: EventEmitter<CuiTooltipDirection>;
+    readonly type = "hint";
+    emitDirection(direction: CuiTooltipDirection): void;
+    getPosition(rect: DOMRect, el?: HTMLElement): CuiPoint;
+    private get fallback();
+    private checkPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipPosition, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipPosition, never, never, { "direction": { "alias": "cuiTooltipDirection"; "required": false; }; }, { "directionChange": "cuiTooltipDirectionChange"; }, never, never, true, never>;
+}

package/directives/tooltip/tooltip-unstyled.component.d.ts

@@ -0,0 +1,17 @@
+import type { WritableSignal } from '@angular/core';
+import type { CuiContext } from '@cuby-ui/cdk';
+import type { CuiPortalItem } from '../../types';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare class CuiTooltipUnstyledComponent {
+    protected readonly context: CuiContext<CuiPortalItem<any> & {
+        content: WritableSignal<PolymorpheusContent>;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipUnstyledComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiTooltipUnstyledComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+export declare class CuiTooltipUnstyled<C> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiTooltipUnstyled<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiTooltipUnstyled<any>, "ng-template[cuiTooltip]", never, {}, {}, never, never, true, never>;
+}