@edsis/ui 0.0.2

package/types/edsis-ui-input-otp.d.ts

@@ -0,0 +1,136 @@
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare const REGEXP_ONLY_DIGITS: RegExp;
+declare const REGEXP_ONLY_DIGITS_AND_CHARS: RegExp;
+declare abstract class InputOtpContextBase {
+    abstract maxLength(): number;
+    abstract slotId(index: number): string;
+    abstract slotValue(index: number): string;
+    abstract slotAriaLabel(index: number): string;
+    abstract slotAriaLabelledBy(index: number): string | null;
+    abstract slotAriaDescribedBy(): string | null;
+    abstract slotInputMode(): string | null;
+    abstract slotAutocomplete(index: number): string | null;
+    abstract isDisabled(): boolean;
+    abstract isRequired(): boolean;
+    abstract isInvalid(): boolean;
+    abstract isActive(index: number): boolean;
+    abstract handleSlotFocus(index: number): void;
+    abstract handleSlotInput(index: number, value: string): void;
+    abstract handleSlotKeydown(index: number, event: KeyboardEvent): void;
+    abstract handleSlotPaste(index: number, event: ClipboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputOtpContextBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InputOtpContextBase, never, never, {}, {}, never, never, true, never>;
+}
+declare class InputOtpGroupComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputOtpGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputOtpGroupComponent, "ui-input-otp-group", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class InputOtpSeparatorComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputOtpSeparatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputOtpSeparatorComponent, "ui-input-otp-separator", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class InputOtpSlotComponent {
+    private readonly ctx;
+    readonly index: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly inputRef;
+    protected readonly maxLength: _angular_core.Signal<number>;
+    protected readonly character: _angular_core.Signal<string>;
+    protected readonly active: _angular_core.Signal<boolean>;
+    protected readonly filled: _angular_core.Signal<boolean>;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    protected readonly required: _angular_core.Signal<boolean>;
+    protected readonly inputId: _angular_core.Signal<string>;
+    protected readonly inputMode: _angular_core.Signal<string | null>;
+    protected readonly autocomplete: _angular_core.Signal<string | null>;
+    protected readonly ariaLabel: _angular_core.Signal<string>;
+    protected readonly ariaLabelledBy: _angular_core.Signal<string | null>;
+    protected readonly ariaDescribedBy: _angular_core.Signal<string | null>;
+    protected readonly effectiveInvalid: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    focus(select?: boolean): void;
+    protected handleFocus(): void;
+    protected handleInput(event: Event): void;
+    protected handleKeydown(event: KeyboardEvent): void;
+    protected handlePaste(event: ClipboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputOtpSlotComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputOtpSlotComponent, "ui-input-otp-slot", never, { "index": { "alias": "index"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "invalid": { "alias": "aria-invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class InputOtpComponent extends InputOtpContextBase implements ControlValueAccessor, OnInit {
+    private readonly host;
+    private readonly injector;
+    private readonly formFieldContext;
+    readonly maxLengthInput: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    readonly pattern: _angular_core.InputSignal<string | RegExp | null>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    readonly ariaDescribedby: _angular_core.InputSignal<string | null>;
+    readonly inputMode: _angular_core.InputSignal<string | null>;
+    readonly autocomplete: _angular_core.InputSignal<string | null>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalidInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    private readonly generatedId;
+    private readonly internalValue;
+    private readonly disabledState;
+    private readonly activeIndex;
+    private readonly slots;
+    private readonly compiledPattern;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    private readonly displayValue;
+    private ngControl;
+    private onChange;
+    private onTouched;
+    ngOnInit(): void;
+    maxLength(): number;
+    slotId(index: number): string;
+    slotValue(index: number): string;
+    slotAriaLabel(index: number): string;
+    slotAriaLabelledBy(index: number): string | null;
+    slotAriaDescribedBy(): string | null;
+    slotInputMode(): string | null;
+    slotAutocomplete(index: number): string | null;
+    isDisabled(): boolean;
+    isRequired(): boolean;
+    isInvalid(): boolean;
+    isActive(index: number): boolean;
+    handleSlotFocus(index: number): void;
+    handleSlotInput(index: number, value: string): void;
+    handleSlotKeydown(index: number, event: KeyboardEvent): void;
+    handleSlotPaste(index: number, event: ClipboardEvent): void;
+    focus(): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    protected describedBy(): string | null;
+    protected handleFocusOut(event: FocusEvent): void;
+    private commitValue;
+    private replaceAt;
+    private removeAt;
+    private applyFragment;
+    private focusSlot;
+    private toCharArray;
+    private serialize;
+    private normalizeValue;
+    private filterCharacters;
+    private acceptsCharacter;
+    private isRtl;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputOtpComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputOtpComponent, "ui-input-otp", never, { "maxLengthInput": { "alias": "maxLength"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "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; }; "inputMode": { "alias": "inputmode"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalidInput": { "alias": "aria-invalid"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, ["slots"], ["*"], true, never>;
+}
+
+export { InputOtpComponent, InputOtpGroupComponent, InputOtpSeparatorComponent, InputOtpSlotComponent, REGEXP_ONLY_DIGITS, REGEXP_ONLY_DIGITS_AND_CHARS };

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

@@ -0,0 +1,16 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Styled native `<input>`. Works with Angular's DefaultValueAccessor,
+ * so `ngModel` and reactive forms just work.
+ */
+declare class InputComponent {
+    private readonly el;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputComponent, "input[ui-input]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { InputComponent };

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

@@ -0,0 +1,88 @@
+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 itemVariants: (props?: ({
+    variant?: "default" | "outline" | "muted" | null | undefined;
+    size?: "default" | "sm" | "xs" | null | undefined;
+    interactive?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const itemMediaVariants: (props?: ({
+    variant?: "default" | "icon" | "image" | null | undefined;
+    size?: "default" | "sm" | "xs" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ItemVariant = NonNullable<VariantProps<typeof itemVariants>['variant']>;
+type ItemSize = NonNullable<VariantProps<typeof itemVariants>['size']>;
+type ItemMediaVariant = NonNullable<VariantProps<typeof itemMediaVariants>['variant']>;
+
+declare class ItemComponent {
+    readonly variant: _angular_core.InputSignal<ItemVariant>;
+    readonly size: _angular_core.InputSignal<ItemSize>;
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly host;
+    protected readonly interactive: boolean;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemComponent, "ui-item, [ui-item]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ItemGroupComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemGroupComponent, "ui-item-group", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ItemSeparatorComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemSeparatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemSeparatorComponent, "ui-item-separator", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ItemHeaderComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemHeaderComponent, "ui-item-header", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ItemMediaComponent {
+    readonly variant: _angular_core.InputSignal<ItemMediaVariant>;
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly item;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemMediaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemMediaComponent, "ui-item-media", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ItemContentComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemContentComponent, "ui-item-content", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ItemTitleComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly item;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemTitleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemTitleComponent, "ui-item-title", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ItemDescriptionComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly item;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemDescriptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemDescriptionComponent, "ui-item-description", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ItemActionsComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemActionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemActionsComponent, "ui-item-actions", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ItemFooterComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemFooterComponent, "ui-item-footer", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { ItemActionsComponent, ItemComponent, ItemContentComponent, ItemDescriptionComponent, ItemFooterComponent, ItemGroupComponent, ItemHeaderComponent, ItemMediaComponent, ItemSeparatorComponent, ItemTitleComponent, itemMediaVariants, itemVariants };
+export type { ItemMediaVariant, ItemSize, ItemVariant };

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

@@ -0,0 +1,70 @@
+import * as _angular_core from '@angular/core';
+
+type KanbanColumnWidth = 'sm' | 'default' | 'lg';
+declare class KanbanComponent {
+    readonly columnWidth: _angular_core.InputSignal<KanbanColumnWidth>;
+    readonly dense: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KanbanComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KanbanComponent, "ui-kanban", never, { "columnWidth": { "alias": "columnWidth"; "required": false; "isSignal": true; }; "dense": { "alias": "dense"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class KanbanColumnComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KanbanColumnComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KanbanColumnComponent, "ui-kanban-column", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class KanbanColumnHeaderComponent {
+    readonly heading: _angular_core.InputSignal<string>;
+    readonly subheading: _angular_core.InputSignal<string>;
+    readonly count: _angular_core.InputSignal<string | number | null>;
+    readonly badge: _angular_core.InputSignal<string>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly displayCount: _angular_core.Signal<string | number | null>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KanbanColumnHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KanbanColumnHeaderComponent, "ui-kanban-column-header", never, { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "subheading": { "alias": "subheading"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["ui-kanban-column-actions,[ui-kanban-column-actions]", "*"], true, never>;
+}
+declare class KanbanColumnActionsComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KanbanColumnActionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KanbanColumnActionsComponent, "ui-kanban-column-actions, [ui-kanban-column-actions]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class KanbanColumnCardsComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KanbanColumnCardsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KanbanColumnCardsComponent, "ui-kanban-column-cards", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class KanbanColumnFooterComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KanbanColumnFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KanbanColumnFooterComponent, "ui-kanban-column-footer", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class KanbanCardComponent {
+    readonly heading: _angular_core.InputSignal<string>;
+    readonly selected: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KanbanCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KanbanCardComponent, "ui-kanban-card, button[ui-kanban-card], a[ui-kanban-card]", never, { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["ui-kanban-card-header,[ui-kanban-card-header]", "ui-kanban-card-footer,[ui-kanban-card-footer]", "*"], true, never>;
+}
+declare class KanbanCardHeaderComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KanbanCardHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KanbanCardHeaderComponent, "ui-kanban-card-header, [ui-kanban-card-header]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class KanbanCardFooterComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KanbanCardFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KanbanCardFooterComponent, "ui-kanban-card-footer, [ui-kanban-card-footer]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { KanbanCardComponent, KanbanCardFooterComponent, KanbanCardHeaderComponent, KanbanColumnActionsComponent, KanbanColumnCardsComponent, KanbanColumnComponent, KanbanColumnFooterComponent, KanbanColumnHeaderComponent, KanbanComponent };
+export type { KanbanColumnWidth };

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

@@ -0,0 +1,16 @@
+import * as _angular_core from '@angular/core';
+
+declare class KbdComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbdComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbdComponent, "ui-kbd, [ui-kbd]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class KbdGroupComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbdGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbdGroupComponent, "ui-kbd-group, [ui-kbd-group]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { KbdComponent, KbdGroupComponent };

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

@@ -0,0 +1,11 @@
+import * as _angular_core from '@angular/core';
+
+declare class LabelComponent {
+    readonly for: _angular_core.InputSignal<string | null>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LabelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LabelComponent, "ui-label, label[ui-label]", never, { "for": { "alias": "for"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { LabelComponent };

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

@@ -0,0 +1,67 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+
+type MenubarAlign = 'start' | 'center' | 'end';
+declare class MenubarComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    readonly loop: _angular_core.InputSignal<boolean>;
+    private readonly triggers;
+    private readonly host;
+    private readonly activeTrigger;
+    private readonly openTrigger;
+    protected readonly classes: _angular_core.Signal<string>;
+    setActiveTrigger(trigger: MenubarTriggerDirective): void;
+    tabIndexFor(trigger: MenubarTriggerDirective): number;
+    hasOpenTrigger(except?: MenubarTriggerDirective): boolean;
+    notifyOpen(trigger: MenubarTriggerDirective): void;
+    notifyClosed(trigger: MenubarTriggerDirective): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    private enabledTriggers;
+    private resolveTrigger;
+    private moveFocus;
+    private nextIndex;
+    private horizontalStep;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenubarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenubarComponent, "ui-menubar", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; }, {}, ["triggers"], ["*"], true, never>;
+}
+declare class MenubarMenuComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenubarMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenubarMenuComponent, "ui-menubar-menu", never, {}, {}, never, ["*"], true, never>;
+}
+declare class MenubarContentDirective {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenubarContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenubarContentDirective, "ng-template[uiMenubarContent]", ["uiMenubarContent"], {}, {}, never, never, true, never>;
+}
+declare class MenubarTriggerDirective {
+    readonly uiMenubarTrigger: _angular_core.InputSignal<MenubarContentDirective>;
+    readonly align: _angular_core.InputSignal<MenubarAlign>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    private readonly overlay;
+    private readonly vcr;
+    private readonly el;
+    private readonly menubar;
+    private readonly destroyRef;
+    private overlayRef;
+    toggle(): void;
+    open(options?: {
+        focusFirstItem?: boolean;
+    }): void;
+    close(options?: {
+        restoreFocus?: boolean;
+    }): void;
+    focus(): void;
+    containsTarget(target: EventTarget | null): boolean;
+    protected tabIndex(): number;
+    protected openFromKeyboard(event: KeyboardEvent, focusFirstItem: boolean): void;
+    protected syncActiveState(): void;
+    protected openFromHover(): void;
+    private focusFirstItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenubarTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenubarTriggerDirective, "[uiMenubarTrigger]", ["uiMenubarTrigger"], { "uiMenubarTrigger": { "alias": "uiMenubarTrigger"; "required": true; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "openedChange": "openedChange"; }, never, never, true, never>;
+}
+
+export { MenubarComponent, MenubarContentDirective, MenubarMenuComponent, MenubarTriggerDirective };
+export type { MenubarAlign };

package/types/edsis-ui-native-select.d.ts

@@ -0,0 +1,26 @@
+import * as _angular_core from '@angular/core';
+
+declare class NativeSelectComponent {
+    private readonly el;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NativeSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NativeSelectComponent, "select[ui-native-select]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class NativeSelectOptionDirective {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NativeSelectOptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NativeSelectOptionDirective, "option[ui-native-select-option]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NativeSelectOptGroupDirective {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NativeSelectOptGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NativeSelectOptGroupDirective, "optgroup[ui-native-select-opt-group]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NativeSelectComponent, NativeSelectOptGroupDirective, NativeSelectOptionDirective };

package/types/edsis-ui-navigation-menu.d.ts

@@ -0,0 +1,96 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef, TemplateRef } from '@angular/core';
+
+type NavigationMenuAlign = 'start' | 'center' | 'end';
+type NavigationMenuLinkVariant = 'trigger' | 'content';
+declare abstract class NavigationMenuRootItem {
+    protected readonly elementRef: ElementRef<HTMLElement>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    isWithin(container: HTMLElement): boolean;
+    focus(): void;
+    containsTarget(target: EventTarget | null): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMenuRootItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationMenuRootItem, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class NavigationMenuComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly loop: _angular_core.InputSignal<boolean>;
+    private readonly items;
+    private readonly host;
+    private readonly activeItem;
+    private readonly openTrigger;
+    protected readonly classes: _angular_core.Signal<string>;
+    setActiveItem(item: NavigationMenuRootItem): void;
+    tabIndexFor(item: NavigationMenuRootItem): number;
+    hasOpenTrigger(except?: NavigationMenuTriggerDirective): boolean;
+    notifyOpen(trigger: NavigationMenuTriggerDirective): void;
+    notifyClosed(trigger: NavigationMenuTriggerDirective): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    private enabledItems;
+    private resolveItem;
+    private moveFocus;
+    private nextIndex;
+    private horizontalStep;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationMenuComponent, "ui-navigation-menu", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
+}
+declare class NavigationMenuListComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMenuListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationMenuListComponent, "ui-navigation-menu-list", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class NavigationMenuItemComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationMenuItemComponent, "ui-navigation-menu-item", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class NavigationMenuContentDirective {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMenuContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationMenuContentDirective, "ng-template[uiNavigationMenuContent]", ["uiNavigationMenuContent"], {}, {}, never, never, true, never>;
+}
+declare class NavigationMenuTriggerDirective extends NavigationMenuRootItem {
+    readonly uiNavigationMenuTrigger: _angular_core.InputSignal<NavigationMenuContentDirective>;
+    readonly align: _angular_core.InputSignal<NavigationMenuAlign>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    private readonly overlay;
+    private readonly vcr;
+    private readonly navigationMenu;
+    private readonly destroyRef;
+    private overlayRef;
+    protected readonly classes: _angular_core.Signal<string>;
+    toggle(): void;
+    open(options?: {
+        focusFirstItem?: boolean;
+    }): void;
+    close(options?: {
+        restoreFocus?: boolean;
+    }): void;
+    protected tabIndex(): number;
+    protected openFromKeyboard(event: KeyboardEvent, focusFirstItem: boolean): void;
+    protected syncActiveState(): void;
+    protected openFromHover(): void;
+    private focusFirstItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMenuTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationMenuTriggerDirective, "[uiNavigationMenuTrigger]", ["uiNavigationMenuTrigger"], { "uiNavigationMenuTrigger": { "alias": "uiNavigationMenuTrigger"; "required": true; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "openedChange": "openedChange"; }, never, never, true, never>;
+}
+declare class NavigationMenuLinkDirective extends NavigationMenuRootItem {
+    readonly class: _angular_core.InputSignal<string>;
+    readonly variant: _angular_core.InputSignal<NavigationMenuLinkVariant>;
+    private readonly navigationMenu;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected tabIndex(): number;
+    focus(): void;
+    protected syncActiveState(): void;
+    protected preventDisabled(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMenuLinkDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationMenuLinkDirective, "a[uiNavigationMenuLink], button[uiNavigationMenuLink]", ["uiNavigationMenuLink"], { "class": { "alias": "class"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NavigationMenuComponent, NavigationMenuContentDirective, NavigationMenuItemComponent, NavigationMenuLinkDirective, NavigationMenuListComponent, NavigationMenuRootItem, NavigationMenuTriggerDirective };
+export type { NavigationMenuAlign, NavigationMenuLinkVariant };

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

@@ -0,0 +1,34 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Simple pagination. Emits the desired page via `(pageChange)` and reflects
+ * the current page through the `page` model input while allowing lightweight
+ * label and visibility tweaks for localized and icon-only demos.
+ */
+declare class PaginationComponent {
+    readonly page: _angular_core.ModelSignal<number>;
+    readonly total: _angular_core.InputSignal<number>;
+    /** Number of sibling pages on each side of current. */
+    readonly siblingCount: _angular_core.InputSignal<number>;
+    readonly showPageNumbers: _angular_core.InputSignal<boolean>;
+    readonly previousText: _angular_core.InputSignal<string>;
+    readonly nextText: _angular_core.InputSignal<string>;
+    readonly previousAriaLabel: _angular_core.InputSignal<string>;
+    readonly nextAriaLabel: _angular_core.InputSignal<string>;
+    readonly formatPageLabel: _angular_core.InputSignal<(page: number) => string>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly pageChange: _angular_core.OutputEmitterRef<number>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly pages: _angular_core.Signal<{
+        key: string;
+        kind: "page" | "ellipsis";
+        value: number;
+    }[]>;
+    protected navClasses(hasText: boolean): string;
+    protected pageClasses(active: boolean): string;
+    protected go(target: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaginationComponent, "ui-pagination, nav[ui-pagination]", never, { "page": { "alias": "page"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "siblingCount": { "alias": "siblingCount"; "required": false; "isSignal": true; }; "showPageNumbers": { "alias": "showPageNumbers"; "required": false; "isSignal": true; }; "previousText": { "alias": "previousText"; "required": false; "isSignal": true; }; "nextText": { "alias": "nextText"; "required": false; "isSignal": true; }; "previousAriaLabel": { "alias": "previousAriaLabel"; "required": false; "isSignal": true; }; "nextAriaLabel": { "alias": "nextAriaLabel"; "required": false; "isSignal": true; }; "formatPageLabel": { "alias": "formatPageLabel"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "page": "pageChange"; "pageChange": "pageChange"; }, never, never, true, never>;
+}
+
+export { PaginationComponent };