@edsis/ui 0.0.2

package/types/edsis-ui-spinner.d.ts

@@ -0,0 +1,13 @@
+import * as _angular_core from '@angular/core';
+
+declare class SpinnerComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    readonly decorative: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpinnerComponent, "ui-spinner", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "decorative": { "alias": "decorative"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { SpinnerComponent };

package/types/edsis-ui-switch.d.ts

@@ -0,0 +1,40 @@
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { MatSlideToggleChange } from '@angular/material/slide-toggle';
+
+type SwitchSize = 'default' | 'sm';
+/**
+ * Switch — shadcn-styled wrapper around `mat-slide-toggle`.
+ */
+declare class SwitchComponent implements ControlValueAccessor {
+    readonly id: _angular_core.InputSignal<string>;
+    readonly name: _angular_core.InputSignal<string | null>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaDescribedby: _angular_core.InputSignal<string | null>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    readonly ariaInvalid: _angular_core.InputSignal<string | boolean | null>;
+    readonly size: _angular_core.InputSignal<SwitchSize>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly checkedChange: _angular_core.OutputEmitterRef<boolean>;
+    private readonly ref;
+    protected readonly checked: _angular_core.WritableSignal<boolean>;
+    protected readonly disabledState: _angular_core.WritableSignal<boolean>;
+    protected readonly ariaInvalidAttr: _angular_core.Signal<string | null>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    private onChange;
+    private onTouched;
+    protected handleChange(e: MatSlideToggleChange): void;
+    focus(): void;
+    writeValue(v: boolean): void;
+    registerOnChange(fn: (v: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(d: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SwitchComponent, "ui-switch", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaInvalid": { "alias": "aria-invalid"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; }, never, ["*"], true, never>;
+}
+
+export { SwitchComponent };
+export type { SwitchSize };

package/types/edsis-ui-table.d.ts

@@ -0,0 +1,52 @@
+import * as _angular_core from '@angular/core';
+
+declare class TableComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableComponent, "ui-table", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TableHeaderComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableHeaderComponent, "thead[ui-table-header]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TableBodyComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableBodyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableBodyComponent, "tbody[ui-table-body]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TableFooterComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableFooterComponent, "tfoot[ui-table-footer]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TableRowComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableRowComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableRowComponent, "tr[ui-table-row]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TableHeadComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableHeadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableHeadComponent, "th[ui-table-head]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TableCellComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableCellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableCellComponent, "td[ui-table-cell]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TableCaptionComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableCaptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableCaptionComponent, "caption[ui-table-caption]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { TableBodyComponent, TableCaptionComponent, TableCellComponent, TableComponent, TableFooterComponent, TableHeadComponent, TableHeaderComponent, TableRowComponent };

package/types/edsis-ui-tabs.d.ts

@@ -0,0 +1,92 @@
+import * as _angular_core from '@angular/core';
+import { model } from '@angular/core';
+
+type TabsListVariant = 'default' | 'line';
+/**
+ * Shared state for a tabs group. Children read the active value and register
+ * themselves so the group can drive roving-tabindex keyboard navigation.
+ */
+declare abstract class TabsContextBase {
+    abstract value: ReturnType<typeof model<string | null>>;
+    abstract register(element: HTMLElement, value: () => string, disabled: () => boolean): void;
+    abstract unregister(element: HTMLElement): void;
+    abstract activate(value: string, focus?: boolean): void;
+    abstract focusNext(from: HTMLElement, offset: number): void;
+    abstract focusFirst(): void;
+    abstract focusLast(): void;
+    abstract triggerId(value: string): string;
+    abstract contentId(value: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsContextBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabsContextBase, never, never, {}, {}, never, never, true, never>;
+}
+declare abstract class TabsListContextBase {
+    abstract listVariant(): TabsListVariant;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsListContextBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabsListContextBase, never, never, {}, {}, never, never, true, never>;
+}
+declare class TabsComponent extends TabsContextBase {
+    readonly value: _angular_core.ModelSignal<string | null>;
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly idPrefix;
+    private readonly triggers;
+    protected readonly classes: _angular_core.Signal<string>;
+    register(element: HTMLElement, value: () => string, disabled: () => boolean): void;
+    unregister(element: HTMLElement): void;
+    activate(value: string, focus?: boolean): void;
+    focusNext(from: HTMLElement, offset: number): void;
+    focusFirst(): void;
+    focusLast(): void;
+    triggerId(value: string): string;
+    contentId(value: string): string;
+    private enabledTriggers;
+    private triggerForValue;
+    private normalizeValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsComponent, "ui-tabs", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["*"], true, never>;
+}
+declare class TabsListComponent extends TabsListContextBase {
+    protected readonly ctx: TabsComponent;
+    readonly variant: _angular_core.InputSignal<TabsListVariant>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    listVariant(): TabsListVariant;
+    private variantClasses;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsListComponent, "ui-tabs-list", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TabsTriggerComponent {
+    protected readonly ctx: TabsComponent;
+    private readonly list;
+    private readonly el;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly selected: _angular_core.Signal<boolean>;
+    protected readonly triggerId: _angular_core.Signal<string>;
+    protected readonly contentId: _angular_core.Signal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected onClick(): void;
+    protected onArrow(e: KeyboardEvent, delta: number, axis: 'horizontal' | 'vertical'): void;
+    protected onHome(e: KeyboardEvent): void;
+    protected onEnd(e: KeyboardEvent): void;
+    private variantClasses;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsTriggerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsTriggerComponent, "button[ui-tabs-trigger]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TabsContentComponent {
+    private readonly ctx;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly active: _angular_core.Signal<boolean>;
+    protected readonly triggerId: _angular_core.Signal<string>;
+    protected readonly contentId: _angular_core.Signal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsContentComponent, "ui-tabs-content", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { TabsComponent, TabsContentComponent, TabsContextBase, TabsListComponent, TabsListContextBase, TabsTriggerComponent };
+export type { TabsListVariant };

package/types/edsis-ui-textarea.d.ts

@@ -0,0 +1,12 @@
+import * as _angular_core from '@angular/core';
+
+declare class TextareaComponent {
+    private readonly el;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextareaComponent, "textarea[ui-textarea]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { TextareaComponent };

package/types/edsis-ui-timeline.d.ts

@@ -0,0 +1,63 @@
+import * as _angular_core from '@angular/core';
+
+type TimelineAlign = 'start' | 'baseline' | 'center' | 'end';
+type TimelineSize = 'default' | 'lg';
+type TimelineStatus = 'complete' | 'current' | 'incomplete';
+type TimelineIndicatorVariant = 'default' | 'bare';
+type TimelineIndicatorColor = 'red' | 'orange' | 'amber' | 'yellow' | 'lime' | 'green' | 'emerald' | 'teal' | 'cyan' | 'sky' | 'blue' | 'indigo' | 'violet' | 'purple' | 'fuchsia' | 'pink' | 'rose';
+declare class TimelineComponent {
+    readonly horizontal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly align: _angular_core.InputSignal<TimelineAlign>;
+    readonly size: _angular_core.InputSignal<TimelineSize>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimelineComponent, "ui-timeline", never, { "horizontal": { "alias": "horizontal"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TimelineItemComponent {
+    private readonly timeline;
+    readonly status: _angular_core.InputSignal<TimelineStatus | null>;
+    readonly align: _angular_core.InputSignal<TimelineAlign | null>;
+    readonly size: _angular_core.InputSignal<TimelineSize | null>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly orientation: _angular_core.Signal<"horizontal" | "vertical">;
+    readonly resolvedAlign: _angular_core.Signal<TimelineAlign>;
+    readonly resolvedSize: _angular_core.Signal<TimelineSize>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimelineItemComponent, "ui-timeline-item", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TimelineIndicatorComponent {
+    private readonly item;
+    readonly variant: _angular_core.InputSignal<TimelineIndicatorVariant>;
+    readonly status: _angular_core.InputSignal<TimelineStatus | null>;
+    readonly color: _angular_core.InputSignal<TimelineIndicatorColor | null>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly resolvedStatus: _angular_core.Signal<TimelineStatus>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineIndicatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimelineIndicatorComponent, "ui-timeline-indicator", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TimelineContentComponent {
+    private readonly item;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimelineContentComponent, "ui-timeline-content", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TimelineBlockComponent {
+    private readonly item;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineBlockComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimelineBlockComponent, "ui-timeline-block", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TimelineSubgridComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineSubgridComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimelineSubgridComponent, "ui-timeline-subgrid", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { TimelineBlockComponent, TimelineComponent, TimelineContentComponent, TimelineIndicatorComponent, TimelineItemComponent, TimelineSubgridComponent };
+export type { TimelineAlign, TimelineIndicatorColor, TimelineIndicatorVariant, TimelineSize, TimelineStatus };

package/types/edsis-ui-toast.d.ts

@@ -0,0 +1,38 @@
+import { MatSnackBarConfig, MatSnackBarRef } from '@angular/material/snack-bar';
+import * as i0 from '@angular/core';
+
+type ToastVariant = 'default' | 'destructive' | 'success' | 'info' | 'warning';
+type ToastMessage<T> = string | ((value: T) => string);
+interface ToastPromiseMessages<T> {
+    readonly loading: string;
+    readonly success: ToastMessage<T>;
+    readonly error: ToastMessage<unknown>;
+}
+interface ToastOptions {
+    readonly title?: string;
+    readonly description?: string;
+    readonly action?: string;
+    readonly variant?: ToastVariant;
+    readonly durationMs?: number | null;
+    readonly horizontalPosition?: MatSnackBarConfig['horizontalPosition'];
+    readonly verticalPosition?: MatSnackBarConfig['verticalPosition'];
+}
+/**
+ * Thin, opinionated wrapper over MatSnackBar that applies shadcn styling
+ * via `panelClass: ui-toast-panel` and variant data attributes.
+ */
+declare class ToastService {
+    private readonly snack;
+    show(options: ToastOptions): MatSnackBarRef<unknown>;
+    success(opts: Omit<ToastOptions, 'variant'>): MatSnackBarRef<unknown>;
+    info(opts: Omit<ToastOptions, 'variant'>): MatSnackBarRef<unknown>;
+    warning(opts: Omit<ToastOptions, 'variant'>): MatSnackBarRef<unknown>;
+    error(opts: Omit<ToastOptions, 'variant'>): MatSnackBarRef<unknown>;
+    promise<T>(taskOrFactory: Promise<T> | (() => Promise<T>), messages: ToastPromiseMessages<T>): Promise<T>;
+    dismiss(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
+}
+
+export { ToastService };
+export type { ToastMessage, ToastOptions, ToastPromiseMessages, ToastVariant };

package/types/edsis-ui-toggle-group.d.ts

@@ -0,0 +1,89 @@
+import * as _angular_core from '@angular/core';
+import { ToggleVariant, ToggleSize } from '@edsis/ui/toggle';
+
+type ToggleGroupType = 'single' | 'multiple';
+type ToggleGroupOrientation = 'horizontal' | 'vertical';
+type ToggleGroupVariant = ToggleVariant;
+type ToggleGroupSize = ToggleSize;
+declare abstract class ToggleGroupContextBase {
+    abstract groupType(): ToggleGroupType;
+    abstract groupOrientation(): ToggleGroupOrientation;
+    abstract groupVariant(): ToggleGroupVariant;
+    abstract groupSize(): ToggleGroupSize;
+    abstract groupDisabled(): boolean;
+    abstract isRtl(): boolean;
+    abstract register(element: HTMLElement, value: () => string, disabled: () => boolean): void;
+    abstract unregister(element: HTMLElement): void;
+    abstract isSelected(value: string): boolean;
+    abstract toggle(value: string): void;
+    abstract tabindexFor(value: string, disabled: boolean): number;
+    abstract markFocused(value: string): void;
+    abstract focusNext(from: HTMLElement, offset: number): void;
+    abstract focusFirst(): void;
+    abstract focusLast(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleGroupContextBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToggleGroupContextBase, never, never, {}, {}, never, never, true, never>;
+}
+declare class ToggleGroupComponent extends ToggleGroupContextBase {
+    readonly type: _angular_core.InputSignal<ToggleGroupType>;
+    readonly value: _angular_core.ModelSignal<string | null>;
+    readonly values: _angular_core.ModelSignal<string[]>;
+    readonly orientation: _angular_core.InputSignal<ToggleGroupOrientation>;
+    readonly variant: _angular_core.InputSignal<ToggleVariant>;
+    readonly size: _angular_core.InputSignal<ToggleSize>;
+    readonly spacing: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly loop: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly dir: _angular_core.InputSignal<"ltr" | "rtl" | null>;
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly host;
+    private readonly focusedValue;
+    private readonly registrationVersion;
+    private readonly items;
+    private readonly resolvedSpacing;
+    private readonly tabStopValue;
+    protected readonly classes: _angular_core.Signal<string>;
+    groupType(): ToggleGroupType;
+    groupOrientation(): ToggleGroupOrientation;
+    groupVariant(): ToggleGroupVariant;
+    groupSize(): ToggleGroupSize;
+    groupDisabled(): boolean;
+    isRtl(): boolean;
+    register(element: HTMLElement, value: () => string, disabled: () => boolean): void;
+    unregister(element: HTMLElement): void;
+    isSelected(value: string): boolean;
+    toggle(value: string): void;
+    tabindexFor(value: string, disabled: boolean): number;
+    markFocused(value: string): void;
+    focusNext(from: HTMLElement, offset: number): void;
+    focusFirst(): void;
+    focusLast(): void;
+    private enabledItems;
+    private itemForValue;
+    private bumpRegistrationVersion;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleGroupComponent, "ui-toggle-group", never, { "type": { "alias": "type"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "values": { "alias": "values"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "spacing": { "alias": "spacing"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "values": "valuesChange"; }, never, ["*"], true, never>;
+}
+declare class ToggleGroupItemDirective {
+    protected readonly ctx: ToggleGroupContextBase;
+    private readonly element;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly selected: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected isDisabled(): boolean;
+    protected onClick(): void;
+    protected onFocus(): void;
+    protected onArrow(event: KeyboardEvent, offset: number): void;
+    protected onHorizontalArrow(event: KeyboardEvent, offset: number): void;
+    protected onHome(event: KeyboardEvent): void;
+    protected onEnd(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleGroupItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToggleGroupItemDirective, "button[ui-toggle-group-item]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { ToggleGroupComponent, ToggleGroupContextBase, ToggleGroupItemDirective };
+export type { ToggleGroupOrientation, ToggleGroupSize, ToggleGroupType, ToggleGroupVariant };

package/types/edsis-ui-toggle.d.ts

@@ -0,0 +1,25 @@
+import * as _angular_core from '@angular/core';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ToggleVariant = NonNullable<VariantProps<typeof toggleVariants>['variant']>;
+type ToggleSize = NonNullable<VariantProps<typeof toggleVariants>['size']>;
+
+declare class ToggleComponent {
+    readonly pressed: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly variant: _angular_core.InputSignal<ToggleVariant>;
+    readonly size: _angular_core.InputSignal<ToggleSize>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleComponent, "button[ui-toggle]", never, { "pressed": { "alias": "pressed"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "pressed": "pressedChange"; }, never, ["*"], true, never>;
+}
+
+export { ToggleComponent, toggleVariants };
+export type { ToggleSize, ToggleVariant };

package/types/edsis-ui-tooltip.d.ts

@@ -0,0 +1,89 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, TemplateRef } from '@angular/core';
+import * as i1 from '@angular/material/tooltip';
+export { TooltipPosition } from '@angular/material/tooltip';
+
+type TooltipSide = 'top' | 'right' | 'bottom' | 'left';
+type TooltipAlign = 'start' | 'center' | 'end';
+interface TooltipDefaults {
+    readonly side: Signal<TooltipSide>;
+    readonly align: Signal<TooltipAlign>;
+    readonly sideOffset: Signal<number>;
+    readonly openDelay: Signal<number>;
+    readonly closeDelay: Signal<number>;
+}
+declare const TOOLTIP_DEFAULTS: InjectionToken<TooltipDefaults>;
+declare class TooltipComponent implements TooltipDefaults {
+    readonly side: _angular_core.InputSignal<TooltipSide>;
+    readonly align: _angular_core.InputSignal<TooltipAlign>;
+    readonly sideOffset: _angular_core.InputSignal<number>;
+    readonly openDelay: _angular_core.InputSignal<number>;
+    readonly closeDelay: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TooltipComponent, "ui-tooltip", never, { "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TooltipContentDirective {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipContentDirective, "ng-template[uiTooltipContent]", ["uiTooltipContent"], {}, {}, never, never, true, never>;
+}
+
+declare class TooltipTriggerDirective {
+    private readonly overlay;
+    private readonly vcr;
+    private readonly el;
+    private readonly destroyRef;
+    private readonly defaults;
+    readonly uiTooltipTrigger: _angular_core.InputSignal<TooltipContentDirective>;
+    readonly side: _angular_core.InputSignal<TooltipSide | undefined>;
+    readonly align: _angular_core.InputSignal<TooltipAlign | undefined>;
+    readonly sideOffset: _angular_core.InputSignal<number | undefined>;
+    readonly openDelay: _angular_core.InputSignal<number | undefined>;
+    readonly closeDelay: _angular_core.InputSignal<number | undefined>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly contentId: _angular_core.WritableSignal<string | null>;
+    private overlayRef;
+    private openTimeoutId;
+    private closeTimeoutId;
+    private isPointerInsideTrigger;
+    private isTriggerFocused;
+    private isDestroying;
+    constructor();
+    handlePointerEnter(): void;
+    handlePointerLeave(event: PointerEvent): void;
+    handleFocusIn(): void;
+    handleFocusOut(event: FocusEvent): void;
+    open(): void;
+    close(): void;
+    private bindOverlayLifecycle;
+    private scheduleOpen;
+    private scheduleClose;
+    private clearOpenTimeout;
+    private clearCloseTimeout;
+    private oppositeSide;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipTriggerDirective, "[uiTooltipTrigger]", ["uiTooltipTrigger"], { "uiTooltipTrigger": { "alias": "uiTooltipTrigger"; "required": true; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "openedChange": "openedChange"; }, never, never, true, never>;
+}
+
+/**
+ * Shadcn-styled tooltip directive. Thin wrapper around `matTooltip` that
+ * forces the shadcn panel class and sensible defaults.
+ *
+ * @example
+ * <button ui-button [uiTooltip]="'Save changes'" uiTooltipPosition="above">Save</button>
+ */
+declare class TooltipDirective {
+    private readonly tooltip;
+    readonly uiTooltip: _angular_core.InputSignal<string>;
+    constructor();
+    show(): void;
+    hide(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipDirective, "[uiTooltip]", ["uiTooltip"], { "uiTooltip": { "alias": "uiTooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.MatTooltip; inputs: { "matTooltipPosition": "uiTooltipPosition"; "matTooltipDisabled": "uiTooltipDisabled"; "matTooltipShowDelay": "uiTooltipShowDelay"; "matTooltipHideDelay": "uiTooltipHideDelay"; "matTooltipTouchGestures": "uiTooltipTouchGestures"; }; outputs: {}; }]>;
+}
+
+export { TOOLTIP_DEFAULTS, TooltipComponent, TooltipContentDirective, TooltipDirective, TooltipTriggerDirective };
+export type { TooltipAlign, TooltipDefaults, TooltipSide };

package/types/edsis-ui-utils.d.ts

@@ -0,0 +1,5 @@
+import { ClassValue } from 'clsx';
+
+declare function cn(...inputs: ClassValue[]): string;
+
+export { cn };

package/types/edsis-ui.d.ts

@@ -0,0 +1,2 @@
+
+export { };