@harmolody/ui 0.1.0

package/types/harmolody-ui.d.ts

@@ -0,0 +1,2480 @@
+import { ControlValueAccessor, FormArray, FormControl, FormGroup, ValidationErrors, ValidatorFn } from "@angular/forms";
+import * as i0 from "@angular/core";
+import { ElementRef, EnvironmentProviders, InjectionToken, OnDestroy, OnInit, TemplateRef, Type } from "@angular/core";
+import { Observable } from "rxjs";
+export type FieldType = 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'textarea' | 'select' | 'radio' | 'checkbox' | 'switch' | 'autocomplete' | 'search' | 'date' | 'datetime' | 'month' | 'year' | 'file' | 'image-selector' | 'array';
+export type OperatorType = 'eq' | 'neq' | 'in' | 'nin' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains';
+/**
+ * Configuration for an action button alongside a form field (select, autocomplete)
+ * Useful for "Create New" buttons that open dialogs
+ */
+export interface FieldAction {
+  /** Icon name from the icon set */
+  icon: string;
+  /** Aria label for accessibility */
+  ariaLabel: string;
+  /** Tooltip text (optional) */
+  tooltip?: string;
+}
+export interface FieldConfig {
+  key: string;
+  label: string;
+  type: FieldType;
+  placeholder?: string;
+  hint?: string;
+  helper?: string;
+  description?: string;
+  note?: string;
+  noteVariant?: 'info' | 'warning' | 'success' | 'error' | 'neutral';
+  noteClasses?: string;
+  defaultValue?: any;
+  required?: boolean;
+  disabled?: boolean;
+  hidden?: boolean;
+  validation?: ValidationRule[];
+  options?: SelectOption$1[];
+  searchable?: boolean;
+  minSearchLength?: number;
+  /**
+   * Enable multiple selection (for select and autocomplete fields)
+   * When true:
+   * - Shows checkboxes for each option (autocomplete)
+   * - Form control value will be an array of selected values
+   * - If emitSelectedObject is true, selectedObjects will contain an array of selected option objects
+   * @default false
+   */
+  multiple?: boolean;
+  optionPresentation?: 'dropdown' | 'chips';
+  chipLayout?: 'inline' | 'wrap';
+  action?: FieldAction;
+  optionsFromApi?: ApiOptionsConfig;
+  /**
+   * Whether to emit the full selected object in fieldChange event
+   * Only applies to autocomplete and select fields
+   * When true, the selected option object(s) will be included in fieldChange event's selectedObjects
+   * - For single select: returns single option object
+   * - For multiple select: returns array of option objects
+   * @default false
+   */
+  emitSelectedObject?: boolean;
+  dependsOn?: FieldDependency | FieldDependency[];
+  showWhen?: ConditionRule | ConditionRule[];
+  hideWhen?: ConditionRule | ConditionRule[];
+  rows?: number;
+  min?: number;
+  max?: number;
+  step?: number;
+  accept?: string;
+  minDate?: string;
+  maxDate?: string;
+  dateMode?: 'date' | 'datetime-local' | 'month' | 'year';
+  mediaType?: string;
+  allowUpload?: boolean;
+  altText?: string;
+  showPreview?: boolean;
+  editableInput?: boolean;
+  maxSize?: number;
+  maxFiles?: number;
+  enableDragDrop?: boolean;
+  arrayFields?: FieldConfig[];
+  minItems?: number;
+  maxItems?: number;
+  addButtonLabel?: string;
+  removeButtonLabel?: string;
+  canRemoveAll?: boolean;
+  arrayLayout?: 'vertical' | 'grid';
+  arrayColumns?: number;
+  itemLabel?: string;
+  cssClass?: string;
+  containerClass?: string;
+  order?: number;
+  fullWidth?: boolean;
+  columnSpan?: number;
+  onChange?: string;
+  onBlur?: string;
+}
+export interface ApiOptionsConfig {
+  url: string;
+  method: 'GET' | 'POST';
+  baseUrl?: string;
+  cache?: boolean;
+  searchParam?: string;
+  debounceTime?: number;
+  loadOnInit?: boolean;
+  filters?: ApiFilter[];
+  dynamicFilters?: DynamicFilter[];
+  map?: {
+    label: string | string[];
+    value: string;
+    data?: string;
+  };
+  transformRequest?: (query: string, formValues: any) => any;
+  transformResponse?: (response: any) => SelectOption$1[];
+}
+export interface ApiFilter {
+  field: string;
+  operator: OperatorType;
+  values?: any[];
+  value?: any;
+  valueFrom?: string;
+  whenNotEmpty?: boolean;
+}
+export interface DynamicFilter extends ApiFilter {
+  valueFrom: string;
+  whenNotEmpty?: boolean;
+}
+export interface FieldDependency {
+  field: string;
+  refreshOn?: 'change' | 'blur';
+  clearOnChange?: boolean;
+}
+export interface ConditionRule {
+  field: string;
+  operator: OperatorType;
+  value?: any;
+  values?: any[];
+}
+export interface ValidationRule {
+  type: 'required' | 'email' | 'minLength' | 'maxLength' | 'min' | 'max' | 'pattern' | 'custom';
+  value?: any;
+  message?: string;
+  validator?: string;
+}
+interface SelectOption$1 {
+  label: string;
+  value: any;
+  disabled?: boolean;
+  [key: string]: any;
+}
+/**
+ * Custom action button configuration
+ */
+export interface FormAction {
+  /** Unique identifier for the action (used in actionClick event) */
+  key: string;
+  /** Button label text */
+  label: string;
+  /** Button type: 'button' (default), 'submit', or 'reset' */
+  type?: 'button' | 'submit' | 'reset';
+  /** Button variant for styling */
+  variant?: 'primary' | 'secondary' | 'outline' | 'danger' | 'success' | 'link';
+  /** Custom CSS classes (overrides variant styling) */
+  cssClass?: string;
+  /** Icon name to display (optional) */
+  icon?: string;
+  /** Icon position: 'left' (default) or 'right' */
+  iconPosition?: 'left' | 'right';
+  /** Whether to disable the button when form is invalid */
+  disableOnInvalid?: boolean;
+  /** Whether to disable the button when form is submitting */
+  disableOnSubmitting?: boolean;
+  /** Whether the button is hidden */
+  hidden?: boolean;
+  /** Order/position of the button (lower numbers appear first) */
+  order?: number;
+}
+/**
+ * Semantic group of fields rendered inside a fieldset.
+ * Field values remain flat; `fields` only controls presentation and ordering.
+ */
+export interface FormFieldsetConfig {
+  /** Stable identifier used to track the fieldset */
+  key: string;
+  /** Accessible fieldset legend */
+  legend: string;
+  /** Supporting text displayed below the legend */
+  description?: string;
+  /** Field keys to render in this group, in display order */
+  fields: string[];
+  /** Optional classes applied to the fieldset */
+  cssClass?: string;
+}
+export interface FormConfig {
+  fields: FieldConfig[];
+  layout?: 'vertical' | 'horizontal' | 'grid';
+  columns?: number;
+  /**
+   * Label/control arrangement for every field. Defaults to `column`.
+   * `stacked` is retained as a compatibility alias for `column`.
+   */
+  fieldLayout?: 'column' | 'row' | 'stacked';
+  /** Optional semantic field groups. Fields not listed here render after the groups. */
+  fieldsets?: FormFieldsetConfig[];
+  showCancelButton?: {
+    label?: string;
+    cssClass?: string;
+    hidden?: boolean;
+  };
+  submitButton?: {
+    label: string;
+    cssClass?: string;
+    hidden?: boolean;
+  };
+  resetButton?: {
+    label: string;
+    cssClass?: string;
+    hidden?: boolean;
+  };
+  /**
+   * Custom action buttons array
+   * When provided, the built-in cancel, submit, and reset buttons are ignored
+   * Use this for multi-step forms, custom workflows, etc.
+   */
+  actions?: FormAction[];
+  actionsWrapper?: {
+    cssClass?: string;
+  };
+  apiConfig?: {
+    baseUrl?: string;
+    headers?: Record<string, string>;
+  };
+  validationStrategy?: 'touched' | 'submit';
+  /**
+   * Whether to emit full selected objects in fieldChange event
+   * When true, fieldChange event includes selectedObjects with full option data
+   * When false, only valueChange event is emitted (default behavior)
+   * @default false
+   */
+  emitSelectedObjects?: boolean;
+}
+export declare class LocalizationService {
+  private readonly config;
+  translate(text: string | null | undefined, parameters?: Record<string, string | number>): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LocalizationService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class DynamicFieldComponent {
+  field: import("@angular/core").InputSignal<FieldConfig>;
+  form: import("@angular/core").InputSignal<FormGroup<any>>;
+  fieldLayout: import("@angular/core").InputSignal<"column" | "row" | "stacked">;
+  apiConfig: import("@angular/core").InputSignal<{
+    baseUrl?: string;
+    headers?: Record<string, string>;
+  } | undefined>;
+  validationStrategy: import("@angular/core").InputSignal<"submit" | "touched">;
+  formSubmitted: import("@angular/core").InputSignal<boolean>;
+  /** Emits when a field's action button is clicked, with the field key */
+  actionClick: import("@angular/core").OutputEmitterRef<{
+    fieldKey: string;
+  }>;
+  private readonly optionsLoader;
+  private readonly destroyRef;
+  protected readonly localization: LocalizationService;
+  protected readonly options: import("@angular/core").WritableSignal<SelectOption$1[]>;
+  protected readonly loading: import("@angular/core").WritableSignal<boolean>;
+  private readonly controlTouched;
+  private readonly controlInvalid;
+  protected readonly fieldId: import("@angular/core").Signal<string>;
+  protected readonly control: import("@angular/core").Signal<FormControl<any>>;
+  protected readonly showError: import("@angular/core").Signal<boolean>;
+  private readonly formChangeSignal;
+  protected readonly isVisible: import("@angular/core").Signal<boolean>;
+  constructor();
+  private evaluateCondition;
+  protected loadOptions(searchQuery?: string): void;
+  protected onSearch(query: string): void;
+  protected onAutocompleteSelect(value: any): void;
+  /** Emit action click event with the field key */
+  protected onFieldActionClick(): void;
+  /** Reload options - can be called from parent component after creating new item */
+  reloadOptions(): void;
+  /** Get the selected option object for autocomplete/select fields */
+  getSelectedOption(): SelectOption$1 | SelectOption$1[] | undefined;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFieldComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFieldComponent, "hui-dynamic-field", never, {
+    "field": {
+      "alias": "field";
+      "required": true;
+      "isSignal": true;
+    };
+    "form": {
+      "alias": "form";
+      "required": true;
+      "isSignal": true;
+    };
+    "fieldLayout": {
+      "alias": "fieldLayout";
+      "required": false;
+      "isSignal": true;
+    };
+    "apiConfig": {
+      "alias": "apiConfig";
+      "required": false;
+      "isSignal": true;
+    };
+    "validationStrategy": {
+      "alias": "validationStrategy";
+      "required": false;
+      "isSignal": true;
+    };
+    "formSubmitted": {
+      "alias": "formSubmitted";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "actionClick": "actionClick";
+  }, never, never, true, never>;
+}
+export declare class DynamicFormComponent implements OnInit, OnDestroy {
+  config: import("@angular/core").InputSignal<FormConfig>;
+  initialValues: import("@angular/core").InputSignal<Record<string, any>>;
+  formSubmit: import("@angular/core").OutputEmitterRef<any>;
+  reset: import("@angular/core").OutputEmitterRef<void>;
+  cancel: import("@angular/core").OutputEmitterRef<void>;
+  valueChange: import("@angular/core").OutputEmitterRef<any>;
+  /** Emits when form values change with full selected objects for autocomplete/select fields */
+  fieldChange: import("@angular/core").OutputEmitterRef<{
+    values: any;
+    selectedObjects: Record<string, any>;
+  }>;
+  actionClick: import("@angular/core").OutputEmitterRef<{
+    action: FormAction;
+    formValue: any;
+    isValid: boolean;
+  }>;
+  /** Emits when a field's action button is clicked (e.g., "Create New" button) */
+  fieldActionClick: import("@angular/core").OutputEmitterRef<{
+    fieldKey: string;
+    formValue: any;
+  }>;
+  private readonly dynamicFields;
+  private readonly formBuilder;
+  private readonly fieldResolver;
+  protected readonly localization: LocalizationService;
+  private readonly destroy$;
+  private isSubmitting;
+  private initialized;
+  protected readonly form: import("@angular/core").WritableSignal<FormGroup<any>>;
+  protected readonly formValues: import("@angular/core").WritableSignal<Record<string, any>>;
+  protected readonly submitting: import("@angular/core").WritableSignal<boolean>;
+  protected readonly submitted: import("@angular/core").WritableSignal<boolean>;
+  protected readonly busy: import("@angular/core").Signal<boolean>;
+  constructor();
+  protected readonly visibleFields: import("@angular/core").Signal<FieldConfig[]>;
+  protected readonly visibleFieldsets: import("@angular/core").Signal<{
+    config: FormFieldsetConfig;
+    fields: FieldConfig[];
+  }[]>;
+  protected readonly ungroupedFields: import("@angular/core").Signal<FieldConfig[]>;
+  protected readonly layoutClass: import("@angular/core").Signal<string>;
+  /** Whether the form uses custom actions array */
+  protected readonly hasCustomActions: import("@angular/core").Signal<boolean | undefined>;
+  /** Sorted and filtered actions */
+  protected readonly sortedActions: import("@angular/core").Signal<FormAction[]>;
+  protected getFieldColumnClass(field: any): string;
+  protected getFieldsetClass(fieldset: FormFieldsetConfig): string;
+  ngOnInit(): void;
+  ngOnDestroy(): void;
+  private initializeForm;
+  private addMissingControls;
+  private patchInitialValues;
+  private setupValueChangeListener;
+  private updateHiddenFieldValidators;
+  private setupDependencies;
+  protected onSubmit(): void;
+  /**
+   * Call this method to reset the submitting state and re-enable the form
+   * Should be called from parent component after async operation completes
+   */
+  finishSubmit(): void;
+  validate(): boolean;
+  getRawValue<T>(): T;
+  onReset(): void;
+  onCancel(): void;
+  /** Handle custom action button click */
+  protected onActionClick(action: FormAction): void;
+  /** Check if an action button should be disabled */
+  protected isActionDisabled(action: FormAction): boolean;
+  /** Get CSS classes for an action button based on variant */
+  protected getActionClass(action: FormAction): string;
+  /** Handle field action button click (e.g., "Create New" button on select/autocomplete) */
+  protected onFieldActionClick(event: {
+    fieldKey: string;
+  }): void;
+  /**
+   * Reload options for a specific field (useful after creating a new item via action button)
+   * @param fieldKey The key of the field to reload options for
+   */
+  reloadFieldOptions(fieldKey: string): void;
+  /**
+   * Reload options for a field and set the newly created value
+   * @param fieldKey The key of the field to reload and set value for
+   * @param newValue The value to set after reloading (e.g., the ID of the newly created item)
+   */
+  reloadFieldOptionsAndSetValue(fieldKey: string, newValue: any): void;
+  /** Get a dynamic field component by field key */
+  getField(fieldKey: string): DynamicFieldComponent | undefined;
+  /**
+   * Set value for a specific field
+   * @param fieldKey The key of the field to set value for
+   * @param value The value to set
+   */
+  setFieldValue(fieldKey: string, value: any): void;
+  /**
+   * Get selected objects for all autocomplete/select fields
+   * @returns Record of field keys to their selected option objects
+   */
+  private getSelectedObjects;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormComponent, "hui-dynamic-form", never, {
+    "config": {
+      "alias": "config";
+      "required": true;
+      "isSignal": true;
+    };
+    "initialValues": {
+      "alias": "initialValues";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "formSubmit": "formSubmit";
+    "reset": "reset";
+    "cancel": "cancel";
+    "valueChange": "valueChange";
+    "fieldChange": "fieldChange";
+    "actionClick": "actionClick";
+    "fieldActionClick": "fieldActionClick";
+  }, never, never, true, never>;
+}
+export declare class FormArrayFieldComponent {
+  field: import("@angular/core").InputSignal<FieldConfig>;
+  form: import("@angular/core").InputSignal<FormGroup<any>>;
+  fieldLayout: import("@angular/core").InputSignal<"column" | "row" | "stacked">;
+  apiConfig: import("@angular/core").InputSignal<{
+    baseUrl?: string;
+    headers?: Record<string, string>;
+  } | undefined>;
+  validationStrategy: import("@angular/core").InputSignal<"submit" | "touched">;
+  formSubmitted: import("@angular/core").InputSignal<boolean>;
+  private readonly formBuilder;
+  protected readonly localization: LocalizationService;
+  protected readonly expandedItems: import("@angular/core").WritableSignal<Set<number>>;
+  protected readonly arrayLength: import("@angular/core").WritableSignal<number>;
+  protected readonly formArray: import("@angular/core").Signal<FormArray<any>>;
+  protected readonly items: import("@angular/core").Signal<number[]>;
+  constructor();
+  protected readonly canAddMore: import("@angular/core").Signal<boolean>;
+  protected readonly canRemove: import("@angular/core").Signal<boolean>;
+  protected readonly addButtonLabel: import("@angular/core").Signal<string>;
+  protected readonly removeButtonLabel: import("@angular/core").Signal<string>;
+  protected readonly itemLabel: import("@angular/core").Signal<(index: number) => string>;
+  protected getItemGroup(index: number): FormGroup;
+  protected addItem(): void;
+  protected removeItem(index: number): void;
+  protected toggleItem(index: number): void;
+  protected isExpanded(index: number): boolean;
+  protected getArrayLayoutClass(): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FormArrayFieldComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FormArrayFieldComponent, "hui-form-array-field", never, {
+    "field": {
+      "alias": "field";
+      "required": true;
+      "isSignal": true;
+    };
+    "form": {
+      "alias": "form";
+      "required": true;
+      "isSignal": true;
+    };
+    "fieldLayout": {
+      "alias": "fieldLayout";
+      "required": false;
+      "isSignal": true;
+    };
+    "apiConfig": {
+      "alias": "apiConfig";
+      "required": false;
+      "isSignal": true;
+    };
+    "validationStrategy": {
+      "alias": "validationStrategy";
+      "required": false;
+      "isSignal": true;
+    };
+    "formSubmitted": {
+      "alias": "formSubmitted";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Wrapper component to break circular dependency between FormArrayFieldComponent and DynamicFieldComponent
+ */
+export declare class FormArrayItemComponent {
+  fields: import("@angular/core").InputSignal<FieldConfig[]>;
+  form: import("@angular/core").InputSignal<FormGroup<any>>;
+  fieldLayout: import("@angular/core").InputSignal<"column" | "row" | "stacked">;
+  apiConfig: import("@angular/core").InputSignal<{
+    baseUrl?: string;
+    headers?: Record<string, string>;
+  } | undefined>;
+  validationStrategy: import("@angular/core").InputSignal<"submit" | "touched">;
+  formSubmitted: import("@angular/core").InputSignal<boolean>;
+  layoutClass: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FormArrayItemComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FormArrayItemComponent, "hui-form-array-item", never, {
+    "fields": {
+      "alias": "fields";
+      "required": true;
+      "isSignal": true;
+    };
+    "form": {
+      "alias": "form";
+      "required": true;
+      "isSignal": true;
+    };
+    "fieldLayout": {
+      "alias": "fieldLayout";
+      "required": false;
+      "isSignal": true;
+    };
+    "apiConfig": {
+      "alias": "apiConfig";
+      "required": false;
+      "isSignal": true;
+    };
+    "validationStrategy": {
+      "alias": "validationStrategy";
+      "required": false;
+      "isSignal": true;
+    };
+    "formSubmitted": {
+      "alias": "formSubmitted";
+      "required": false;
+      "isSignal": true;
+    };
+    "layoutClass": {
+      "alias": "layoutClass";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class FieldResolverService {
+  shouldShowField(field: FieldConfig, formValues: Record<string, any>): boolean;
+  getDependentFields(fieldKey: string, allFields: FieldConfig[]): FieldConfig[];
+  getFieldsWithDependency(allFields: FieldConfig[]): Map<string, FieldConfig[]>;
+  private evaluateCondition;
+  evaluateConditions(conditions: ConditionRule[], formValues: Record<string, any>, logic?: 'AND' | 'OR'): boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FieldResolverService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class FormBuilderService {
+  private readonly fb;
+  private customValidators;
+  buildForm(config: FormConfig): FormGroup;
+  /**
+   * Create a FormGroup from an array of field configurations
+   * Used for creating array item groups
+   */
+  createFormGroupFromFields(fields: FieldConfig[]): FormGroup;
+  registerCustomValidator(name: string, validator: ValidatorFn): void;
+  getCustomValidator(name: string): ValidatorFn | undefined;
+  buildValidatorsFromConfig(field: FieldConfig): ValidatorFn[];
+  private buildValidators;
+  private getDefaultValue;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FormBuilderService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class OptionsLoaderService {
+  private readonly http;
+  private cache;
+  loadOptions(config: ApiOptionsConfig, formValues: Record<string, any>, searchQuery?: string, apiConfig?: {
+    baseUrl?: string;
+    headers?: Record<string, string>;
+  }): Observable<SelectOption$1[]>;
+  private buildRequest;
+  private buildFilters;
+  private transformResponse;
+  private getNestedValue;
+  private makeRequest;
+  private getCacheKey;
+  clearCache(url?: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OptionsLoaderService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export interface AutocompleteOption {
+  label: string;
+  value: any;
+  disabled?: boolean;
+  [key: string]: any;
+}
+/**
+ * Configuration for an action button alongside the autocomplete
+ */
+export interface AutocompleteActionButton {
+  /** Icon name from the icon set */
+  icon: string;
+  /** Aria label for accessibility */
+  ariaLabel: string;
+  /** Tooltip text (optional) */
+  tooltip?: string;
+}
+export declare class AutocompleteComponent implements ControlValueAccessor {
+  private readonly elementRef;
+  protected readonly localization: LocalizationService;
+  private searchSubject;
+  private readonly scrollParents;
+  private readonly onScrollParentChange;
+  id: import("@angular/core").InputSignal<string>;
+  placeholder: import("@angular/core").InputSignal<string>;
+  mode: import("@angular/core").InputSignal<"local" | "server">;
+  options: import("@angular/core").InputSignal<AutocompleteOption[]>;
+  serverResults: import("@angular/core").InputSignal<AutocompleteOption[]>;
+  loading: import("@angular/core").InputSignal<boolean>;
+  minChars: import("@angular/core").InputSignal<number>;
+  debounce: import("@angular/core").InputSignal<number>;
+  displayFn: import("@angular/core").InputSignal<((option: any) => string) | undefined>;
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  ariaDescribedby: import("@angular/core").InputSignal<string>;
+  invalid: import("@angular/core").InputSignal<boolean>;
+  /** Enable multiple selection with checkboxes */
+  multiple: import("@angular/core").InputSignal<boolean>;
+  /** Action button configuration */
+  action: import("@angular/core").InputSignal<AutocompleteActionButton | undefined>;
+  search: import("@angular/core").OutputEmitterRef<string>;
+  select: import("@angular/core").OutputEmitterRef<any>;
+  /** Emits when the action button is clicked */
+  actionClick: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly inputValue: import("@angular/core").WritableSignal<string>;
+  protected readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+  protected readonly selectedIndex: import("@angular/core").WritableSignal<number>;
+  protected readonly value: import("@angular/core").WritableSignal<any>;
+  protected readonly selectedValues: import("@angular/core").WritableSignal<any[]>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly dropdownPlacement: import("@angular/core").WritableSignal<"up" | "down">;
+  protected readonly dropdownMaxHeight: import("@angular/core").WritableSignal<number>;
+  protected readonly isInvalid: import("@angular/core").Signal<boolean>;
+  protected readonly hasAction: import("@angular/core").Signal<boolean>;
+  protected readonly isMultiple: import("@angular/core").Signal<boolean>;
+  /** Display text for multi-select showing count of selected items */
+  protected readonly displayText: import("@angular/core").Signal<string>;
+  protected readonly inputElement: import("@angular/core").Signal<ElementRef<any> | undefined>;
+  protected readonly dropdownElement: import("@angular/core").Signal<ElementRef<any> | undefined>;
+  protected readonly filteredOptions: import("@angular/core").Signal<AutocompleteOption[]>;
+  protected readonly inputClasses: import("@angular/core").Signal<string>;
+  protected readonly dropdownClasses: import("@angular/core").Signal<string>;
+  private onChange;
+  protected onTouched: () => void;
+  constructor();
+  ngOnDestroy(): void;
+  protected onInput(event: Event): void;
+  protected onKeyDown(event: KeyboardEvent): void;
+  protected onFocus(): void;
+  protected onBlur(): void;
+  protected selectOption(option: AutocompleteOption): void;
+  protected clearSelection(): void;
+  protected onActionClick(): void;
+  protected onDocumentClick(event: MouseEvent): void;
+  protected onViewportChange(): void;
+  private updateDropdownPlacement;
+  private findClippingParent;
+  private registerScrollParents;
+  private unregisterScrollParents;
+  private scrollToSelected;
+  private getDisplayValue;
+  writeValue(value: any): void;
+  registerOnChange(fn: (value: any) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  /** Check if an option is selected (for multi-select) */
+  protected isOptionSelected(option: AutocompleteOption): boolean;
+  /** Find option by value in all available options */
+  private findOption;
+  /** Get all selected option objects (for multi-select) */
+  getSelectedOptions(): AutocompleteOption[];
+  static ɵfac: i0.ɵɵFactoryDeclaration<AutocompleteComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<AutocompleteComponent, "hui-autocomplete", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "mode": {
+      "alias": "mode";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+    "serverResults": {
+      "alias": "serverResults";
+      "required": false;
+      "isSignal": true;
+    };
+    "loading": {
+      "alias": "loading";
+      "required": false;
+      "isSignal": true;
+    };
+    "minChars": {
+      "alias": "minChars";
+      "required": false;
+      "isSignal": true;
+    };
+    "debounce": {
+      "alias": "debounce";
+      "required": false;
+      "isSignal": true;
+    };
+    "displayFn": {
+      "alias": "displayFn";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "multiple": {
+      "alias": "multiple";
+      "required": false;
+      "isSignal": true;
+    };
+    "action": {
+      "alias": "action";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "search": "search";
+    "select": "select";
+    "actionClick": "actionClick";
+  }, never, never, true, never>;
+}
+export declare class CheckboxComponent implements ControlValueAccessor {
+  id: import("@angular/core").InputSignal<string>;
+  label: import("@angular/core").InputSignal<string>;
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  ariaDescribedby: import("@angular/core").InputSignal<string>;
+  class: import("@angular/core").InputSignal<string>;
+  fullWidth: import("@angular/core").InputSignal<boolean>;
+  protected readonly value: import("@angular/core").WritableSignal<boolean>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly checkboxId: import("@angular/core").Signal<string>;
+  protected readonly checkboxClasses: import("@angular/core").Signal<string>;
+  protected readonly containerClasses: import("@angular/core").Signal<"flex w-full items-center" | "flex items-center">;
+  protected readonly labelClasses: import("@angular/core").Signal<string>;
+  private onChangeFn;
+  protected onTouched: () => void;
+  protected onChange(event: Event): void;
+  writeValue(value: boolean): void;
+  registerOnChange(fn: (value: boolean) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "hui-checkbox", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+    "fullWidth": {
+      "alias": "fullWidth";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export interface CheckboxDropdownOption {
+  label: string;
+  value: string | boolean;
+  checked?: boolean;
+}
+export declare class CheckboxDropdownComponent {
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly options: import("@angular/core").InputSignal<CheckboxDropdownOption[]>;
+  readonly buttonClass: import("@angular/core").InputSignal<string>;
+  readonly icon: import("@angular/core").InputSignal<string>;
+  readonly selectionChange: import("@angular/core").OutputEmitterRef<CheckboxDropdownOption[]>;
+  protected readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+  protected readonly selectedOptions: import("@angular/core").WritableSignal<CheckboxDropdownOption[]>;
+  protected readonly selectedCount: import("@angular/core").Signal<number>;
+  protected readonly displayLabel: import("@angular/core").Signal<string>;
+  constructor();
+  protected toggleDropdown(): void;
+  protected closeDropdown(): void;
+  protected onCheckboxChange(option: CheckboxDropdownOption, checked: boolean): void;
+  protected isChecked(option: CheckboxDropdownOption): boolean;
+  protected clearAll(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxDropdownComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxDropdownComponent, "hui-checkbox-dropdown", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": true;
+      "isSignal": true;
+    };
+    "buttonClass": {
+      "alias": "buttonClass";
+      "required": false;
+      "isSignal": true;
+    };
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "selectionChange": "selectionChange";
+  }, never, never, true, never>;
+}
+export type ChoiceChipsLayout = 'inline' | 'wrap';
+export type ChoiceChipsValue = unknown | unknown[] | null;
+export interface ChoiceChipsActionButton {
+  icon: string;
+  ariaLabel: string;
+  tooltip?: string;
+}
+export declare class ChoiceChipsComponent implements ControlValueAccessor {
+  protected readonly localization: LocalizationService;
+  readonly id: import("@angular/core").InputSignal<string>;
+  readonly options: import("@angular/core").InputSignal<SelectOption$1[]>;
+  readonly multiple: import("@angular/core").InputSignal<boolean>;
+  readonly layout: import("@angular/core").InputSignal<ChoiceChipsLayout>;
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  readonly ariaDescribedby: import("@angular/core").InputSignal<string>;
+  readonly invalid: import("@angular/core").InputSignal<boolean>;
+  readonly action: import("@angular/core").InputSignal<ChoiceChipsActionButton | undefined>;
+  readonly actionClick: import("@angular/core").OutputEmitterRef<void>;
+  private readonly generatedId;
+  protected readonly value: import("@angular/core").WritableSignal<unknown>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly controlId: import("@angular/core").Signal<string>;
+  protected readonly groupClasses: import("@angular/core").Signal<"flex min-w-0 flex-1 flex-nowrap gap-2 overflow-x-auto py-0.5" | "flex flex-1 flex-wrap gap-2 py-0.5">;
+  private onChangeFn;
+  private onTouchedFn;
+  protected optionId(index: number): string;
+  protected isSelected(option: SelectOption$1): boolean;
+  protected optionClasses(option: SelectOption$1): string;
+  protected selectOption(option: SelectOption$1): void;
+  protected onBlur(): void;
+  protected onActionClick(): void;
+  writeValue(value: ChoiceChipsValue | undefined): void;
+  registerOnChange(fn: (value: ChoiceChipsValue) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ChoiceChipsComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ChoiceChipsComponent, "hui-choice-chips", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+    "multiple": {
+      "alias": "multiple";
+      "required": false;
+      "isSignal": true;
+    };
+    "layout": {
+      "alias": "layout";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "action": {
+      "alias": "action";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "actionClick": "actionClick";
+  }, never, never, true, never>;
+}
+export type DateInputMode = 'date' | 'datetime-local' | 'month' | 'year';
+export declare class DateInputComponent implements ControlValueAccessor {
+  id: import("@angular/core").InputSignal<string>;
+  mode: import("@angular/core").InputSignal<DateInputMode>;
+  placeholder: import("@angular/core").InputSignal<string>;
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  ariaDescribedby: import("@angular/core").InputSignal<string>;
+  invalid: import("@angular/core").InputSignal<boolean>;
+  class: import("@angular/core").InputSignal<string>;
+  min: import("@angular/core").InputSignal<string>;
+  max: import("@angular/core").InputSignal<string>;
+  protected readonly value: import("@angular/core").WritableSignal<string>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly isInvalid: import("@angular/core").Signal<boolean>;
+  protected readonly inputType: import("@angular/core").Signal<"number" | "date" | "month" | "datetime-local">;
+  protected readonly inputClasses: import("@angular/core").Signal<string>;
+  private onChange;
+  protected onTouched: () => void;
+  protected onInput(event: Event): void;
+  writeValue(value: string): void;
+  registerOnChange(fn: (value: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DateInputComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<DateInputComponent, "hui-date-input", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "mode": {
+      "alias": "mode";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+    "min": {
+      "alias": "min";
+      "required": false;
+      "isSignal": true;
+    };
+    "max": {
+      "alias": "max";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class EmailInputComponent implements ControlValueAccessor {
+  id: import("@angular/core").InputSignal<string>;
+  placeholder: import("@angular/core").InputSignal<string>;
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  ariaDescribedby: import("@angular/core").InputSignal<string>;
+  displayInvalid: import("@angular/core").InputSignal<boolean>;
+  protected readonly value: import("@angular/core").WritableSignal<string>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly isInvalid: import("@angular/core").Signal<boolean>;
+  protected readonly inputClasses: import("@angular/core").Signal<string>;
+  private onChange;
+  protected onTouched: () => void;
+  protected onInput(event: Event): void;
+  writeValue(value: string): void;
+  registerOnChange(fn: (value: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<EmailInputComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<EmailInputComponent, "hui-email-input", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "displayInvalid": {
+      "alias": "displayInvalid";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export interface FileInfo {
+  file: File;
+  name: string;
+  size: number;
+  type: string;
+}
+export declare class FileInputComponent implements ControlValueAccessor {
+  id: import("@angular/core").InputSignal<string>;
+  placeholder: import("@angular/core").InputSignal<string>;
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  ariaDescribedby: import("@angular/core").InputSignal<string>;
+  invalid: import("@angular/core").InputSignal<boolean>;
+  accept: import("@angular/core").InputSignal<string>;
+  multiple: import("@angular/core").InputSignal<boolean>;
+  maxSize: import("@angular/core").InputSignal<number | undefined>;
+  maxFiles: import("@angular/core").InputSignal<number | undefined>;
+  enableDragDrop: import("@angular/core").InputSignal<boolean>;
+  protected readonly files: import("@angular/core").WritableSignal<FileInfo[]>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly isDragOver: import("@angular/core").WritableSignal<boolean>;
+  protected readonly validationError: import("@angular/core").WritableSignal<string>;
+  protected readonly isInvalid: import("@angular/core").Signal<boolean>;
+  protected readonly acceptDescription: import("@angular/core").Signal<string>;
+  protected readonly dropZoneClasses: import("@angular/core").Signal<string>;
+  protected readonly buttonClasses: import("@angular/core").Signal<string>;
+  private onChange;
+  protected onTouched: () => void;
+  protected onFileSelect(event: Event): void;
+  protected onDragOver(event: DragEvent): void;
+  protected onDragLeave(event: DragEvent): void;
+  protected onDrop(event: DragEvent): void;
+  protected removeFile(fileInfo: FileInfo): void;
+  protected formatBytes(bytes: number): string;
+  protected getFileIcon(mimeType: string): string;
+  private addFiles;
+  private isFileTypeValid;
+  private emitChange;
+  writeValue(value: File[] | null): void;
+  registerOnChange(fn: (value: File[]) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FileInputComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FileInputComponent, "hui-file-input", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "accept": {
+      "alias": "accept";
+      "required": false;
+      "isSignal": true;
+    };
+    "multiple": {
+      "alias": "multiple";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxSize": {
+      "alias": "maxSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxFiles": {
+      "alias": "maxFiles";
+      "required": false;
+      "isSignal": true;
+    };
+    "enableDragDrop": {
+      "alias": "enableDragDrop";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class FormDescriptionComponent {
+  id: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FormDescriptionComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FormDescriptionComponent, "hui-form-description", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare class FormErrorComponent {
+  show: import("@angular/core").InputSignal<boolean>;
+  id: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FormErrorComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FormErrorComponent, "hui-form-error", never, {
+    "show": {
+      "alias": "show";
+      "required": false;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare class FormFieldComponent {
+  private readonly destroyRef;
+  protected readonly localization: LocalizationService;
+  label: import("@angular/core").InputSignal<string>;
+  hint: import("@angular/core").InputSignal<string>;
+  helper: import("@angular/core").InputSignal<string>;
+  description: import("@angular/core").InputSignal<string>;
+  layout: import("@angular/core").InputSignal<"column" | "row" | "stacked">;
+  note: import("@angular/core").InputSignal<string>;
+  noteVariant: import("@angular/core").InputSignal<"info" | "warning" | "success" | "error" | "neutral">;
+  noteClasses: import("@angular/core").InputSignal<string>;
+  required: import("@angular/core").InputSignal<boolean>;
+  fieldName: import("@angular/core").InputSignal<string>;
+  validationStrategy: import("@angular/core").InputSignal<"submit" | "touched">;
+  formSubmitted: import("@angular/core").InputSignal<boolean>;
+  inputId: import("@angular/core").InputSignal<string>;
+  type: import("@angular/core").InputSignal<FieldType>;
+  control: import("@angular/core").InputSignal<FormControl<any> | null>;
+  private readonly uniqueId;
+  readonly fieldId: import("@angular/core").Signal<string>;
+  protected readonly controlTouched: import("@angular/core").WritableSignal<boolean>;
+  protected readonly controlInvalid: import("@angular/core").WritableSignal<boolean>;
+  protected readonly controlDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly controlErrors: import("@angular/core").WritableSignal<any>;
+  constructor();
+  protected readonly computedInputId: import("@angular/core").Signal<string>;
+  protected readonly hintId: import("@angular/core").Signal<string>;
+  protected readonly descriptionId: import("@angular/core").Signal<string>;
+  protected readonly errorId: import("@angular/core").Signal<string>;
+  protected readonly isDisabled: import("@angular/core").Signal<boolean>;
+  readonly showError: import("@angular/core").Signal<boolean>;
+  protected readonly errorMessage: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldComponent, "hui-form-field", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "hint": {
+      "alias": "hint";
+      "required": false;
+      "isSignal": true;
+    };
+    "helper": {
+      "alias": "helper";
+      "required": false;
+      "isSignal": true;
+    };
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+    "layout": {
+      "alias": "layout";
+      "required": false;
+      "isSignal": true;
+    };
+    "note": {
+      "alias": "note";
+      "required": false;
+      "isSignal": true;
+    };
+    "noteVariant": {
+      "alias": "noteVariant";
+      "required": false;
+      "isSignal": true;
+    };
+    "noteClasses": {
+      "alias": "noteClasses";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "fieldName": {
+      "alias": "fieldName";
+      "required": false;
+      "isSignal": true;
+    };
+    "validationStrategy": {
+      "alias": "validationStrategy";
+      "required": false;
+      "isSignal": true;
+    };
+    "formSubmitted": {
+      "alias": "formSubmitted";
+      "required": false;
+      "isSignal": true;
+    };
+    "inputId": {
+      "alias": "inputId";
+      "required": false;
+      "isSignal": true;
+    };
+    "type": {
+      "alias": "type";
+      "required": false;
+      "isSignal": true;
+    };
+    "control": {
+      "alias": "control";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+type PopoverPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+export declare class FormHelperComponent {
+  id: import("@angular/core").InputSignal<string>;
+  label: import("@angular/core").InputSignal<string>;
+  protected readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+  protected readonly position: import("@angular/core").WritableSignal<PopoverPosition>;
+  private readonly triggerButton;
+  protected togglePopover(): void;
+  protected onBlur(): void;
+  private calculatePosition;
+  protected getPopoverPositionClasses(): string;
+  protected getArrowClasses(): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FormHelperComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FormHelperComponent, "hui-form-helper", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare class FormHintComponent {
+  id: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FormHintComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FormHintComponent, "hui-form-hint", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare class FormLabelComponent {
+  htmlFor: import("@angular/core").InputSignal<string>;
+  required: import("@angular/core").InputSignal<boolean>;
+  class: import("@angular/core").InputSignal<string>;
+  type: import("@angular/core").InputSignal<FieldType>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FormLabelComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FormLabelComponent, "hui-form-label", never, {
+    "htmlFor": {
+      "alias": "htmlFor";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+    "type": {
+      "alias": "type";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare class FormNoteComponent {
+  id: import("@angular/core").InputSignal<string>;
+  variant: import("@angular/core").InputSignal<"info" | "warning" | "success" | "error" | "neutral">;
+  customClasses: import("@angular/core").InputSignal<string>;
+  protected readonly noteClasses: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FormNoteComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FormNoteComponent, "hui-form-note", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "customClasses": {
+      "alias": "customClasses";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare class ImageSelectorInputComponent implements ControlValueAccessor {
+  protected readonly mediaSelector: import("@harmolody/ui").MediaSelector | null;
+  id: import("@angular/core").InputSignal<string>;
+  placeholder: import("@angular/core").InputSignal<string>;
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  ariaDescribedby: import("@angular/core").InputSignal<string>;
+  invalid: import("@angular/core").InputSignal<boolean>;
+  altText: import("@angular/core").InputSignal<string>;
+  mediaType: import("@angular/core").InputSignal<string>;
+  allowUpload: import("@angular/core").InputSignal<boolean>;
+  selectionMode: import("@angular/core").InputSignal<"single" | "multiple">;
+  showPreview: import("@angular/core").InputSignal<boolean>;
+  editableInput: import("@angular/core").InputSignal<boolean>;
+  protected readonly value: import("@angular/core").WritableSignal<string | null>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly imageError: import("@angular/core").WritableSignal<boolean>;
+  protected readonly isInvalid: import("@angular/core").Signal<boolean>;
+  protected readonly inputClasses: import("@angular/core").Signal<string>;
+  protected readonly browseButtonClasses: import("@angular/core").Signal<string>;
+  protected readonly clearButtonClasses: import("@angular/core").Signal<string>;
+  private onChange;
+  protected onTouched: () => void;
+  protected openMediaSelector(): Promise<void>;
+  protected clearSelection(): void;
+  protected onImageError(): void;
+  protected onInputChange(event: Event): void;
+  private setImage;
+  writeValue(value: string | null): void;
+  registerOnChange(fn: (value: string | null) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ImageSelectorInputComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ImageSelectorInputComponent, "hui-image-selector-input", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "altText": {
+      "alias": "altText";
+      "required": false;
+      "isSignal": true;
+    };
+    "mediaType": {
+      "alias": "mediaType";
+      "required": false;
+      "isSignal": true;
+    };
+    "allowUpload": {
+      "alias": "allowUpload";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectionMode": {
+      "alias": "selectionMode";
+      "required": false;
+      "isSignal": true;
+    };
+    "showPreview": {
+      "alias": "showPreview";
+      "required": false;
+      "isSignal": true;
+    };
+    "editableInput": {
+      "alias": "editableInput";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class InputComponent implements ControlValueAccessor {
+  id: import("@angular/core").InputSignal<string>;
+  type: import("@angular/core").InputSignal<string>;
+  placeholder: import("@angular/core").InputSignal<string>;
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  ariaDescribedby: import("@angular/core").InputSignal<string>;
+  invalid: import("@angular/core").InputSignal<boolean>;
+  class: import("@angular/core").InputSignal<string>;
+  protected readonly value: import("@angular/core").WritableSignal<string>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly isInvalid: import("@angular/core").Signal<boolean>;
+  protected readonly inputClasses: import("@angular/core").Signal<string>;
+  private onChange;
+  protected onTouched: () => void;
+  protected onInput(event: Event): void;
+  writeValue(value: string): void;
+  registerOnChange(fn: (value: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent, "hui-input", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "type": {
+      "alias": "type";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class NumberInputComponent implements ControlValueAccessor {
+  id: import("@angular/core").InputSignal<string>;
+  placeholder: import("@angular/core").InputSignal<string>;
+  min: import("@angular/core").InputSignal<number | undefined>;
+  max: import("@angular/core").InputSignal<number | undefined>;
+  step: import("@angular/core").InputSignal<number>;
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  ariaDescribedby: import("@angular/core").InputSignal<string>;
+  invalid: import("@angular/core").InputSignal<boolean>;
+  protected readonly value: import("@angular/core").WritableSignal<number | null>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly isInvalid: import("@angular/core").Signal<boolean>;
+  protected readonly inputClasses: import("@angular/core").Signal<string>;
+  private onChange;
+  protected onTouched: () => void;
+  protected onInput(event: Event): void;
+  writeValue(value: number | null): void;
+  registerOnChange(fn: (value: number | null) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NumberInputComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<NumberInputComponent, "hui-number-input", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "min": {
+      "alias": "min";
+      "required": false;
+      "isSignal": true;
+    };
+    "max": {
+      "alias": "max";
+      "required": false;
+      "isSignal": true;
+    };
+    "step": {
+      "alias": "step";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class PasswordInputComponent implements ControlValueAccessor {
+  id: import("@angular/core").InputSignal<string>;
+  placeholder: import("@angular/core").InputSignal<string>;
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  ariaDescribedby: import("@angular/core").InputSignal<string>;
+  displayInvalid: import("@angular/core").InputSignal<boolean>;
+  protected readonly value: import("@angular/core").WritableSignal<string>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly showPassword: import("@angular/core").WritableSignal<boolean>;
+  protected readonly isInvalid: import("@angular/core").Signal<boolean>;
+  protected readonly inputClasses: import("@angular/core").Signal<string>;
+  private onChange;
+  protected onTouched: () => void;
+  protected togglePasswordVisibility(): void;
+  protected onInput(event: Event): void;
+  writeValue(value: string): void;
+  registerOnChange(fn: (value: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PasswordInputComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<PasswordInputComponent, "hui-password-input", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "displayInvalid": {
+      "alias": "displayInvalid";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export interface RadioOption {
+  label: string;
+  value: string | number;
+  disabled?: boolean;
+}
+export declare class RadioGroupComponent implements ControlValueAccessor {
+  id: import("@angular/core").InputSignal<string>;
+  name: import("@angular/core").InputSignal<string>;
+  options: import("@angular/core").InputSignal<RadioOption[]>;
+  inline: import("@angular/core").InputSignal<boolean>;
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  class: import("@angular/core").InputSignal<string>;
+  protected readonly value: import("@angular/core").WritableSignal<string | number | null>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly radioClasses: import("@angular/core").Signal<string>;
+  private onChangeFn;
+  protected onTouched: () => void;
+  protected onChange(value: string | number): void;
+  writeValue(value: string | number | null): void;
+  registerOnChange(fn: (value: string | number | null) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RadioGroupComponent, "hui-radio-group", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+    "inline": {
+      "alias": "inline";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class SearchInputComponent implements ControlValueAccessor {
+  protected readonly localization: LocalizationService;
+  readonly id: import("@angular/core").InputSignal<string>;
+  readonly placeholder: import("@angular/core").InputSignal<string>;
+  readonly showClear: import("@angular/core").InputSignal<boolean>;
+  readonly clearLabel: import("@angular/core").InputSignal<string>;
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  readonly ariaDescribedby: import("@angular/core").InputSignal<string>;
+  readonly invalid: import("@angular/core").InputSignal<boolean>;
+  readonly class: import("@angular/core").InputSignal<string>;
+  /** Emitted when Enter is pressed and after the clear action. */
+  readonly search: import("@angular/core").OutputEmitterRef<string>;
+  /** Emitted only when the clear action is used. */
+  readonly cleared: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly inputElement: import("@angular/core").Signal<ElementRef<HTMLInputElement> | undefined>;
+  protected readonly value: import("@angular/core").WritableSignal<string>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly hasValue: import("@angular/core").Signal<boolean>;
+  protected readonly accessibleLabel: import("@angular/core").Signal<string>;
+  protected readonly inputClasses: import("@angular/core").Signal<string>;
+  private onChangeFn;
+  private onTouchedFn;
+  protected onInput(event: Event): void;
+  protected submitSearch(): void;
+  protected clear(): void;
+  protected markTouched(): void;
+  writeValue(value: string | null | undefined): void;
+  registerOnChange(fn: (value: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SearchInputComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SearchInputComponent, "hui-search-input", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "showClear": {
+      "alias": "showClear";
+      "required": false;
+      "isSignal": true;
+    };
+    "clearLabel": {
+      "alias": "clearLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "search": "search";
+    "cleared": "cleared";
+  }, never, never, true, never>;
+}
+type SelectValue = string | number;
+type SelectControlValue = SelectValue | SelectValue[] | null;
+type SelectDropdownAlign = 'left' | 'right';
+type SelectDropdownPlacement = 'top' | 'bottom';
+type SelectDropdownWidth = 'trigger' | 'content';
+interface SelectOption {
+  label: string;
+  value: SelectValue;
+  disabled?: boolean;
+}
+/** Configuration for an action button alongside the select. */
+interface SelectActionButton {
+  /** Icon name from the icon set. */
+  icon: string;
+  /** Aria label for accessibility. */
+  ariaLabel: string;
+  /** Tooltip text. */
+  tooltip?: string;
+}
+export declare class SelectComponent implements ControlValueAccessor, OnDestroy {
+  protected readonly localization: LocalizationService;
+  readonly id: import("@angular/core").InputSignal<string>;
+  readonly placeholder: import("@angular/core").InputSignal<string>;
+  readonly options: import("@angular/core").InputSignal<SelectOption[]>;
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  readonly ariaDescribedby: import("@angular/core").InputSignal<string>;
+  readonly invalid: import("@angular/core").InputSignal<boolean>;
+  readonly class: import("@angular/core").InputSignal<string>;
+  /** Allows the control to emit an array and keep the dropdown open while selecting. */
+  readonly multiple: import("@angular/core").InputSignal<boolean>;
+  /** Horizontal edge used to anchor the dropdown panel. */
+  readonly dropdownAlign: import("@angular/core").InputSignal<SelectDropdownAlign>;
+  /** Matches the trigger width by default, or expands to fit option content. */
+  readonly dropdownWidth: import("@angular/core").InputSignal<SelectDropdownWidth>;
+  /** Maximum height for the scrollable options area before viewport constraints are applied. */
+  readonly maxDropdownHeight: import("@angular/core").InputSignal<number>;
+  /** Space retained between the dropdown and the viewport edge. */
+  readonly viewportPadding: import("@angular/core").InputSignal<number>;
+  /** Prevents compact layouts and short values from collapsing the control. */
+  readonly minWidth: import("@angular/core").InputSignal<string>;
+  /** Action button configuration. */
+  readonly action: import("@angular/core").InputSignal<SelectActionButton | undefined>;
+  /** Emits when the action button is clicked. */
+  readonly actionClick: import("@angular/core").OutputEmitterRef<void>;
+  private readonly generatedId;
+  private typeaheadQuery;
+  private typeaheadTimer;
+  private placementTimer;
+  private viewportListenersRegistered;
+  private dropdownResizeObserver;
+  private readonly onViewportChange;
+  protected readonly triggerElement: import("@angular/core").Signal<ElementRef<HTMLButtonElement> | undefined>;
+  protected readonly dropdownElement: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+  protected readonly dropdownHeaderElement: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+  protected readonly optionsViewportElement: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+  protected readonly value: import("@angular/core").WritableSignal<SelectControlValue>;
+  protected readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+  protected readonly activeIndex: import("@angular/core").WritableSignal<number>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly dropdownPlacement: import("@angular/core").WritableSignal<SelectDropdownPlacement>;
+  protected readonly availableOptionsHeight: import("@angular/core").WritableSignal<number>;
+  protected readonly isInvalid: import("@angular/core").Signal<boolean>;
+  protected readonly hasAction: import("@angular/core").Signal<boolean>;
+  protected readonly controlId: import("@angular/core").Signal<string>;
+  protected readonly listboxId: import("@angular/core").Signal<string>;
+  protected readonly selectedValues: import("@angular/core").Signal<SelectValue[]>;
+  protected readonly selectedCount: import("@angular/core").Signal<number>;
+  protected readonly hasSelection: import("@angular/core").Signal<boolean>;
+  protected readonly displayLabel: import("@angular/core").Signal<string>;
+  protected readonly panelLabel: import("@angular/core").Signal<string>;
+  protected readonly triggerClasses: import("@angular/core").Signal<string>;
+  protected readonly dropdownClasses: import("@angular/core").Signal<string>;
+  private onChangeFn;
+  private onTouchedFn;
+  protected toggleDropdown(): void;
+  protected closeDropdown(markTouched?: boolean): void;
+  protected selectOption(option: SelectOption): void;
+  protected clearAll(event: MouseEvent): void;
+  protected onTriggerKeydown(event: KeyboardEvent): void;
+  protected isOptionSelected(option: SelectOption): boolean;
+  protected optionId(index: number): string;
+  protected optionClasses(option: SelectOption, index: number): string;
+  protected onActionClick(): void;
+  writeValue(value: SelectControlValue | undefined): void;
+  registerOnChange(fn: (value: SelectControlValue) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  ngOnDestroy(): void;
+  private openDropdown;
+  private startDropdownPositionTracking;
+  private stopDropdownPositionTracking;
+  private scheduleDropdownPlacementUpdate;
+  private updateDropdownPlacement;
+  private getPlacementViewport;
+  private moveActiveOption;
+  private findNextEnabledIndex;
+  private handleTypeahead;
+  private resetTypeahead;
+  private scrollActiveOptionIntoView;
+  private findOption;
+  private includesValue;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "hui-select", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+    "multiple": {
+      "alias": "multiple";
+      "required": false;
+      "isSignal": true;
+    };
+    "dropdownAlign": {
+      "alias": "dropdownAlign";
+      "required": false;
+      "isSignal": true;
+    };
+    "dropdownWidth": {
+      "alias": "dropdownWidth";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxDropdownHeight": {
+      "alias": "maxDropdownHeight";
+      "required": false;
+      "isSignal": true;
+    };
+    "viewportPadding": {
+      "alias": "viewportPadding";
+      "required": false;
+      "isSignal": true;
+    };
+    "minWidth": {
+      "alias": "minWidth";
+      "required": false;
+      "isSignal": true;
+    };
+    "action": {
+      "alias": "action";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "actionClick": "actionClick";
+  }, never, never, true, never>;
+}
+export declare class SwitchComponent implements ControlValueAccessor {
+  id: import("@angular/core").InputSignal<string>;
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  ariaDescribedby: import("@angular/core").InputSignal<string>;
+  protected readonly checked: import("@angular/core").WritableSignal<boolean>;
+  protected readonly disabled: import("@angular/core").WritableSignal<boolean>;
+  private onChange;
+  protected onTouched: () => void;
+  protected toggle(): void;
+  writeValue(value: boolean): void;
+  registerOnChange(fn: (value: boolean) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(disabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SwitchComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SwitchComponent, "hui-switch", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class TelInputComponent implements ControlValueAccessor {
+  id: import("@angular/core").InputSignal<string>;
+  placeholder: import("@angular/core").InputSignal<string>;
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  ariaDescribedby: import("@angular/core").InputSignal<string>;
+  invalid: import("@angular/core").InputSignal<boolean>;
+  protected readonly value: import("@angular/core").WritableSignal<string>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly isInvalid: import("@angular/core").Signal<boolean>;
+  protected readonly inputClasses: import("@angular/core").Signal<string>;
+  private onChange;
+  protected onTouched: () => void;
+  protected onInput(event: Event): void;
+  writeValue(value: string): void;
+  registerOnChange(fn: (value: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TelInputComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<TelInputComponent, "hui-tel-input", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class TextareaComponent implements ControlValueAccessor {
+  id: import("@angular/core").InputSignal<string>;
+  placeholder: import("@angular/core").InputSignal<string>;
+  rows: import("@angular/core").InputSignal<number>;
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  ariaDescribedby: import("@angular/core").InputSignal<string>;
+  invalid: import("@angular/core").InputSignal<boolean>;
+  class: import("@angular/core").InputSignal<string>;
+  protected readonly value: import("@angular/core").WritableSignal<string>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly isInvalid: import("@angular/core").Signal<boolean>;
+  protected readonly inputClasses: import("@angular/core").Signal<string>;
+  private onChange;
+  protected onTouched: () => void;
+  protected onInput(event: Event): void;
+  writeValue(value: string): void;
+  registerOnChange(fn: (value: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TextareaComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<TextareaComponent, "hui-textarea", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "rows": {
+      "alias": "rows";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class UrlInputComponent implements ControlValueAccessor {
+  id: import("@angular/core").InputSignal<string>;
+  placeholder: import("@angular/core").InputSignal<string>;
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  ariaDescribedby: import("@angular/core").InputSignal<string>;
+  invalid: import("@angular/core").InputSignal<boolean>;
+  protected readonly value: import("@angular/core").WritableSignal<string>;
+  protected readonly isDisabled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly isInvalid: import("@angular/core").Signal<boolean>;
+  protected readonly inputClasses: import("@angular/core").Signal<string>;
+  private onChange;
+  protected onTouched: () => void;
+  protected onInput(event: Event): void;
+  writeValue(value: string): void;
+  registerOnChange(fn: (value: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UrlInputComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UrlInputComponent, "hui-url-input", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedby": {
+      "alias": "ariaDescribedby";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalid": {
+      "alias": "invalid";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare const FORM_CONTROL_BASE_CLASSES = "w-full pl-3 pr-3 py-2 border rounded-lg shadow placeholder-gray-400 focus:outline-none focus:ring-1 bg-surface placeholder:text-md disabled:opacity-50 disabled:cursor-not-allowed";
+interface FormControlClassOptions {
+  invalid?: boolean;
+  additionalClasses?: string;
+  customClasses?: string;
+}
+export declare function buildFormControlClasses(options?: FormControlClassOptions): string;
+/**
+ * Maps Angular validation errors to user-friendly error messages
+ */
+export declare function getErrorMessage(errors: ValidationErrors | null | undefined, fieldName?: string): string;
+/**
+ * Gets all error messages for a control
+ */
+export declare function getErrorMessages(errors: ValidationErrors | null | undefined, fieldName?: string): string[];
+export declare class IconComponent {
+  private readonly config;
+  /** Icon name from the icons constant */
+  name: import("@angular/core").InputSignal<string>;
+  /** Size in pixels */
+  size: import("@angular/core").InputSignal<number>;
+  /** Custom CSS classes */
+  customClass: import("@angular/core").InputSignal<string>;
+  /** Accessible label for the icon */
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  /** Get icon data from the icons constant */
+  protected readonly iconData: import("@angular/core").Signal<import("@harmolody/ui").SvgIcon | undefined>;
+  /** Convert path to array for consistent handling */
+  protected readonly paths: import("@angular/core").Signal<string[] | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "hui-icon", never, {
+    "name": {
+      "alias": "name";
+      "required": true;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "customClass": {
+      "alias": "customClass";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * SVG Icon definitions as objects
+ * Each icon contains the SVG path data and optional viewBox
+ */
+export interface SvgIcon {
+  path: string | string[];
+  viewBox?: string;
+  strokeWidth?: number;
+  fill?: string;
+  stroke?: string;
+}
+export declare const ICONS: Record<string, SvgIcon>;
+/**
+ * Helper function to get icon data
+ */
+export declare function getIcon(name: string): SvgIcon | undefined;
+/**
+ * Helper function to check if icon exists
+ */
+export declare function hasIcon(name: string): boolean;
+export declare class TableCellDirective<T = unknown> {
+  readonly columnKey: import("@angular/core").InputSignal<string>;
+  readonly templateRef: TemplateRef<any>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TableCellDirective<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<TableCellDirective<any>, "ng-template[huiTableCell]", never, {
+    "columnKey": {
+      "alias": "huiTableCell";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export type ColumnAlign = 'left' | 'center' | 'right';
+export type SortDirection = 'asc' | 'desc' | null;
+export interface TableCellContext<T = unknown> {
+  $implicit: unknown;
+  row: T;
+  index: number;
+  column: TableColumn<T>;
+}
+export interface TableColumn<T = any> {
+  key: string;
+  label: string;
+  sortable?: boolean;
+  align?: ColumnAlign;
+  headerAlign?: ColumnAlign;
+  width?: string;
+  type?: 'text' | 'image' | 'icon' | 'link' | 'component' | 'template';
+  imageClass?: string;
+  imageFallback?: string;
+  icon?: string | ((value: any, row: T, index: number) => string);
+  iconClass?: string | ((value: any, row: T, index: number) => string);
+  iconLabel?: string | ((value: any, row: T, index: number) => string);
+  iconSize?: number;
+  linkGenerator?: (row: T) => string | null;
+  linkTarget?: '_blank' | '_self';
+  onClick?: (row: T) => void;
+  render?: (value: any, row: T, index: number) => string | null;
+  component?: Type<any>;
+  componentInputs?: (row: T, value: any, index: number) => Record<string, any>;
+  template?: TemplateRef<TableCellContext<T>>;
+  cellClass?: string | ((value: any, row: T) => string);
+  hideable?: boolean;
+  hideOnScreens?: ('sm' | 'md' | 'lg' | 'xl')[];
+}
+export interface TableAction<T = any> {
+  label: string;
+  icon?: string;
+  onClick?: (row: T, index: number) => void;
+  disabled?: (row: T) => boolean;
+  hidden?: (row: T) => boolean;
+  variant?: 'primary' | 'secondary' | 'danger' | 'success';
+  title?: string;
+  submenu?: TableAction<T>[];
+  divider?: boolean;
+}
+export interface TableSort {
+  column: string;
+  direction: SortDirection;
+}
+export interface TablePagination {
+  layout?: 'stacked';
+  page: number;
+  pageSize: number;
+  total: number;
+  pageSizeOptions?: number[];
+}
+export interface TableSelection<T = any> {
+  mode: 'none' | 'single' | 'multiple';
+  selectedRows: T[];
+  onSelectionChange?: (rows: T[]) => void;
+}
+export interface TableRowReorderEvent<T = any> {
+  row: T;
+  previousIndex: number;
+  currentIndex: number;
+  data: T[];
+}
+export interface TableRowReorder<T = any> {
+  enabled: boolean;
+  disabled?: (row: T, index: number) => boolean;
+  onDisabledAttempt?: (row: T, index: number) => void;
+  onReorder?: (event: TableRowReorderEvent<T>) => void;
+}
+export interface TableConfig<T = any> {
+  columns: TableColumn<T>[];
+  data: T[];
+  rowKey?: keyof T | ((row: T) => string | number);
+  actions?: TableAction<T>[];
+  pagination?: TablePagination;
+  selection?: TableSelection<T>;
+  sort?: TableSort;
+  loading?: boolean;
+  emptyMessage?: string;
+  headerAlign?: ColumnAlign;
+  stickyHeader?: boolean;
+  showHeader?: boolean;
+  showHeaderOnlyOnScroll?: boolean;
+  maxHeight?: string;
+  rowReorder?: TableRowReorder<T>;
+  bordered?: boolean;
+  striped?: boolean;
+  hoverable?: boolean;
+  compact?: boolean;
+  showRowNumbers?: boolean;
+  onSort?: (sort: TableSort) => void;
+  onPageChange?: (page: number) => void;
+  onPageSizeChange?: (pageSize: number) => void;
+  onRowClick?: (row: T, index: number) => void;
+  rowClass?: string | ((row: T, index: number) => string);
+}
+export declare class TableColumnSelectorComponent {
+  readonly allColumns: import("@angular/core").InputSignal<TableColumn<any>[]>;
+  readonly visibleColumnKeys: import("@angular/core").InputSignal<string[]>;
+  readonly class: import("@angular/core").InputSignal<string>;
+  readonly visibleColumnsChange: import("@angular/core").OutputEmitterRef<string[]>;
+  protected readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+  protected readonly hideableColumns: import("@angular/core").Signal<TableColumn<any>[]>;
+  protected readonly buttonClasses: import("@angular/core").Signal<string>;
+  protected readonly allSelected: import("@angular/core").Signal<boolean>;
+  protected readonly someSelected: import("@angular/core").Signal<boolean>;
+  protected toggleDropdown(): void;
+  protected closeDropdown(): void;
+  protected isColumnVisible(key: string): boolean;
+  protected toggleColumn(key: string): void;
+  protected onColumnVisibilityChange(key: string, checked: boolean): void;
+  protected selectAll(): void;
+  protected deselectAll(): void;
+  protected resetToDefault(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnSelectorComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnSelectorComponent, "hui-table-column-selector", never, {
+    "allColumns": {
+      "alias": "allColumns";
+      "required": true;
+      "isSignal": true;
+    };
+    "visibleColumnKeys": {
+      "alias": "visibleColumnKeys";
+      "required": true;
+      "isSignal": true;
+    };
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "visibleColumnsChange": "visibleColumnsChange";
+  }, never, never, true, never>;
+}
+export declare class TableComponent<T = any> {
+  protected readonly localization: LocalizationService;
+  protected readonly instanceId: string;
+  readonly config: import("@angular/core").InputSignal<TableConfig<T>>;
+  readonly sortChange: import("@angular/core").OutputEmitterRef<TableSort>;
+  readonly pageChange: import("@angular/core").OutputEmitterRef<number>;
+  readonly pageSizeChange: import("@angular/core").OutputEmitterRef<number>;
+  readonly selectionChange: import("@angular/core").OutputEmitterRef<T[]>;
+  readonly rowReorder: import("@angular/core").OutputEmitterRef<TableRowReorderEvent<T>>;
+  private readonly customCellTemplates;
+  private inputDataReference;
+  protected readonly Math: Math;
+  constructor();
+  protected readonly selectedRows: import("@angular/core").WritableSignal<Set<string | number>>;
+  protected readonly currentSort: import("@angular/core").WritableSignal<TableSort>;
+  protected readonly openDropdowns: import("@angular/core").WritableSignal<Set<string>>;
+  protected readonly tableRows: import("@angular/core").WritableSignal<T[]>;
+  protected readonly draggedRowIndex: import("@angular/core").WritableSignal<number | null>;
+  protected readonly dragOverRowIndex: import("@angular/core").WritableSignal<number | null>;
+  protected readonly isTableScrolled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly dropdownPosition: import("@angular/core").WritableSignal<{
+    top: number | null;
+    bottom: number | null;
+    left: number;
+  }>;
+  protected readonly hasActions: import("@angular/core").Signal<boolean | undefined>;
+  protected readonly hasSelection: import("@angular/core").Signal<boolean | undefined>;
+  protected readonly isMultiSelect: import("@angular/core").Signal<boolean>;
+  protected readonly showRowNumbers: import("@angular/core").Signal<boolean>;
+  protected readonly hasStickyHeader: import("@angular/core").Signal<boolean>;
+  protected readonly shouldRenderHeader: import("@angular/core").Signal<boolean>;
+  protected readonly isHeaderVisible: import("@angular/core").Signal<boolean>;
+  protected readonly tableMaxHeight: import("@angular/core").Signal<string | null>;
+  protected readonly hasRowReordering: import("@angular/core").Signal<boolean>;
+  protected readonly allRowsSelected: import("@angular/core").Signal<boolean>;
+  protected readonly someRowsSelected: import("@angular/core").Signal<boolean>;
+  protected readonly displayedData: import("@angular/core").Signal<T[]>;
+  protected readonly totalPages: import("@angular/core").Signal<number>;
+  protected readonly pageNumbers: import("@angular/core").Signal<(string | number)[]>;
+  protected getRowKey(row: T, index: number): string | number;
+  protected getCellValue(row: T, column: any, index: number): any;
+  protected getCellTemplate(column: TableColumn<T>): TemplateRef<TableCellContext<T>> | undefined;
+  protected getCellIcon(row: T, column: TableColumn<T>, index: number): string;
+  protected getCellIconClass(row: T, column: TableColumn<T>, index: number): string;
+  protected getCellIconLabel(row: T, column: TableColumn<T>, index: number): string;
+  private resolveColumnValue;
+  protected getCellClass(row: T, column: any): string;
+  protected getRowClass(row: T, index: number): string;
+  protected onSort(columnKey: string): void;
+  protected getSortIcon(columnKey: string): string;
+  protected isSorted(columnKey: string): boolean;
+  protected isRowSelected(row: T): boolean;
+  protected toggleRowSelection(row: T, index: number): void;
+  protected toggleAllRows(): void;
+  private emitSelection;
+  protected isRowReorderDisabled(row: T, index: number): boolean;
+  protected onRowReorderHandleClick(row: T, index: number, event: Event): void;
+  protected onRowDragStart(event: DragEvent, index: number): void;
+  protected onRowDragOver(event: DragEvent, index: number): void;
+  protected onRowDrop(event: DragEvent, currentIndex: number): void;
+  protected clearRowDragState(): void;
+  protected onPageChange(page: number | string): void;
+  protected onPageSizeChange(event: Event): void;
+  protected getVisibleActions(row: T): TableAction<T>[];
+  protected isActionDisabled(action: TableAction<T>, row: T): boolean;
+  protected getActionVariantClass(variant?: string): string;
+  protected getActionSubmenuVariantClass(variant?: string): string;
+  protected getAlignClass(align?: string): string;
+  protected getHeaderAlign(column: TableColumn<T>): ColumnAlign;
+  protected getHeaderContentAlignClass(column: TableColumn<T>): string;
+  protected onTableScroll(event: Event): void;
+  protected getResponsiveHideClass(column: any): string;
+  protected getRowNumber(index: number): number;
+  protected getComponentInputs(row: T, column: any, index: number): Record<string, any>;
+  protected getLinkUrl(row: T, column: TableColumn<T>): string | null;
+  protected onRowClick(row: T, index: number, event: Event): void;
+  protected onLinkClick(row: T, column: any, event: Event): void;
+  protected toggleDropdown(rowIndex: number, actionIndex: number, buttonElement?: HTMLElement): void;
+  protected isDropdownOpen(rowIndex: number, actionIndex: number): boolean;
+  protected closeAllDropdowns(): void;
+  protected hasSubmenu(action: any): boolean;
+  protected handleActionClick(action: any, row: T, index: number, event: Event): void;
+  protected getDropdownId(rowIndex: number, actionIndex: number): string;
+  private calculateDropdownPosition;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "hui-table", never, {
+    "config": {
+      "alias": "config";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {
+    "sortChange": "sortChange";
+    "pageChange": "pageChange";
+    "pageSizeChange": "pageSizeChange";
+    "selectionChange": "selectionChange";
+    "rowReorder": "rowReorder";
+  }, ["customCellTemplates"], never, true, never>;
+}
+export type UiTranslator = (text: string, parameters?: Record<string, string | number>) => string;
+export interface MediaSelectorRequest {
+  mediaType: string;
+  allowUpload: boolean;
+  selectionMode: 'single' | 'multiple';
+}
+export type MediaSelector = (request: MediaSelectorRequest) => Promise<string | null | undefined>;
+export interface HarmolodyUiConfig {
+  translate?: UiTranslator;
+  icons?: Record<string, SvgIcon>;
+  selectMedia?: MediaSelector;
+}
+export declare const HARMOLODY_UI_CONFIG: InjectionToken<HarmolodyUiConfig>;
+export declare const HARMOLODY_MEDIA_SELECTOR: InjectionToken<MediaSelector | null>;
+export declare function provideHarmolodyUi(config?: HarmolodyUiConfig): EnvironmentProviders;
+export { type SelectActionButton, type SelectOption as SelectControlOption, type SelectControlValue, type SelectDropdownAlign, type SelectDropdownPlacement, type SelectDropdownWidth, SelectOption$1 as SelectOption, type SelectValue };