@bootkit/ng0 0.0.0-alpha.4 → 0.0.0-alpha.40

package/common/index.d.ts

@@ -1,20 +1,276 @@
-import { InjectionToken } from '@angular/core';
+import * as i0 from '@angular/core';
+import { InjectionToken, TrackByFunction } from '@angular/core';
+import { Observable } from 'rxjs';
 
-type Placement = 'start' | 'end' | 'top' | 'bottom';
-type Alignment = 'start' | 'center' | 'end';
 declare const RTL: InjectionToken<boolean>;
 
+/**
+ * Represents a claim object that can contain multiple claims.
+ */
 interface ClaimObject {
     all?: string[];
     any?: string[];
 }
+/**
+ * Represents a claim that can be a string or an object containing claims.
+ * This is useful for defining permissions or roles in a security context.
+ * It allows for both simple string claims and more complex claims that can include multiple values.
+ * For example:
+ * - A simple claim: 'admin'
+ * - A complex claim: { all: ['read', 'write']'] }
+ *
+ */
 type ClaimLike = string | ClaimObject;
 
-declare function numberRange(start: number, end: number): number[];
-declare function fillArray(start: number, end: number): number[];
+type Placement = 'start' | 'end' | 'top' | 'bottom';
+type Alignment = 'start' | 'center' | 'end';
+/**
+ * Flips the placement direction.
+ * @param placement The placement direction to flip.
+ * @returns The flipped placement direction.
+ */
 declare function flipPlacement(placement: Placement): "start" | "end" | "top" | "bottom";
 
+/**
+ * Formats a string by replacing placeholders with the provided arguments.
+ * @param str The string to format, containing placeholders in the form of {0}, {1}, etc.
+ * @param args The values to replace the placeholders with.
+ * @returns The formatted string.
+ */
 declare function formatString(str: string, ...args: any[]): string;
 
