@frame-kit/ui-ng 0.0.1

package/types/frame-kit-ui-ng-ui-drawer.d.ts

@@ -0,0 +1,130 @@
+import * as _angular_core from '@angular/core';
+import { Type } from '@angular/core';
+import { Observable } from 'rxjs';
+
+type DrawerWidth = 'sm' | 'md' | 'lg' | 'xl';
+type DrawerAnimation = 'slide-right' | 'fade' | 'none';
+type DrawerCanCloseFn = () => boolean | Promise<boolean>;
+
+declare class DrawerComponent {
+    /** Controls whether the drawer is open. */
+    readonly open: _angular_core.InputSignal<boolean>;
+    /** When true, shows the close button in the drawer header. */
+    readonly closable: _angular_core.InputSignal<boolean>;
+    /** When true, pressing Escape closes the drawer. */
+    readonly closeOnEscape: _angular_core.InputSignal<boolean>;
+    /** When true, clicking the backdrop overlay closes the drawer. */
+    readonly closeOnBackdrop: _angular_core.InputSignal<boolean>;
+    /** Width variant of the drawer panel. */
+    readonly width: _angular_core.InputSignal<DrawerWidth>;
+    /** Optional title text rendered in the drawer header. */
+    readonly header: _angular_core.InputSignal<string | null>;
+    /** When true, focus returns to the previously focused element when the drawer closes. */
+    readonly restoreFocus: _angular_core.InputSignal<boolean>;
+    /** When true, CDK auto-focus is applied when the drawer opens. */
+    readonly autoFocus: _angular_core.InputSignal<boolean>;
+    /** Entry/exit animation applied to the drawer panel. */
+    readonly animation: _angular_core.InputSignal<DrawerAnimation>;
+    /** When true, all close mechanisms are blocked. */
+    readonly preventClose: _angular_core.InputSignal<boolean>;
+    /** Async guard function called before closing; return false to cancel the close. */
+    readonly canClose: _angular_core.InputSignal<DrawerCanCloseFn | null>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /** Fires when the drawer's open state should change, emitting the new boolean. */
+    readonly openChange: _angular_core.OutputEmitterRef<boolean>;
+    /** Fires immediately before the drawer begins its open animation. */
+    readonly beforeOpen: _angular_core.OutputEmitterRef<void>;
+    /** Fires after the drawer is fully open. */
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    /** Fires immediately before the drawer begins its close animation. */
+    readonly beforeClose: _angular_core.OutputEmitterRef<void>;
+    /** Fires after the drawer is fully closed. */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly doc;
+    private readonly destroyRef;
+    readonly titleId: string;
+    private previouslyFocusedElement;
+    private closeGuardRunning;
+    readonly visible: _angular_core.WritableSignal<boolean>;
+    readonly animatingOut: _angular_core.WritableSignal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    readonly ariaLabelledBy: _angular_core.Signal<string | null>;
+    constructor();
+    get hostClass(): string;
+    get hostId(): string | null;
+    onEscapeKey(): void;
+    /** Closes the drawer, running any `canClose` guard first; no-ops when `preventClose` is true. */
+    close(): Promise<void>;
+    onOverlayClick(): void;
+    onExitAnimationDone(): void;
+    private onDrawerOpen;
+    private onDrawerClose;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DrawerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DrawerComponent, "fk-drawer", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; "preventClose": { "alias": "preventClose"; "required": false; "isSignal": true; }; "canClose": { "alias": "canClose"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; "beforeOpen": "beforeOpen"; "opened": "opened"; "beforeClose": "beforeClose"; "closed": "closed"; }, never, ["*", "[fkDrawerFooter]"], true, never>;
+}
+
+interface DrawerConfig<TData = unknown> {
+    closable?: boolean;
+    closeOnEscape?: boolean;
+    closeOnBackdrop?: boolean;
+    width?: DrawerWidth;
+    animation?: DrawerAnimation;
+    header?: string | null;
+    restoreFocus?: boolean;
+    autoFocus?: boolean;
+    preventClose?: boolean;
+    canClose?: DrawerCanCloseFn;
+    className?: string;
+    ariaLabel?: string | null;
+    data?: TData;
+    /** Element to append the drawer into. Must have `position: relative`. Defaults to `document.body`. */
+    container?: HTMLElement;
+}
+declare const DEFAULT_DRAWER_CONFIG: DrawerConfig;
+
+declare class DrawerRef<TResult = unknown, TData = unknown> {
+    private readonly beforeOpenSubject;
+    private readonly afterOpenedSubject;
+    private readonly beforeCloseSubject;
+    private readonly afterClosedSubject;
+    private closed;
+    private closeGuard;
+    readonly config: DrawerConfig<TData>;
+    constructor(config?: DrawerConfig<TData>);
+    get data(): TData | undefined;
+    setCanClose(guard: DrawerCanCloseFn | null): void;
+    close(result?: TResult): Promise<void>;
+    beforeOpen(): Observable<void>;
+    afterOpened(): Observable<void>;
+    beforeClose(): Observable<void>;
+    afterClosed(): Observable<TResult | undefined>;
+    /** @internal */
+    markBeforeOpen(): void;
+    /** @internal */
+    markOpened(): void;
+}
+
+declare const DRAWER_DATA: unique symbol;
+declare const DRAWER_REF: unique symbol;
+declare class DrawerService {
+    private readonly appRef;
+    private readonly injector;
+    private readonly doc;
+    private readonly orchestrator;
+    private activeDrawers;
+    private overlayIds;
+    get openCount(): number;
+    open<TResult = unknown, TData = unknown>(content: Type<unknown>, config?: DrawerConfig<TData>): DrawerRef<TResult, TData>;
+    closeAll(): void;
+    private applyContainerBounds;
+    private applyZIndex;
+    private applyConfig;
+    private destroyDrawer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DrawerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DrawerService>;
+}
+
+export { DEFAULT_DRAWER_CONFIG, DRAWER_DATA, DRAWER_REF, DrawerComponent, DrawerRef, DrawerService };
+export type { DrawerAnimation, DrawerCanCloseFn, DrawerConfig, DrawerWidth };

