yukit-web 0.0.1

package/types/yukit-web-helm-dialog.d.ts

@@ -0,0 +1,90 @@
+import * as i1 from '@spartan-ng/brain/dialog';
+import { BrnDialog, BrnDialogOptions, BrnDialogRef } from '@spartan-ng/brain/dialog';
+import * as i0 from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ComponentType } from '@angular/cdk/portal';
+import { ClassValue } from 'clsx';
+
+declare class HlmDialog extends BrnDialog {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialog, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDialog, "hlm-dialog", ["hlmDialog"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class HlmDialogClose {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogClose, "button[hlmDialogClose]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnDialogClose; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDialogContent {
+    private readonly _dialogRef;
+    private readonly _dialogContext;
+    readonly showCloseButton: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly state: i0.Signal<i1.BrnDialogState>;
+    readonly component: ComponentType<unknown> | undefined;
+    private readonly _dynamicComponentClass;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDialogContent, "hlm-dialog-content", never, { "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HlmDialogDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogDescription, "[hlmDialogDescription]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnDialogDescription; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDialogFooter {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogFooter, "[hlmDialogFooter],hlm-dialog-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmDialogHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogHeader, "[hlmDialogHeader],hlm-dialog-header", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmDialogOverlayClass: string;
+declare class HlmDialogOverlay {
+    private readonly _classSettable;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogOverlay, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogOverlay, "[hlmDialogOverlay],hlm-dialog-overlay", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnDialogOverlay; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDialogPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogPortal, "[hlmDialogPortal]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnDialogContent; inputs: { "context": "context"; "class": "class"; }; outputs: {}; }]>;
+}
+
+declare class HlmDialogTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogTitle, "[hlmDialogTitle]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnDialogTitle; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDialogTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogTrigger, "button[hlmDialogTrigger],button[hlmDialogTriggerFor]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnDialogTrigger; inputs: { "id": "id"; "brnDialogTriggerFor": "hlmDialogTriggerFor"; "type": "type"; }; outputs: {}; }]>;
+}
+
+type HlmDialogOptions<DialogContext = unknown> = BrnDialogOptions & {
+    contentClass?: string;
+    showCloseButton?: boolean;
+    context?: DialogContext;
+};
+declare class HlmDialogService {
+    private readonly _brnDialogService;
+    open<TResult = unknown, TContext = unknown>(component: ComponentType<unknown> | TemplateRef<unknown>, options?: Partial<HlmDialogOptions<TContext>>): BrnDialogRef<TResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HlmDialogService>;
+}
+
+declare const HlmDialogImports: readonly [typeof HlmDialog, typeof HlmDialogContent, typeof HlmDialogDescription, typeof HlmDialogFooter, typeof HlmDialogHeader, typeof HlmDialogOverlay, typeof HlmDialogPortal, typeof HlmDialogTitle, typeof HlmDialogTrigger, typeof HlmDialogClose];
+
+export { HlmDialog, HlmDialogClose, HlmDialogContent, HlmDialogDescription, HlmDialogFooter, HlmDialogHeader, HlmDialogImports, HlmDialogOverlay, HlmDialogPortal, HlmDialogService, HlmDialogTitle, HlmDialogTrigger, hlmDialogOverlayClass };
+export type { HlmDialogOptions };

package/types/yukit-web-helm-drawer.d.ts

@@ -0,0 +1,71 @@
+import * as i1 from '@spartan-ng/brain/drawer';
+import { BrnDrawer } from '@spartan-ng/brain/drawer';
+import * as i0 from '@angular/core';
+import * as _spartan_ng_brain_core from '@spartan-ng/brain/core';
+import { ClassValue } from 'clsx';
+
+declare class HlmDrawer extends BrnDrawer {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDrawer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDrawer, "hlm-drawer", ["hlmDrawer"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class HlmDrawerClose {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDrawerClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDrawerClose, "button[hlmDrawerClose]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnDrawerClose; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDrawerContent {
+    private readonly _stateProvider;
+    protected readonly _sideProvider: _spartan_ng_brain_core.ExposesSide;
+    readonly state: i0.Signal<"closed" | "open">;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDrawerContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDrawerContent, "hlm-drawer-content", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.BrnDrawerHandle; inputs: { "closeThreshold": "closeThreshold"; }; outputs: {}; }]>;
+}
+
+declare class HlmDrawerDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDrawerDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDrawerDescription, "[hlmDrawerDescription]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnDrawerDescription; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDrawerFooter {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDrawerFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDrawerFooter, "[hlmDrawerFooter],hlm-drawer-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmDrawerHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDrawerHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDrawerHeader, "[hlmDrawerHeader],hlm-drawer-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmDrawerOverlay {
+    private readonly _classSettable;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDrawerOverlay, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDrawerOverlay, "[hlmDrawerOverlay],hlm-drawer-overlay", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnDrawerOverlay; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDrawerPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDrawerPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDrawerPortal, "[hlmDrawerPortal]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnDrawerContent; inputs: { "context": "context"; "class": "class"; }; outputs: {}; }]>;
+}
+
+declare class HlmDrawerTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDrawerTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDrawerTitle, "[hlmDrawerTitle]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnDrawerTitle; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDrawerTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDrawerTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDrawerTrigger, "button[hlmDrawerTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnDrawerTrigger; inputs: { "id": "id"; "direction": "direction"; "type": "type"; }; outputs: {}; }]>;
+}
+
+declare const HlmDrawerImports: readonly [typeof HlmDrawer, typeof HlmDrawerClose, typeof HlmDrawerContent, typeof HlmDrawerDescription, typeof HlmDrawerFooter, typeof HlmDrawerHeader, typeof HlmDrawerOverlay, typeof HlmDrawerPortal, typeof HlmDrawerTitle, typeof HlmDrawerTrigger];
+
+export { HlmDrawer, HlmDrawerClose, HlmDrawerContent, HlmDrawerDescription, HlmDrawerFooter, HlmDrawerHeader, HlmDrawerImports, HlmDrawerOverlay, HlmDrawerPortal, HlmDrawerTitle, HlmDrawerTrigger };

