@impartner/design-components 1.0.0

package/lib/form-field/controls/select/index.d.ts

@@ -0,0 +1,5 @@
+export { SelectOptionSelectionChangeEvent, SelectOptionComponent } from './option';
+export { ISelectOptionParentComponent, IMPDC_SELECT_OPTION_PARENT_COMPONENT } from './option-parent';
+export { SelectChange, SelectModel } from './select-model';
+export { SelectChangeEvent, SelectComponent } from './select.component';
+export { SelectModule } from './select.module';

package/lib/form-field/controls/select/option/index.d.ts

@@ -0,0 +1 @@
+export { SelectOptionSelectionChangeEvent, SelectOptionComponent } from './select-option.component';

package/lib/form-field/controls/select/option/select-option.component.d.ts

@@ -0,0 +1,60 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy, Renderer2 } from '@angular/core';
+import { NgbDropdownItem } from '@ng-bootstrap/ng-bootstrap';
+import { BooleanInput } from '../../../../../utilities';
+import { Subject } from 'rxjs';
+import { ISelectOptionParentComponent } from '../option-parent';
+import * as i0 from "@angular/core";
+export declare class SelectOptionSelectionChangeEvent<T = any> {
+    source: SelectOptionComponent;
+    isUserInput: boolean;
+    constructor(source: SelectOptionComponent, isUserInput?: boolean);
+}
+export declare class SelectOptionComponent<T = any> extends NgbDropdownItem implements OnDestroy {
+    private readonly _parent;
+    private readonly _changeDetector;
+    /** @ignore */
+    readonly stateChanges: Subject<void>;
+    private _selected;
+    private __disabled;
+    /** @ignore */
+    get multiple(): boolean;
+    /** @ignore */
+    get selected(): boolean;
+    /**
+     * The specific value represented by the select option.
+     */
+    value?: T;
+    /**
+     * Label text describing the select option.
+     */
+    get label(): string;
+    set label(label: string);
+    private _label;
+    /** @ignore */
+    id: string;
+    /**
+     * Used to enable or disable the specific select option.
+     */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    /** @ignore */
+    readonly onSelectionChange: EventEmitter<SelectOptionSelectionChangeEvent<T>>;
+    constructor(_parent: ISelectOptionParentComponent, _changeDetector: ChangeDetectorRef, _elementRef: ElementRef, _renderer: Renderer2);
+    /** @ignore */
+    select(): void;
+    /** @ignore */
+    deselect(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    /** Ensures the option is selected when activated from the keyboard. */
+    protected _handleKeydown(event: KeyboardEvent): void;
+    /**
+     * `Selects the option while indicating the selection came from the user. Used to
+     * determine if the select's view -> model callback should be invoked.`
+     */
+    protected _selectViaInteraction(): void;
+    private _emitSelectionChangeEvent;
+    private _isInteractionKeyEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectOptionComponent<any>, [{ optional: true; }, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectOptionComponent<any>, "impdc-select-option", never, { "value": "value"; "label": "label"; "id": "id"; "disabled": "disabled"; }, { "onSelectionChange": "onSelectionChange"; }, never, never, false>;
+}

package/lib/form-field/controls/select/option-parent.d.ts

@@ -0,0 +1,5 @@
+import { InjectionToken } from '@angular/core';
+export interface ISelectOptionParentComponent {
+    multiple?: boolean;
+}
+export declare const IMPDC_SELECT_OPTION_PARENT_COMPONENT: InjectionToken<ISelectOptionParentComponent>;

package/lib/form-field/controls/select/select-model.d.ts

@@ -0,0 +1,36 @@
+import { Subject } from 'rxjs';
+export interface SelectChange<T> {
+    source: SelectModel<T>;
+    added: T[];
+    removed: T[];
+}
+export declare function getMultipleValuesInSingleSelectError(): Error;
+export declare class SelectModel<T> {
+    private readonly _multiple;
+    private readonly _emitChanges;
+    compareFunc?: ((a: T, b: T) => boolean) | undefined;
+    private _selection;
+    private _pendingDeselectionsToEmit;
+    private _pendingSelectionsToEmit;
+    private _selected;
+    get selected(): T[];
+    readonly changed$: Subject<SelectChange<T>>;
+    constructor(_multiple?: boolean, initialSelectedValues?: T[], _emitChanges?: boolean, compareFunc?: ((a: T, b: T) => boolean) | undefined);
+    select(...values: T[]): boolean | void;
+    deselect(...values: T[]): boolean | void;
+    setSelection(...values: T[]): boolean | void;
+    toggle(value: T): boolean | void;
+    clear(flushEvent?: boolean): boolean | void;
+    isSelected(value: T): boolean;
+    isEmpty(): boolean;
+    hasValue(): boolean;
+    sort(predicateFunc?: (a: T, b: T) => number): void;
+    isMultipleSelection(): boolean;
+    private _emitChangeEvent;
+    private _markSelected;
+    private _unmarkSelected;
+    private _unmarkAll;
+    private _verifyValueAssignment;
+    private _hasQueuedChanges;
+    private _getConcreteValue;
+}

package/lib/form-field/controls/select/select.component.d.ts

@@ -0,0 +1,170 @@
+import { AfterContentInit, AfterViewInit, ChangeDetectorRef, DoCheck, ElementRef, EventEmitter, NgZone, OnChanges, OnDestroy, OnInit, QueryList, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor, FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { NgbDropdown, NgbDropdownMenu } from '@ng-bootstrap/ng-bootstrap';
+import { BooleanInput } from '../../../../utilities';
+import { Observable, Subject } from 'rxjs';
+import { ErrorStateMatcher } from '../../services';
+import { ImpdcFormRoot } from '../../directives';
+import { CanDisable, HasTabIndex, ICanUpdateErrorState, IHasErrorState, ImpdcFormFieldControl } from '../../shared';
+import { SelectOptionSelectionChangeEvent, SelectOptionComponent } from './option/select-option.component';
+import { SelectModel } from './select-model';
+import * as i0 from "@angular/core";
+export declare class SelectChangeEvent {
+    /** The specific SelectComponent that changed. */
+    readonly source: SelectComponent;
+    /** The selected value(s) */
+    readonly value: any;
+    constructor(
+    /** The specific SelectComponent that changed. */
+    source: SelectComponent, 
+    /** The selected value(s) */
+    value: any);
+}
+/**
+ * Returns an exception to be thrown when attempting to assign a non-array value to a select
+ * in `multiple` mode. Note that `undefined` and `null` are still valid values to allow for
+ * resetting the value.
+ * @ignore
+ */
+export declare function getImpdcSelectNonArrayValueError(): Error;
+/**
+ * Returns an exception to be thrown when assigning a non-function value to the comparator
+ * used to determine if a value corresponds to an option. Note that whether the function
+ * actually takes two values and returns a boolean is not checked.
+ */
+export declare function getImpdcSelectNonFunctionValueError(): Error;
+/**
+ * Returns an exception to be thrown when attempting to change a select's `multiple` option
+ * after initialization.
+ * @ignore
+ */
+export declare function getImpdcSelectDynamicMultipleError(): Error;
+declare const _SelectComponentBase: import("../../shared").Constructor<HasTabIndex> & import("../../shared").AbstractConstructor<HasTabIndex> & import("../../shared").Constructor<CanDisable> & import("../../shared").AbstractConstructor<CanDisable> & import("../../shared").Constructor<ICanUpdateErrorState> & import("../../shared").AbstractConstructor<ICanUpdateErrorState> & {
+    new (_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null): {
+        readonly stateChanges: Subject<void>;
+        _defaultErrorStateMatcher: ErrorStateMatcher;
+        _formRoot: ImpdcFormRoot;
+        _parentForm: NgForm;
+        _parentFormGroup: FormGroupDirective;
+        ngControl: NgControl | null;
+    };
+};
+/**
+ * The `SelectComponent` (`<impdc-select`) is a select-style dropdown input where an item (or multiple items) can be picked
+ * from a list of available options. This component can be used within a `FormFieldComponent` (`<impdc-form-field`).
+ * To use, import `SelectModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+export declare class SelectComponent extends _SelectComponentBase implements OnInit, AfterContentInit, AfterViewInit, OnChanges, DoCheck, OnDestroy, ControlValueAccessor, HasTabIndex, ImpdcFormFieldControl<any>, CanDisable, ICanUpdateErrorState, IHasErrorState {
+    private readonly _changeDetector;
+    protected readonly _ngZone: NgZone;
+    /** @ignore */
+    options: QueryList<SelectOptionComponent>;
+    protected _ngbDropdown: NgbDropdown;
+    protected _ngbDropdownMenu: NgbDropdownMenu;
+    protected _toggleButtonRef: ElementRef<HTMLButtonElement>;
+    /** @ignore */
+    readonly optionSelectionChanges: Observable<SelectOptionSelectionChangeEvent>;
+    protected readonly _uid: string;
+    protected _selectionModel: SelectModel<SelectOptionComponent>;
+    private readonly _ngDestroy;
+    private _previousControl?;
+    private _compareWith;
+    private _cvaOnChange;
+    private _cvaOnTouched;
+    /**
+     * The placeholder text that will be displayed when no selection has been made.
+     *
+     * @default \- Select -
+     */
+    get placeholder(): string;
+    set placeholder(value: string);
+    private _placeholder;
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    private _required;
+    /**
+     * Sets whether the control is a single-select or multiple-select. Cannot be changed after component initialization.
+     */
+    get multiple(): boolean;
+    set multiple(value: BooleanInput);
+    protected _multiple: boolean;
+    /**
+     * Function used to compare option values with selected values. The first arg is a
+     * value from an option, and the second arg is a value from the selection.
+     *
+     * @returns Boolean indicating if the values are equivalent.
+     */
+    get compareWith(): (a: any, b: any) => boolean;
+    set compareWith(fn: (a: any, b: any) => boolean);
+    errorStateMatcher: ErrorStateMatcher;
+    /** Events fire when selection has been changed by the user. */
+    readonly selectionChange: EventEmitter<SelectChangeEvent>;
+    /**
+     * Events fire when raw value of select changes. Mainly exists to handle
+     * two-way binding of `value` input property.
+     * @ignore
+     */
+    readonly valueChange: EventEmitter<any>;
+    get dropdownOpen(): boolean;
+    constructor(_changeDetector: ChangeDetectorRef, _ngZone: NgZone, tabIndex: string, _defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl);
+    get empty(): boolean;
+    get displayedValue(): string;
+    get selected(): SelectOptionComponent | SelectOptionComponent[];
+    /** @ignore */
+    focus(options?: FocusOptions): void;
+    protected _handleOpenChange(isOpen: boolean): void;
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    ngAfterContentInit(): void;
+    /** @ignore */
+    ngAfterViewInit(): void;
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngOnChanges(changes: SimpleChanges): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    readonly controlType: string;
+    readonly supportsAffixes: boolean;
+    get value(): any;
+    set value(value: any);
+    protected _value: any;
+    get id(): string;
+    set id(value: string);
+    protected _id: string;
+    get focused(): boolean;
+    protected _focused: boolean;
+    /** @ignore */
+    writeValue(value: any): void;
+    /** @ignore */
+    registerOnChange(fn: (value: any) => void): void;
+    /** @ignore */
+    registerOnTouched(fn: () => {}): void;
+    /** @ignore */
+    setDisabledState(isDisabled: boolean): void;
+    protected _onFocus(): void;
+    /**
+     * Calls the CVA touched callback only if the dropdown is closed.
+     */
+    protected _onBlur(): void;
+    private _initializeSelection;
+    private _setSelectionByValue;
+    private _selectOptionByValue;
+    /** Assigns a value to the select control. Returns a boolean indicating whether or not
+     * the value has changed.
+     */
+    private _assignValue;
+    private _resetOptions;
+    private _onSelect;
+    private _sortValues;
+    private _propagateChanges;
+    private _buildChangeEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, [null, null, { attribute: "tabindex"; }, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "impdc-select", ["impdcSelect"], { "disabled": "disabled"; "tabIndex": "tabIndex"; "placeholder": "placeholder"; "required": "required"; "multiple": "multiple"; "compareWith": "compareWith"; "errorStateMatcher": "errorStateMatcher"; "value": "value"; "id": "id"; }, { "selectionChange": "selectionChange"; "valueChange": "valueChange"; }, ["options"], ["*"], false>;
+}
+export {};

package/lib/form-field/controls/select/select.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./option/select-option.component";
+import * as i2 from "./select.component";
+import * as i3 from "@angular/common";
+import * as i4 from "@ng-bootstrap/ng-bootstrap";
+export declare class SelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectModule, [typeof i1.SelectOptionComponent, typeof i2.SelectComponent], [typeof i3.CommonModule, typeof i4.NgbDropdownModule], [typeof i1.SelectOptionComponent, typeof i2.SelectComponent, typeof i4.NgbDropdownModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SelectModule>;
+}

package/lib/form-field/controls/shared/index.d.ts

@@ -0,0 +1 @@
+export * from './toggle';

package/lib/form-field/controls/shared/toggle/components/index.d.ts

@@ -0,0 +1 @@
+export * from './toggle-input/toggle-input.component';

package/lib/form-field/controls/shared/toggle/components/toggle-input/toggle-input.component.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class ToggleInputComponent {
+    classFormCheck: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleInputComponent, "input[impdc-toggle-input]", never, {}, {}, never, never, false>;
+}

package/lib/form-field/controls/shared/toggle/index.d.ts

@@ -0,0 +1,3 @@
+export { ToggleComponent } from './toggle.component';
+export { ToggleInputComponent } from './components';
+export { ToggleModule } from './toggle.module';

package/lib/form-field/controls/shared/toggle/toggle.component.d.ts

@@ -0,0 +1,26 @@
+import { ElementRef, ChangeDetectorRef, AfterViewChecked } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ToggleComponent implements AfterViewChecked {
+    private changeDetectorRef;
+    private _id;
+    isSwitch: boolean;
+    label: string;
+    description: string;
+    inline: boolean;
+    switchIcons: boolean;
+    branded: boolean;
+    private classDefaults;
+    private get classHasDescription();
+    private get classFormSwitch();
+    private get classFormCheckInline();
+    private get classFormSwitchIcons();
+    private get classBranded();
+    inputRef?: ElementRef<HTMLInputElement>;
+    get id(): string;
+    get isCheckbox(): boolean;
+    get showDescription(): boolean;
+    constructor(changeDetectorRef: ChangeDetectorRef);
+    ngAfterViewChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleComponent, "impdc-toggle", never, { "isSwitch": "isSwitch"; "label": "label"; "description": "description"; "inline": "inline"; "switchIcons": "switchIcons"; }, {}, ["inputRef"], ["[impdc-toggle-input]"], false>;
+}

package/lib/form-field/controls/shared/toggle/toggle.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./toggle.component";
+import * as i2 from "./components/toggle-input/toggle-input.component";
+import * as i3 from "@angular/common";
+export declare class ToggleModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ToggleModule, [typeof i1.ToggleComponent, typeof i2.ToggleInputComponent], [typeof i3.CommonModule], [typeof i1.ToggleComponent, typeof i2.ToggleInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ToggleModule>;
+}

package/lib/form-field/directives/corner-hint.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class CornerHintDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CornerHintDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CornerHintDirective, "impdc-corner-hint", never, {}, {}, never, never, false>;
+}

package/lib/form-field/directives/error.directive.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const IMPDC_ERROR: InjectionToken<ErrorDirective>;
+export declare class ErrorDirective {
+    id: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ErrorDirective, "impdc-error, [impdc-error]", never, { "id": "id"; }, {}, never, never, false>;
+}

package/lib/form-field/directives/form-root.directive.d.ts

@@ -0,0 +1,26 @@
+import { InjectionToken } from '@angular/core';
+import { FormGroupDirective, NgForm } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare const IMPDC_FORM_ROOT: InjectionToken<ImpdcFormRoot>;
+export interface ImpdcFormRoot {
+    get submitted(): boolean;
+    get form(): FormGroupDirective | NgForm;
+}
+export declare class RootFormGroupDirective implements ImpdcFormRoot {
+    private _formGroupDirective;
+    private _parentRoot?;
+    constructor(_formGroupDirective: FormGroupDirective, _parentRoot?: ImpdcFormRoot | undefined);
+    get submitted(): boolean;
+    get form(): FormGroupDirective | NgForm;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RootFormGroupDirective, [{ host: true; }, { optional: true; skipSelf: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RootFormGroupDirective, "[formGroup]", never, {}, {}, never, never, false>;
+}
+export declare class RootNgFormDirective implements ImpdcFormRoot {
+    private _ngForm;
+    private _parentRoot?;
+    constructor(_ngForm: NgForm, _parentRoot?: ImpdcFormRoot | undefined);
+    get submitted(): boolean;
+    get form(): FormGroupDirective | NgForm;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RootNgFormDirective, [{ host: true; }, { optional: true; skipSelf: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RootNgFormDirective, "[ngForm]", never, {}, {}, never, never, false>;
+}

package/lib/form-field/directives/hint.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class HintDirective {
+    id: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HintDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HintDirective, "impdc-hint", never, { "id": "id"; }, {}, never, never, false>;
+}

package/lib/form-field/directives/index.d.ts

@@ -0,0 +1,7 @@
+export { CornerHintDirective } from './corner-hint.directive';
+export { ErrorDirective } from './error.directive';
+export { IMPDC_FORM_ROOT, ImpdcFormRoot, RootFormGroupDirective, RootNgFormDirective } from './form-root.directive';
+export { HintDirective } from './hint.directive';
+export { LabelDirective } from './label.directive';
+export { PrefixDirective } from './prefix.directive';
+export { SuffixDirective } from './suffix.directive';

package/lib/form-field/directives/label.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class LabelDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LabelDirective, "impdc-label", never, {}, {}, never, never, false>;
+}

package/lib/form-field/directives/prefix.directive.d.ts

@@ -0,0 +1,9 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const IMPDC_PREFIX: InjectionToken<PrefixDirective>;
+export declare class PrefixDirective {
+    set isTextSelector(value: '');
+    isText: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrefixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PrefixDirective, "[impdcPrefix], [impdcTextPrefix]", never, { "isTextSelector": "impdcTextPrefix"; }, {}, never, never, false>;
+}

package/lib/form-field/directives/suffix.directive.d.ts

@@ -0,0 +1,9 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const IMPDC_SUFFIX: InjectionToken<SuffixDirective>;
+export declare class SuffixDirective {
+    set isTextSelector(value: '');
+    isText: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuffixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SuffixDirective, "[impdcSuffix], [impdcTextSuffix]", never, { "isTextSelector": "impdcTextSuffix"; }, {}, never, never, false>;
+}

package/lib/form-field/form-field-errors.d.ts

@@ -0,0 +1,2 @@
+/** @docs-private */
+export declare function getImpdcFormFieldMissingControlError(): Error;

package/lib/form-field/form-field.component.d.ts

@@ -0,0 +1,39 @@
+import { AfterContentChecked, AfterContentInit, AfterViewInit, ChangeDetectorRef, ElementRef, InjectionToken, QueryList } from '@angular/core';
+import { AbstractControlDirective } from '@angular/forms';
+import { ErrorDirective } from './directives/error.directive';
+import { PrefixDirective } from './directives/prefix.directive';
+import { SuffixDirective } from './directives/suffix.directive';
+import { ImpdcFormFieldControl } from './shared/form-field-control';
+import * as i0 from "@angular/core";
+export declare const IMPDC_FORM_FIELD: InjectionToken<FormFieldComponent>;
+export declare class FormFieldComponent implements AfterViewInit, AfterContentInit, AfterContentChecked {
+    private readonly _elementRef;
+    private readonly _changeDetectorRef;
+    protected _inputArea: ElementRef<HTMLElement>;
+    protected _formFieldControl: ImpdcFormFieldControl<unknown>;
+    protected _prefixChildren: QueryList<PrefixDirective>;
+    protected _suffixChildren: QueryList<SuffixDirective>;
+    protected _errorChildren?: QueryList<ErrorDirective>;
+    private readonly _destroyedSubject;
+    protected _hasTextPrefix: boolean;
+    protected _hasTextSuffix: boolean;
+    private _isFocused;
+    private _explicitFormFieldControl;
+    protected readonly _labelId: string;
+    protected get _control(): ImpdcFormFieldControl<unknown>;
+    protected set _control(value: ImpdcFormFieldControl<unknown>);
+    constructor(_elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterContentChecked(): void;
+    protected _showErrors(): boolean;
+    protected _shouldForwardControlState(prop: keyof AbstractControlDirective): boolean;
+    private _initializeControl;
+    private _assertFormFieldControl;
+    private _updateFocusState;
+    private _checkPrefixAndSuffixTypes;
+    /** Initializes the prefix and suffix containers. */
+    private _initializePrefixAndSuffix;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldComponent, "impdc-form-field", ["impdcFormField"], {}, {}, ["_formFieldControl", "_prefixChildren", "_suffixChildren", "_errorChildren"], ["impdc-label", "impdc-corner-hint", "[impdcPrefix]", "[impdcTextPrefix]", "*", "[impdcTextSuffix]", "[impdcSuffix]", "impdc-hint", "impdc-error, [impdc-error]"], false>;
+}

package/lib/form-field/impdc-forms.d.ts

@@ -0,0 +1,7 @@
+export * from './controls';
+export * from './directives';
+export * from './services';
+export * from './shared';
+export * from './form-field-errors';
+export { IMPDC_FORM_FIELD, FormFieldComponent } from './form-field.component';
+export { ImpdcFormsModule } from './impdc-forms.module';

package/lib/form-field/impdc-forms.module.d.ts

@@ -0,0 +1,19 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./form-field.component";
+import * as i2 from "./controls/input/input.directive";
+import * as i3 from "./directives/corner-hint.directive";
+import * as i4 from "./directives/error.directive";
+import * as i5 from "./directives/hint.directive";
+import * as i6 from "./directives/label.directive";
+import * as i7 from "./directives/prefix.directive";
+import * as i8 from "./directives/form-root.directive";
+import * as i9 from "./directives/suffix.directive";
+import * as i10 from "@angular/common";
+import * as i11 from "./controls/checkbox/checkbox.module";
+import * as i12 from "./controls/radio/radio.module";
+import * as i13 from "./controls/select/select.module";
+export declare class ImpdcFormsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImpdcFormsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ImpdcFormsModule, [typeof i1.FormFieldComponent, typeof i2.InputDirective, typeof i3.CornerHintDirective, typeof i4.ErrorDirective, typeof i5.HintDirective, typeof i6.LabelDirective, typeof i7.PrefixDirective, typeof i8.RootFormGroupDirective, typeof i8.RootNgFormDirective, typeof i9.SuffixDirective], [typeof i10.CommonModule, typeof i11.CheckboxModule, typeof i12.RadioModule, typeof i13.SelectModule], [typeof i11.CheckboxModule, typeof i12.RadioModule, typeof i13.SelectModule, typeof i1.FormFieldComponent, typeof i2.InputDirective, typeof i3.CornerHintDirective, typeof i4.ErrorDirective, typeof i5.HintDirective, typeof i6.LabelDirective, typeof i7.PrefixDirective, typeof i8.RootFormGroupDirective, typeof i8.RootNgFormDirective, typeof i9.SuffixDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ImpdcFormsModule>;
+}

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

@@ -0,0 +1 @@
+export * from './impdc-forms';

package/lib/form-field/services/error-state-matcher.service.d.ts

@@ -0,0 +1,12 @@
+import { AbstractControl, FormGroupDirective, NgForm } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class ShowOnDirtyErrorStateMatcher implements ErrorStateMatcher {
+    isErrorState(control: AbstractControl<any, any> | null, form: FormGroupDirective | NgForm | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowOnDirtyErrorStateMatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShowOnDirtyErrorStateMatcher>;
+}
+export declare class ErrorStateMatcher {
+    isErrorState(control: AbstractControl | null, form: FormGroupDirective | NgForm | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorStateMatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorStateMatcher>;
+}

package/lib/form-field/services/index.d.ts

@@ -0,0 +1,2 @@
+export { ErrorStateMatcher, ShowOnDirtyErrorStateMatcher } from './error-state-matcher.service';
+export { UniqueSelectionDispatcherListener, UniqueSelectionDispatcher } from './unique-selection-dispatcher.service';

package/lib/form-field/services/unique-selection-dispatcher.service.d.ts

@@ -0,0 +1,29 @@
+import { OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare type UniqueSelectionDispatcherListener = (id: string, name: string) => void;
+/**
+ * Class to coordinate unique selection based on name.
+ * Intended to be consumed as an Angular service.
+ * This service is needed because native radio change events are only fired on the item currently
+ * being selected, and we still need to uncheck the previous selection.
+ *
+ * This service does not *store* any IDs and names because they may change at any time, so it is
+ * less error-prone if they are simply passed through when the events occur.
+ */
+export declare class UniqueSelectionDispatcher implements OnDestroy {
+    private _listeners;
+    /**
+     * Notify other items that selection for the given name has been set.
+     * @param id ID of the item.
+     * @param name Name of the item.
+     */
+    notify(id: string, name: string): void;
+    /**
+     * Listen for future changes to item selection.
+     * @return Function used to deregister listener
+     */
+    listen(listener: UniqueSelectionDispatcherListener): () => void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UniqueSelectionDispatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UniqueSelectionDispatcher>;
+}

package/lib/form-field/shared/constructors.type.d.ts

@@ -0,0 +1,7 @@
+/** @docs-private */
+export declare type Constructor<T> = new (...args: any[]) => T;
+/**
+ * This is a permissive type for abstract class constructors.
+ * @docs-private
+ */
+export declare type AbstractConstructor<T = object> = abstract new (...args: any[]) => T;

package/lib/form-field/shared/disabled.mixin.d.ts

@@ -0,0 +1,10 @@
+import { AbstractConstructor, Constructor } from './constructors.type';
+/** @docs-private */
+export interface CanDisable {
+    /** Whether the component is disabled. */
+    disabled: boolean;
+}
+declare type CanDisableCtor = Constructor<CanDisable> & AbstractConstructor<CanDisable>;
+/** Mixin to augment a directive with a `disabled` property. */
+export declare function mixinDisabled<T extends AbstractConstructor<{}>>(base: T): CanDisableCtor & T;
+export {};

package/lib/form-field/shared/error-state.mixin.d.ts

@@ -0,0 +1,31 @@
+import { FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { ImpdcFormRoot } from '../directives';
+import { ErrorStateMatcher } from '../services';
+import { AbstractConstructor, Constructor } from './constructors.type';
+/**
+ * @docs-private
+ */
+export interface ICanUpdateErrorState {
+    updateErrorState(): void;
+    errorState: boolean;
+    errorStateMatcher: ErrorStateMatcher | undefined;
+}
+declare type CanUpdateErrorStateCtor = Constructor<ICanUpdateErrorState> & AbstractConstructor<ICanUpdateErrorState>;
+/**
+ * @docs-private
+ */
+export interface IHasErrorState {
+    _formRoot: ImpdcFormRoot;
+    _parentFormGroup: FormGroupDirective;
+    _parentForm: NgForm;
+    _defaultErrorStateMatcher: ErrorStateMatcher;
+    ngControl: NgControl | null;
+    stateChanges: Subject<void>;
+}
+/**
+ * Mixin to augment a directive with updateErrorState method.
+ * Intended for components with `errorState` and the need to update `errorState`.
+ */
+export declare function mixinErrorState<T extends AbstractConstructor<IHasErrorState>>(base: T): CanUpdateErrorStateCtor & T;
+export {};