yukit-web 0.0.1

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

@@ -0,0 +1,52 @@
+import * as i0 from '@angular/core';
+import * as _angular_router from '@angular/router';
+
+declare class HlmBreadcrumb {
+    readonly ariaLabel: i0.InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBreadcrumb, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBreadcrumb, "[hlmBreadcrumb]", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmBreadcrumbEllipsis {
+    /** Screen reader only text for the ellipsis */
+    readonly srOnlyText: i0.InputSignal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBreadcrumbEllipsis, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmBreadcrumbEllipsis, "hlm-breadcrumb-ellipsis", never, { "srOnlyText": { "alias": "srOnlyText"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmBreadcrumbItem {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBreadcrumbItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBreadcrumbItem, "[hlmBreadcrumbItem]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmBreadcrumbLink {
+    /** The link to navigate to the page. */
+    readonly link: i0.InputSignal<string | readonly any[] | _angular_router.UrlTree | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBreadcrumbLink, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBreadcrumbLink, "[hlmBreadcrumbLink]", never, { "link": { "alias": "link"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _angular_router.RouterLink; inputs: { "target": "target"; "queryParams": "queryParams"; "fragment": "fragment"; "queryParamsHandling": "queryParamsHandling"; "state": "state"; "info": "info"; "relativeTo": "relativeTo"; "preserveFragment": "preserveFragment"; "skipLocationChange": "skipLocationChange"; "replaceUrl": "replaceUrl"; "routerLink": "link"; }; outputs: {}; }]>;
+}
+
+declare class HlmBreadcrumbList {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBreadcrumbList, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBreadcrumbList, "[hlmBreadcrumbList]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmBreadcrumbPage {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBreadcrumbPage, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBreadcrumbPage, "[hlmBreadcrumbPage]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmBreadcrumbSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBreadcrumbSeparator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmBreadcrumbSeparator, "[hlmBreadcrumbSeparator]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare const HlmBreadcrumbImports: readonly [typeof HlmBreadcrumb, typeof HlmBreadcrumbEllipsis, typeof HlmBreadcrumbSeparator, typeof HlmBreadcrumbItem, typeof HlmBreadcrumbLink, typeof HlmBreadcrumbPage, typeof HlmBreadcrumbList];
+
+export { HlmBreadcrumb, HlmBreadcrumbEllipsis, HlmBreadcrumbImports, HlmBreadcrumbItem, HlmBreadcrumbLink, HlmBreadcrumbList, HlmBreadcrumbPage, HlmBreadcrumbSeparator };

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

@@ -0,0 +1,46 @@
+import * as i0 from '@angular/core';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+declare const bubbleVariants: (props?: ({
+    variant?: "default" | "secondary" | "muted" | "tinted" | "outline" | "ghost" | "destructive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type BubbleVariants = VariantProps<typeof bubbleVariants>;
+type BubbleAlign = 'start' | 'end';
+declare class HlmBubble {
+    readonly variant: i0.InputSignal<"default" | "secondary" | "muted" | "tinted" | "outline" | "ghost" | "destructive" | null | undefined>;
+    readonly align: i0.InputSignal<BubbleAlign>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBubble, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBubble, "[hlmBubble],hlm-bubble", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmBubbleContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBubbleContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBubbleContent, "[hlmBubbleContent],hlm-bubble-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmBubbleGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBubbleGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBubbleGroup, "[hlmBubbleGroup],hlm-bubble-group", never, {}, {}, never, never, true, never>;
+}
+
+declare const bubbleReactionsVariants: (props?: ({
+    side?: "top" | "bottom" | null | undefined;
+    align?: "start" | "end" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type BubbleReactionsVariants = VariantProps<typeof bubbleReactionsVariants>;
+declare class HlmBubbleReactions {
+    readonly side: i0.InputSignal<"top" | "bottom" | null | undefined>;
+    readonly align: i0.InputSignal<"start" | "end" | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBubbleReactions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBubbleReactions, "[hlmBubbleReactions],hlm-bubble-reactions", never, { "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HlmBubbleImports: readonly [typeof HlmBubble, typeof HlmBubbleContent, typeof HlmBubbleGroup, typeof HlmBubbleReactions];
+
+export { HlmBubble, HlmBubbleContent, HlmBubbleGroup, HlmBubbleImports, HlmBubbleReactions };
+export type { BubbleAlign, BubbleReactionsVariants, BubbleVariants };

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

@@ -0,0 +1,25 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@spartan-ng/brain/separator';
+
+declare class HlmButtonGroup {
+    constructor();
+    readonly orientation: i0.InputSignal<"horizontal" | "vertical">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmButtonGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmButtonGroup, "[hlmButtonGroup],hlm-button-group", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmButtonGroupSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmButtonGroupSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmButtonGroupSeparator, "[hlmButtonGroupSeparator],hlm-button-group-separator", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnSeparator; inputs: { "orientation": "orientation"; "decorative": "decorative"; }; outputs: {}; }]>;
+}
+
+declare class HlmButtonGroupText {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmButtonGroupText, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmButtonGroupText, "[hlmButtonGroupText],hlm-button-group-text", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmButtonGroupImports: readonly [typeof HlmButtonGroup, typeof HlmButtonGroupText, typeof HlmButtonGroupSeparator];
+
+export { HlmButtonGroup, HlmButtonGroupImports, HlmButtonGroupSeparator, HlmButtonGroupText };

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

@@ -0,0 +1,33 @@
+import * as _angular_core from '@angular/core';
+import { ValueProvider } 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/button';
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "outline" | "secondary" | "ghost" | "destructive" | "link" | null | undefined;
+    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonVariants = VariantProps<typeof buttonVariants>;
+declare class HlmButton {
+    private readonly _config;
+    private readonly _additionalClasses;
+    readonly variant: _angular_core.InputSignal<"default" | "outline" | "secondary" | "ghost" | "destructive" | "link" | null | undefined>;
+    readonly size: _angular_core.InputSignal<"default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined>;
+    constructor();
+    setClass(classes: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmButton, "button[hlmBtn], a[hlmBtn]", ["hlmBtn"], { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnButton; inputs: { "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+interface BrnButtonConfig {
+    variant: ButtonVariants['variant'];
+    size: ButtonVariants['size'];
+}
+declare function provideBrnButtonConfig(config: Partial<BrnButtonConfig>): ValueProvider;
+declare function injectBrnButtonConfig(): BrnButtonConfig;
+
+declare const HlmButtonImports: readonly [typeof HlmButton];
+
+export { HlmButton, HlmButtonImports, buttonVariants, injectBrnButtonConfig, provideBrnButtonConfig };
+export type { BrnButtonConfig, ButtonVariants };

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

@@ -0,0 +1,89 @@
+import * as i0 from '@angular/core';
+import * as _spartan_ng_brain_date_time from '@spartan-ng/brain/date-time';
+import * as _spartan_ng_brain_calendar from '@spartan-ng/brain/calendar';
+import { BrnMonthYearCalendar } from '@spartan-ng/brain/calendar';
+
+declare class HlmCalendar<T> {
+    /** Access the calendar i18n */
+    protected readonly _i18n: _spartan_ng_brain_calendar.BrnCalendarI18nService;
+    /** Access the date time adapter */
+    protected readonly _dateAdapter: _spartan_ng_brain_date_time.BrnDateAdapter<T>;
+    /** Show dropdowns to navigate between months or years. */
+    readonly captionLayout: i0.InputSignal<"dropdown" | "label" | "dropdown-months" | "dropdown-years">;
+    /** Access the calendar directive */
+    private readonly _calendar;
+    /** Get the heading for the current month and year */
+    protected readonly _heading: i0.Signal<{
+        header: string;
+        month: string;
+        year: string;
+    }>;
+    protected readonly _btnClass: string;
+    protected readonly _selectClass = "gap-0 px-1.5 py-2 [&>ng-icon]:ms-1";
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCalendar<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmCalendar<any>, "hlm-calendar", never, { "captionLayout": { "alias": "captionLayout"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _spartan_ng_brain_calendar.BrnCalendar; inputs: { "min": "min"; "max": "max"; "disabled": "disabled"; "date": "date"; "dateDisabled": "dateDisabled"; "weekStartsOn": "weekStartsOn"; "highlightDays": "highlightDays"; "defaultFocusedDate": "defaultFocusedDate"; }; outputs: { "dateChange": "dateChange"; }; }]>;
+}
+
+declare class HlmCalendarMulti<T> {
+    /** Show dropdowns to navigate between months or years. */
+    readonly captionLayout: i0.InputSignal<"dropdown" | "label" | "dropdown-months" | "dropdown-years">;
+    /** Access the calendar i18n */
+    protected readonly _i18n: _spartan_ng_brain_calendar.BrnCalendarI18nService;
+    /** Access the date time adapter */
+    protected readonly _dateAdapter: _spartan_ng_brain_date_time.BrnDateAdapter<T>;
+    /** Access the calendar directive */
+    private readonly _calendar;
+    /** Get the heading for the current month and year */
+    protected readonly _heading: i0.Signal<{
+        header: string;
+        month: string;
+        year: string;
+    }>;
+    protected readonly _btnClass: string;
+    protected readonly _selectClass = "gap-0 px-1.5 py-2 [&>ng-icon]:ms-1";
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCalendarMulti<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmCalendarMulti<any>, "hlm-calendar-multi", never, { "captionLayout": { "alias": "captionLayout"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _spartan_ng_brain_calendar.BrnCalendarMulti; inputs: { "min": "min"; "max": "max"; "minSelection": "minSelection"; "maxSelection": "maxSelection"; "disabled": "disabled"; "date": "date"; "dateDisabled": "dateDisabled"; "weekStartsOn": "weekStartsOn"; "highlightDays": "highlightDays"; "defaultFocusedDate": "defaultFocusedDate"; }; outputs: { "dateChange": "dateChange"; }; }]>;
+}
+
+declare class HlmCalendarRange<T> {
+    /** Show dropdowns to navigate between months or years. */
+    readonly captionLayout: i0.InputSignal<"dropdown" | "label" | "dropdown-months" | "dropdown-years">;
+    /** Access the calendar i18n */
+    protected readonly _i18n: _spartan_ng_brain_calendar.BrnCalendarI18nService;
+    /** Access the date time adapter */
+    protected readonly _dateAdapter: _spartan_ng_brain_date_time.BrnDateAdapter<T>;
+    /** Access the calendar directive */
+    private readonly _calendar;
+    /** Get the heading for the current month and year */
+    protected readonly _heading: i0.Signal<{
+        header: string;
+        month: string;
+        year: string;
+    }>;
+    protected readonly _btnClass: string;
+    protected readonly _selectClass = "gap-0 px-1.5 py-2 [&>ng-icon]:ms-1";
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCalendarRange<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmCalendarRange<any>, "hlm-calendar-range", never, { "captionLayout": { "alias": "captionLayout"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _spartan_ng_brain_calendar.BrnCalendarRange; inputs: { "min": "min"; "max": "max"; "disabled": "disabled"; "startDate": "startDate"; "endDate": "endDate"; "dateDisabled": "dateDisabled"; "weekStartsOn": "weekStartsOn"; "highlightDays": "highlightDays"; "defaultFocusedDate": "defaultFocusedDate"; }; outputs: { "endDateChange": "endDateChange"; "startDateChange": "startDateChange"; }; }]>;
+}
+
+declare class HlmMonthYearCalendar<T> {
+    /** Access the calendar i18n */
+    protected readonly _i18n: _spartan_ng_brain_calendar.BrnCalendarI18nService;
+    /** Access the date adapter */
+    protected readonly _dateAdapter: _spartan_ng_brain_date_time.BrnDateAdapter<T>;
+    /** Access the picker directive */
+    protected readonly _picker: BrnMonthYearCalendar<T>;
+    /** The heading for the current view. */
+    protected readonly _heading: i0.Signal<string>;
+    protected readonly _btnClass: string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMonthYearCalendar<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmMonthYearCalendar<any>, "hlm-month-year-calendar", never, {}, {}, never, never, true, [{ directive: typeof _spartan_ng_brain_calendar.BrnMonthYearCalendar; inputs: { "min": "min"; "max": "max"; "disabled": "disabled"; "date": "date"; "defaultFocusedDate": "defaultFocusedDate"; "view": "view"; }; outputs: { "dateChange": "dateChange"; }; }]>;
+}
+
+declare const HlmCalendarImports: readonly [typeof HlmCalendar, typeof HlmCalendarMulti, typeof HlmCalendarRange, typeof HlmMonthYearCalendar];
+
+export { HlmCalendar, HlmCalendarImports, HlmCalendarMulti, HlmCalendarRange, HlmMonthYearCalendar };

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

@@ -0,0 +1,49 @@
+import * as i0 from '@angular/core';
+
+declare class HlmCard {
+    private readonly _defaultConfig;
+    readonly size: i0.InputSignal<"sm" | "default">;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCard, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCard, "[hlmCard],hlm-card", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmCardAction {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCardAction, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCardAction, "[hlmCardAction]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmCardContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCardContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCardContent, "[hlmCardContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmCardDescription {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCardDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCardDescription, "[hlmCardDescription]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmCardFooter {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCardFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCardFooter, "[hlmCardFooter],hlm-card-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmCardHeader {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCardHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCardHeader, "[hlmCardHeader],hlm-card-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmCardTitle {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCardTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCardTitle, "[hlmCardTitle]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmCardImports: readonly [typeof HlmCard, typeof HlmCardAction, typeof HlmCardContent, typeof HlmCardDescription, typeof HlmCardFooter, typeof HlmCardHeader, typeof HlmCardTitle];
+
+export { HlmCard, HlmCardAction, HlmCardContent, HlmCardDescription, HlmCardFooter, HlmCardHeader, HlmCardImports, HlmCardTitle };

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

@@ -0,0 +1,79 @@
+import * as i0 from '@angular/core';
+import { Signal, InputSignal } from '@angular/core';
+import { EmblaOptionsType, EmblaPluginType, EmblaEventType } from 'embla-carousel';
+import { EmblaCarouselDirective } from 'embla-carousel-angular';
+import * as i1 from 'yukit-web/helm/button';
+import { ClassValue } from 'clsx';
+
+declare class HlmCarousel {
+    protected readonly _emblaCarousel: Signal<EmblaCarouselDirective>;
+    private readonly _dir;
+    readonly orientation: InputSignal<"horizontal" | "vertical">;
+    readonly options: InputSignal<Omit<EmblaOptionsType, 'axis'> | undefined>;
+    readonly plugins: InputSignal<EmblaPluginType[]>;
+    protected readonly _emblaOptions: Signal<EmblaOptionsType>;
+    private readonly _canScrollPrev;
+    readonly canScrollPrev: Signal<boolean>;
+    private readonly _canScrollNext;
+    readonly canScrollNext: Signal<boolean>;
+    private readonly _currentSlide;
+    readonly currentSlide: Signal<number>;
+    private readonly _slideCount;
+    readonly slideCount: Signal<number>;
+    constructor();
+    protected onEmblaEvent(event: EmblaEventType): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    scrollPrev(): void;
+    scrollNext(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCarousel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmCarousel, "hlm-carousel", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "plugins": { "alias": "plugins"; "required": false; "isSignal": true; }; }, {}, never, ["[hlmCarouselContent],hlm-carousel-content", "*"], true, never>;
+}
+
+declare class HlmCarouselContent {
+    private readonly _orientation;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCarouselContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCarouselContent, "[hlmCarouselContent],hlm-carousel-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmCarouselItem {
+    private readonly _orientation;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCarouselItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCarouselItem, "[hlmCarouselItem],hlm-carousel-item", never, {}, {}, never, never, true, never>;
+}
+
+declare class HlmCarouselNext {
+    private readonly _button;
+    protected readonly _carousel: HlmCarousel;
+    private readonly _computedClass;
+    protected readonly isDisabled: () => boolean;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCarouselNext, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmCarouselNext, "button[hlm-carousel-next], button[hlmCarouselNext]", never, {}, {}, never, never, true, [{ directive: typeof i1.HlmButton; inputs: { "variant": "variant"; "size": "size"; }; outputs: {}; }]>;
+}
+
+declare class HlmCarouselPrevious {
+    private readonly _button;
+    protected readonly _carousel: HlmCarousel;
+    private readonly _computedClass;
+    protected readonly isDisabled: () => boolean;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCarouselPrevious, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmCarouselPrevious, "button[hlm-carousel-previous], button[hlmCarouselPrevious]", never, {}, {}, never, never, true, [{ directive: typeof i1.HlmButton; inputs: { "variant": "variant"; "size": "size"; }; outputs: {}; }]>;
+}
+
+declare class HlmCarouselSlideDisplay {
+    protected readonly _carousel: HlmCarousel;
+    protected readonly _currentSlide: i0.Signal<number>;
+    readonly slideClass: i0.InputSignal<ClassValue>;
+    /** Screen reader only text for the slide display */
+    readonly label: i0.InputSignal<string>;
+    protected readonly _labelContent: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCarouselSlideDisplay, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmCarouselSlideDisplay, "hlm-carousel-slide-display", never, { "slideClass": { "alias": "slideClass"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HlmCarouselImports: readonly [typeof HlmCarousel, typeof HlmCarouselContent, typeof HlmCarouselItem, typeof HlmCarouselPrevious, typeof HlmCarouselNext, typeof HlmCarouselSlideDisplay];
+
+export { HlmCarousel, HlmCarouselContent, HlmCarouselImports, HlmCarouselItem, HlmCarouselNext, HlmCarouselPrevious, HlmCarouselSlideDisplay };

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

@@ -0,0 +1,60 @@
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ControlValueAccessor } from '@angular/forms';
+import { ChangeFn, TouchFn } from '@spartan-ng/brain/forms';
+import { ClassValue } from 'clsx';
+import * as i1 from '@spartan-ng/brain/field';
+
+declare const HLM_CHECKBOX_VALUE_ACCESSOR: {
+    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: _angular_core.Type<any>;
+    multi: boolean;
+};
+declare class HlmCheckbox implements ControlValueAccessor {
+    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 | null>;
+    /** Used to set the aria-label attribute on the underlying brn element. */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /** Used to set the aria-labelledby attribute on the underlying brn element. */
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    /** Used to set the aria-describedby attribute on the underlying brn element. */
+    readonly ariaDescribedby: _angular_core.InputSignal<string | null>;
+    /** The checked state of the checkbox. */
+    readonly checkedInput: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly checked: _angular_core.WritableSignal<boolean>;
+    /** Emits when checked state changes. */
+    readonly checkedChange: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * The indeterminate state of the checkbox.
+     * For example, a "select all/deselect all" checkbox may be in the indeterminate state when some but not all of its sub-controls are checked.
+     */
+    readonly indeterminate: _angular_core.ModelSignal<boolean>;
+    /** The name attribute of the checkbox. */
+    readonly name: _angular_core.InputSignal<string | null>;
+    /** Whether the checkbox is required. */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether the checkbox is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether to force the checkbox into an invalid state. */
+    readonly forceInvalid: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _disabled: _angular_core.WritableSignal<boolean>;
+    private readonly _brnCheckbox;
+    private readonly _spartanInvalid;
+    protected readonly _errorStateClass: _angular_core.Signal<"" | "border-destructive focus-visible:border-destructive focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40">;
+    protected _onChange?: ChangeFn<boolean>;
+    protected _onTouched?: TouchFn;
+    protected _handleChange(value: boolean): void;
+    /** CONTROL VALUE ACCESSOR */
+    writeValue(value: boolean): void;
+    registerOnChange(fn: ChangeFn<boolean>): void;
+    registerOnTouched(fn: TouchFn): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmCheckbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmCheckbox, "hlm-checkbox", 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; }; "checkedInput": { "alias": "checked"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "forceInvalid": { "alias": "forceInvalid"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; "indeterminate": "indeterminateChange"; }, never, never, true, [{ directive: typeof i1.BrnFieldControlDescribedBy; inputs: {}; outputs: {}; }]>;
+}
+
+declare const HlmCheckboxImports: readonly [typeof HlmCheckbox];
+
+export { HLM_CHECKBOX_VALUE_ACCESSOR, HlmCheckbox, HlmCheckboxImports };

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

@@ -0,0 +1,22 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@spartan-ng/brain/collapsible';
+
+declare class HlmCollapsible {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCollapsible, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCollapsible, "[hlmCollapsible],hlm-collapsible", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnCollapsible; inputs: { "expanded": "expanded"; "disabled": "disabled"; }; outputs: { "expandedChange": "expandedChange"; }; }]>;
+}
+
+declare class HlmCollapsibleContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCollapsibleContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCollapsibleContent, "[hlmCollapsibleContent],hlm-collapsible-content", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnCollapsibleContent; inputs: { "id": "id"; }; outputs: {}; }]>;
+}
+
+declare class HlmCollapsibleTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCollapsibleTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCollapsibleTrigger, "button[hlmCollapsibleTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnCollapsibleTrigger; inputs: { "type": "type"; }; outputs: {}; }]>;
+}
+
+declare const HlmCollapsibleImports: readonly [typeof HlmCollapsible, typeof HlmCollapsibleContent, typeof HlmCollapsibleTrigger];
+
+export { HlmCollapsible, HlmCollapsibleContent, HlmCollapsibleImports, HlmCollapsibleTrigger };

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

@@ -0,0 +1,150 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@spartan-ng/brain/combobox';
+import * as i2 from '@spartan-ng/brain/popover';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i2$1 from 'yukit-web/helm/input-group';
+import { ClassValue } from 'clsx';
+
+declare class HlmCombobox {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCombobox, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCombobox, "[hlmCombobox],hlm-combobox", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnCombobox; inputs: { "autoHighlight": "autoHighlight"; "disabled": "disabled"; "filter": "filter"; "search": "search"; "value": "value"; "itemToString": "itemToString"; "filterOptions": "filterOptions"; "isItemEqualToValue": "isItemEqualToValue"; }; outputs: { "searchChange": "searchChange"; "valueChange": "valueChange"; }; }, { directive: typeof i2.BrnPopover; inputs: { "align": "align"; "closeOnOutsidePointerEvents": "closeOnOutsidePointerEvents"; "sideOffset": "sideOffset"; "state": "state"; "offsetX": "offsetX"; }; outputs: { "stateChanged": "stateChanged"; "closed": "closed"; }; }]>;
+}
+
+declare class HlmComboboxChip {
+    readonly showRemove: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxChip, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmComboboxChip, "hlm-combobox-chip", never, { "showRemove": { "alias": "showRemove"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.BrnComboboxChip; inputs: { "value": "value"; }; outputs: {}; }]>;
+}
+
+declare class HlmComboboxChipInput {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxChipInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxChipInput, "input[hlmComboboxChipInput]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnComboboxChipInput; inputs: { "id": "id"; "aria-invalid": "aria-invalid"; }; outputs: {}; }]>;
+}
+
+declare class HlmComboboxChips {
+    private readonly _combobox;
+    readonly forceInvalid: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _spartanInvalid: i0.Signal<boolean | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxChips, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxChips, "[hlmComboboxChips],hlm-combobox-chips", never, { "forceInvalid": { "alias": "forceInvalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnComboboxAnchor; inputs: {}; outputs: {}; }, { directive: typeof i1.BrnComboboxPopoverTrigger; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmComboboxContent {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxContent, "[hlmComboboxContent],hlm-combobox-content", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnComboboxContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmComboboxEmpty {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxEmpty, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxEmpty, "[hlmComboboxEmpty],hlm-combobox-empty", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnComboboxEmpty; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmComboboxGroup {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxGroup, "[hlmComboboxGroup]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnComboboxGroup; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmComboboxInput {
+    private static _id;
+    readonly inputId: i0.InputSignal<string>;
+    readonly placeholder: i0.InputSignal<string>;
+    readonly showTrigger: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly showClear: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly forceInvalid: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Accessible name for the icon-only popover trigger button. */
+    readonly triggerAriaLabel: i0.InputSignal<string>;
+    /** Accessible name for the icon-only clear button. */
+    readonly clearAriaLabel: i0.InputSignal<string>;
+    /** Manual override for aria-invalid. When not set, auto-detects from the parent combobox error state. */
+    readonly ariaInvalidOverride: i0.InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmComboboxInput, "hlm-combobox-input", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "showTrigger": { "alias": "showTrigger"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "forceInvalid": { "alias": "forceInvalid"; "required": false; "isSignal": true; }; "triggerAriaLabel": { "alias": "triggerAriaLabel"; "required": false; "isSignal": true; }; "clearAriaLabel": { "alias": "clearAriaLabel"; "required": false; "isSignal": true; }; "ariaInvalidOverride": { "alias": "aria-invalid"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.BrnComboboxAnchor; inputs: {}; outputs: {}; }, { directive: typeof i2$1.HlmInputGroup; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmComboboxItem {
+    private readonly _brnComboboxItem;
+    protected readonly _active: i0.Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmComboboxItem, "hlm-combobox-item", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.BrnComboboxItem; inputs: { "id": "id"; "disabled": "disabled"; "value": "value"; }; outputs: {}; }]>;
+}
+
+declare class HlmComboboxLabel {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxLabel, "[hlmComboboxLabel]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnComboboxLabel; inputs: { "id": "id"; }; outputs: {}; }]>;
+}
+
+declare class HlmComboboxList {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxList, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxList, "[hlmComboboxList]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnComboboxList; inputs: { "id": "id"; }; outputs: {}; }]>;
+}
+
+declare class HlmComboboxMultiple {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxMultiple, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxMultiple, "[hlmComboboxMultiple],hlm-combobox-multiple", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnComboboxMultiple; inputs: { "autoHighlight": "autoHighlight"; "disabled": "disabled"; "filter": "filter"; "search": "search"; "value": "value"; "itemToString": "itemToString"; "filterOptions": "filterOptions"; "isItemEqualToValue": "isItemEqualToValue"; }; outputs: { "searchChange": "searchChange"; "valueChange": "valueChange"; }; }, { directive: typeof i2.BrnPopover; inputs: { "align": "align"; "closeOnOutsidePointerEvents": "closeOnOutsidePointerEvents"; "sideOffset": "sideOffset"; "state": "state"; "offsetX": "offsetX"; }; outputs: { "stateChanged": "stateChanged"; "closed": "closed"; }; }]>;
+}
+
+declare class HlmComboboxPlaceholder {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxPlaceholder, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxPlaceholder, "[hlmComboboxPlaceholder],hlm-combobox-placeholder", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnComboboxPlaceholder; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmComboboxPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxPortal, "[hlmComboboxPortal]", never, {}, {}, never, never, true, [{ directive: typeof i2.BrnPopoverContent; inputs: { "context": "context"; "class": "class"; }; outputs: {}; }]>;
+}
+
+declare class HlmComboboxSeparator {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxSeparator, "[hlmComboboxSeparator]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnComboboxSeparator; inputs: { "orientation": "orientation"; }; outputs: {}; }]>;
+}
+
+declare class HlmComboboxStatus {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxStatus, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxStatus, "[hlmComboboxStatus],hlm-combobox-status", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnComboboxStatus; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmComboboxTrigger {
+    private static _id;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    readonly buttonId: i0.InputSignal<string>;
+    readonly variant: i0.InputSignal<"default" | "outline" | "secondary" | "ghost" | "destructive" | "link" | null | undefined>;
+    readonly forceInvalid: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxTrigger, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmComboboxTrigger, "hlm-combobox-trigger", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "buttonId": { "alias": "buttonId"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "forceInvalid": { "alias": "forceInvalid"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HlmComboboxValue {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxValue, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxValue, "[hlmComboboxValue],hlm-combobox-value", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnComboboxValue; inputs: { "placeholder": "placeholder"; }; outputs: {}; }]>;
+}
+
+declare class HlmComboboxValueTemplate {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxValueTemplate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxValueTemplate, "[hlmComboboxValueTemplate]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnComboboxValueTemplate; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmComboboxValues {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmComboboxValues, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmComboboxValues, "[hlmComboboxValues]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnComboboxValues; inputs: {}; outputs: {}; }]>;
+}
+
+declare const HlmComboboxImports: readonly [typeof HlmCombobox, typeof HlmComboboxChip, typeof HlmComboboxChipInput, typeof HlmComboboxChips, typeof HlmComboboxContent, typeof HlmComboboxEmpty, typeof HlmComboboxGroup, typeof HlmComboboxInput, typeof HlmComboboxItem, typeof HlmComboboxLabel, typeof HlmComboboxList, typeof HlmComboboxMultiple, typeof HlmComboboxPlaceholder, typeof HlmComboboxPortal, typeof HlmComboboxSeparator, typeof HlmComboboxStatus, typeof HlmComboboxTrigger, typeof HlmComboboxValue, typeof HlmComboboxValueTemplate, typeof HlmComboboxValues];
+
+export { HlmCombobox, HlmComboboxChip, HlmComboboxChipInput, HlmComboboxChips, HlmComboboxContent, HlmComboboxEmpty, HlmComboboxGroup, HlmComboboxImports, HlmComboboxInput, HlmComboboxItem, HlmComboboxLabel, HlmComboboxList, HlmComboboxMultiple, HlmComboboxPlaceholder, HlmComboboxPortal, HlmComboboxSeparator, HlmComboboxStatus, HlmComboboxTrigger, HlmComboboxValue, HlmComboboxValueTemplate, HlmComboboxValues };