package/types/frame-kit-ui-ng-ui-dropdown-menu.d.ts

@@ -0,0 +1,77 @@
+import * as _frame_kit_ui_ng_ui_dropdown_menu from '@frame-kit/ui-ng/ui/dropdown-menu';
+import * as _angular_core from '@angular/core';
+import { ElementRef, TemplateRef, InjectionToken } from '@angular/core';
+
+type DropdownPlacement = 'bottom-start' | 'bottom-end';
+
+declare class DropdownMenuComponent {
+    /** Preferred placement of the panel relative to the trigger. */
+    readonly placement: _angular_core.InputSignal<DropdownPlacement>;
+    /** When true, the trigger is non-interactive and the panel cannot open. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** When true, the panel is appended to `document.body` instead of rendered inline. */
+    readonly portal: _angular_core.InputSignal<boolean>;
+    /** Extra CSS class applied to the floating panel element. */
+    readonly panelClass: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    /** Fires when the dropdown panel opens. */
+    readonly menuOpen: _angular_core.OutputEmitterRef<void>;
+    /** Fires when the dropdown panel closes. */
+    readonly menuClose: _angular_core.OutputEmitterRef<void>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly triggerRef: _angular_core.Signal<_frame_kit_ui_ng_ui_dropdown_menu.DropdownTriggerDirective | undefined>;
+    readonly panelRef: _angular_core.Signal<_frame_kit_ui_ng_ui_dropdown_menu.DropdownPanelDirective | undefined>;
+    readonly menuPanelEl: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    private readonly elRef;
+    private readonly destroyRef;
+    private portalCleanup;
+    constructor();
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get hostId(): string | null;
+    onHostClick(event: Event): void;
+    onHostKeydown(event: KeyboardEvent): void;
+    onDocumentClick(event: MouseEvent): void;
+    onDocumentKeydown(event: KeyboardEvent): void;
+    /** Toggles the dropdown panel open or closed if not disabled. */
+    toggle(): void;
+    /** Opens the dropdown panel and positions it relative to the trigger. */
+    open(): void;
+    /** Closes the dropdown panel and cleans up any portal attachment. */
+    close(): void;
+    onPanelItemSelect(): void;
+    private onTriggerKeydown;
+    private getMenuItems;
+    private focusNext;
+    private focusPrev;
+    private focusFirst;
+    private focusLast;
+    private focusTrigger;
+    private updateTriggerAria;
+    private attachPortal;
+    private cleanupPortal;
+    private positionPanel;
+    private positionPortalPanel;
+    private positionInlinePanel;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownMenuComponent, "fk-dropdown-menu", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "portal": { "alias": "portal"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "menuOpen": "menuOpen"; "menuClose": "menuClose"; }, ["triggerRef", "panelRef"], ["[fkDropdownTrigger]"], true, never>;
+}
+
+declare const FK_DROPDOWN_PANEL: InjectionToken<DropdownPanelDirective>;
+declare class DropdownPanelDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownPanelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DropdownPanelDirective, "[fkDropdownPanel]", never, {}, {}, never, never, true, never>;
+}
+
+declare const FK_DROPDOWN_TRIGGER: InjectionToken<DropdownTriggerDirective>;
+declare class DropdownTriggerDirective {
+    readonly elRef: ElementRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DropdownTriggerDirective, "[fkDropdownTrigger]", never, {}, {}, never, never, true, never>;
+}
+
+export { DropdownMenuComponent, DropdownPanelDirective, DropdownTriggerDirective, FK_DROPDOWN_PANEL, FK_DROPDOWN_TRIGGER };
+export type { DropdownPlacement };

