novo-elements 11.4.0 → 12.0.0

package/elements/field/index.d.ts

@@ -1,14 +1,513 @@
-export * from './error';
-export * from './field';
-export * from './field-control';
-export * from './field.module';
-export * from './fieldset';
-export * from './formats/base-format';
-export * from './formats/date-format';
-export * from './formats/date-range-format';
-export * from './formats/time-format';
-export * from './formats/date-time-format';
-export * from './hint';
-export * from './input';
-export * from './picker.directive';
-export * from './toggle/picker-toggle.component';
+import * as i0 from '@angular/core';
+import { OnInit, InjectionToken, AfterContentInit, OnDestroy, ElementRef, QueryList, EventEmitter, ChangeDetectorRef, OnChanges, AfterViewInit, DoCheck, NgZone, SimpleChanges } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as _angular_forms from '@angular/forms';
+import { NgControl, NgForm, FormGroupDirective, ControlValueAccessor } from '@angular/forms';
+import * as i14 from 'novo-elements/elements/common';
+import { NovoLabel, HasOverlay, NovoOverlayTemplateComponent } from 'novo-elements/elements/common';
+import { Observable, Subject } from 'rxjs';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { Platform } from '@angular/cdk/platform';
+import { AutofillMonitor } from '@angular/cdk/text-field';
+import { IMaskDirective } from 'angular-imask';
+import { NovoLabelService, DateFormatService } from 'novo-elements/services';
+import { DateParseOptions } from 'novo-elements/utils';
+import * as i13 from 'novo-elements/elements/button';
+import { NovoButtonElement } from 'novo-elements/elements/button';
+import * as i12 from '@angular/common';
+
+declare class NovoErrorElement implements OnInit {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    ngOnInit(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoErrorElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoErrorElement, "novo-error", never, {}, {}, never, ["*"], false, never>;
+}
+
+/** An interface which allows a control to work inside of a `NovoField`. */
+declare abstract class NovoFieldControl<T> {
+    /** The value of the control. */
+    value: T | null;
+    /** The last key pressed. */
+    lastKeyValue: string | null;
+    /** The last cursor position. */
+    lastCaretPosition: number | null;
+    /**
+     * Stream that emits whenever the state of the control changes such that the parent `NovoField`
+     * needs to run change detection.
+     */
+    readonly stateChanges: Observable<void>;
+    /** The element ID for this control. */
+    readonly id: string;
+    /** The placeholder for this control. */
+    readonly placeholder: string;
+    /** Gets the NgControl for this control. */
+    readonly ngControl: NgControl | null;
+    /** Whether the control is focused. */
+    readonly focused: boolean;
+    /** Whether the control is empty. */
+    readonly empty: boolean;
+    /** Whether the `NovoField` label should try to float. */
+    /** Whether the control is required. */
+    readonly required: boolean;
+    /** Whether the control is disabled. */
+    readonly disabled: boolean;
+    /** Whether the control is in an error state. */
+    readonly errorState: boolean;
+    /** Whether the control can have multiple values. */
+    readonly multiple?: boolean;
+    /**
+     * An optional name for the control type that can be used to distinguish `novo-form-field` elements
+     * based on their control type. The form field will add a class,
+     * `novo-form-field-type-{{controlType}}` to its root element.
+     */
+    readonly controlType?: string;
+    /**
+     * Whether the input is currently in an autofilled state. If property is not present on the
+     * control it is assumed to be false.
+     */
+    readonly autofilled?: boolean;
+    /** Sets the list of element IDs that currently describe this control. */
+    abstract setDescribedByIds(ids: string[]): void;
+    /** Handles a click on the control's container. */
+    abstract onContainerClick(event: MouseEvent): void;
+    abstract focus(options?: FocusOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoFieldControl<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoFieldControl<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class NovoHintElement implements OnInit {
+    /** Whether to align the hint label at the start or end of the line. */
+    align: 'start' | 'end';
+    /** Unique ID for the hint. Used for the aria-describedby on the form field control. */
+    id: string;
+    ngOnInit(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoHintElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoHintElement, "novo-hint", never, { "align": { "alias": "align"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class NovoFieldPrefixDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoFieldPrefixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoFieldPrefixDirective, "[novoPrefix]", never, {}, {}, never, never, false, never>;
+}
+declare class NovoFieldSuffixDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoFieldSuffixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoFieldSuffixDirective, "[novoSuffix]", never, {}, {}, never, never, false, never>;
+}
+declare const NOVO_FORM_FIELD: InjectionToken<NovoFieldElement>;
+declare class NovoFieldElement implements AfterContentInit, OnDestroy {
+    _elementRef: ElementRef;
+    private _changeDetectorRef;
+    private _labelClicks;
+    _inputContainerRef: ElementRef;
+    _labelElement: NovoLabel;
+    _hintElements: QueryList<NovoHintElement>;
+    _errorElements: QueryList<NovoErrorElement>;
+    _prefixElements: QueryList<NovoFieldPrefixDirective>;
+    _suffixElements: QueryList<NovoFieldSuffixDirective>;
+    _overlayElements: QueryList<HasOverlay>;
+    _control: NovoFieldControl<any>;
+    layout: 'horizontal' | 'vertical';
+    appearance: 'standard' | 'outline' | 'fill' | 'list';
+    /**
+     * When this field has a picker element, express which element it should be parented to
+     */
+    customOverlayOrigin: ElementRef;
+    width: string;
+    private _destroyed;
+    valueChanges: EventEmitter<any>;
+    stateChanges: EventEmitter<void>;
+    constructor(_elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef);
+    /**
+     * Gets an ElementRef for the element that a overlay attached to the form-field should be
+     * positioned relative to.
+     */
+    getConnectedOverlayOrigin(): ElementRef;
+    ngAfterContentInit(): any;
+    ngOnDestroy(): void;
+    /** Throws an error if the form field's control is missing. */
+    protected _validateControlChild(): void;
+    blurEventIsInField(blurEvt: FocusEvent): boolean;
+    _handleContainerClick(evt: MouseEvent): void;
+    _isUnderlinedInput(): boolean;
+    /** Determines whether to display hints or errors. */
+    _getDisplayedMessages(): 'error' | 'hint';
+    /** Determines whether a class from the NgControl should be forwarded to the host element. */
+    _shouldForward(prop: keyof NgControl): boolean;
+    _hasLabel(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoFieldElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoFieldElement, "novo-field", never, { "layout": { "alias": "layout"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "customOverlayOrigin": { "alias": "customOverlayOrigin"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, { "valueChanges": "valueChanges"; "stateChanges": "stateChanges"; }, ["_labelElement", "_control", "_hintElements", "_errorElements", "_prefixElements", "_suffixElements", "_overlayElements"], ["novo-label", "[novoPrefix]", "*", "[novoSuffix]", "novo-error", "novo-hint", "novo-hint[align=end]"], false, never>;
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * This token is used to inject the object whose value should be set into `NovoInput`. If none is
+ * provided, the native `HTMLInputElement` is used. Directives like `MatDatepickerInput` can provide
+ * themselves for this token, in order to make `NovoInput` delegate the getting and setting of the
+ * value to them.
+ */
+declare const NOVO_INPUT_VALUE_ACCESSOR: InjectionToken<{
+    value: any;
+}>;
+declare class NovoInputBase {
+    _parentForm: NgForm;
+    _parentFormGroup: FormGroupDirective;
+    /** @docs-private */
+    ngControl: NgControl;
+    constructor(_parentForm: NgForm, _parentFormGroup: FormGroupDirective, 
+    /** @docs-private */
+    ngControl: NgControl);
+}
+/** Directive that allows a native input to work inside a `NovoField`. */
+declare class NovoInput extends NovoInputBase implements NovoFieldControl<any>, OnChanges, OnDestroy, AfterViewInit, DoCheck {
+    protected _elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+    protected _platform: Platform;
+    /** @docs-private */
+    ngControl: NgControl;
+    private _autofillMonitor;
+    protected _uid: string;
+    protected _previousNativeValue: any;
+    private _inputValueAccessor;
+    /** The aria-describedby attribute on the input for improved a11y. */
+    _ariaDescribedby: string;
+    /** Whether the component is being rendered on the server. */
+    readonly _isServer: boolean;
+    /** Whether the component is a native html select. */
+    readonly _isNativeSelect: boolean;
+    /** Whether the component is a textarea. */
+    readonly _isTextarea: boolean;
+    /**
+     * Implemented as part of NovoFieldControl.
+     * @docs-private
+     */
+    focused: boolean;
+    errorState: boolean;
+    /** @docs-private Implemented as part of NovoFieldControl. */
+    lastKeyValue: string;
+    /** @docs-private Implemented as part of NovoFieldControl.*/
+    lastCaretPosition: number | null;
+    /**
+     * Implemented as part of NovoFieldControl.
+     * @docs-private
+     */
+    readonly stateChanges: Subject<void>;
+    /**
+     * Implemented as part of NovoFieldControl.
+     * @docs-private
+     */
+    controlType: string;
+    /**
+     * Implemented as part of NovoFieldControl.
+     * @docs-private
+     */
+    autofilled: boolean;
+    /**
+     * Implemented as part of NovoFieldControl.
+     * @docs-private
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    protected _disabled: boolean;
+    /**
+     * Implemented as part of NovoFieldControl.
+     * @docs-private
+     */
+    get id(): string;
+    set id(value: string);
+    protected _id: string;
+    /**
+     * Implemented as part of NovoFieldControl.
+     * @docs-private
+     */
+    placeholder: string;
+    /**
+     * Implemented as part of NovoFieldControl.
+     * @docs-private
+     */
+    get required(): boolean;
+    set required(value: boolean);
+    protected _required: boolean;
+    /** Input type of the element. */
+    get type(): string;
+    set type(value: string);
+    protected _type: string;
+    /**
+     * Implemented as part of NovoFieldControl.
+     * @docs-private
+     */
+    get value(): string;
+    set value(value: string);
+    /** Whether the element is readonly. */
+    get readonly(): boolean;
+    set readonly(value: boolean);
+    private _readonly;
+    protected _neverEmptyInputTypes: string[];
+    constructor(_elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>, _platform: Platform, 
+    /** @docs-private */
+    ngControl: NgControl, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, inputValueAccessor: any, _autofillMonitor: AutofillMonitor, ngZone: NgZone);
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    ngDoCheck(): void;
+    /** Focuses the input. */
+    focus(options?: FocusOptions): void;
+    _focusChanged(isFocused: boolean): void;
+    _onInput(event: InputEvent): void;
+    /** Does some manual dirty checking on the native input `value` property. */
+    protected _dirtyCheckNativeValue(): void;
+    /** Make sure the input is a supported type. */
+    protected _validateType(): void;
+    /** Checks whether the input type is one of the types that are never empty. */
+    protected _isNeverEmpty(): boolean;
+    /** Checks whether the input is invalid based on the native validation. */
+    protected _isBadInput(): boolean;
+    /**
+     * Implemented as part of NovoFieldControl.
+     * @docs-private
+     */
+    get empty(): boolean;
+    /**
+     * Implemented as part of NovoFieldControl.
+     * @docs-private
+     */
+    get shouldLabelFloat(): boolean;
+    /**
+     * Implemented as part of NovoFieldControl.
+     * @docs-private
+     */
+    setDescribedByIds(ids: string[]): void;
+    /**
+     * Implemented as part of NovoFieldControl.
+     * @docs-private
+     */
+    onContainerClick(): void;
+    static ngAcceptInputType_disabled: BooleanInput;
+    static ngAcceptInputType_readonly: BooleanInput;
+    static ngAcceptInputType_required: BooleanInput;
+    static ngAcceptInputType_value: any;
+    onSelect: EventEmitter<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoInput, [null, null, { optional: true; self: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoInput, "input[novoInput], textarea[novoInput], select[novoInput]", never, { "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "onSelect": "onSelect"; }, never, never, false, never>;
+}
+
+declare class NovoFieldsElement implements AfterContentInit {
+    _fields: QueryList<NovoFieldElement>;
+    _layout: 'horizontal' | 'vertical';
+    get layout(): any;
+    set layout(value: any);
+    _appearance: 'standard' | 'outline' | 'fill' | 'list';
+    get appearance(): any;
+    set appearance(value: any);
+    fullWidth: boolean;
+    ngAfterContentInit(): any;
+    private _updateFieldLayout;
+    private _updateFieldAppearance;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoFieldsElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoFieldsElement, "novo-fields", never, { "layout": { "alias": "layout"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; }, {}, ["_fields"], ["*"], false, never>;
+}
+
+declare const NOVO_INPUT_FORMAT: InjectionToken<NovoInputFormat<any>>;
+interface NovoInputFormat<T = any> extends ControlValueAccessor {
+    valueChange: EventEmitter<any>;
+    formatValue(value: T): string;
+}
+declare enum DATE_FORMATS {
+    DATE = "date",
+    ISO8601 = "iso8601",
+    STRING = "string",
+    YEAR_MONTH_DAY = "yyyy-mm-dd"
+}
+
+declare const TIMEFORMAT_VALUE_ACCESSOR: {
+    provide: i0.InjectionToken<readonly _angular_forms.ControlValueAccessor[]>;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+};
+declare enum TIME_FORMATS {
+    DATE = "date",
+    ISO8601 = "iso8601",
+    STRING = "string"
+}
+declare class NovoTimeFormatDirective extends IMaskDirective<any> implements NovoInputFormat, AfterViewInit, OnChanges {
+    private labels;
+    private cdr;
+    valueChange: EventEmitter<any>;
+    military: boolean;
+    timeFormat: TIME_FORMATS;
+    constructor(labels: NovoLabelService, cdr: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    initFormatOptions(): void;
+    _checkInput(event: InputEvent): void;
+    _handleBlur(event: FocusEvent): void;
+    _handleKeydown(event: KeyboardEvent): void;
+    normalize(value: string): string;
+    formatValue(value: any): string;
+    formatAsIso(date: Date): string;
+    convertTime12to24(time12h: string): string;
+    convertTime24to12(time24h: string): string;
+    writeValue(value: any): void;
+    registerOnChange(fn: (date: any) => void): void;
+    hourOneFormatRequired(hourInput: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoTimeFormatDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoTimeFormatDirective, "input[timeFormat]", never, { "military": { "alias": "military"; "required": false; }; "timeFormat": { "alias": "timeFormat"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare const DATEFORMAT_VALUE_ACCESSOR: {
+    provide: i0.InjectionToken<readonly _angular_forms.ControlValueAccessor[]>;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+};
+declare class NovoDateFormatDirective extends IMaskDirective<any> {
+    private labels;
+    private dateFormatService;
+    valueChange: EventEmitter<any>;
+    dateFormat: DATE_FORMATS;
+    constructor(labels: NovoLabelService, dateFormatService: DateFormatService);
+    normalize(value: string): string;
+    formatAsIso(date: Date): string;
+    formatYearMonthDay(date: Date): string;
+    formatValue(value: any, options?: DateParseOptions): string;
+    writeValue(value: any): void;
+    registerOnChange(fn: (_: any) => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoDateFormatDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoDateFormatDirective, "input[dateFormat]", never, { "dateFormat": { "alias": "dateFormat"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare const DATETIMEFORMAT_VALUE_ACCESSOR: {
+    provide: i0.InjectionToken<readonly _angular_forms.ControlValueAccessor[]>;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+};
+declare class NovoDateTimeFormatDirective extends IMaskDirective<any> implements NovoInputFormat, OnChanges {
+    private labels;
+    private dateFormat;
+    valueChange: EventEmitter<any>;
+    military: boolean;
+    dateTimeFormat: DATE_FORMATS;
+    constructor(labels: NovoLabelService, dateFormat: DateFormatService);
+    initFormatOptions(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    _checkInput(event: InputEvent): void;
+    _handleBlur(event: FocusEvent): void;
+    _handleKeydown(event: KeyboardEvent): void;
+    normalize(value: string, options?: DateParseOptions): string;
+    formatAsIso(date: Date): string;
+    convertTime12to24(time12h: string): string;
+    convertTime24to12(time24h: string): string;
+    formatValue(value: Date | string, options?: DateParseOptions): string;
+    writeValue(value: any): void;
+    registerOnChange(fn: (_: any) => void): void;
+    hourOneFormatRequired(hourInput: string): boolean;
+    get initialValue(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoDateTimeFormatDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoDateTimeFormatDirective, "input[dateTimeFormat]", never, { "military": { "alias": "military"; "required": false; }; "dateTimeFormat": { "alias": "dateTimeFormat"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare const DATERANGEFORMAT_VALUE_ACCESSOR: {
+    provide: i0.InjectionToken<readonly _angular_forms.ControlValueAccessor[]>;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+};
+type DateRange = {
+    startDate: Date;
+    endDate: Date;
+};
+declare class NovoDateRangeFormatDirective extends IMaskDirective<any> {
+    private labels;
+    private dateFormat;
+    valueChange: EventEmitter<any>;
+    dateRangeFormat: DATE_FORMATS;
+    constructor(labels: NovoLabelService, dateFormat: DateFormatService);
+    normalize(value: string | Date, options?: DateParseOptions): string;
+    formatAsIso(value: DateRange): string;
+    formatValue(value: DateRange): string;
+    formatDate(source: Date | string): string;
+    writeValue(value: any): void;
+    registerOnChange(fn: (_: any) => void): void;
+    extractDatesFromInput(value: any): {
+        startDate: Date;
+        endDate: Date;
+    };
+    validate(dateStr: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoDateRangeFormatDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoDateRangeFormatDirective, "input[dateRangeFormat]", never, { "dateRangeFormat": { "alias": "dateRangeFormat"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NovoPickerToggleElement<T = any> implements AfterContentInit, AfterViewInit, OnChanges, OnDestroy {
+    private _elementRef;
+    private cdr;
+    private _formField;
+    private _stateChanges;
+    private _onDestroy;
+    /** Datepicker instance that the button will toggle. */
+    picker: T;
+    icon: string;
+    /** Tabindex for the toggle. */
+    tabIndex: number | null;
+    /** Screenreader label for the button. */
+    ariaLabel: string;
+    /** Determines whether the overlay is triggered on input focus or solely button click. */
+    triggerOnFocus: boolean;
+    /** An id to select the correct overlay.*/
+    overlayId: string;
+    /** Width to pass to overlay.*/
+    width: string;
+    /** Whether the toggle button is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /** Underlying button element. */
+    _button: NovoButtonElement;
+    /** Element for the panel containing the autocomplete options. */
+    overlay: NovoOverlayTemplateComponent;
+    element: ElementRef;
+    constructor(_elementRef: ElementRef, cdr: ChangeDetectorRef, defaultTabIndex: string, _formField: NovoFieldElement);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    checkPanel(): void;
+    togglePanel(event?: Event): void;
+    /** BEGIN: Convenient Panel Methods. */
+    openPanel(event?: Event): void;
+    closePanel(event?: Event): void;
+    get panelOpen(): boolean;
+    private _watchStateChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoPickerToggleElement<any>, [null, null, { attribute: "tabindex"; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoPickerToggleElement<any>, "novo-picker-toggle", ["novoPickerToggle"], { "picker": { "alias": "for"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "triggerOnFocus": { "alias": "triggerOnFocus"; "required": false; }; "overlayId": { "alias": "overlayId"; "required": false; }; "width": { "alias": "width"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+/** Directive used to connect an input to a MatDatepicker. */
+declare class NovoPickerDirective {
+    private _elementRef;
+    private formatter;
+    /** The datepicker that this input is associated with. */
+    set picker(picker: ControlValueAccessor);
+    _picker: ControlValueAccessor;
+    /**
+     * `autocomplete` attribute to be set on the input element.
+     * @docs-private
+     */
+    autocompleteAttribute: string;
+    constructor(_elementRef: ElementRef<HTMLInputElement>, formatter: NovoInputFormat<any>);
+    updateValue(value: any): void;
+    updatePicker(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoPickerDirective, [null, { optional: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NovoPickerDirective, "input[picker]", never, { "picker": { "alias": "picker"; "required": false; }; "autocompleteAttribute": { "alias": "autocomplete"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NovoFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoFieldModule, [typeof NovoFieldElement, typeof NovoHintElement, typeof NovoErrorElement, typeof NovoInput, typeof NovoFieldPrefixDirective, typeof NovoFieldSuffixDirective, typeof NovoFieldsElement, typeof NovoTimeFormatDirective, typeof NovoDateFormatDirective, typeof NovoDateTimeFormatDirective, typeof NovoDateRangeFormatDirective, typeof NovoPickerToggleElement, typeof NovoPickerDirective], [typeof i12.CommonModule, typeof i13.NovoButtonModule, typeof i14.NovoOverlayModule, typeof i14.NovoOptionModule, typeof i14.NovoCommonModule], [typeof NovoFieldElement, typeof NovoHintElement, typeof NovoErrorElement, typeof NovoInput, typeof NovoFieldPrefixDirective, typeof NovoFieldSuffixDirective, typeof NovoFieldsElement, typeof NovoTimeFormatDirective, typeof NovoDateFormatDirective, typeof NovoDateRangeFormatDirective, typeof NovoDateTimeFormatDirective, typeof NovoPickerToggleElement, typeof NovoPickerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoFieldModule>;
+}
+
+export { DATEFORMAT_VALUE_ACCESSOR, DATERANGEFORMAT_VALUE_ACCESSOR, DATETIMEFORMAT_VALUE_ACCESSOR, DATE_FORMATS, NOVO_FORM_FIELD, NOVO_INPUT_FORMAT, NOVO_INPUT_VALUE_ACCESSOR, NovoDateFormatDirective, NovoDateRangeFormatDirective, NovoDateTimeFormatDirective, NovoErrorElement, NovoFieldControl, NovoFieldElement, NovoFieldModule, NovoFieldPrefixDirective, NovoFieldSuffixDirective, NovoFieldsElement, NovoHintElement, NovoInput, NovoPickerDirective, NovoPickerToggleElement, NovoTimeFormatDirective, TIMEFORMAT_VALUE_ACCESSOR, TIME_FORMATS };
+export type { NovoInputFormat };

package/elements/flex/index.d.ts

@@ -1,4 +1,53 @@
-export * from './Box';
-export * from './Flex';
-export * from './Flex.module';
-export * from './Grid';
+import * as i0 from '@angular/core';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i4 from '@angular/common';
+
+declare class NovoBoxElement {
+    get display(): string;
+    direction: string;
+    align: string;
+    justify: string;
+    wrap: string;
+    gap: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoBoxElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoBoxElement, "novo-box", never, { "direction": { "alias": "direction"; "required": false; }; "align": { "alias": "align"; "required": false; }; "justify": { "alias": "justify"; "required": false; }; "wrap": { "alias": "wrap"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class NovoFlexElement {
+    get display(): string;
+    direction: string;
+    align: string;
+    justify: string;
+    wrap: string;
+    gap: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoFlexElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoFlexElement, "novo-flex,novo-row", never, { "direction": { "alias": "direction"; "required": false; }; "align": { "alias": "align"; "required": false; }; "justify": { "alias": "justify"; "required": false; }; "wrap": { "alias": "wrap"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+declare class NovoStackElement extends NovoFlexElement {
+    direction: string;
+    align: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoStackElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoStackElement, "novo-stack,novo-column", never, { "direction": { "alias": "direction"; "required": false; }; "align": { "alias": "align"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class NovoGridElement {
+    private _sanitizer;
+    get display(): string;
+    direction: string;
+    align: string;
+    justify: string;
+    columns: string;
+    get hb_gridCols(): _angular_platform_browser.SafeStyle;
+    constructor(_sanitizer: DomSanitizer);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoGridElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoGridElement, "novo-grid", never, { "direction": { "alias": "direction"; "required": false; }; "align": { "alias": "align"; "required": false; }; "justify": { "alias": "justify"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class NovoFlexModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoFlexModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoFlexModule, [typeof NovoFlexElement, typeof NovoStackElement, typeof NovoGridElement, typeof NovoBoxElement], [typeof i4.CommonModule], [typeof NovoFlexElement, typeof NovoStackElement, typeof NovoGridElement, typeof NovoBoxElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoFlexModule>;
+}
+
+export { NovoBoxElement, NovoFlexElement, NovoFlexModule, NovoGridElement, NovoStackElement };