@clr/angular 17.12.1 → 18.0.0-beta.1

package/types/clr-angular-forms-combobox.d.ts

@@ -0,0 +1,300 @@
+import * as i0 from '@angular/core';
+import { AfterContentInit, AfterViewInit, ElementRef, TemplateRef, ChangeDetectorRef, RendererFactory2, Renderer2, EventEmitter, ViewContainerRef, Injector, OnInit, OnDestroy, QueryList, DoCheck, IterableDiffers, TrackByFunction } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import * as i9 from '@angular/forms';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import * as i12 from '@clr/angular/forms/common';
+import { ClrAbstractContainer, LayoutService, ControlClassService, NgControlService, WrappedFormControl } from '@clr/angular/forms/common';
+import * as i1 from '@clr/angular/popover/common';
+import { ClrPopoverService, ClrPopoverPosition, ClrPopoverType } from '@clr/angular/popover/common';
+import * as i11 from '@clr/angular/utils';
+import { LoadingListener, ClrCommonStringsService, ClrLoadingState } from '@clr/angular/utils';
+import * as i8 from '@angular/common';
+import { NgForOfContext } from '@angular/common';
+import * as i10 from '@clr/angular/icon';
+import * as i14 from '@clr/angular/progress/spinner';
+
+declare class ComboboxContainerService {
+    labelOffset: number;
+    labelText: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxContainerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComboboxContainerService>;
+}
+
+declare class ClrComboboxContainer extends ClrAbstractContainer implements AfterContentInit, AfterViewInit {
+    private containerService;
+    private el;
+    controlContainer: ElementRef<HTMLElement>;
+    constructor(layoutService: LayoutService, controlClassService: ControlClassService, ngControlService: NgControlService, containerService: ComboboxContainerService, el: ElementRef<HTMLElement>);
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrComboboxContainer, [{ optional: true; }, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrComboboxContainer, "clr-combobox-container", never, {}, {}, never, ["label", "clr-combobox", "clr-control-helper", "clr-control-error", "clr-control-success"], false, never>;
+}
+
+declare abstract class ComboboxModel<T> {
+    model: T | T[];
+    displayField?: string;
+    abstract containsItem(item: T): boolean;
+    abstract select(item: T): void;
+    abstract unselect(item: T): void;
+    abstract toString(displayField?: string, index?: number): string;
+    abstract isEmpty(): boolean;
+    abstract pop(): T;
+}
+
+declare class ClrOptionSelected<T> {
+    template: TemplateRef<{
+        $implicit: T;
+    }>;
+    selected: T;
+    constructor(template: TemplateRef<{
+        $implicit: T;
+    }>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrOptionSelected<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrOptionSelected<any>, "[clrOptionSelected]", never, { "selected": { "alias": "clrOptionSelected"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class OptionSelectionService<T> {
+    loading: boolean;
+    editable: boolean;
+    filtering: boolean;
+    selectionModel: ComboboxModel<T>;
+    inputChanged: Observable<string>;
+    showAllOptions: boolean;
+    private _currentInput;
+    private _displayField;
+    private _inputChanged;
+    private _selectionChanged;
+    constructor();
+    get displayField(): string;
+    set displayField(value: string);
+    get currentInput(): string;
+    set currentInput(input: string);
+    get selectionChanged(): Observable<ComboboxModel<T>>;
+    get multiselectable(): boolean;
+    select(item: T): void;
+    toggle(item: T): void;
+    unselect(item: T): void;
+    setSelectionValue(value: T | T[]): void;
+    parseStringToModel(value: string): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionSelectionService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OptionSelectionService<any>>;
+}
+
+declare class SingleSelectComboboxModel<T> implements ComboboxModel<T> {
+    model: T;
+    containsItem(item: T): boolean;
+    select(item: T): void;
+    unselect(item: T): void;
+    isEmpty(): boolean;
+    pop(): T;
+    toString(displayField?: string): string;
+}
+
+declare class PseudoFocusModel<T> extends SingleSelectComboboxModel<T> {
+    private _focusChanged;
+    get focusChanged(): Observable<T>;
+    select(item: T): void;
+}
+
+declare class ComboboxFocusHandler<T> {
+    private popoverService;
+    private selectionService;
+    private platformId;
+    componentCdRef: ChangeDetectorRef;
+    pseudoFocus: PseudoFocusModel<OptionData<T>>;
+    private renderer;
+    private _trigger;
+    private _listbox;
+    private _textInput;
+    private optionData;
+    constructor(rendererFactory: RendererFactory2, popoverService: ClrPopoverService, selectionService: OptionSelectionService<T>, platformId: any);
+    get trigger(): HTMLElement;
+    set trigger(el: HTMLElement);
+    get listbox(): HTMLElement;
+    set listbox(el: HTMLElement);
+    get textInput(): HTMLElement;
+    set textInput(el: HTMLElement);
+    focusInput(): void;
+    focusFirstActive(): void;
+    addOptionValues(options: OptionData<T>[]): void;
+    private handleFocusSubscription;
+    private moveFocusTo;
+    private openAndMoveTo;
+    private handleTextInput;
+    private scrollIntoSelectedModel;
+    private preventViewportScrolling;
+    private addFocusOnBlurListener;
+    private focusOutOfComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxFocusHandler<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComboboxFocusHandler<any>>;
+}
+declare class OptionData<T> {
+    id: string;
+    value: T;
+    el: HTMLElement;
+    constructor(id: string, value: T);
+    equals(other: OptionData<T>): boolean;
+}
+
+declare class ClrCombobox<T> extends WrappedFormControl<ClrComboboxContainer> implements ControlValueAccessor, LoadingListener, AfterContentInit {
+    control: NgControl;
+    protected renderer: Renderer2;
+    protected el: ElementRef<HTMLElement>;
+    optionSelectionService: OptionSelectionService<T>;
+    commonStrings: ClrCommonStringsService;
+    private popoverService;
+    private containerService;
+    private platformId;
+    private focusHandler;
+    private cdr;
+    placeholder: string;
+    clrInputChange: EventEmitter<string>;
+    clrOpenChange: rxjs.Observable<boolean>;
+    /**
+     * This output should be used to set up a live region using aria-live and populate it with updates that reflect each combobox change.
+     */
+    clrSelectionChange: rxjs.Observable<ComboboxModel<T>>;
+    textbox: ElementRef<HTMLInputElement>;
+    trigger: ElementRef<HTMLButtonElement>;
+    optionSelected: ClrOptionSelected<T>;
+    focused: boolean;
+    popoverPosition: ClrPopoverPosition;
+    protected index: number;
+    protected popoverType: ClrPopoverType;
+    private options;
+    private _searchText;
+    private onTouchedCallback;
+    private onChangeCallback;
+    constructor(vcr: ViewContainerRef, injector: Injector, control: NgControl, renderer: Renderer2, el: ElementRef<HTMLElement>, optionSelectionService: OptionSelectionService<T>, commonStrings: ClrCommonStringsService, popoverService: ClrPopoverService, containerService: ComboboxContainerService, platformId: any, focusHandler: ComboboxFocusHandler<T>, cdr: ChangeDetectorRef);
+    get editable(): boolean;
+    set editable(value: boolean);
+    get multiSelect(): boolean | string;
+    set multiSelect(value: boolean | string);
+    get id(): string;
+    set id(id: string);
+    get searchText(): string;
+    set searchText(text: string);
+    get openState(): boolean;
+    get multiSelectModel(): T[];
+    get ariaControls(): string;
+    get ariaOwns(): string;
+    get ariaDescribedBySelection(): string;
+    get displayField(): string;
+    private get disabled();
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    onKeyUp(event: KeyboardEvent): void;
+    inputId(): string;
+    loadingStateChange(state: ClrLoadingState): void;
+    unselect(item: T): void;
+    onBlur(event: any): void;
+    onFocus(): void;
+    onChange(): void;
+    getSelectionAriaLabel(): string;
+    focusFirstActive(): void;
+    writeValue(value: T | T[]): void;
+    registerOnTouched(onTouched: any): void;
+    registerOnChange(onChange: any): void;
+    getActiveDescendant(): string;
+    setDisabledState(): void;
+    onWrapperClick(event: any): void;
+    private initializeSubscriptions;
+    private updateInputValue;
+    private updateControlValue;
+    private getDisplayNames;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrCombobox<any>, [null, null, { optional: true; self: true; }, null, null, null, null, null, { optional: true; }, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrCombobox<any>, "clr-combobox", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "editable": { "alias": "clrEditable"; "required": false; }; "multiSelect": { "alias": "clrMulti"; "required": false; }; }, { "clrInputChange": "clrInputChange"; "clrOpenChange": "clrOpenChange"; "clrSelectionChange": "clrSelectionChange"; }, ["optionSelected", "options"], ["*"], false, [{ directive: typeof i1.ClrPopoverHostDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ClrOption<T> implements OnInit {
+    elRef: ElementRef<HTMLElement>;
+    commonStrings: ClrCommonStringsService;
+    private focusHandler;
+    private optionSelectionService;
+    optionProxy: OptionData<T>;
+    private _id;
+    private _value;
+    constructor(elRef: ElementRef<HTMLElement>, commonStrings: ClrCommonStringsService, focusHandler: ComboboxFocusHandler<T>, optionSelectionService: OptionSelectionService<T>);
+    get optionId(): string;
+    set optionId(id: string);
+    get value(): T;
+    set value(value: T);
+    get selected(): boolean;
+    get focusClass(): boolean;
+    ngOnInit(): void;
+    onClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrOption<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrOption<any>, "clr-option", never, { "optionId": { "alias": "id"; "required": false; }; "value": { "alias": "clrValue"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class ClrOptions<T> implements AfterViewInit, LoadingListener, OnDestroy {
+    optionSelectionService: OptionSelectionService<T>;
+    id: number;
+    el: ElementRef<HTMLElement>;
+    commonStrings: ClrCommonStringsService;
+    private focusHandler;
+    private popoverService;
+    private document;
+    optionsId: string;
+    loading: boolean;
+    _items: QueryList<ClrOption<T>>;
+    private subscriptions;
+    constructor(optionSelectionService: OptionSelectionService<T>, id: number, el: ElementRef<HTMLElement>, commonStrings: ClrCommonStringsService, focusHandler: ComboboxFocusHandler<T>, popoverService: ClrPopoverService, parentHost: ElementRef<HTMLElement>, document: any);
+    get items(): QueryList<ClrOption<T>>;
+    set items(items: QueryList<ClrOption<T>>);
+    /**
+     * Tests if the list of options is empty, meaning it doesn't contain any items
+     */
+    get emptyOptions(): boolean;
+    get editable(): boolean;
+    get noResultsElementId(): string;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    searchText(input: string): string;
+    loadingStateChange(state: ClrLoadingState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrOptions<any>, [null, null, null, null, null, null, { optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrOptions<any>, "clr-options", never, { "optionsId": { "alias": "id"; "required": false; }; }, {}, ["items"], ["*"], false, never>;
+}
+
+declare class ClrOptionItems<T> implements DoCheck, OnDestroy {
+    template: TemplateRef<NgForOfContext<T>>;
+    private differs;
+    private optionService;
+    private iterableProxy;
+    private _rawItems;
+    private filteredItems;
+    private subscriptions;
+    private filter;
+    private _filterField;
+    private differ;
+    constructor(template: TemplateRef<NgForOfContext<T>>, differs: IterableDiffers, optionService: OptionSelectionService<T>, vcr: ViewContainerRef);
+    set rawItems(items: T[]);
+    set trackBy(value: TrackByFunction<T>);
+    set field(field: string);
+    get hasResults(): number;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    private updateItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrOptionItems<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrOptionItems<any>, "[clrOptionItems][clrOptionItemsOf]", never, { "rawItems": { "alias": "clrOptionItemsOf"; "required": false; }; "trackBy": { "alias": "clrOptionItemsTrackBy"; "required": false; }; "field": { "alias": "clrOptionItemsField"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ClrOptionGroup<T> {
+    label: string;
+    protected clrOptionItems: ClrOptionItems<T>;
+    protected labelId: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrOptionGroup<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrOptionGroup<any>, "clr-option-group", never, { "label": { "alias": "clrOptionGroupLabel"; "required": false; }; }, {}, ["clrOptionItems"], ["*"], false, never>;
+}
+
+declare class ClrComboboxModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrComboboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrComboboxModule, [typeof ClrCombobox, typeof ClrComboboxContainer, typeof ClrOptions, typeof ClrOption, typeof ClrOptionGroup, typeof ClrOptionSelected, typeof ClrOptionItems], [typeof i8.CommonModule, typeof i9.FormsModule, typeof i10.ClrIcon, typeof i11.ClrKeyFocusModule, typeof i12.ClrCommonFormsModule, typeof i11.ClrConditionalModule, typeof i1.ÇlrClrPopoverModuleNext, typeof i14.ClrSpinnerModule], [typeof i12.ClrCommonFormsModule, typeof ClrCombobox, typeof ClrComboboxContainer, typeof ClrOptions, typeof ClrOption, typeof ClrOptionGroup, typeof ClrOptionSelected, typeof i11.ClrConditionalModule, typeof ClrOptionItems]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrComboboxModule>;
+}
+
+export { ClrCombobox, ClrComboboxContainer, ClrComboboxModule, ClrOption, ClrOptionGroup, ClrOptionItems, ClrOptionSelected, ClrOptions };

package/types/clr-angular-forms-common.d.ts

@@ -0,0 +1,336 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, Renderer2, ElementRef, TemplateRef, ViewContainerRef, QueryList, DoCheck, Type, Injector, InjectionToken } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { Observable, Subscription } from 'rxjs';
+import * as i11 from '@angular/common';
+import * as i12 from '@clr/angular/icon';
+
+/**
+ * @TODO No idea why I need to use provideIn .. without I'm getting error that
+ * ContainerIdService is not defined - But this must be optional service!?
+ *
+ * There is something wrong - will come back to investigate it when I have more time
+ *
+ */
+declare class ContainerIdService {
+    private _id;
+    private _idChange;
+    get id(): string;
+    set id(value: string);
+    get idChange(): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContainerIdService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContainerIdService>;
+}
+
+declare class ControlIdService {
+    private _id;
+    private _idChange;
+    get id(): string;
+    set id(value: string);
+    get idChange(): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ControlIdService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ControlIdService>;
+}
+
+declare abstract class ClrAbstractControl {
+    protected controlIdService: ControlIdService;
+    protected containerIdService: ContainerIdService;
+    /**
+     * Hold the suffix for the ID
+     */
+    controlIdSuffix: string;
+    protected constructor(controlIdService: ControlIdService, containerIdService: ContainerIdService);
+    get id(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrAbstractControl, [{ optional: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrAbstractControl, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class ClrControlError extends ClrAbstractControl {
+    protected controlIdService: ControlIdService;
+    protected containerIdService: ContainerIdService;
+    controlIdSuffix: string;
+    constructor(controlIdService: ControlIdService, containerIdService: ContainerIdService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrControlError, [{ optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrControlError, "clr-control-error", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class ClrControlHelper extends ClrAbstractControl {
+    protected controlIdService: ControlIdService;
+    protected containerIdService: ContainerIdService;
+    controlIdSuffix: string;
+    constructor(controlIdService: ControlIdService, containerIdService: ContainerIdService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrControlHelper, [{ optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrControlHelper, "clr-control-helper", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare enum ClrFormLayout {
+    VERTICAL = "vertical",
+    HORIZONTAL = "horizontal",
+    COMPACT = "compact"
+}
+declare class LayoutService {
+    readonly minLabelSize = 1;
+    readonly maxLabelSize = 12;
+    layout: ClrFormLayout | string;
+    private layoutValues;
+    private _labelSize;
+    get labelSize(): number;
+    set labelSize(size: number);
+    get layoutClass(): string;
+    isVertical(): boolean;
+    isHorizontal(): boolean;
+    isCompact(): boolean;
+    isValid(layout: string): boolean;
+    labelSizeIsValid(labelSize: number): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutService>;
+}
+
+interface Helpers {
+    show?: boolean;
+    showInvalid?: boolean;
+    showValid?: boolean;
+    showHelper?: boolean;
+}
+declare class NgControlService {
+    container: ClrAbstractContainer;
+    private _controls;
+    private _controlsChanges;
+    get controls(): NgControl[];
+    get controlsChanges(): Observable<NgControl[]>;
+    get hasMultipleControls(): boolean;
+    addControl(control: NgControl): void;
+    emitControlsChange(controls: NgControl[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgControlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgControlService>;
+}
+
+declare class ClrControlLabel implements OnInit, OnDestroy {
+    private controlIdService;
+    private layoutService;
+    private ngControlService;
+    private renderer;
+    private el;
+    idInput: string;
+    idAttr: string;
+    forAttr: string;
+    private signpost;
+    private enableGrid;
+    private subscriptions;
+    constructor(controlIdService: ControlIdService, layoutService: LayoutService, ngControlService: NgControlService, renderer: Renderer2, el: ElementRef<HTMLLabelElement>);
+    get labelText(): string;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    disableGrid(): void;
+    /**
+     * Allowing signposts inside labels to work without disabling default behavior. <label> is spreading a click event to its children so signposts get
+     * automatically closed once clicked inside a <label>.
+     * @param event
+     */
+    private onClick;
+    private preventDefaultOnSignpostTarget;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrControlLabel, [{ optional: true; }, { optional: true; }, { optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrControlLabel, "label", never, { "idInput": { "alias": "id"; "required": false; }; "forAttr": { "alias": "for"; "required": false; }; }, {}, ["signpost"], never, false, never>;
+}
+
+declare class ControlClassService {
+    private layoutService;
+    className: string;
+    constructor(layoutService: LayoutService);
+    controlClass(state: string, grid?: boolean, additional?: string): string;
+    initControlClass(renderer: Renderer2, element: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ControlClassService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ControlClassService>;
+}
+
+declare class ClrControlSuccess extends ClrAbstractControl {
+    protected controlIdService: ControlIdService;
+    protected containerIdService: ContainerIdService;
+    controlIdSuffix: string;
+    constructor(controlIdService: ControlIdService, containerIdService: ContainerIdService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrControlSuccess, [{ optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrControlSuccess, "clr-control-success", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare abstract class ClrAbstractContainer implements OnDestroy {
+    protected layoutService: LayoutService;
+    protected controlClassService: ControlClassService;
+    protected ngControlService: NgControlService;
+    label: ClrControlLabel;
+    controlSuccessComponent: ClrControlSuccess;
+    controlErrorComponent: ClrControlError;
+    controlHelperComponent: ClrControlHelper;
+    controls: NgControl[];
+    protected subscriptions: Subscription[];
+    constructor(layoutService: LayoutService, controlClassService: ControlClassService, ngControlService: NgControlService);
+    get control(): NgControl;
+    /**
+     * @NOTE
+     * Helper control is a bit different than the others, it must be always visible:
+     *   -  Labels and instructions must always accompany forms and are persistent.
+     *   -  The recommendation here is to always have helper text or anything instructions visible.
+     *   -  The expectation is to have error text + helper text in the errored state. this way all users will have the helper text information always available.
+     */
+    get showHelper(): boolean;
+    /**
+     * We gonna set the helper control state, after all or most of the components
+     * are ready - also this will trigger some initial flows into wrappers and controls,
+     * like locating IDs  and setting  attributes.
+     */
+    get helpers(): {
+        show: boolean;
+        showInvalid: boolean;
+        showHelper: boolean;
+        showValid: boolean;
+    };
+    get showValid(): boolean;
+    get showInvalid(): boolean;
+    protected get successMessagePresent(): boolean;
+    protected get errorMessagePresent(): boolean;
+    private get touched();
+    private get state();
+    ngOnDestroy(): void;
+    controlClass(): string;
+    addGrid(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrAbstractContainer, [{ optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrAbstractContainer, never, never, {}, {}, ["label", "controlSuccessComponent", "controlErrorComponent", "controlHelperComponent"], never, true, never>;
+}
+
+declare abstract class AbstractIfState {
+    protected ngControlService: NgControlService;
+    protected displayedContent: boolean;
+    protected controls: NgControl[];
+    protected constructor(ngControlService: NgControlService);
+    protected handleState(_state: any): void;
+    private getControlStatusChangesObservable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractIfState, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractIfState, never, never, {}, {}, never, never, true, never>;
+}
+
+declare enum CONTROL_STATE {
+    VALID = "VALID",
+    INVALID = "INVALID"
+}
+
+declare class ClrIfError extends AbstractIfState {
+    private template;
+    private container;
+    error: string;
+    private embeddedViewRef;
+    constructor(ngControlService: NgControlService, template: TemplateRef<any>, container: ViewContainerRef);
+    /**
+     * @param state CONTROL_STATE
+     */
+    protected handleState(state: CONTROL_STATE): void;
+    private displayError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrIfError, [{ optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrIfError, "[clrIfError]", never, { "error": { "alias": "clrIfError"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ClrIfSuccess extends AbstractIfState {
+    private template;
+    private container;
+    constructor(ngControlService: NgControlService, template: TemplateRef<any>, container: ViewContainerRef);
+    /**
+     * @param state CONTROL_STATE
+     */
+    protected handleState(state: CONTROL_STATE): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrIfSuccess, [{ optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrIfSuccess, "[clrIfSuccess]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MarkControlService {
+    private _touched;
+    get touchedChange(): Observable<void>;
+    markAsTouched(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkControlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MarkControlService>;
+}
+
+declare class ClrForm {
+    layoutService: LayoutService;
+    private markControlService;
+    labels: QueryList<ClrControlLabel>;
+    constructor(layoutService: LayoutService, markControlService: MarkControlService);
+    set labelSize(size: number | string);
+    onFormSubmit(): void;
+    markAsTouched(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrForm, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrForm, "[clrForm]", never, { "labelSize": { "alias": "clrLabelSize"; "required": false; }; }, {}, ["labels"], never, false, never>;
+}
+
+declare class ClrLayout implements OnInit {
+    layoutService: LayoutService;
+    layout: ClrFormLayout | string;
+    constructor(layoutService: LayoutService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrLayout, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrLayout, "[clrForm][clrLayout]", never, { "layout": { "alias": "clrLayout"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ClrControlContainer extends ClrAbstractContainer {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrControlContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrControlContainer, "clr-control-container", never, {}, {}, never, ["label", "*", "clr-control-helper", "clr-control-error", "clr-control-success"], false, never>;
+}
+
+declare enum CHANGE_KEYS {
+    FORM = "form",
+    MODEL = "model"
+}
+declare class WrappedFormControl<W> implements OnInit, DoCheck, OnDestroy {
+    protected vcr: ViewContainerRef;
+    protected wrapperType: Type<W>;
+    private ngControl;
+    protected renderer: Renderer2;
+    protected el: ElementRef<HTMLElement>;
+    _id: string;
+    protected controlIdService: ControlIdService;
+    protected ngControlService: NgControlService;
+    protected index: number;
+    protected subscriptions: Subscription[];
+    private controlClassService;
+    private markControlService;
+    private containerIdService;
+    private _containerInjector;
+    private differs;
+    private differ;
+    constructor(vcr: ViewContainerRef, wrapperType: Type<W>, injector: Injector, ngControl: NgControl | null, renderer: Renderer2, el: ElementRef<HTMLElement>);
+    get id(): string;
+    set id(value: string);
+    private get ariaDescribedById();
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    triggerValidation(): void;
+    protected getProviderFromContainer<T>(token: Type<T> | InjectionToken<T>, notFoundValue?: T): T;
+    private injectControlClassService;
+    private triggerDoCheck;
+    private markAsTouched;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrappedFormControl<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WrappedFormControl<any>, never, never, { "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ClrControl extends WrappedFormControl<ClrControlContainer> {
+    protected index: number;
+    constructor(vcr: ViewContainerRef, injector: Injector, control: NgControl, renderer: Renderer2, el: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrControl, [null, null, { optional: true; self: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClrControl, "[clrControl]", never, {}, {}, never, never, false, never>;
+}
+
+declare class ClrCommonFormsModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrCommonFormsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrCommonFormsModule, [typeof ClrControlLabel, typeof ClrControlError, typeof ClrControlSuccess, typeof ClrControlHelper, typeof ClrIfError, typeof ClrIfSuccess, typeof ClrForm, typeof ClrLayout, typeof ClrControlContainer, typeof ClrControl], [typeof i11.CommonModule, typeof i12.ClrIcon], [typeof ClrControlLabel, typeof ClrControlError, typeof ClrControlSuccess, typeof ClrControlHelper, typeof ClrIfError, typeof ClrIfSuccess, typeof ClrForm, typeof ClrLayout, typeof ClrControlContainer, typeof ClrControl, typeof i12.ClrIcon]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClrCommonFormsModule>;
+}
+
+declare class FormsFocusService {
+    private _focused;
+    get focusChange(): Observable<boolean>;
+    set focused(state: boolean);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormsFocusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormsFocusService>;
+}
+
+export { AbstractIfState, CHANGE_KEYS, ClrAbstractContainer, ClrCommonFormsModule, ClrControl, ClrControlContainer, ClrControlError, ClrControlHelper, ClrControlLabel, ClrControlSuccess, ClrForm, ClrFormLayout, ClrIfError, ClrIfSuccess, ClrLayout, ContainerIdService, ControlClassService, ControlIdService, FormsFocusService, LayoutService, MarkControlService, NgControlService, WrappedFormControl };
+export type { Helpers };