package/types/frame-kit-ui-ng-ui-editable-field.d.ts

@@ -0,0 +1,65 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+
+type EditableFieldSize = 'sm' | 'md' | 'lg';
+
+/**
+ * A single-line text field that lives in two states:
+ *
+ *   - **Display** — the field reads as a regular bordered input
+ *     showing the current value. A pencil icon sits inside the
+ *     trailing edge. Clicking anywhere on the field surface enters
+ *     edit mode.
+ *   - **Edit** — the field becomes a live `<input>`. The pencil slot
+ *     swaps to a cancel (✗) icon inside the trailing edge. A
+ *     separate Save button slides in as a sibling to the field's
+ *     right.
+ *
+ * Distinct from `fk-inline-edit`, which renders the value as a span +
+ * an Edit button as siblings. `fk-editable-field` is meant for form-
+ * shaped surfaces (billing details, profile pages) where every row
+ * should *look* like a regular input even in display mode.
+ *
+ * The save / cancel / pencil icons can be overridden via the named
+ * content slots `[editIcon]`, `[cancelIcon]`, and `[saveIcon]`.
+ */
+declare class EditableFieldComponent {
+    /** Current committed value displayed in read mode. */
+    readonly value: _angular_core.InputSignal<string>;
+    /** Placeholder text shown in the input when the edit buffer is empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Size variant controlling the font and spacing of the component. */
+    readonly size: _angular_core.InputSignal<EditableFieldSize>;
+    /** Text displayed in read mode when the committed value is empty. */
+    readonly emptyText: _angular_core.InputSignal<string>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaDescribedBy: _angular_core.InputSignal<string | null>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Fires when the user saves an edit, emitting the trimmed new value. */
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    /** Fires when the component enters edit mode. */
+    readonly editStart: _angular_core.OutputEmitterRef<void>;
+    /** Fires when the user cancels an in-progress edit without saving. */
+    readonly editCancel: _angular_core.OutputEmitterRef<void>;
+    readonly editing: _angular_core.WritableSignal<boolean>;
+    readonly editValue: _angular_core.WritableSignal<string>;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get hostId(): string | null;
+    /** Enters edit mode and focuses the input, copying the current value into the edit buffer. */
+    startEdit(): void;
+    /** Commits the current edit buffer, exits edit mode, and emits the trimmed value. */
+    save(): void;
+    /** Discards the current edit buffer and exits edit mode. */
+    cancel(): void;
+    onKeydown(event: KeyboardEvent): void;
+    onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditableFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditableFieldComponent, "fk-editable-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "editStart": "editStart"; "editCancel": "editCancel"; }, never, ["[cancelIcon]", "[saveIcon]", "[editIcon]"], true, never>;
+}
+
+export { EditableFieldComponent };
+export type { EditableFieldSize };

package/types/frame-kit-ui-ng-ui-icon-badge.d.ts

