yukit-web 0.0.1

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

@@ -0,0 +1,18 @@
+import * as _angular_core from '@angular/core';
+
+declare class HlmSpinner {
+    /**
+     * The name of the icon to be used as the spinner.
+     * Use provideIcons({ ... }) to register custom icons.
+     */
+    readonly icon: _angular_core.InputSignal<string>;
+    /** Aria label for the spinner for accessibility. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmSpinner, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmSpinner, "hlm-spinner", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HlmSpinnerImports: readonly [typeof HlmSpinner];
+
+export { HlmSpinner, HlmSpinnerImports };

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

@@ -0,0 +1,54 @@
+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 { BrnSwitchSize } from '@spartan-ng/brain/switch';
+import { ClassValue } from 'clsx';
+
+declare const HLM_SWITCH_VALUE_ACCESSOR: {
+    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: _angular_core.Type<any>;
+    multi: boolean;
+};
+declare class HlmSwitch implements ControlValueAccessor {
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    /** The checked state of the switch. */
+    readonly checkedInput: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly checked: _angular_core.WritableSignal<boolean>;
+    /** Emits when the checked state of the switch changes. */
+    readonly checkedChange: _angular_core.OutputEmitterRef<boolean>;
+    /** The disabled state of the switch. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The size of the switch. */
+    readonly size: _angular_core.InputSignal<BrnSwitchSize>;
+    /** 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>;
+    protected readonly _disabled: _angular_core.WritableSignal<boolean>;
+    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<HlmSwitch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmSwitch, "hlm-switch", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "checkedInput": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "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; }; }, { "checkedChange": "checkedChange"; }, never, never, true, never>;
+}
+
+declare class HlmSwitchThumb {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmSwitchThumb, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmSwitchThumb, "brn-switch-thumb[hlm],[hlmSwitchThumb]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmSwitchImports: readonly [typeof HlmSwitch, typeof HlmSwitchThumb];
+
+export { HLM_SWITCH_VALUE_ACCESSOR, HlmSwitch, HlmSwitchImports, HlmSwitchThumb };

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

@@ -0,0 +1,82 @@
+import * as i0 from '@angular/core';
+
+declare class HlmTableContainer {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTableContainer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTableContainer, "div[hlmTableContainer]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <table> element.
+ */
+declare class HlmTable {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTable, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTable, "table[hlmTable]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <thead> element
+ * within an HlmTable context.
+ */
+declare class HlmTHead {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTHead, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTHead, "thead[hlmTHead],thead[hlmTableHeader]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <tbody> element
+ * within an HlmTable context.
+ */
+declare class HlmTBody {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTBody, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTBody, "tbody[hlmTBody],tbody[hlmTableBody]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <tfoot> element
+ * within an HlmTable context.
+ */
+declare class HlmTFoot {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTFoot, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTFoot, "tfoot[hlmTFoot],tfoot[hlmTableFooter]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <tr> element
+ * within an HlmTable context.
+ */
+declare class HlmTr {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTr, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTr, "tr[hlmTr],tr[hlmTableRow]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <th> element
+ * within an HlmTable context.
+ */
+declare class HlmTh {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTh, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTh, "th[hlmTh],th[hlmTableHead]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <td> element
+ * within an HlmTable context.
+ */
+declare class HlmTd {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTd, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTd, "td[hlmTd],td[hlmTableCell]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to apply Shadcn-like styling to a <caption> element
+ * within an HlmTable context.
+ */
+declare class HlmCaption {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCaption, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCaption, "caption[hlmCaption],caption[hlmTableCaption]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmTableImports: readonly [typeof HlmCaption, typeof HlmTableContainer, typeof HlmTable, typeof HlmTBody, typeof HlmTd, typeof HlmTFoot, typeof HlmTh, typeof HlmTHead, typeof HlmTr];
+
+export { HlmCaption, HlmTBody, HlmTFoot, HlmTHead, HlmTable, HlmTableContainer, HlmTableImports, HlmTd, HlmTh, HlmTr };

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

@@ -0,0 +1,66 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import * as i1 from '@spartan-ng/brain/tabs';
+import { BrnTabsPaginatedList, BrnTabsTrigger, BrnPaginatedTabHeaderItem } from '@spartan-ng/brain/tabs';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { ClassValue } from 'clsx';
+import { Observable } from 'rxjs';
+
+declare class HlmTabs {
+    readonly tab: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmTabs, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmTabs, "[hlmTabs],hlm-tabs", never, { "tab": { "alias": "tab"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnTabs; inputs: { "orientation": "orientation"; "activationMode": "activationMode"; "brnTabs": "tab"; }; outputs: { "tabActivated": "tabActivated"; }; }]>;
+}
+
+declare class HlmTabsContent {
+    readonly contentFor: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmTabsContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmTabsContent, "[hlmTabsContent]", never, { "contentFor": { "alias": "hlmTabsContent"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnTabsContent; inputs: { "brnTabsContent": "hlmTabsContent"; }; outputs: {}; }]>;
+}
+
+declare class HlmTabsContentLazy {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmTabsContentLazy, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmTabsContentLazy, "ng-template[hlmTabsContentLazy]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnTabsContentLazy; inputs: {}; outputs: {}; }]>;
+}
+
+declare const listVariants: (props?: ({
+    variant?: "default" | "line" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare class HlmTabsList {
+    readonly variant: _angular_core.InputSignal<"default" | "line" | null | undefined>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmTabsList, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmTabsList, "[hlmTabsList],hlm-tabs-list", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnTabsList; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmTabsPaginatedList extends BrnTabsPaginatedList {
+    constructor();
+    readonly items: _angular_core.Signal<readonly BrnTabsTrigger[]>;
+    /** Explicitly annotating type to avoid non-portable inferred type */
+    readonly itemsChanges: Observable<ReadonlyArray<BrnPaginatedTabHeaderItem>>;
+    readonly tabListContainer: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly tabList: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly tabListInner: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly nextPaginator: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly previousPaginator: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly tabListClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _tabListClass: _angular_core.Signal<string>;
+    readonly paginationButtonClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _paginationButtonClass: _angular_core.Signal<string>;
+    protected _itemSelected(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmTabsPaginatedList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmTabsPaginatedList, "hlm-paginated-tabs-list", never, { "tabListClass": { "alias": "tabListClass"; "required": false; "isSignal": true; }; "paginationButtonClass": { "alias": "paginationButtonClass"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
+}
+
+declare class HlmTabsTrigger {
+    readonly triggerFor: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmTabsTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmTabsTrigger, "[hlmTabsTrigger]", never, { "triggerFor": { "alias": "hlmTabsTrigger"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnTabsTrigger; inputs: { "brnTabsTrigger": "hlmTabsTrigger"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+declare const HlmTabsImports: readonly [typeof HlmTabs, typeof HlmTabsList, typeof HlmTabsTrigger, typeof HlmTabsContent, typeof HlmTabsContentLazy, typeof HlmTabsPaginatedList];
+
+export { HlmTabs, HlmTabsContent, HlmTabsContentLazy, HlmTabsImports, HlmTabsList, HlmTabsPaginatedList, HlmTabsTrigger, listVariants };

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

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

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

@@ -0,0 +1,34 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Type, ExistingProvider } from '@angular/core';
+import { NumberInput } from '@angular/cdk/coercion';
+import * as i1 from '@spartan-ng/brain/toggle-group';
+import * as yukit_web_helm_toggle_group from 'yukit-web/helm/toggle-group';
+
+declare class HlmToggleGroup {
+    readonly variant: _angular_core.InputSignal<"default" | "outline" | null | undefined>;
+    readonly size: _angular_core.InputSignal<"default" | "sm" | "lg" | null | undefined>;
+    readonly spacing: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmToggleGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmToggleGroup, "[hlmToggleGroup],hlm-toggle-group", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "spacing": { "alias": "spacing"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnToggleGroup; inputs: { "type": "type"; "value": "value"; "nullable": "nullable"; "disabled": "disabled"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+
+declare class HlmToggleGroupItem {
+    protected readonly _toggleGroup: yukit_web_helm_toggle_group.HlmToggleGroup;
+    readonly variant: _angular_core.InputSignal<"default" | "outline" | null | undefined>;
+    readonly size: _angular_core.InputSignal<"default" | "sm" | "lg" | null | undefined>;
+    protected readonly _variant: _angular_core.Signal<"default" | "outline" | null | undefined>;
+    protected readonly _size: _angular_core.Signal<"default" | "sm" | "lg" | null | undefined>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmToggleGroupItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmToggleGroupItem, "button[hlmToggleGroupItem]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnToggleGroupItem; inputs: { "id": "id"; "value": "value"; "disabled": "disabled"; "state": "state"; "aria-label": "aria-label"; "type": "type"; }; outputs: { "stateChange": "stateChange"; }; }]>;
+}
+
+declare const HlmToggleGroupToken: InjectionToken<HlmToggleGroup>;
+declare function injectHlmToggleGroup(): HlmToggleGroup;
+declare function provideHlmToggleGroup(toggleGroup: Type<HlmToggleGroup>): ExistingProvider;
+
+declare const HlmToggleGroupImports: readonly [typeof HlmToggleGroup, typeof HlmToggleGroupItem];
+
+export { HlmToggleGroup, HlmToggleGroupImports, HlmToggleGroupItem, HlmToggleGroupToken, injectHlmToggleGroup, provideHlmToggleGroup };

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

@@ -0,0 +1,22 @@
+import * as _angular_core 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/toggle';
+
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ToggleVariants = VariantProps<typeof toggleVariants>;
+declare class HlmToggle {
+    readonly variant: _angular_core.InputSignal<"default" | "outline" | null | undefined>;
+    readonly size: _angular_core.InputSignal<"default" | "sm" | "lg" | null | undefined>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmToggle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmToggle, "button[hlmToggle]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnToggle; inputs: { "id": "id"; "value": "value"; "disabled": "disabled"; "state": "state"; "aria-label": "aria-label"; "type": "type"; }; outputs: { "stateChange": "stateChange"; }; }]>;
+}
+
+declare const HlmToggleImports: readonly [typeof HlmToggle];
+
+export { HlmToggle, HlmToggleImports, toggleVariants };
+export type { ToggleVariants };

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

@@ -0,0 +1,17 @@
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import * as i0 from '@angular/core';
+import * as i1 from '@spartan-ng/brain/tooltip';
+
+declare const DEFAULT_TOOLTIP_SVG_CLASS = "bg-foreground fill-foreground z-50 block size-2.5 translate-y-[calc(-50%-2px)] rotate-45 rounded-[2px]";
+declare const DEFAULT_TOOLTIP_CONTENT_CLASSES: string;
+declare const tooltipPositionVariants: (props?: ({
+    position?: "top" | "bottom" | "left" | "right" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare class HlmTooltip {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmTooltip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmTooltip, "[hlmTooltip]", never, {}, {}, never, never, true, [{ directive: typeof i1.BrnTooltip; inputs: { "brnTooltip": "hlmTooltip"; "position": "position"; "hideDelay": "hideDelay"; "showDelay": "showDelay"; "tooltipDisabled": "tooltipDisabled"; }; outputs: {}; }]>;
+}
+
+declare const HlmTooltipImports: readonly [typeof HlmTooltip];
+
+export { DEFAULT_TOOLTIP_CONTENT_CLASSES, DEFAULT_TOOLTIP_SVG_CLASS, HlmTooltip, HlmTooltipImports, tooltipPositionVariants };

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

@@ -0,0 +1,89 @@
+import * as i0 from '@angular/core';
+
+declare const hlmBlockquote = "mt-6 border-border border-l-2 pl-6 italic";
+declare class HlmBlockquote {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmBlockquote, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmBlockquote, "[hlmBlockquote]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmCode = "relative rounded bg-muted px-[0.3rem] py-[0.2rem] font-mono text-sm font-semibold";
+declare class HlmCode {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmCode, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmCode, "[hlmCode]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmH1 = "scroll-m-20 text-4xl font-extrabold tracking-tight lg:text-5xl";
+declare class HlmH1 {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmH1, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmH1, "[hlmH1]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmH2 = "scroll-m-20 border-border border-b pb-2 text-3xl font-semibold tracking-tight transition-colors first:mt-0";
+declare class HlmH2 {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmH2, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmH2, "[hlmH2]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmH3 = "scroll-m-20 text-2xl font-semibold tracking-tight";
+declare class HlmH3 {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmH3, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmH3, "[hlmH3]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmH4 = "scroll-m-20 text-xl font-semibold tracking-tight";
+declare class HlmH4 {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmH4, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmH4, "[hlmH4]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmLarge = "text-lg font-semibold";
+declare class HlmLarge {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmLarge, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmLarge, "[hlmLarge]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmLead = "text-xl text-muted-foreground";
+declare class HlmLead {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmLead, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmLead, "[hlmLead]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmMuted = "text-sm text-muted-foreground";
+declare class HlmMuted {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmMuted, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmMuted, "[hlmMuted]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmP = "leading-7 [&:not(:first-child)]:mt-6";
+declare class HlmP {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmP, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmP, "[hlmP]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmSmall = "text-sm font-medium leading-none";
+declare class HlmSmall {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmSmall, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmSmall, "[hlmSmall]", never, {}, {}, never, never, true, never>;
+}
+
+declare const hlmUl = "my-6 ml-6 list-disc [&>li]:mt-2";
+declare class HlmUl {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmUl, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmUl, "[hlmUl]", never, {}, {}, never, never, true, never>;
+}
+
+declare const HlmTypographyImports: (typeof HlmBlockquote)[];
+
+export { HlmBlockquote, HlmCode, HlmH1, HlmH2, HlmH3, HlmH4, HlmLarge, HlmLead, HlmMuted, HlmP, HlmSmall, HlmTypographyImports, HlmUl, hlmBlockquote, hlmCode, hlmH1, hlmH2, hlmH3, hlmH4, hlmLarge, hlmLead, hlmMuted, hlmP, hlmSmall, hlmUl };

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

@@ -0,0 +1,44 @@
+import { ElementRef, Injector, EnvironmentProviders } from '@angular/core';
+import { ClassValue } from 'clsx';
+
+declare function hlm(...inputs: ClassValue[]): string;
+/**
+ * This function dynamically adds and removes classes for a given element without requiring
+ * the a class binding (e.g. `[class]="..."`) which may interfere with other class bindings.
+ *
+ * 1. This will merge the existing classes on the element with the new classes.
+ * 2. It will also remove any classes that were previously added by this function but are no longer present in the new classes.
+ * 3. Multiple calls to this function on the same element will be merged efficiently.
+ */
+declare function classes(computed: () => ClassValue[] | string, options?: ClassesOptions): void;
+interface ClassesOptions {
+    elementRef?: ElementRef<HTMLElement>;
+    injector?: Injector;
+}
+
+/**
+ * Provides default configuration for Spartan Helm components.
+ *
+ * This utility configures the Angular CDK overlay to disable the `usePopover`
+ * behavior introduced in Angular 21, which causes CDK overlay-based components
+ * (sheets, dialogs, tooltips, etc.) to render above `position: fixed` elements
+ * like `<hlm-toaster>`.
+ *
+ * @returns {EnvironmentProviders} Environment providers to be added to the application config.
+ *
+ * @example
+ * ```ts
+ * // app.config.ts
+ * import { provideSpartanHlm } from 'yukit-web/helm/utils';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideSpartanHlm(),
+ *     // ... other providers
+ *   ],
+ * };
+ * ```
+ */
+declare function provideSpartanHlm(): EnvironmentProviders;
+
+export { classes, hlm, provideSpartanHlm };