yukit-web 0.0.1

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

@@ -0,0 +1,66 @@
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1 from '@spartan-ng/brain/radio-group';
+import { BrnRadioChange } from '@spartan-ng/brain/radio-group';
+import { ClassValue } from 'clsx';
+import * as i2 from '@spartan-ng/brain/field';
+
+declare class HlmRadio<T = unknown> {
+    private readonly _document;
+    private readonly _renderer;
+    private readonly _elementRef;
+    private readonly _isBrowser;
+    private readonly _radioGroup;
+    protected readonly _ariaInvalid: _angular_core.Signal<boolean | undefined>;
+    protected readonly _touched: _angular_core.Signal<boolean | undefined>;
+    protected readonly _dirty: _angular_core.Signal<boolean | undefined>;
+    protected readonly _groupSpartanInvalid: _angular_core.Signal<boolean | undefined>;
+    protected readonly _errorStateClass: _angular_core.Signal<"text-destructive" | "">;
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    /** Used to set the id on the underlying brn element. */
+    readonly inputId: _angular_core.InputSignal<string | undefined>;
+    /** Used to set the aria-label attribute on the underlying brn element. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Used to set the aria-labelledby attribute on the underlying brn element. */
+    readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
+    /** Used to set the aria-describedby attribute on the underlying brn element. */
+    readonly ariaDescribedby: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The value this radio button represents.
+     */
+    readonly value: _angular_core.InputSignal<T>;
+    /** Whether the checkbox is required. */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether the checkbox is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Event emitted when the checked state of this radio button changes.
+     */
+    readonly change: _angular_core.OutputEmitterRef<BrnRadioChange<T>>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmRadio<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmRadio<any>, "hlm-radio", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "change": "change"; }, never, ["[target],[indicator],hlm-radio-indicator", "*"], true, never>;
+}
+
+declare class HlmRadioGroup {
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    private readonly _brnRadioGroup;
+    protected readonly _ariaInvalid: _angular_core.Signal<boolean | undefined>;
+    protected readonly _touched: _angular_core.Signal<boolean | undefined>;
+    protected readonly _dirty: _angular_core.Signal<boolean | undefined>;
+    protected readonly _errorState: _angular_core.Signal<boolean | undefined>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmRadioGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmRadioGroup, "[hlmRadioGroup],hlm-radio-group", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnRadioGroup; inputs: { "name": "name"; "value": "value"; "disabled": "disabled"; "required": "required"; }; outputs: { "valueChange": "valueChange"; }; }, { directive: typeof i2.BrnFieldControlDescribedBy; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmRadioIndicator {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmRadioIndicator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmRadioIndicator, "hlm-radio-indicator", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmRadioGroupImports: readonly [typeof HlmRadioGroup, typeof HlmRadio, typeof HlmRadioIndicator];
+
+export { HlmRadio, HlmRadioGroup, HlmRadioGroupImports, HlmRadioIndicator };

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

@@ -0,0 +1,27 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@spartan-ng/brain/resizable';
+import { BrnResizableHandle } from '@spartan-ng/brain/resizable';
+
+declare class HlmResizableGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmResizableGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmResizableGroup, "[hlmResizableGroup],hlm-resizable-group", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnResizableGroup; inputs: { "direction": "direction"; "layout": "layout"; }; outputs: { "dragEnd": "dragEnd"; "dragStart": "dragStart"; "layoutChange": "layoutChange"; }; }]>;
+}
+
+declare class HlmResizableHandle {
+    protected readonly _brnResizableHandle: BrnResizableHandle;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmResizableHandle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmResizableHandle, "hlm-resizable-handle", ["hlmResizableHandle"], {}, {}, never, never, true, [{ directive: typeof i1.BrnResizableHandle; inputs: { "withHandle": "withHandle"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+declare class HlmResizablePanel {
+    private readonly _resizablePanel;
+    setSize(size: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmResizablePanel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmResizablePanel, "[hlmResizablePanel],hlm-resizable-panel", ["hlmResizablePanel"], {}, {}, never, never, true, [{ directive: typeof i1.BrnResizablePanel; inputs: { "defaultSize": "defaultSize"; "id": "id"; "collapsible": "collapsible"; "maxSize": "maxSize"; "minSize": "minSize"; }; outputs: {}; }]>;
+}
+
+declare const HlmResizableImports: readonly [typeof HlmResizableGroup, typeof HlmResizablePanel, typeof HlmResizableHandle];
+
+export { HlmResizableGroup, HlmResizableHandle, HlmResizableImports, HlmResizablePanel };

package/types/yukit-web-helm-scroll-area.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from '@angular/core';
+
+declare class HlmScrollArea {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmScrollArea, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmScrollArea, "ng-scrollbar[hlm],ng-scrollbar[hlmScrollbar]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmScrollAreaImports: readonly [typeof HlmScrollArea];
+
+export { HlmScrollArea, HlmScrollAreaImports };

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

@@ -0,0 +1,114 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@spartan-ng/brain/select';
+import * as i2 from '@spartan-ng/brain/popover';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ClassValue } from 'clsx';
+
+declare class HlmSelect {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelect, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelect, "[hlmSelect],hlm-select", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSelect; inputs: { "disabled": "disabled"; "value": "value"; "isItemEqualToValue": "isItemEqualToValue"; "itemToString": "itemToString"; }; outputs: { "valueChange": "valueChange"; }; }, { directive: typeof i2.BrnPopover; inputs: { "align": "align"; "closeOnOutsidePointerEvents": "closeOnOutsidePointerEvents"; "sideOffset": "sideOffset"; "state": "state"; "offsetX": "offsetX"; }; outputs: { "stateChanged": "stateChanged"; "closed": "closed"; }; }]>;
+}
+
+declare class HlmSelectContent {
+    protected readonly _computedListboxClasses: i0.Signal<string>;
+    readonly showScroll: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSelectContent, "hlm-select-content", never, { "showScroll": { "alias": "showScroll"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.BrnSelectContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectGroup, "[hlmSelectGroup],hlm-select-group", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSelectGroup; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectItem {
+    private readonly _brnSelectItem;
+    protected readonly _active: i0.Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSelectItem, "hlm-select-item", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.BrnSelectItem; inputs: { "id": "id"; "disabled": "disabled"; "value": "value"; }; outputs: {}; }]>;
+}
+
+declare class HlmSelectLabel {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectLabel, "[hlmSelectLabel],hlm-select-label", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSelectLabel; inputs: { "id": "id"; }; outputs: {}; }]>;
+}
+
+declare class HlmSelectMultiple {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectMultiple, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectMultiple, "[hlmSelectMultiple],hlm-select-multiple", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSelectMultiple; inputs: { "disabled": "disabled"; "value": "value"; "isItemEqualToValue": "isItemEqualToValue"; "itemToString": "itemToString"; }; outputs: { "valueChange": "valueChange"; }; }, { directive: typeof i2.BrnPopover; inputs: { "align": "align"; "closeOnOutsidePointerEvents": "closeOnOutsidePointerEvents"; "sideOffset": "sideOffset"; "state": "state"; "offsetX": "offsetX"; }; outputs: { "stateChanged": "stateChanged"; "closed": "closed"; }; }]>;
+}
+
+declare class HlmSelectPlaceholder {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectPlaceholder, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectPlaceholder, "[hlmSelectPlaceholder],hlm-select-placeholder", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSelectPlaceholder; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectPortal, "[hlmSelectPortal]", never, {}, {}, never, never, true, [{ directive: typeof i2.BrnPopoverContent; inputs: { "context": "context"; "class": "class"; }; outputs: {}; }]>;
+}
+
+declare class HlmSelectScrollDown {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectScrollDown, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSelectScrollDown, "hlm-select-scroll-down", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSelectScrollDown; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectScrollUp {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectScrollUp, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSelectScrollUp, "hlm-select-scroll-up", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSelectScrollUp; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectSeparator, "[hlmSelectSeparator],hlm-select-separator", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSelectSeparator; inputs: { "orientation": "orientation"; }; outputs: {}; }]>;
+}
+
+declare class HlmSelectTrigger {
+    private static _id;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    readonly buttonId: i0.InputSignal<string>;
+    readonly size: i0.InputSignal<"default" | "sm">;
+    /** Whether to force the trigger into an invalid state. */
+    readonly forceInvalid: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectTrigger, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSelectTrigger, "hlm-select-trigger", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "buttonId": { "alias": "buttonId"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "forceInvalid": { "alias": "forceInvalid"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HlmSelectValue {
+    private readonly _brnSelectValue;
+    protected readonly _hidden: i0.Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectValue, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectValue, "[hlmSelectValue],hlm-select-value", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSelectValue; inputs: { "placeholder": "placeholder"; }; outputs: {}; }]>;
+}
+
+declare class HlmSelectValueTemplate {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectValueTemplate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectValueTemplate, "[hlmSelectValueTemplate]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSelectValueTemplate; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectValues {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectValues, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectValues, "[hlmSelectValues]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSelectValues; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectValuesContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSelectValuesContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSelectValuesContent, "[hlmSelectValuesContent],hlm-select-values-content", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmSelectImports: readonly [typeof HlmSelect, typeof HlmSelectContent, typeof HlmSelectGroup, typeof HlmSelectItem, typeof HlmSelectLabel, typeof HlmSelectMultiple, typeof HlmSelectPlaceholder, typeof HlmSelectPortal, typeof HlmSelectScrollDown, typeof HlmSelectScrollUp, typeof HlmSelectSeparator, typeof HlmSelectTrigger, typeof HlmSelectValue, typeof HlmSelectValues, typeof HlmSelectValuesContent, typeof HlmSelectValueTemplate];
+
+export { HlmSelect, HlmSelectContent, HlmSelectGroup, HlmSelectImports, HlmSelectItem, HlmSelectLabel, HlmSelectMultiple, HlmSelectPlaceholder, HlmSelectPortal, HlmSelectScrollDown, HlmSelectScrollUp, HlmSelectSeparator, HlmSelectTrigger, HlmSelectValue, HlmSelectValueTemplate, HlmSelectValues, HlmSelectValuesContent };

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

@@ -0,0 +1,13 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@spartan-ng/brain/separator';
+
+declare const hlmSeparatorClass = "inline-flex shrink-0 bg-border data-horizontal:h-px data-horizontal:w-full data-vertical:w-px data-vertical:self-stretch";
+declare class HlmSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSeparator, "[hlmSeparator],hlm-separator", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSeparator; inputs: { "orientation": "orientation"; "decorative": "decorative"; }; outputs: {}; }]>;
+}
+
+declare const HlmSeparatorImports: readonly [typeof HlmSeparator];
+
+export { HlmSeparator, HlmSeparatorImports, hlmSeparatorClass };

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

