design-angular-kit 1.0.0-9 → 1.0.0-prerelease.2

package/lib/components/core/steppers/steppers.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./steppers-container/steppers-container.component";
+import * as i2 from "./steppers-item/steppers-item.component";
+export declare class ItSteppersModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItSteppersModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ItSteppersModule, never, [typeof i1.ItSteppersContainerComponent, typeof i2.ItSteppersItemComponent], [typeof i1.ItSteppersContainerComponent, typeof i2.ItSteppersItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ItSteppersModule>;
+}

package/lib/components/core/tab/tab-container/tab-container.component.d.ts

@@ -1,30 +1,33 @@
-import { OnDestroy, QueryList } from '@angular/core';
-import { BooleanInput } from '../../../../utils/boolean-input';
-import { TabItemComponent } from '../tab-item/tab-item.component';
-import { AbstractComponent } from '../../../../abstracts/abstract.component';
+import { AfterViewInit, OnDestroy, QueryList } from '@angular/core';
+import { ItTabItemComponent } from '../tab-item/tab-item.component';
+import { ItAbstractComponent } from '../../../../abstracts/abstract.component';
 import * as i0 from "@angular/core";
-export declare class TabContainerComponent extends AbstractComponent implements OnDestroy {
+import * as i1 from "../../../../utils/coercion";
+export declare class ItTabContainerComponent extends ItAbstractComponent implements OnDestroy, AfterViewInit {
     /**
      * Tabs automatically occupy the entire available width
+     * @default false
      */
-    auto?: BooleanInput;
+    auto?: boolean;
     /**
      * To obtain the correct margin between text and icon in the horizontally developed tab
      */
-    iconText?: BooleanInput;
+    iconText?: boolean;
     /**
      * Dark style
      */
-    dark?: BooleanInput;
+    dark?: boolean;
     /**
      * The tab items
      */
-    tabs?: QueryList<TabItemComponent>;
+    tabs?: QueryList<ItTabItemComponent>;
     private tabNavLinks?;
     private tabSubscriptions?;
-    isTrueBooleanInput(booleanInput?: BooleanInput): boolean;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TabContainerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TabContainerComponent, "it-tab-container", never, { "auto": "auto"; "iconText": "iconText"; "dark": "dark"; }, {}, ["tabs"], never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItTabContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ItTabContainerComponent, "it-tab-container", never, { "auto": { "alias": "auto"; "required": false; }; "iconText": { "alias": "iconText"; "required": false; }; "dark": { "alias": "dark"; "required": false; }; }, {}, ["tabs"], never, true, never>;
+    static ngAcceptInputType_auto: i1.BooleanInput;
+    static ngAcceptInputType_iconText: i1.BooleanInput;
+    static ngAcceptInputType_dark: i1.BooleanInput;
 }

package/lib/components/core/tab/tab-item/tab-item.component.d.ts

@@ -1,25 +1,27 @@
-import { TemplateRef } from '@angular/core';
-import { AbstractComponent } from '../../../../abstracts/abstract.component';
-import { BooleanInput } from '../../../../utils/boolean-input';
+import { AfterViewInit, TemplateRef } from '@angular/core';
+import { ItAbstractComponent } from '../../../../abstracts/abstract.component';
 import { IconName } from '../../../../interfaces/icon';
 import * as i0 from "@angular/core";
-export declare class TabItemComponent extends AbstractComponent {
+import * as i1 from "../../../../utils/coercion";
+export declare class ItTabItemComponent extends ItAbstractComponent implements AfterViewInit {
     /**
      * The tab label
      */
-    label?: string;
+    label: string | undefined;
     /**
      * The icon name
      */
-    icon?: IconName;
+    icon: IconName | undefined;
     /**
      * Default active tab
+     * @default false
      */
-    active?: BooleanInput;
+    active?: boolean;
     /**
      * Default disabled tab
+     * @default false
      */
-    disabled?: BooleanInput;
+    disabled?: boolean;
     /**
      * Custom class
      */
@@ -29,6 +31,8 @@ export declare class TabItemComponent extends AbstractComponent {
      */
     htmlContent: TemplateRef<any>;
     ngAfterViewInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TabItemComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TabItemComponent, "it-tab-item[id]", never, { "label": "label"; "icon": "icon"; "active": "active"; "disabled": "disabled"; "class": "class"; }, {}, never, ["*"], false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItTabItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ItTabItemComponent, "it-tab-item", never, { "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "active": { "alias": "active"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_active: i1.BooleanInput;
+    static ngAcceptInputType_disabled: i1.BooleanInput;
 }

package/lib/components/core/tab/tab.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tab-container/tab-container.component";
+import * as i2 from "./tab-item/tab-item.component";
+export declare class ItTabModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItTabModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ItTabModule, never, [typeof i1.ItTabContainerComponent, typeof i2.ItTabItemComponent], [typeof i1.ItTabContainerComponent, typeof i2.ItTabItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ItTabModule>;
+}

package/lib/components/core/table/sort/sort-header/sort-header.component.d.ts

@@ -0,0 +1,72 @@
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { ItSortDirective } from '../sort.directive';
+import { IconName } from '../../../../../interfaces/icon';
+import { ItSortable, ItSortDefaultOptions, SortDirection, SortHeaderArrowPosition } from '../../../../../interfaces/sortable-table';
+import * as i0 from "@angular/core";
+/**
+ * Applies sorting behavior (click to change sort) and styles to an element, including an
+ * arrow to display the current sort direction.
+ *
+ * Must be provided with an id and contained within a parent ItSort directive.
+ *
+ * If used on header cells in a CdkTable, it will automatically default its id from its containing
+ * column definition.
+ */
+export declare class ItSortHeaderComponent implements ItSortable, OnDestroy, OnInit {
+    private readonly _changeDetectorRef;
+    readonly _sort: ItSortDirective;
+    /**
+     * ID of this sort header. If used within the context of a CdkColumnDef, this will default to
+     * the column's name.
+     */
+    id: string;
+    /** Sets the position of the arrow that displays when sorted. */
+    arrowPosition: SortHeaderArrowPosition;
+    /** Overrides the sort start value of the containing MatSort for this SortHeaderComponent. */
+    start?: SortDirection;
+    /** whether the sort header is disabled. */
+    sortDisabled: boolean;
+    /** Overrides the disable clear value of the containing SortDirective for this MatSortable. */
+    disableSortClear?: boolean;
+    readonly sortHeaderClass = "it-sort-header";
+    private _rerenderSubscription?;
+    /** The direction the arrow should be facing according to the current state. */
+    private _arrowDirection?;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _sort: ItSortDirective, defaultOptions?: ItSortDefaultOptions);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    _handleClick(): void;
+    /**
+     * Whether this MatSortHeader is currently sorted in either ascending or descending order.
+     */
+    protected get isSorted(): boolean;
+    /**
+     * Returns the icon class by the arrow direction
+     */
+    protected get arrowIconClass(): IconName;
+    /**
+     * Updates the direction the arrow should be pointing. If it is not sorted, the arrow should be
+     * facing the start direction. Otherwise if it is sorted, the arrow should point in the currently
+     * active sorted direction. The reason this is updated through a function is because the direction
+     * should only be changed at specific times - when deactivated but the hint is displayed and when
+     * the sort is active and the direction changes. Otherwise the arrow's direction should linger
+     * in cases such as the sort becoming deactivated but we want to animate the arrow away while
+     * preserving its direction, even though the next sort direction is actually different and should
+     * only be changed once the arrow displays again (hint or activation).
+     */
+    private updateArrowDirection;
+    get isDisabled(): boolean;
+    /**
+     * Gets the aria-sort attribute that should be applied to this sort header. If this header
+     * is not sorted, returns null so that the attribute is removed from the host element. Aria spec
+     * says that the aria-sort property should only be present on one header at a time, so removing
+     * ensures this is true.
+     */
+    get ariaSortAttribute(): "none" | "ascending" | "descending";
+    /** Handles changes in the sorting state. */
+    private _handleStateChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItSortHeaderComponent, [null, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ItSortHeaderComponent, "[it-sort-header]", ["itSortHeader"], { "id": { "alias": "it-sort-header"; "required": false; }; "arrowPosition": { "alias": "arrowPosition"; "required": false; }; "start": { "alias": "start"; "required": false; }; "sortDisabled": { "alias": "sortDisabled"; "required": false; }; "disableSortClear": { "alias": "disableSortClear"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_sortDisabled: unknown;
+    static ngAcceptInputType_disableSortClear: unknown;
+}

package/lib/components/core/table/sort/sort.directive.d.ts

@@ -0,0 +1,53 @@
+import { EventEmitter, OnChanges, OnDestroy } from '@angular/core';
+import { Subject } from 'rxjs';
+import { ItSortable, ItSortDefaultOptions, ItSortEvent, SortDirection } from "../../../../interfaces/sortable-table";
+import * as i0 from "@angular/core";
+export declare class ItSortDirective implements OnChanges, OnDestroy {
+    private _defaultOptions?;
+    /** The id of the most recently sorted ItSortable. */
+    active?: string;
+    /**
+      * The direction to set when an MatSortable is initially sorted.
+      * May be overridden by the MatSortable's sort start.
+      */
+    start: SortDirection;
+    /** The sort direction of the currently active ItSortable. */
+    get direction(): SortDirection;
+    set direction(direction: SortDirection);
+    private _direction;
+    /**
+     * Whether to disable the user from clearing the sort by finishing the sort direction cycle.
+     * May be overridden by the ItSortable's disable clear input.
+     */
+    disableSortClear?: boolean;
+    /** Whether the sortable is disabled. */
+    sortDisabled: boolean;
+    /** Event emitted when the user changes either the active sort or sort direction. */
+    readonly sortChange: EventEmitter<ItSortEvent>;
+    readonly sortDirectiveClass = "it-sort";
+    /** Collection of all registered sortables that this directive manages. */
+    protected sortables: Map<string, ItSortable>;
+    /** Used to notify any child components listening to state changes. */
+    readonly _stateChanges: Subject<void>;
+    constructor(_defaultOptions?: ItSortDefaultOptions | undefined);
+    /**
+       * Register function to be used by the contained ItSortables. Adds the ItSortable to the
+       * collection of ItSortables.
+       */
+    register(sortable: ItSortable): void;
+    /**
+     * Unregister function to be used by the contained ItSortables. Removes the ItSortable from the
+     * collection of contained ItSortables.
+     */
+    deregister(sortable: ItSortable): void;
+    /** Sets the active sort id and determines the new sort direction. */
+    sort(sortable: ItSortable): void;
+    /** Returns the next sort direction of the active sortable, checking for potential overrides. */
+    getNextSortDirection(sortable: ItSortable): SortDirection;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItSortDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ItSortDirective, "[itSort]", ["itSort"], { "active": { "alias": "itSortActive"; "required": false; }; "start": { "alias": "itSortStart"; "required": false; }; "direction": { "alias": "itSortDirection"; "required": false; }; "disableSortClear": { "alias": "disableSortClear"; "required": false; }; "sortDisabled": { "alias": "sortDisabled"; "required": false; }; }, { "sortChange": "sortChange"; }, never, never, true, never>;
+    static ngAcceptInputType_disableSortClear: unknown;
+    static ngAcceptInputType_sortDisabled: unknown;
+}

package/lib/components/core/table/table.component.d.ts

@@ -1,54 +1,60 @@
-import { TableColor, TableHeadColor, TableResponsive, VerticalAlignment } from "../../../interfaces/core";
-import { BooleanInput } from "../../../utils/boolean-input";
+import { TableColor, TableHeadColor, TableResponsive, VerticalAlignment } from '../../../interfaces/core';
 import * as i0 from "@angular/core";
-export declare class TableComponent {
+import * as i1 from "../../../utils/coercion";
+export declare class ItTableComponent {
     /**
      * Table color
      */
-    color?: TableColor;
+    color: TableColor | undefined;
     /**
      * Head table color
      */
-    headColor?: TableHeadColor;
+    headColor: TableHeadColor | undefined;
     /**
      * Use vertical alignment classes to realign where needed.
      */
-    alignment?: VerticalAlignment;
+    alignment: VerticalAlignment | undefined;
     /**
      * Use .table-striped to add zebra stripes to each table row contained in <tbody>.
+     * @default false
      */
-    striped?: BooleanInput;
+    striped?: boolean;
     /**
      * Add .table-hover to enable hover state on table rows contained in <tbody>.
+     * @default false
      */
-    hover?: BooleanInput;
+    hover?: boolean;
     /**
      * Add .table-bordered to have borders on all sides of the table and on all cells.
+     * @default false
      */
-    bordered?: BooleanInput;
+    bordered?: boolean;
     /**
      * Add the .table-borderless class for a borderless table.
+     * @default false
      */
-    borderless?: BooleanInput;
+    borderless?: boolean;
     /**
      * Add .table-sm to make tables more compact by halving the cell padding.
+     * @efault false
      */
-    compact?: BooleanInput;
+    compact?: boolean;
     /**
      * To render the <caption> on top of the table
+     * @default false
      */
-    captionTop?: BooleanInput;
+    captionTop?: boolean;
     /**
      * Responsive tables allow you to scroll tables horizontally with ease.
      * @default responsive
      */
     responsive: TableResponsive;
-    get isStriped(): boolean;
-    get isHover(): boolean;
-    get isBordered(): boolean;
-    get isBorderless(): boolean;
-    get isCompact(): boolean;
-    get isCaptionTop(): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "it-table", never, { "color": "color"; "headColor": "headColor"; "alignment": "alignment"; "striped": "striped"; "hover": "hover"; "bordered": "bordered"; "borderless": "borderless"; "compact": "compact"; "captionTop": "captionTop"; "responsive": "responsive"; }, {}, never, ["[caption]", "[thead]", "[tbody]", "[tfoot]"], false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ItTableComponent, "it-table", never, { "color": { "alias": "color"; "required": false; }; "headColor": { "alias": "headColor"; "required": false; }; "alignment": { "alias": "alignment"; "required": false; }; "striped": { "alias": "striped"; "required": false; }; "hover": { "alias": "hover"; "required": false; }; "bordered": { "alias": "bordered"; "required": false; }; "borderless": { "alias": "borderless"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "captionTop": { "alias": "captionTop"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; }, {}, never, ["[caption]", "[thead]", "[tbody]", "[tfoot]"], true, never>;
+    static ngAcceptInputType_striped: i1.BooleanInput;
+    static ngAcceptInputType_hover: i1.BooleanInput;
+    static ngAcceptInputType_bordered: i1.BooleanInput;
+    static ngAcceptInputType_borderless: i1.BooleanInput;
+    static ngAcceptInputType_compact: i1.BooleanInput;
+    static ngAcceptInputType_captionTop: i1.BooleanInput;
 }

package/lib/components/core/table/table.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./table.component";
+import * as i2 from "./sort/sort.directive";
+import * as i3 from "./sort/sort-header/sort-header.component";
+export declare class ItTableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ItTableModule, never, [typeof i1.ItTableComponent, typeof i2.ItSortDirective, typeof i3.ItSortHeaderComponent], [typeof i1.ItTableComponent, typeof i2.ItSortDirective, typeof i3.ItSortHeaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ItTableModule>;
+}

package/lib/components/core/tooltip/tooltip.directive.d.ts

@@ -1,8 +1,8 @@
 import { AfterViewInit, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
 import { ElementPlacement } from '../../../interfaces/core';
-import { BooleanInput } from '../../../utils/boolean-input';
 import * as i0 from "@angular/core";
-export declare class TooltipDirective implements AfterViewInit, OnDestroy {
+import * as i1 from "../../../utils/coercion";
+export declare class ItTooltipDirective implements AfterViewInit, OnDestroy {
     private readonly _elementRef;
     /**
      * Define the tooltip title
@@ -13,32 +13,32 @@ export declare class TooltipDirective implements AfterViewInit, OnDestroy {
      * Define the tooltip placement
      * @param placement
      */
-    set placement(placement: ElementPlacement);
+    set tooltipPlacement(placement: ElementPlacement);
     /**
      * Indicates whether the title contains html
      * @param html true if contain html
      */
-    set html(html: BooleanInput);
+    set tooltipHtml(html: boolean);
     /**
      * This event fires immediately when the show method is called.
      */
-    onShow: EventEmitter<Event>;
+    showEvent: EventEmitter<Event>;
     /**
      * This event is triggered when the tooltip has been made visible to the user (it will wait for the CSS transitions to complete).
      */
-    onShown: EventEmitter<Event>;
+    shownEvent: EventEmitter<Event>;
     /**
      * This event fires immediately when the hide method is called.
      */
-    onHide: EventEmitter<Event>;
+    hideEvent: EventEmitter<Event>;
     /**
      * This event is raised when the tooltip has finished being hidden from the user (it will wait for the CSS transitions to complete).
      */
-    onHidden: EventEmitter<Event>;
+    hiddenEvent: EventEmitter<Event>;
     /**
      * This event fires after the show event when the tooltip template has been added to the DOM.
      */
-    onInserted: EventEmitter<Event>;
+    insertedEvent: EventEmitter<Event>;
     private readonly element;
     private tooltip?;
     constructor(_elementRef: ElementRef);
@@ -76,6 +76,7 @@ export declare class TooltipDirective implements AfterViewInit, OnDestroy {
      * Updates the position of an element's tooltip.
      */
     update(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipDirective, "[itTooltip]", ["itTooltip"], { "title": "itTooltip"; "placement": "tooltipPlacement"; "html": "tooltipHtml"; }, { "onShow": "onShow"; "onShown": "onShown"; "onHide": "onHide"; "onHidden": "onHidden"; "onInserted": "onInserted"; }, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ItTooltipDirective, "[itTooltip]", ["itTooltip"], { "title": { "alias": "itTooltip"; "required": false; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; }; "tooltipHtml": { "alias": "tooltipHtml"; "required": false; }; }, { "showEvent": "showEvent"; "shownEvent": "shownEvent"; "hideEvent": "hideEvent"; "hiddenEvent": "hiddenEvent"; "insertedEvent": "insertedEvent"; }, never, never, true, never>;
+    static ngAcceptInputType_tooltipHtml: i1.BooleanInput;
 }

package/lib/components/form/autocomplete/autocomplete.component.d.ts

@@ -0,0 +1,55 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ItAbstractFormComponent } from '../../../abstracts/abstract-form.component';
+import { AutocompleteItem } from '../../../interfaces/form';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../utils/coercion";
+export declare class ItAutocompleteComponent extends ItAbstractFormComponent<string | null | undefined> implements OnInit {
+    /**
+     * Indicates the list of searchable elements on which to base the input autocomplete system
+     * If you need to retrieve items via API, can pass a function of Observable
+     * @default undefined
+     */
+    autocompleteData: Array<AutocompleteItem> | ((search?: string | null) => Observable<Array<AutocompleteItem>>);
+    /**
+     * To get a large version of Autocomplete
+     */
+    big?: boolean;
+    /**
+     * Time span [ms] has passed without another source emission, to delay data filtering.
+     * Useful when the user is typing multiple letters
+     * @default 300 [ms]
+     */
+    debounceTime: number;
+    /**
+     * The input placeholder
+     */
+    placeholder: string;
+    /**
+     * Show the label
+     */
+    forceShowLabel: boolean;
+    /**
+     * Fired when the Autocomplete Item has been selected
+     */
+    autocompleteSelectedEvent: EventEmitter<AutocompleteItem>;
+    protected showAutocompletion: boolean;
+    /** Observable da cui vengono emessi i risultati dell'auto completamento */
+    protected autocompleteResults$: Observable<{
+        searchedValue: string | undefined | null;
+        relatedEntries: Array<AutocompleteItem>;
+    }>;
+    ngOnInit(): void;
+    /**
+     * Create the autocomplete list
+     */
+    private getAutocompleteResults$;
+    protected onEntryClick(entry: AutocompleteItem, event: Event): void;
+    protected autocompleteItemTrackByValueFn(index: number, item: AutocompleteItem): string;
+    protected onKeyDown(): void;
+    protected get isActiveLabel(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItAutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ItAutocompleteComponent, "it-autocomplete", never, { "autocompleteData": { "alias": "autocompleteData"; "required": true; }; "big": { "alias": "big"; "required": false; }; "debounceTime": { "alias": "debounceTime"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "forceShowLabel": { "alias": "forceShowLabel"; "required": false; }; }, { "autocompleteSelectedEvent": "autocompleteSelectedEvent"; }, never, ["[error]"], true, never>;
+    static ngAcceptInputType_big: i1.BooleanInput;
+    static ngAcceptInputType_forceShowLabel: i1.BooleanInput;
+}

package/lib/components/form/checkbox/checkbox.component.d.ts

@@ -1,30 +1,41 @@
-import { AbstractFormComponent } from '../../../abstracts/abstract-form-component';
-import { BooleanInput } from '../../../utils/boolean-input';
+import { OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { ItAbstractFormComponent } from '../../../abstracts/abstract-form.component';
 import * as i0 from "@angular/core";
-export declare class CheckboxComponent extends AbstractFormComponent<boolean> {
+import * as i1 from "../../../utils/coercion";
+export declare class ItCheckboxComponent extends ItAbstractFormComponent<boolean | null | undefined> implements OnInit, OnChanges {
     /**
      * If show checkbox as toggle
+     * @default false
      */
-    toggle?: BooleanInput;
+    toggle?: boolean;
     /**
      * If show checkbox inline
+     * @default false
      */
-    inline?: BooleanInput;
+    inline?: boolean;
     /**
      * If is checkbox group
+     * @default false
      */
-    group?: BooleanInput;
+    group?: boolean;
     /**
      * If checkbox is checked
+     * @default false
      */
-    checked?: BooleanInput;
+    checked?: boolean;
     /**
      * If checkbox is indeterminate
+     * @default false
      */
-    indeterminate?: BooleanInput;
-    get isIndeterminate(): boolean;
-    get isGroup(): boolean;
+    indeterminate?: boolean;
     ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "it-checkbox[id]", never, { "toggle": "toggle"; "inline": "inline"; "group": "group"; "checked": "checked"; "indeterminate": "indeterminate"; }, {}, never, ["*", "[error]", "[label]"], false, never>;
+    ngOnChanges(changes: SimpleChanges): void;
+    private markAsChecked;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ItCheckboxComponent, "it-checkbox", never, { "toggle": { "alias": "toggle"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "group": { "alias": "group"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; }, {}, never, ["*", "[error]", "[label]"], true, never>;
+    static ngAcceptInputType_toggle: i1.BooleanInput;
+    static ngAcceptInputType_inline: i1.BooleanInput;
+    static ngAcceptInputType_group: i1.BooleanInput;
+    static ngAcceptInputType_checked: i1.BooleanInput;
+    static ngAcceptInputType_indeterminate: i1.BooleanInput;
 }

package/lib/components/form/form.module.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./autocomplete/autocomplete.component";
+import * as i2 from "./checkbox/checkbox.component";
+import * as i3 from "./input/input.component";
+import * as i4 from "./password-input/password-input.component";
+import * as i5 from "./radio-button/radio-button.component";
+import * as i6 from "./range/range.component";
+import * as i7 from "./rating/rating.component";
+import * as i8 from "./select/select.component";
+import * as i9 from "./textarea/textarea.component";
+import * as i10 from "./upload-drag-drop/upload-drag-drop.component";
+import * as i11 from "./upload-file-list/upload-file-list.component";
+export declare class ItFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ItFormModule, never, [typeof i1.ItAutocompleteComponent, typeof i2.ItCheckboxComponent, typeof i3.ItInputComponent, typeof i4.ItPasswordInputComponent, typeof i5.ItRadioButtonComponent, typeof i6.ItRangeComponent, typeof i7.ItRatingComponent, typeof i8.ItSelectComponent, typeof i9.ItTextareaComponent, typeof i10.ItUploadDragDropComponent, typeof i11.ItUploadFileListComponent], [typeof i1.ItAutocompleteComponent, typeof i2.ItCheckboxComponent, typeof i3.ItInputComponent, typeof i4.ItPasswordInputComponent, typeof i5.ItRadioButtonComponent, typeof i6.ItRangeComponent, typeof i7.ItRatingComponent, typeof i8.ItSelectComponent, typeof i9.ItTextareaComponent, typeof i10.ItUploadDragDropComponent, typeof i11.ItUploadFileListComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ItFormModule>;
+}