@@ -0,0 +1,45 @@
+import * as _angular_core from '@angular/core';
+import { IconSize, IconColor } from '@frame-kit/ui-ng/core/icon';
+
+type IconBadgeShape = 'circle' | 'rounded' | 'square';
+type IconBadgeSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | (string & {});
+
+declare class IconBadgeComponent {
+    /** Name of the icon rendered inside the badge container. */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Size of the icon within the badge. */
+    readonly size: _angular_core.InputSignal<IconSize>;
+    /** Size of the badge container; defaults to matching `size` when null. */
+    readonly badgeSize: _angular_core.InputSignal<IconBadgeSize | null>;
+    /** Shape of the badge container — circle or square. */
+    readonly shape: _angular_core.InputSignal<IconBadgeShape>;
+    /** Color of the icon. */
+    readonly color: _angular_core.InputSignal<IconColor>;
+    /** Custom border color applied directly to the host element. */
+    readonly borderColor: _angular_core.InputSignal<string | null>;
+    /** Custom background color applied directly to the host element. */
+    readonly backgroundColor: _angular_core.InputSignal<string | null>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /** Explicit aria-hidden override; when null it defaults to true unless `ariaLabel` is set. */
+    readonly ariaHidden: _angular_core.InputSignal<boolean | null>;
+    private readonly badgeSizePresets;
+    readonly effectiveBadgeSize: _angular_core.Signal<(string & {}) | "xs" | "sm" | "md" | "lg" | "xl">;
+    readonly isCustomBadgeSize: _angular_core.Signal<boolean>;
+    readonly effectiveAriaHidden: _angular_core.Signal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get hostRole(): string | null;
+    get hostAriaLabel(): string | null;
+    get hostAriaHidden(): string | null;
+    get hostId(): string | null;
+    get hostPadding(): string | null;
+    get hostBorderColor(): string | null;
+    get hostBackgroundColor(): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconBadgeComponent, "fk-icon-badge", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "badgeSize": { "alias": "badgeSize"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "borderColor": { "alias": "borderColor"; "required": false; "isSignal": true; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaHidden": { "alias": "ariaHidden"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { IconBadgeComponent };
+export type { IconBadgeShape, IconBadgeSize };

package/types/frame-kit-ui-ng-ui-icon-list.d.ts

@@ -0,0 +1,67 @@
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+
+type IconListVariant = 'default' | 'primary' | 'success' | 'warning' | 'danger';
+type IconListSize = 'sm' | 'md' | 'lg';
+interface IconListItem {
+    /** The label text shown after the icon. */
+    label: string;
+    /** Optional per-item icon name. Overrides the list-level `icon` prop. */
+    icon?: string;
+}
+
+/**
+ * Parent contract exposed by `fk-icon-list` to `fk-icon-list-item` children.
+ * Lives in its own file so the two components can reference it without the
+ * circular ES-module import that a direct `IconListComponent` type import
+ * would create (item -> list -> item).
+ */
+interface IconListParent {
+    readonly icon: Signal<string | null>;
+    readonly variant: Signal<IconListVariant>;
+    readonly size: Signal<IconListSize>;
+}
+
+declare class IconListComponent implements IconListParent {
+    /** Optional array of items to render declaratively; when null, projected `fk-icon-list-item` elements are used. */
+    readonly items: _angular_core.InputSignal<readonly IconListItem[] | null>;
+    /** Default icon name inherited by all child items that don't specify their own. */
+    readonly icon: _angular_core.InputSignal<string | null>;
+    /** Color variant applied to the icon in each list item. */
+    readonly variant: _angular_core.InputSignal<IconListVariant>;
+    /** Size applied to the icon and text in each list item. */
+    readonly size: _angular_core.InputSignal<IconListSize>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconListComponent, "fk-icon-list", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class IconListItemComponent {
+    private readonly parent;
+    /** Icon name for this item; falls back to the parent list's `icon` when null. */
+    readonly icon: _angular_core.InputSignal<string | null>;
+    /** Color variant for this item's icon; falls back to the parent list's `variant` when null. */
+    readonly variant: _angular_core.InputSignal<IconListVariant | null>;
+    /** Size for this item; falls back to the parent list's `size` when null. */
+    readonly size: _angular_core.InputSignal<IconListSize | null>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    protected readonly resolvedIcon: _angular_core.Signal<string | null>;
+    protected readonly resolvedVariant: _angular_core.Signal<IconListVariant>;
+    protected readonly resolvedSize: _angular_core.Signal<IconListSize>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get hostRole(): string | null;
+    get hostId(): string | null;
+    get hostAriaLabel(): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconListItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconListItemComponent, "fk-icon-list-item", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { IconListComponent, IconListItemComponent };
+export type { IconListItem, IconListSize, IconListVariant };

package/types/frame-kit-ui-ng-ui-inline-edit.d.ts

@@ -0,0 +1,44 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+
+type InlineEditSize = 'sm' | 'md' | 'lg';
+
+declare class InlineEditComponent {
+    readonly className: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Current committed value displayed in read mode. */
+    readonly value: _angular_core.InputSignal<string>;
+    /** Placeholder text shown in the input when the edit value is empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Size variant controlling the font and spacing of the component. */
+    readonly size: _angular_core.InputSignal<InlineEditSize>;
+    /** Text displayed in read mode when the committed value is empty. */
+    readonly emptyText: _angular_core.InputSignal<string>;
+    /** Fires when the user saves an edit, emitting the trimmed new value. */
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    /** Fires when the component enters edit mode. */
+    readonly editStart: _angular_core.OutputEmitterRef<void>;
+    /** Fires when the user cancels an in-progress edit without saving. */
+    readonly editCancel: _angular_core.OutputEmitterRef<void>;
+    readonly editing: _angular_core.WritableSignal<boolean>;
+    readonly editValue: _angular_core.WritableSignal<string>;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get hostId(): string | null;
+    /** Enters edit mode and focuses the input, copying the current value into the edit buffer. */
+    startEdit(): void;
+    /** Commits the current edit buffer, exits edit mode, and emits the trimmed value. */
+    save(): void;
+    /** Discards the current edit buffer and exits edit mode. */
+    cancel(): void;
+    onKeydown(event: KeyboardEvent): void;
+    onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InlineEditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InlineEditComponent, "fk-inline-edit", never, { "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "editStart": "editStart"; "editCancel": "editCancel"; }, never, ["[saveIcon]", "[cancelIcon]", "[editIcon]"], true, never>;
+}
+
+export { InlineEditComponent };
+export type { InlineEditSize };

package/types/frame-kit-ui-ng-ui-list-editor.d.ts

@@ -0,0 +1,56 @@
+import * as _angular_core from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+
+type ListEditorSize = 'sm' | 'md';
+
+declare class ListEditorComponent {
+    /** The current list of string items; two-way bindable via `[(items)]`. */
+    readonly items: _angular_core.ModelSignal<string[]>;
+    /** Placeholder text for the new-item input field. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Message displayed when the list is empty. */
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    /** Label for the add button. */
+    readonly addLabel: _angular_core.InputSignal<string>;
+    /** When true, items can be reordered via drag-and-drop. */
+    readonly orderable: _angular_core.InputSignal<boolean>;
+    /** When true, shows a numeric position indicator next to each item. */
+    readonly showOrder: _angular_core.InputSignal<boolean>;
+    /** Size variant controlling the spacing and font of the component. */
+    readonly size: _angular_core.InputSignal<ListEditorSize>;
+    /** Items that cannot be removed by the user (matched case-insensitively). */
+    readonly lockedItems: _angular_core.InputSignal<string[]>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /** Fires whenever the items array changes, emitting the full updated array. */
+    readonly itemsChange: _angular_core.OutputEmitterRef<string[]>;
+    /** Fires when a new item is successfully added, emitting the added value. */
+    readonly itemAdded: _angular_core.OutputEmitterRef<string>;
+    /** Fires when an item is removed, emitting the removed value and its former index. */
+    readonly itemRemoved: _angular_core.OutputEmitterRef<{
+        item: string;
+        index: number;
+    }>;
+    readonly newItemValue: _angular_core.WritableSignal<string>;
+    readonly canAdd: _angular_core.Signal<boolean>;
+    readonly hasDuplicates: _angular_core.Signal<boolean>;
+    readonly hasEmptyItems: _angular_core.Signal<boolean>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    /** Adds the current input value as a new item if it is non-empty and not a duplicate. */
+    addItem(): void;
+    /** Removes the item at the given index unless it is locked or the component is disabled. */
+    removeItem(index: number): void;
+    /** Updates the item at the given index with a new value and emits the changed array. */
+    updateItem(index: number, value: string): void;
+    onDrop(event: CdkDragDrop<string[]>): void;
+    /** Returns true if the given item matches any entry in `lockedItems`. */
+    isLocked(item: string): boolean;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListEditorComponent, "fk-list-editor", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "addLabel": { "alias": "addLabel"; "required": false; "isSignal": true; }; "orderable": { "alias": "orderable"; "required": false; "isSignal": true; }; "showOrder": { "alias": "showOrder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "lockedItems": { "alias": "lockedItems"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "items": "itemsChange"; "itemsChange": "itemsChange"; "itemAdded": "itemAdded"; "itemRemoved": "itemRemoved"; }, never, never, true, never>;
+}
+
+export { ListEditorComponent };
+export type { ListEditorSize };

package/types/frame-kit-ui-ng-ui-loader.d.ts

@@ -0,0 +1,32 @@
+import * as _angular_core from '@angular/core';
+import { AfterContentInit } from '@angular/core';
+
+type LoaderSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type LoaderColor = 'inherit' | 'default' | 'muted' | 'primary' | 'danger' | 'success';
+
+declare class FkLoaderIconDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FkLoaderIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FkLoaderIconDirective, "[fkLoaderIcon]", never, {}, {}, never, never, true, never>;
+}
+declare class LoaderComponent implements AfterContentInit {
+    private customIcon?;
+    hasCustomIcon: boolean;
+    /** Size of the spinning loader indicator. */
+    readonly size: _angular_core.InputSignal<LoaderSize>;
+    /** Color of the spinner; "inherit" adopts the nearest ancestor's color. */
+    readonly color: _angular_core.InputSignal<LoaderColor>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    get hostRole(): string;
+    get hostAriaLabel(): string;
+    get hostId(): string | null;
+    ngAfterContentInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoaderComponent, "fk-loader", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, ["customIcon"], ["[fkLoaderIcon]"], true, never>;
+}
+
+export { FkLoaderIconDirective, LoaderComponent };
+export type { LoaderColor, LoaderSize };

package/types/frame-kit-ui-ng-ui-menu-item.d.ts

@@ -0,0 +1,27 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+
+declare class MenuItemComponent {
+    /** Optional icon name rendered to the leading side of the label. */
+    readonly icon: _angular_core.InputSignal<string | null>;
+    /** When true, applies destructive (danger) color styling to the item. */
+    readonly danger: _angular_core.InputSignal<boolean>;
+    /** When true, prevents interaction and applies disabled styling. */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Fires when the user activates the item via click or keyboard. */
+    readonly itemClick: _angular_core.OutputEmitterRef<void>;
+    readonly elRef: ElementRef<any>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    onClick(): void;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItemComponent, "fk-menu-item", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "danger": { "alias": "danger"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, never, ["*"], true, never>;
+}
+
+declare class MenuSeparatorComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuSeparatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuSeparatorComponent, "fk-menu-separator", never, {}, {}, never, never, true, never>;
+}
+
+export { MenuItemComponent, MenuSeparatorComponent };

package/types/frame-kit-ui-ng-ui-nav-brand.d.ts

@@ -0,0 +1,25 @@
+import * as _angular_core from '@angular/core';
+
+declare class NavBrandComponent {
+    /** Brand or application name rendered as the nav logo text. */
+    readonly brandText: _angular_core.InputSignal<string>;
+    /** Router path the brand link navigates to when clicked. */
+    readonly href: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly classes: _angular_core.Signal<string>;
+    get hostClass(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavBrandComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavBrandComponent, "fk-nav-brand", never, { "brandText": { "alias": "brandText"; "required": true; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["[navLogo]"], true, never>;
+}
+
+interface NavBrandProps {
+    /** Text displayed adjacent to the logo */
+    brandText: string;
+    /** Optional link destination (defaults to '/') */
+    href?: string;
+}
+
+export { NavBrandComponent };
+export type { NavBrandProps };