@@ -0,0 +1,75 @@
+import * as i1 from '@spartan-ng/brain/sheet';
+import { BrnSheet } from '@spartan-ng/brain/sheet';
+import * as i0 from '@angular/core';
+import * as _spartan_ng_brain_core from '@spartan-ng/brain/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ClassValue } from 'clsx';
+
+declare class HlmSheet extends BrnSheet {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheet, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSheet, "hlm-sheet", ["hlmSheet"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class HlmSheetClose {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetClose, "button[hlmSheetClose]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSheetClose; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSheetContent {
+    private readonly _stateProvider;
+    protected readonly _sideProvider: _spartan_ng_brain_core.ExposesSide;
+    readonly state: i0.Signal<"closed" | "open">;
+    private readonly _renderer;
+    private readonly _element;
+    readonly showCloseButton: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSheetContent, "hlm-sheet-content", never, { "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HlmSheetDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetDescription, "[hlmSheetDescription]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSheetDescription; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSheetFooter {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetFooter, "[hlmSheetFooter],hlm-sheet-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSheetHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetHeader, "[hlmSheetHeader],hlm-sheet-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSheetOverlay {
+    private readonly _classSettable;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetOverlay, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetOverlay, "[hlmSheetOverlay],hlm-sheet-overlay", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnSheetOverlay; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSheetPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetPortal, "[hlmSheetPortal]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSheetContent; inputs: { "context": "context"; "class": "class"; }; outputs: {}; }]>;
+}
+
+declare class HlmSheetTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetTitle, "[hlmSheetTitle]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSheetTitle; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSheetTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSheetTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSheetTrigger, "button[hlmSheetTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSheetTrigger; inputs: { "id": "id"; "side": "side"; "type": "type"; }; outputs: {}; }]>;
+}
+
+declare const HlmSheetImports: readonly [typeof HlmSheet, typeof HlmSheetClose, typeof HlmSheetContent, typeof HlmSheetDescription, typeof HlmSheetFooter, typeof HlmSheetHeader, typeof HlmSheetOverlay, typeof HlmSheetPortal, typeof HlmSheetTitle, typeof HlmSheetTrigger];
+
+export { HlmSheet, HlmSheetClose, HlmSheetContent, HlmSheetDescription, HlmSheetFooter, HlmSheetHeader, HlmSheetImports, HlmSheetOverlay, HlmSheetPortal, HlmSheetTitle, HlmSheetTrigger };

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

@@ -0,0 +1,232 @@
+import * as i0 from '@angular/core';
+import { Signal, ValueProvider } from '@angular/core';
+import { ClassValue } from 'clsx';
+import * as i1 from 'yukit-web/helm/input';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1$1 from '@spartan-ng/brain/tooltip';
+import * as i1$2 from 'yukit-web/helm/separator';
+import * as i1$3 from 'yukit-web/helm/button';
+
+type SidebarVariant = 'sidebar' | 'floating' | 'inset';
+declare class HlmSidebarService {
+    private readonly _platformId;
+    private readonly _request;
+    private readonly _config;
+    private readonly _document;
+    private readonly _window;
+    private readonly _open;
+    private readonly _openMobile;
+    private readonly _isMobile;
+    private readonly _variant;
+    private _mediaQuery;
+    readonly open: Signal<boolean>;
+    readonly openMobile: Signal<boolean>;
+    readonly isMobile: Signal<boolean>;
+    readonly variant: Signal<SidebarVariant>;
+    readonly state: Signal<"expanded" | "collapsed">;
+    constructor();
+    setOpen(open: boolean): void;
+    setOpenMobile(open: boolean): void;
+    setVariant(variant: SidebarVariant): void;
+    toggleSidebar(): void;
+    private restoreStateFromCookie;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HlmSidebarService>;
+}
+
+declare class HlmSidebar {
+    protected readonly _sidebarService: HlmSidebarService;
+    private readonly _config;
+    readonly sidebarWidthMobile: i0.InputSignal<string>;
+    readonly side: i0.InputSignal<"left" | "right">;
+    readonly variant: i0.InputSignal<SidebarVariant>;
+    readonly collapsible: i0.InputSignal<"offcanvas" | "icon" | "none">;
+    protected readonly _sidebarGapComputedClass: i0.Signal<string>;
+    readonly sidebarContainerClass: i0.InputSignal<ClassValue>;
+    protected readonly _sidebarContainerComputedClass: i0.Signal<string>;
+    protected readonly _dataSlot: i0.Signal<"sidebar" | undefined>;
+    private readonly _collapsibleAndNonMobile;
+    protected readonly _dataState: i0.Signal<"expanded" | "collapsed" | undefined>;
+    protected readonly _dataCollapsible: i0.Signal<"offcanvas" | "icon" | "none" | "" | undefined>;
+    protected readonly _dataVariant: i0.Signal<SidebarVariant | undefined>;
+    protected readonly _dataSide: i0.Signal<"left" | "right" | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSidebar, "hlm-sidebar", never, { "sidebarWidthMobile": { "alias": "sidebarWidthMobile"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "sidebarContainerClass": { "alias": "sidebarContainerClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HlmSidebarContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarContent, "[hlmSidebarContent],hlm-sidebar-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarFooter {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarFooter, "[hlmSidebarFooter],hlm-sidebar-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarGroup, "[hlmSidebarGroup],hlm-sidebar-group", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarGroupAction {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarGroupAction, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarGroupAction, "button[hlmSidebarGroupAction]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarGroupContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarGroupContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarGroupContent, "div[hlmSidebarGroupContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarGroupLabel {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarGroupLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarGroupLabel, "div[hlmSidebarGroupLabel], button[hlmSidebarGroupLabel]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarHeader, "[hlmSidebarHeader],hlm-sidebar-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarInput {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarInput, "input[hlmSidebarInput]", never, {}, {}, never, never, true, [{ directive: typeof i1.HlmInput; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSidebarInset {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarInset, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarInset, "main[hlmSidebarInset]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenu {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenu, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenu, "ul[hlmSidebarMenu]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenuAction {
+    readonly showOnHover: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuAction, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenuAction, "button[hlmSidebarMenuAction]", never, { "showOnHover": { "alias": "showOnHover"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenuBadge {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuBadge, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenuBadge, "[hlmSidebarMenuBadge],hlm-sidebar-menu-badge", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenuButton {
+    private readonly _config;
+    private readonly _sidebarService;
+    private readonly _brnTooltip;
+    readonly variant: i0.InputSignal<"default" | "outline">;
+    readonly size: i0.InputSignal<"default" | "sm" | "lg">;
+    readonly isActive: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly closeMobileSidebarOnClick: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _isTooltipHidden: i0.Signal<boolean>;
+    constructor();
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenuButton, "button[hlmSidebarMenuButton], a[hlmSidebarMenuButton]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "closeMobileSidebarOnClick": { "alias": "closeMobileSidebarOnClick"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.BrnTooltip; inputs: { "brnTooltip": "tooltip"; }; outputs: {}; }]>;
+}
+
+declare class HlmSidebarMenuItem {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenuItem, "li[hlmSidebarMenuItem]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenuSkeleton {
+    readonly showIcon: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _width: string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuSkeleton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSidebarMenuSkeleton, "hlm-sidebar-menu-skeleton,div[hlmSidebarMenuSkeleton]", never, { "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenuSub {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuSub, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenuSub, "ul[hlmSidebarMenuSub]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenuSubButton {
+    private readonly _sidebarService;
+    private readonly _config;
+    readonly closeMobileSidebarOnClick: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly size: i0.InputSignal<"sm" | "md">;
+    readonly isActive: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuSubButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenuSubButton, "a[hlmSidebarMenuSubButton], button[hlmSidebarMenuSubButton]", never, { "closeMobileSidebarOnClick": { "alias": "closeMobileSidebarOnClick"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarMenuSubItem {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarMenuSubItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarMenuSubItem, "li[hlmSidebarMenuSubItem]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarRail {
+    private readonly _sidebarService;
+    readonly ariaLabel: i0.InputSignal<string>;
+    constructor();
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarRail, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarRail, "button[hlmSidebarRail]", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmSidebarSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarSeparator, "[hlmSidebarSeparator],hlm-sidebar-separator", never, {}, {}, never, never, true, [{ directive: typeof i1$2.HlmSeparator; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSidebarTrigger {
+    private readonly _sidebarService;
+    readonly srOnlyText: i0.InputSignal<string>;
+    protected _onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarTrigger, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSidebarTrigger, "button[hlmSidebarTrigger]", never, { "srOnlyText": { "alias": "srOnlyText"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$3.HlmButton; inputs: { "variant": "variant"; "size": "size"; }; outputs: {}; }]>;
+}
+
+declare class HlmSidebarWrapper {
+    private readonly _config;
+    readonly sidebarWidth: i0.InputSignal<string>;
+    readonly sidebarWidthIcon: i0.InputSignal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSidebarWrapper, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSidebarWrapper, "[hlmSidebarWrapper],hlm-sidebar-wrapper", never, { "sidebarWidth": { "alias": "sidebarWidth"; "required": false; "isSignal": true; }; "sidebarWidthIcon": { "alias": "sidebarWidthIcon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface HlmSidebarConfig {
+    sidebarWidth: string;
+    sidebarWidthMobile: string;
+    sidebarWidthIcon: string;
+    sidebarCookieName: string;
+    sidebarCookieMaxAge: number;
+    sidebarKeyboardShortcut: string;
+    mobileBreakpoint: string;
+    closeMobileSidebarOnMenuButtonClick: boolean;
+}
+declare function provideHlmSidebarConfig(config: Partial<HlmSidebarConfig>): ValueProvider;
+declare function injectHlmSidebarConfig(): HlmSidebarConfig;
+
+declare const HlmSidebarImports: readonly [typeof HlmSidebar, typeof HlmSidebarContent, typeof HlmSidebarFooter, typeof HlmSidebarGroup, typeof HlmSidebarGroupAction, typeof HlmSidebarGroupContent, typeof HlmSidebarGroupLabel, typeof HlmSidebarHeader, typeof HlmSidebarInput, typeof HlmSidebarInset, typeof HlmSidebarMenu, typeof HlmSidebarMenuSkeleton, typeof HlmSidebarMenuAction, typeof HlmSidebarMenuBadge, typeof HlmSidebarMenuButton, typeof HlmSidebarMenuItem, typeof HlmSidebarMenuSub, typeof HlmSidebarMenuSubButton, typeof HlmSidebarRail, typeof HlmSidebarSeparator, typeof HlmSidebarTrigger, typeof HlmSidebarWrapper, typeof HlmSidebarMenuSubItem];
+
+export { HlmSidebar, HlmSidebarContent, HlmSidebarFooter, HlmSidebarGroup, HlmSidebarGroupAction, HlmSidebarGroupContent, HlmSidebarGroupLabel, HlmSidebarHeader, HlmSidebarImports, HlmSidebarInput, HlmSidebarInset, HlmSidebarMenu, HlmSidebarMenuAction, HlmSidebarMenuBadge, HlmSidebarMenuButton, HlmSidebarMenuItem, HlmSidebarMenuSkeleton, HlmSidebarMenuSub, HlmSidebarMenuSubButton, HlmSidebarMenuSubItem, HlmSidebarRail, HlmSidebarSeparator, HlmSidebarService, HlmSidebarTrigger, HlmSidebarWrapper, injectHlmSidebarConfig, provideHlmSidebarConfig };
+export type { HlmSidebarConfig, SidebarVariant };

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

@@ -0,0 +1,11 @@
+import * as i0 from '@angular/core';
+
+declare class HlmSkeleton {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSkeleton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSkeleton, "[hlmSkeleton],hlm-skeleton", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmSkeletonImports: readonly [typeof HlmSkeleton];
+
+export { HlmSkeleton, HlmSkeletonImports };

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

@@ -0,0 +1,14 @@
+import * as i1 from '@spartan-ng/brain/slider';
+import { BrnSlider } from '@spartan-ng/brain/slider';
+import * as i0 from '@angular/core';
+
+declare class HlmSlider {
+    protected readonly _slider: BrnSlider;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSlider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmSlider, "hlm-slider, brn-slider [hlm]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSlider; inputs: { "id": "id"; "value": "value"; "disabled": "disabled"; "min": "min"; "max": "max"; "step": "step"; "minStepsBetweenThumbs": "minStepsBetweenThumbs"; "inverted": "inverted"; "orientation": "orientation"; "showTicks": "showTicks"; "maxTicks": "maxTicks"; "tickLabelInterval": "tickLabelInterval"; "formatTick": "formatTick"; "draggableRange": "draggableRange"; "draggableRangeOnly": "draggableRangeOnly"; "aria-label": "aria-label"; "aria-labelledby": "aria-labelledby"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+
+declare const HlmSliderImports: readonly [typeof HlmSlider];
+
+export { HlmSlider, HlmSliderImports };

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

@@ -0,0 +1,52 @@
+import * as _spartan_ng_brain_sonner from '@spartan-ng/brain/sonner';
+import * as _angular_core from '@angular/core';
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { ClassValue } from 'clsx';
+
+declare class HlmToaster {
+    readonly invert: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly theme: _angular_core.InputSignal<"light" | "dark" | "system">;
+    readonly position: _angular_core.InputSignal<_spartan_ng_brain_sonner.Position>;
+    readonly hotKey: _angular_core.InputSignal<string[]>;
+    readonly richColors: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly expand: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly duration: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly visibleToasts: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly closeButton: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly toastOptions: _angular_core.InputSignal<_spartan_ng_brain_sonner.ToastOptions>;
+    protected readonly _computedToastOptions: _angular_core.Signal<{
+        classes: {
+            toast: string;
+            title?: string;
+            description?: string;
+            loader?: string;
+            closeButton?: string;
+            cancelButton?: string;
+            actionButton?: string;
+            action?: string | undefined;
+            success?: string | undefined;
+            info?: string | undefined;
+            warning?: string | undefined;
+            error?: string | undefined;
+            loading?: string | undefined;
+            default?: string | undefined;
+        };
+        class?: string;
+        descriptionClass?: string;
+        style?: Record<string, unknown>;
+        cancelButtonStyle?: string;
+        actionButtonStyle?: string;
+        duration?: number;
+        unstyled?: boolean;
+    }>;
+    readonly offset: _angular_core.InputSignal<string | number | null>;
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    readonly userStyle: _angular_core.InputSignal<Record<string, string>>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmToaster, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmToaster, "hlm-toaster", never, { "invert": { "alias": "invert"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "hotKey": { "alias": "hotKey"; "required": false; "isSignal": true; }; "richColors": { "alias": "richColors"; "required": false; "isSignal": true; }; "expand": { "alias": "expand"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "visibleToasts": { "alias": "visibleToasts"; "required": false; "isSignal": true; }; "closeButton": { "alias": "closeButton"; "required": false; "isSignal": true; }; "toastOptions": { "alias": "toastOptions"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "userStyle": { "alias": "style"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HlmToasterImports: readonly [typeof HlmToaster];
+
+export { HlmToaster, HlmToasterImports };