package/types/yukit-web-helm-dropdown-menu.d.ts

@@ -0,0 +1,171 @@
+import * as i0 from '@angular/core';
+import { ValueProvider } from '@angular/core';
+import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
+import { MenuSide, MenuAlign } from '@spartan-ng/brain/core';
+import * as i1 from '@angular/cdk/menu';
+import { CdkMenuItemCheckbox, CdkMenuItemRadio } from '@angular/cdk/menu';
+
+declare class HlmDropdownMenu {
+    private readonly _host;
+    private readonly _elementRef;
+    private readonly _menuSide;
+    protected readonly _state: i0.WritableSignal<string>;
+    protected readonly _side: i0.WritableSignal<MenuSide>;
+    readonly sideOffset: i0.InputSignalWithTransform<number, NumberInput>;
+    constructor();
+    private setSideFromTransformOrigin;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenu, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenu, "[hlmDropdownMenu],hlm-dropdown-menu", never, { "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkMenu; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * @internal
+ * Moves DOM focus to the hovered menu item. CDK menus only move focus with the keyboard, so on a pointer
+ * the highlight would otherwise stay on the last keyboard-focused item (leaving two rows highlighted) and,
+ * when a submenu closes, focus would fall to <body>, the menu stack would report no focus, and the whole
+ * dropdown would collapse. Following the pointer with focus (Radix/shadcn behaviour) keeps a single
+ * highlight and keeps focus inside the menu stack. setActiveMenuItem also syncs the key manager so keyboard
+ * navigation continues from the hovered item.
+ *
+ * Applied as a host directive on every dropdown item type (item, checkbox, radio, sub-trigger).
+ */
+declare class HlmDropdownMenuFocusOnHover {
+    private readonly _cdkMenuItem;
+    private readonly _parentMenu;
+    private readonly _inputModality;
+    protected _focusOnHover(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuFocusOnHover, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuFocusOnHover, "[hlmDropdownMenuFocusOnHover]", never, {}, {}, never, never, true, never>;
+}
+
+/** @internal. Use HlmDropdownMenuCheckbox instead. */
+declare class HlmDropdownMenuCheckboxCdk extends CdkMenuItemCheckbox {
+    readonly keepOpen: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    trigger(options?: {
+        keepOpen: boolean;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuCheckboxCdk, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuCheckboxCdk, "[hlmDropdownMenuCheckboxCdk]", never, { "keepOpen": { "alias": "keepOpen"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class HlmDropdownMenuCheckbox {
+    protected readonly _cdkMenuItem: HlmDropdownMenuCheckboxCdk;
+    readonly inset: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuCheckbox, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuCheckbox, "[hlmDropdownMenuCheckbox],[hlmDropdownMenuCheckboxItem]", never, { "inset": { "alias": "inset"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof HlmDropdownMenuCheckboxCdk; inputs: { "cdkMenuItemDisabled": "disabled"; "cdkMenuItemChecked": "checked"; "keepOpen": "keepOpen"; }; outputs: { "cdkMenuItemTriggered": "triggered"; }; }, { directive: typeof HlmDropdownMenuFocusOnHover; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDropdownMenuCheckboxIndicator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuCheckboxIndicator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDropdownMenuCheckboxIndicator, "hlm-dropdown-menu-checkbox-indicator", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmDropdownMenuGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuGroup, "[hlmDropdownMenuGroup],hlm-dropdown-menu-group", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkMenuGroup; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDropdownMenuItem {
+    protected readonly _isButton: boolean;
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly variant: i0.InputSignal<"default" | "destructive">;
+    readonly inset: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuItem, "[hlmDropdownMenuItem],hlm-dropdown-menu-item", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "inset": { "alias": "inset"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkMenuItem; inputs: { "cdkMenuItemDisabled": "disabled"; }; outputs: { "cdkMenuItemTriggered": "triggered"; }; }, { directive: typeof HlmDropdownMenuFocusOnHover; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDropdownMenuItemSubIndicator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuItemSubIndicator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDropdownMenuItemSubIndicator, "hlm-dropdown-menu-item-sub-indicator", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmDropdownMenuLabel {
+    readonly inset: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuLabel, "[hlmDropdownMenuLabel],hlm-dropdown-menu-label", never, { "inset": { "alias": "inset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** @internal. Use HlmDropdownMenuRadio instead. */
+declare class HlmDropdownMenuRadioCdk extends CdkMenuItemRadio {
+    readonly keepOpen: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    trigger(options?: {
+        keepOpen: boolean;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuRadioCdk, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuRadioCdk, "[hlmDropdownMenuRadioCdk]", never, { "keepOpen": { "alias": "keepOpen"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class HlmDropdownMenuRadio {
+    protected readonly _cdkMenuItem: HlmDropdownMenuRadioCdk;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuRadio, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuRadio, "[hlmDropdownMenuRadio]", never, {}, {}, never, never, true, [{ directive: typeof HlmDropdownMenuRadioCdk; inputs: { "cdkMenuItemDisabled": "disabled"; "cdkMenuItemChecked": "checked"; "keepOpen": "keepOpen"; }; outputs: { "cdkMenuItemTriggered": "triggered"; }; }, { directive: typeof HlmDropdownMenuFocusOnHover; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDropdownMenuRadioIndicator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuRadioIndicator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDropdownMenuRadioIndicator, "hlm-dropdown-menu-radio-indicator", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmDropdownMenuSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuSeparator, "[hlmDropdownMenuSeparator],hlm-dropdown-menu-separator", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmDropdownMenuShortcut {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuShortcut, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuShortcut, "[hlmDropdownMenuShortcut],hlm-dropdown-menu-shortcut", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmDropdownMenuSub {
+    private readonly _host;
+    private readonly _elementRef;
+    private readonly _menuSide;
+    protected readonly _state: i0.WritableSignal<string>;
+    protected readonly _side: i0.WritableSignal<MenuSide>;
+    constructor();
+    private setSideFromTransformOrigin;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuSub, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuSub, "[hlmDropdownMenuSub],hlm-dropdown-menu-sub", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkMenu; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDropdownMenuSubTrigger {
+    private readonly _cdkTrigger;
+    private readonly _config;
+    readonly align: i0.InputSignal<MenuAlign>;
+    readonly side: i0.InputSignal<MenuSide>;
+    private readonly _menuPosition;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuSubTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuSubTrigger, "[hlmDropdownMenuSubTrigger]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkMenuTrigger; inputs: { "cdkMenuTriggerFor": "hlmDropdownMenuSubTrigger"; "cdkMenuTriggerData": "hlmDropdownMenuTriggerData"; }; outputs: { "cdkMenuOpened": "hlmDropdownMenuSubOpened"; "cdkMenuClosed": "hlmDropdownMenuSubClosed"; }; }]>;
+}
+
+declare class HlmDropdownMenuTrigger {
+    private readonly _cdkTrigger;
+    private readonly _config;
+    readonly align: i0.InputSignal<MenuAlign>;
+    readonly side: i0.InputSignal<MenuSide>;
+    private readonly _menuPosition;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDropdownMenuTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDropdownMenuTrigger, "[hlmDropdownMenuTrigger]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkMenuTrigger; inputs: { "cdkMenuTriggerFor": "hlmDropdownMenuTrigger"; "cdkMenuTriggerData": "hlmDropdownMenuTriggerData"; }; outputs: { "cdkMenuOpened": "hlmDropdownMenuOpened"; "cdkMenuClosed": "hlmDropdownMenuClosed"; }; }]>;
+}
+
+interface HlmDropdownMenuConfig {
+    align: MenuAlign;
+    side: MenuSide;
+}
+declare function provideHlmDropdownMenuConfig(config: Partial<HlmDropdownMenuConfig>): ValueProvider;
+declare function injectHlmDropdownMenuConfig(): HlmDropdownMenuConfig;
+
+declare const HlmDropdownMenuImports: readonly [typeof HlmDropdownMenu, typeof HlmDropdownMenuCheckbox, typeof HlmDropdownMenuCheckboxIndicator, typeof HlmDropdownMenuGroup, typeof HlmDropdownMenuItem, typeof HlmDropdownMenuItemSubIndicator, typeof HlmDropdownMenuLabel, typeof HlmDropdownMenuRadio, typeof HlmDropdownMenuRadioIndicator, typeof HlmDropdownMenuSeparator, typeof HlmDropdownMenuShortcut, typeof HlmDropdownMenuSub, typeof HlmDropdownMenuSubTrigger, typeof HlmDropdownMenuTrigger];
+
+export { HlmDropdownMenu, HlmDropdownMenuCheckbox, HlmDropdownMenuCheckboxCdk, HlmDropdownMenuCheckboxIndicator, HlmDropdownMenuFocusOnHover, HlmDropdownMenuGroup, HlmDropdownMenuImports, HlmDropdownMenuItem, HlmDropdownMenuItemSubIndicator, HlmDropdownMenuLabel, HlmDropdownMenuRadio, HlmDropdownMenuRadioCdk, HlmDropdownMenuRadioIndicator, HlmDropdownMenuSeparator, HlmDropdownMenuShortcut, HlmDropdownMenuSub, HlmDropdownMenuSubTrigger, HlmDropdownMenuTrigger, injectHlmDropdownMenuConfig, provideHlmDropdownMenuConfig };
+export type { HlmDropdownMenuConfig };

package/types/yukit-web-helm-empty.d.ts

@@ -0,0 +1,49 @@
+import * as i0 from '@angular/core';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+declare class HlmEmpty {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmEmpty, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmEmpty, "[hlmEmpty],hlm-empty", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmEmptyContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmEmptyContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmEmptyContent, "[hlmEmptyContent],hlm-empty-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmEmptyDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmEmptyDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmEmptyDescription, "[hlmEmptyDescription]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmEmptyHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmEmptyHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmEmptyHeader, "[hlmEmptyHeader],hlm-empty-header", never, {}, {}, never, never, true, never>;
+}
+
+declare const emptyMediaVariants: (props?: ({
+    variant?: "default" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type EmptyMediaVariants = VariantProps<typeof emptyMediaVariants>;
+declare class HlmEmptyMedia {
+    readonly variant: i0.InputSignal<"default" | "icon" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmEmptyMedia, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmEmptyMedia, "[hlmEmptyMedia],hlm-empty-media", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmEmptyTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmEmptyTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmEmptyTitle, "[hlmEmptyTitle]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmEmptyImports: readonly [typeof HlmEmpty, typeof HlmEmptyContent, typeof HlmEmptyDescription, typeof HlmEmptyHeader, typeof HlmEmptyTitle, typeof HlmEmptyMedia];
+
+export { HlmEmpty, HlmEmptyContent, HlmEmptyDescription, HlmEmptyHeader, HlmEmptyImports, HlmEmptyMedia, HlmEmptyTitle };
+export type { EmptyMediaVariants };

package/types/yukit-web-helm-field.d.ts

@@ -0,0 +1,102 @@
+import * as i0 from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as i1 from '@spartan-ng/brain/field';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1$1 from 'yukit-web/helm/label';
+
+declare const fieldVariants: (props?: ({
+    orientation?: "vertical" | "horizontal" | "responsive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type FieldVariants = VariantProps<typeof fieldVariants>;
+declare class HlmField {
+    readonly orientation: i0.InputSignal<"vertical" | "horizontal" | "responsive" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmField, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmField, "[hlmField],hlm-field", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnField; inputs: { "data-invalid": "data-invalid"; "forceInvalid": "forceInvalid"; }; outputs: {}; }]>;
+}
+
+declare class HlmFieldContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldContent, "[hlmFieldContent],hlm-field-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmFieldDescription implements OnDestroy {
+    private static _id;
+    private readonly _a11y;
+    readonly id: i0.InputSignal<string>;
+    private _registeredId?;
+    private readonly _cleanup;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldDescription, "[hlmFieldDescription],hlm-field-description", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmFieldError implements OnDestroy {
+    private static _id;
+    private readonly _field;
+    private readonly _a11y;
+    private _registeredId?;
+    private readonly _hasParentField;
+    /** The unique ID for the field error. If none is supplied, it will be auto-generated. */
+    readonly id: i0.InputSignal<string>;
+    /**
+     * The name of the specific validator error key to match (e.g. 'required').
+     * When omitted, the error is shown if any validation error is present.
+     */
+    readonly validator: i0.InputSignal<string | undefined>;
+    /** Forces the error message to be visible regardless of the control's validation state. */
+    readonly forceShow: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _display: i0.Signal<boolean>;
+    protected readonly _hasError: i0.Signal<boolean>;
+    private readonly _cleanup;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldError, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmFieldError, "hlm-field-error", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "validator": { "alias": "validator"; "required": false; "isSignal": true; }; "forceShow": { "alias": "forceShow"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HlmFieldGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldGroup, "[hlmFieldGroup],hlm-field-group", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmFieldLabel {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldLabel, "[hlmFieldLabel],hlm-field-label", never, {}, {}, never, never, true, [{ directive: typeof i1$1.HlmLabel; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmFieldLegend {
+    readonly variant: i0.InputSignal<"label" | "legend">;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldLegend, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldLegend, "legend[hlmFieldLegend]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmFieldSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldSeparator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmFieldSeparator, "hlm-field-separator", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class HlmFieldSet {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldSet, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldSet, "fieldset[hlmFieldSet]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmFieldTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmFieldTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmFieldTitle, "[hlmFieldTitle],hlm-field-title", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmFieldImports: readonly [typeof HlmField, typeof HlmFieldContent, typeof HlmFieldDescription, typeof HlmFieldError, typeof HlmFieldGroup, typeof HlmFieldLabel, typeof HlmFieldLegend, typeof HlmFieldSeparator, typeof HlmFieldSet, typeof HlmFieldTitle];
+
+export { HlmField, HlmFieldContent, HlmFieldDescription, HlmFieldError, HlmFieldGroup, HlmFieldImports, HlmFieldLabel, HlmFieldLegend, HlmFieldSeparator, HlmFieldSet, HlmFieldTitle };
+export type { FieldVariants };

package/types/yukit-web-helm-hover-card.d.ts

@@ -0,0 +1,31 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@spartan-ng/brain/hover-card';
+
+declare class HlmHoverCard {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmHoverCard, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmHoverCard, "[hlmHoverCard],hlm-hover-card", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnHoverCard; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmHoverCardContent {
+    private readonly _renderer;
+    private readonly _element;
+    readonly state: i0.Signal<"open" | "closed">;
+    readonly side: i0.Signal<"top" | "bottom" | "left" | "right">;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmHoverCardContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmHoverCardContent, "[hlmHoverCardContent],hlm-hover-card-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmHoverCardPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmHoverCardPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmHoverCardPortal, "[hlmHoverCardPortal],hlm-hover-card-portal", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnHoverCardContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmHoverCardTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmHoverCardTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmHoverCardTrigger, "[hlmHoverCardTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnHoverCardTrigger; inputs: { "showDelay": "showDelay"; "hideDelay": "hideDelay"; "animationDelay": "animationDelay"; "sideOffset": "sideOffset"; "align": "align"; "brnHoverCardTriggerFor": "hlmHoverCardTriggerFor"; }; outputs: {}; }]>;
+}
+
+declare const HlmHoverCardImports: readonly [typeof HlmHoverCardContent, typeof HlmHoverCardPortal, typeof HlmHoverCard, typeof HlmHoverCardTrigger];
+
+export { HlmHoverCard, HlmHoverCardContent, HlmHoverCardImports, HlmHoverCardPortal, HlmHoverCardTrigger };

package/types/yukit-web-helm-input-group.d.ts

@@ -0,0 +1,47 @@
+import * as i0 from '@angular/core';
+import * as i1 from 'yukit-web/helm/button';
+import * as i1$1 from 'yukit-web/helm/input';
+import * as i1$2 from 'yukit-web/helm/textarea';
+
+declare class HlmInputGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputGroup, "[hlmInputGroup],hlm-input-group", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmInputGroupAddon {
+    readonly align: i0.InputSignal<"inline-start" | "inline-end" | "block-start" | "block-end" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputGroupAddon, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputGroupAddon, "[hlmInputGroupAddon],hlm-input-group-addon", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmInputGroupButton {
+    readonly size: i0.InputSignal<"xs" | "sm" | "icon-xs" | "icon-sm" | null | undefined>;
+    readonly type: i0.InputSignal<"button" | "submit" | "reset">;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputGroupButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputGroupButton, "button[hlmInputGroupButton]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.HlmButton; inputs: { "variant": "variant"; }; outputs: {}; }]>;
+}
+
+declare class HlmInputGroupInput {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputGroupInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputGroupInput, "input[hlmInputGroupInput]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.HlmInput; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmInputGroupText {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputGroupText, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputGroupText, "[hlmInputGroupText],hlm-input-group-text", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmInputGroupTextarea {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputGroupTextarea, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputGroupTextarea, "textarea[hlmInputGroupTextarea]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.HlmTextarea; inputs: {}; outputs: {}; }]>;
+}
+
+declare const HlmInputGroupImports: readonly [typeof HlmInputGroup, typeof HlmInputGroupAddon, typeof HlmInputGroupButton, typeof HlmInputGroupInput, typeof HlmInputGroupText, typeof HlmInputGroupTextarea];
+
+export { HlmInputGroup, HlmInputGroupAddon, HlmInputGroupButton, HlmInputGroupImports, HlmInputGroupInput, HlmInputGroupText, HlmInputGroupTextarea };

package/types/yukit-web-helm-input-otp.d.ts

@@ -0,0 +1,40 @@
+import * as i0 from '@angular/core';
+import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
+
+declare class HlmInputOtp {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputOtp, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputOtp, "brn-input-otp[hlmInputOtp], brn-input-otp[hlm]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmInputOtpFakeCaret {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputOtpFakeCaret, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmInputOtpFakeCaret, "hlm-input-otp-fake-caret", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmInputOtpGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputOtpGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInputOtpGroup, "[hlmInputOtpGroup],hlm-input-otp-group", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmInputOtpSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputOtpSeparator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmInputOtpSeparator, "hlm-input-otp-separator", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmInputOtpSlot {
+    /** The index of the slot to render the char or a fake caret */
+    readonly index: i0.InputSignalWithTransform<number, NumberInput>;
+    /** Whether to force the input into an invalid state. */
+    readonly forceInvalid: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInputOtpSlot, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmInputOtpSlot, "hlm-input-otp-slot", never, { "index": { "alias": "index"; "required": true; "isSignal": true; }; "forceInvalid": { "alias": "forceInvalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HlmInputOtpImports: readonly [typeof HlmInputOtp, typeof HlmInputOtpGroup, typeof HlmInputOtpSeparator, typeof HlmInputOtpSlot, typeof HlmInputOtpFakeCaret];
+
+export { HlmInputOtp, HlmInputOtpFakeCaret, HlmInputOtpGroup, HlmInputOtpImports, HlmInputOtpSeparator, HlmInputOtpSlot };

package/types/yukit-web-helm-input.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@spartan-ng/brain/input';
+import * as i2 from '@spartan-ng/brain/field';
+
+declare class HlmInput {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmInput, "[hlmInput]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnInput; inputs: { "id": "id"; "forceInvalid": "forceInvalid"; }; outputs: {}; }, { directive: typeof i2.BrnFieldControlDescribedBy; inputs: {}; outputs: {}; }]>;
+}
+
+declare const HlmInputImports: readonly [typeof HlmInput];
+
+export { HlmInput, HlmInputImports };