-export { RTL, fillArray, flipPlacement, formatString, numberRange };
-export type { Alignment, ClaimLike, ClaimObject, Placement };
+/** Menu item  */
+interface MenuItem {
+    type?: string;
+    id?: any;
+    disabled?: boolean;
+    active?: boolean;
+    show?: boolean;
+    claim?: ClaimLike;
+    parent?: MenuItem;
+    text?: string;
+    expanded?: boolean;
+    icon?: string;
+    children?: MenuItem[];
+    routerLink?: string | string[];
+}
+
+/**
+ * Converts a value to an Observable.
+ * If the value is already an Observable, it returns it directly.
+ * If the value is a Promise, it converts it to an Observable.
+ * If the value is neither, it wraps it in an Observable using `of`.
+ * @param value The value to convert.
+ * @returns An Observable that emits the value.
+ */
+declare function toObservable<T>(value: T | Observable<T> | Promise<T>): Observable<T>;
+
+/**
+ * Creates an array of numbers within a specified range.
+ * @param start The starting number of the range (inclusive).
+ * @param end The ending number of the range (inclusive).
+ * @returns An array of numbers within the specified range.
+ */
+declare function numberArray(start: number, end: number): number[];
+/**
+ * Deletes multiple entries from an array based on the provided indices.
+ * @param array
+ * @param indices
+ * @private
+ */
+declare function deleteEntries(array: any[], indices: number[]): void;
+
+declare function getEnumValues(enumClass: Record<string, string | number>): Array<string | number>;
+
+/**
+ * Type definition for an ID generator function.
+ * @param item The item for which the ID is to be generated.
+ * @returns A string representing the generated ID.
+ */
+type IdGenerator = (item: any) => string;
+/**
+ * Type definition for an ID generator which can be a function or a string representing the property name to extract the ID from.
+ */
+type IdGeneratorLike = IdGenerator | string;
+/**
+ * Creates a sequential ID generator function with an optional prefix.
+ * This function generates unique IDs by incrementing a counter each time it is called.
+ * @param prefix Optional prefix for the generated IDs.
+ * @returns A function that generates sequential IDs with the given prefix.
+ */
+declare function sequentialIdGenerator(prefix?: string): IdGenerator;
+/**
+ * Converts an IdGeneratorLike to an IdGenerator function.
+ * @param v The ID generator to convert.
+ * @returns An IdGenerator function.
+ */
+declare function IdGeneratorAttribute(v: IdGeneratorLike): IdGenerator;
+
+/**
+ * CSS class type which can be a string, array of strings, set of strings, or an object with class names as keys.
+ */
+type CssClass = string | string[] | Set<string> | {
+    [klass: string]: any;
+} | null | undefined;
+/**
+ * A function that takes an item and returns a CssClass.
+ * @param item The item to get the CSS class for.
+ * @returns The CSS class for the item.
+ */
+type CssClassGetter = (obj: any) => CssClass;
+/**
+ * A type that represents a CSS class or a function that returns a CSS class.
+ */
+type CssClassLike = CssClass | CssClassGetter;
+/**
+ * Converts a CssClassLike to a CssClassGetter function.
+ * @param v The CssClassLike to convert.
+ * @returns A function that returns the desired CSS class.
+ */
+declare function CssClassAttribute(v: CssClassLike): CssClassGetter;
+
+/**
+ * Equality comparer function type.
+ * @param a First value to compare.
+ * @param b Second value to compare.
+ * @returns true if a is considered equal to b else returns false
+ */
+type EqualityComparer = (a: any, b: any) => boolean;
+/**
+ * Equality comparer like type.
+ * can be a function or a string representing the property name to compare.
+ */
+type EqualityComparerLike = EqualityComparer | string;
+/**
+ * Default equality comparer function.
+ * @param a First value to compare.
+ * @param b Second value to compare.
+ * @returns true if a === b else returns false
+ */
+declare function defaultEqualityComparer(a: any, b: any): boolean;
+/**
+ * Converts an EqualityComparerLike to an EqualityComparer function.
+ * @param e The EqualityComparerLike to convert.
+ * @returns The converted EqualityComparer.
+ */
+declare function equalityComparerAttribute(e: EqualityComparerLike): EqualityComparer;
+
+/**
+ * Value writer function type.
+ * @param a The input value
+ * @returns The written value
+ */
+type ValueWriter = (a: any) => any;
+/**
+ * Value writer can be a function or a string representing the property name to extract the value from.
+ */
+type ValueWriterLike = ValueWriter | string;
+/**
+ * Default value writer function.
+ * @param a The input value
+ * @returns the input value (it does not transform it)
+ */
+declare function defaultValueWriter(a: any): any;
+/**
+ * Converts a ValueWriterLike to a ValueWriterFunction.
+ * @param v The value writer to convert.
+ * @returns A ValueWriter function.
+ */
+declare function valueWriterAttribute(v: ValueWriterLike): ValueWriter;
+
+/**
+ * A comparison function type that defines an ordering relation between two values.
+ * @param a The first value to compare.
+ * @param b The second value to compare.
+ * @returns
+ * - A negative number if `a` should come before `b`
+ * - A positive number if `a` should come after `b`
+ * - Zero if `a` and `b` are considered equal
+ */
+type Comparer = (a: any, b: any) => number;
+/**
+ * Value comparer can be a function or a string representing the property name to compare.
+ */
+type ComparerLike = Comparer | string;
+/**
+ * A simple comparer function.
+ * @param a The first value to compare.
+ * @param b The second value to compare.
+ * @returns -1 if a < b, 1 if a > b, 0 if a === b
+ */
+declare function defaultComparer(a: any, b: any): number;
+/**
+ * Converts a ComparerLike to a Comparer.
+ * @param v The comparer to convert.
+ * @returns A function that compares two values.
+ */
+declare function comparerAttribute(v: ComparerLike): Comparer;
+
+/**
+ * Filter predicate function type.
+ * @param item The item to test against the filter.
+ * @param params Additional parameters to pass to the filter.
+ * @returns True if the item matches the filter, false otherwise.
+ */
+type FilterPredicate = (item: any, ...params: any[]) => boolean;
+/**
+ * Filter predicate can be a function or a string representing the property name to filter.
+ */
+type FilterPredicateLike = FilterPredicate | string;
+/**
+ * No-op filter predicate that always returns true.
+ * @param item The item to test against the filter.
+ * @returns true
+ */
+declare const noopFilter: FilterPredicate;
+/**
+ * A simple filter predicate that checks if the item's string representation includes the match string.
+ * @param item The item to test against the filter.
+ * @param match The string to match.
+ * @returns True if the item matches the filter, false otherwise.
+ */
+declare const defaultFilter: FilterPredicate;
+/**
+ * Converts a FilterPredicateLike to a FilterPredicate function.
+ * If the input is a string, it creates a predicate that checks the property with that name.
+ * @param v The FilterPredicateLike to convert.
+ * @returns The corresponding FilterPredicate function.
+ */
+declare function filterPredicateAttribute(v: FilterPredicateLike): FilterPredicate;
+
+/**
+ * An item tracker that can be either a TrackByFunction or a string property name.
+ */
+type TrackByLike = TrackByFunction<any> | string;
+/**
+ * A trackBy function that tracks items by their index.
+ */
+declare const trackByIndex: TrackByFunction<any>;
+/**
+ * A trackBy function that tracks items by the item itself.
+ */
+declare const trackByItem: TrackByFunction<any>;
+/**
+ * Converts a TrackByLike to a TrackByFunction.
+ * @param v The item tracker to convert.
+ * @returns A TrackByFunction.
+ */
+declare function TrackByAttribute(v: TrackByLike): TrackByFunction<any>;
+
+/**
+ * IfDirective is a structural directive that conditionally includes or excludes a template
+ * based on the boolean value of the `show` input property.
+ *
+ */
+declare class IfDirective {
+    private readonly _templateRef;
+    private _vcr;
+    private _viewRef?;
+    readonly show: i0.InputSignal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<IfDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IfDirective, "[ng0If]", ["ng0If"], { "show": { "alias": "ng0If"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { CssClassAttribute, IdGeneratorAttribute, IfDirective, RTL, TrackByAttribute, comparerAttribute, defaultComparer, defaultEqualityComparer, defaultFilter, defaultValueWriter, deleteEntries, equalityComparerAttribute, filterPredicateAttribute, flipPlacement, formatString, getEnumValues, noopFilter, numberArray, sequentialIdGenerator, toObservable, trackByIndex, trackByItem, valueWriterAttribute };
+export type { Alignment, ClaimLike, ClaimObject, Comparer, ComparerLike, CssClass, CssClassGetter, CssClassLike, EqualityComparer, EqualityComparerLike, FilterPredicate, FilterPredicateLike, IdGenerator, IdGeneratorLike, MenuItem, Placement, TrackByLike, ValueWriter, ValueWriterLike };

package/components/accordion/index.d.ts

@@ -1,13 +1,19 @@
 import * as i0 from '@angular/core';
-import { ElementRef, Renderer2, QueryList } from '@angular/core';
+import { QueryList, ElementRef, Renderer2 } from '@angular/core';
 
 declare class AccordionItemComponent {
     private _element;
     private _renderer;
     private _accordion;
+    /**
+     * The header text of the accordion item.
+     */
     header: i0.InputSignal<string | undefined>;
+    /**
+     * Whether the accordion item is collapsed or expanded.
+     */
     collapsed: i0.ModelSignal<boolean>;
-    constructor(_element: ElementRef, _renderer: Renderer2, _accordion: AccordionComponent);
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<AccordionItemComponent, "ng0-accordion-item", ["ng0AccordionItem"], { "header": { "alias": "header"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, ["*"], true, never>;
 }
@@ -15,7 +21,11 @@ declare class AccordionItemComponent {
 declare class AccordionComponent {
     private _element;
     private _renderer;
-    /** Items open mode */
+    /**
+     * The mode of the accordion - 'single' or 'multiple'.
+     * 'single' mode allows only one item to be expanded at a time.
+     * 'multiple' mode allows multiple items to be expanded simultaneously.
+     */
     mode: i0.InputSignal<"single" | "multiple">;
     readonly items: QueryList<AccordionItemComponent>;
     constructor(_element: ElementRef, _renderer: Renderer2);

package/components/backdrop/index.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from '@angular/core';
+
+/**
+ * This component is used to display a backdrop behind another component.
+ */
+declare class BackdropComponent {
+    readonly fixed: i0.WritableSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackdropComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BackdropComponent, "ng0-backdrop", never, {}, {}, never, never, true, never>;
+}
+
+export { BackdropComponent };

package/components/dropdown/index.d.ts

@@ -0,0 +1,156 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef, EventEmitter } from '@angular/core';
+import { Placement, CssClass } from '@bootkit/ng0/common';
+
+declare class DropdownDividerComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownDividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownDividerComponent, "ng0-dropdown-divider", ["ng0DropdownDivider"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Defines the possible values for the dropdown auto-close behavior.
+ *
+ * 'default': The dropdown will close when clicking inside or outside the menu.
+ * 'inside': The dropdown will close only when clicking inside the menu.
+ * 'outside': The dropdown will close only when clicking outside the menu.
+ * 'manual': The dropdown will not close automatically; it must be closed programmatically.
+ */
+type DropdownAutoCloseBehavior = 'default' | 'inside' | 'outside' | 'manual';
+/**
+ *
+ */
+type DropdownSize = 'default' | 'small' | 'large';
+
+/**
+ * Dropdown component
+ */
+declare class DropdownComponent {
+    private _dropdownMenu;
+    private _mainButton;
+    private _splitButton?;
+    protected _el: ElementRef<any>;
+    private _renderer;
+    /**
+     * The placement of the dropdown menu in relation to the dropdown toggle.
+     */
+    placement: _angular_core.InputSignal<Placement>;
+    /**
+     * Indicates whether the dropdown should use the default Bootstrap styles.
+     * This will apply the 'btn-group' class to the dropdown.
+     * @default true
+     */
+    defaultStyle: _angular_core.InputSignal<boolean>;
+    /**
+     * The CSS classes to apply to the dropdown toggle button.
+     * @default 'btn btn-primary'
+     */
+    toggleCss: _angular_core.InputSignal<CssClass>;
+    /**
+     * The CSS classes to apply to the dropdown split button.
+     * @default 'btn btn-primary'
+     */
+    splitCss: _angular_core.InputSignal<CssClass>;
+    /**
+     * Indicates whether the dropdown is open or closed.
+     * @default false
+     */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /**
+     * Indicates whether the dropdown is a split button.
+     * A split button dropdown has a separate toggle button.
+     * @default false
+     */
+    readonly split: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Indicates whether the dropdown has an automatic close behavior.
+     * @default 'default'
+     */
+    readonly autoClose: _angular_core.InputSignal<DropdownAutoCloseBehavior>;
+    /**
+     * Dropdown size
+     * @default 'default'
+     */
+    readonly size: _angular_core.InputSignal<DropdownSize>;
+    /**
+     * Indicates whether the dropdown is disabled.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+    * Emits when the dropdown toggle button is clicked.
+    */
+    toggleClick: EventEmitter<PointerEvent>;
+    constructor();
+    /**
+     * Toggle the dropdown open or closed.
+     */
+    toggle(): void;
+    private _onDocumentClick;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownComponent, "ng0-dropdown", ["ng0Dropdown"], { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "defaultStyle": { "alias": "defaultStyle"; "required": false; "isSignal": true; }; "toggleCss": { "alias": "toggleCss"; "required": false; "isSignal": true; }; "splitCss": { "alias": "splitCss"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "split": { "alias": "split"; "required": false; "isSignal": true; }; "autoClose": { "alias": "autoClose"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "toggleClick": "toggleClick"; }, ["_dropdownMenu"], ["*", "ng0-dropdown-menu"], true, never>;
+}
+
+declare class DropdownMenuComponent {
+    private _renderer;
+    private _dropdown;
+    elementRef: ElementRef<any>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownMenuComponent, "ng0-dropdown-menu", ["ng0Dropdownmenu"], {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * An item within a dropdown menu.
+ */
+declare class DropdownItemComponent {
+    /**
+     * The CSS classes to apply to the dropdown item.
+     * */
+    readonly cssClass: _angular_core.InputSignal<CssClass>;
+    /**
+     * Whether the dropdown item is disabled.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private _onClick;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownItemComponent, "ng0-dropdown-item", ["ng0DropdownItem"], { "cssClass": { "alias": "cssClass"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A link item within a dropdown menu.
+ * This component is used to create a navigable link inside a dropdown.
+ */
+declare class DropdownLinkComponent {
+    /**
+     * The link or URL to navigate to when the dropdown item is clicked.
+     */
+    readonly link: _angular_core.InputSignal<string | string[] | undefined>;
+    /**
+     * The router link active class to apply when the link is active.
+     */
+    readonly active: _angular_core.InputSignal<string | string[]>;
+    /**
+     * Specifies where to open the linked document.
+     */
+    readonly target: _angular_core.InputSignal<"_self" | "_blank" | "_parent" | "_top" | undefined>;
+    /**
+     * Whether the dropdown link is disabled.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private _onClick;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownLinkComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownLinkComponent, "ng0-dropdown-link", ["ng0DropdownLink"], { "link": { "alias": "link"; "required": true; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class DropdownHeaderComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownHeaderComponent, "ng0-dropdown-header", ["ng0DropdownItem"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class DropdownModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<DropdownModule, never, [typeof DropdownComponent, typeof DropdownMenuComponent, typeof DropdownItemComponent, typeof DropdownLinkComponent, typeof DropdownHeaderComponent, typeof DropdownDividerComponent], [typeof DropdownComponent, typeof DropdownMenuComponent, typeof DropdownItemComponent, typeof DropdownLinkComponent, typeof DropdownHeaderComponent, typeof DropdownDividerComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<DropdownModule>;
+}
+
+export { DropdownComponent, DropdownDividerComponent, DropdownHeaderComponent, DropdownItemComponent, DropdownLinkComponent, DropdownMenuComponent, DropdownModule };
+export type { DropdownAutoCloseBehavior, DropdownSize };

package/components/form-field/index.d.ts

@@ -1,66 +1,49 @@
 import * as _angular_core from '@angular/core';
-import { OnInit, AfterContentInit, OnDestroy, Renderer2, DestroyRef } from '@angular/core';
-import { NgForm } from '@angular/forms';
-import { LocalizationService } from '@bootkit/ng0/localization';
+import { AfterContentInit } from '@angular/core';
+import { NgControl } from '@angular/forms';
 import * as i1 from '@angular/common';
 
-declare class FormFieldComponent implements OnInit, AfterContentInit, OnDestroy {
-    private _renderer;
+declare class FormFieldComponent implements AfterContentInit {
+    private _ngControlElement?;
     private _destroyRef;
-    private _form;
-    private _ls;
+    private _renderer;
+    private _localizationService;
+    protected _ngControl?: NgControl;
+    protected _status: _angular_core.WritableSignal<string | null>;
+    protected _hasRequiredControl: _angular_core.WritableSignal<boolean>;
+    protected _errorText: _angular_core.WritableSignal<string | undefined>;
     /**
      * The label text for the form field.
      */
-    label: _angular_core.InputSignal<string | undefined>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
     /**
      * The hint text to display below the form field.
-     * This is typically used to provide additional information or instructions to the user.
      */
-    hint: _angular_core.InputSignal<string | undefined>;
+    readonly hint: _angular_core.InputSignal<string | undefined>;
     /**
      * If true, the form-field will show validation errors.
-     * This is useful for displaying validation messages when the form control is invalid.
      */
-    showErrors: _angular_core.InputSignal<boolean>;
+    readonly showErrors: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
-     * If true, the form-field will show a red asterisk for required fields.
-     * This is only a visual indicator and does not enforce validation.
+     * If undefined, the indicator will be shown based on the control's required state.
+     * If true, the form-field will show a required indicator (*) next to the label (regardless of the control's required state).
+     * If false, the required indicator will not be shown (regardless of the control's required state).
      */
-    showRequiredIndicator: _angular_core.InputSignal<boolean>;
+    readonly showRequired: _angular_core.InputSignal<boolean | undefined>;
     /**
      * If true, the form-field will show subscripts (e.g. hints, errors) for the field label.
-     * This is useful for displaying additional information or validation messages.
      */
-    showSubscripts: _angular_core.InputSignal<boolean>;
+    readonly showSubscripts: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * If true, the form-field will be rendered inside a ".input-group" element.
      */
-    inputGroup: _angular_core.InputSignal<boolean>;
-    /**
-     * Returns the first localized error of the control
-     */
-    get errorText(): string | undefined;
-    /** Reports whether the control is touched. */
-    get touched(): boolean | null | undefined;
-    /** Reports whether the control is dirty. */
-    get dirty(): boolean | null | undefined;
-    /** Returns true if this form-field is required, otherwise returns false. */
-    get isRequired(): boolean;
-    private _onFocusOut;
-    private _ngControl?;
-    private _ngControlElement?;
-    private _isRequired;
-    private _locale?;
-    private _errorText?;
-    constructor(_renderer: Renderer2, _destroyRef: DestroyRef, _form: NgForm, _ls: LocalizationService);
-    ngOnInit(): void;
+    readonly inputGroup: _angular_core.InputSignalWithTransform<boolean, unknown>;
     ngAfterContentInit(): void;
-    private _validate;
-    private _isRequiredField;
-    ngOnDestroy(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldComponent, [null, null, { optional: true; }, null]>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormFieldComponent, "ng0-form-field, ng0-field", ["ng0FormField"], { "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "showErrors": { "alias": "showErrors"; "required": false; "isSignal": true; }; "showRequiredIndicator": { "alias": "showRequiredIndicator"; "required": false; "isSignal": true; }; "showSubscripts": { "alias": "showSubscripts"; "required": false; "isSignal": true; }; "inputGroup": { "alias": "inputGroup"; "required": false; "isSignal": true; }; }, {}, ["_ngControl", "_ngControlElement"], ["*"], true, never>;
+    private _checkValidation;
+    private _isControlRequired;
+    private _onFocusOut;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormFieldComponent, "ng0-form-field, ng0-field", ["ng0FormField"], { "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "showErrors": { "alias": "showErrors"; "required": false; "isSignal": true; }; "showRequired": { "alias": "showRequired"; "required": false; "isSignal": true; }; "showSubscripts": { "alias": "showSubscripts"; "required": false; "isSignal": true; }; "inputGroup": { "alias": "inputGroup"; "required": false; "isSignal": true; }; }, {}, ["_ngControlElement", "_ngControl"], ["*"], true, never>;
 }
 
 declare class FormFieldModule {