@dereekb/dbx-form 0.0.1

package/lib/formly/field/selection/pickable/pickable.list.field.component.d.ts

@@ -0,0 +1,11 @@
+import { MatSelectionListChange } from "@angular/material/list";
+import { AbstractDbxPickableItemFieldDirective } from "./pickable.field.directive";
+import * as i0 from "@angular/core";
+/**
+ * Used for picking pre-set values using a selection list as the presentation.
+ */
+export declare class DbxPickableListFieldComponent<T> extends AbstractDbxPickableItemFieldDirective<T> {
+    matSelectionChanged(selection: MatSelectionListChange): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxPickableListFieldComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxPickableListFieldComponent<any>, "ng-component", never, {}, {}, never, never>;
+}

package/lib/formly/field/selection/searchable/index.d.ts

@@ -0,0 +1,8 @@
+export * from './searchable.chip.field.component';
+export * from './searchable.field.autocomplete.item.component';
+export * from './searchable.field.directive';
+export * from './searchable.field';
+export * from './searchable.field.module';
+export * from './searchable.text.field.component';
+export * from './searchable';
+export * from './text.chip.field';

package/lib/formly/field/selection/searchable/searchable.chip.field.component.d.ts

@@ -0,0 +1,16 @@
+import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
+import { MatChipInputEvent } from '@angular/material/chips';
+import { AbstractDbxSearchableValueFieldDirective, SearchableValueFieldsFieldConfig, SearchableValueFieldsFormlyFieldConfig } from './searchable.field.directive';
+import * as i0 from "@angular/core";
+export interface SearchableChipValueFieldsFieldConfig<T> extends SearchableValueFieldsFieldConfig<T> {
+}
+export interface SearchableChipValueFieldsFormlyFieldConfig<T> extends SearchableChipValueFieldsFieldConfig<T>, SearchableValueFieldsFormlyFieldConfig<T> {
+}
+export declare class DbxSearchableChipFieldComponent<T> extends AbstractDbxSearchableValueFieldDirective<T, SearchableChipValueFieldsFormlyFieldConfig<T>> {
+    readonly separatorKeysCodes: number[];
+    selected(event: MatAutocompleteSelectedEvent): void;
+    tabPressedOnInput(event: KeyboardEvent): boolean;
+    addChip(event: MatChipInputEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxSearchableChipFieldComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxSearchableChipFieldComponent<any>, "ng-component", never, {}, {}, never, never>;
+}

package/lib/formly/field/selection/searchable/searchable.d.ts

@@ -0,0 +1,40 @@
+import { ClickableAnchor } from '@dereekb/dbx-core';
+import { Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { SelectionDisplayValue, SelectionValue, SelectionValueHashFn } from '../selection';
+export interface SearchableFieldDisplayComponent<T> {
+    displayValue?: SearchableValueFieldDisplayValue<T>;
+}
+export interface SearchableValueFieldValue<T, M = any> extends SelectionValue<T, M> {
+    /**
+     * Optional anchor metadata on the field.
+     */
+    anchor?: ClickableAnchor;
+}
+/**
+ * Displayed value.
+ */
+export interface SearchableValueFieldDisplayValue<T, M = any> extends SelectionDisplayValue<T, M>, SearchableValueFieldValue<T, M> {
+    sublabel?: string;
+    /**
+     * Custom component class to use.
+     */
+    componentClass?: Type<SearchableFieldDisplayComponent<T>>;
+}
+/**
+ * SearchableValueField function for searching values.
+ */
+export declare type SearchableValueFieldStringSearchFn<T> = (search: string) => Observable<SearchableValueFieldValue<T>[]>;
+/**
+ * SearchableValueField function that allows the values a chance to go through another observable for any changes.
+ *
+ * An example usage is passing an email address, then getting back metadata that can be used to show the values.
+ *
+ * The value itself should not change. All other fields on the value may change, however.
+ */
+export declare type SearchableValueFieldDisplayFn<T> = (values: SearchableValueFieldValue<T>[]) => Observable<SearchableValueFieldDisplayValue<T>[]>;
+/**
+ * SearchableValueField function for setting anchor values on a field value.
+ */
+export declare type SearchableValueFieldAnchorFn<T> = (value: SearchableValueFieldValue<T>) => ClickableAnchor;
+export declare type SearchableValueFieldHashFn<T> = SelectionValueHashFn<T>;

package/lib/formly/field/selection/searchable/searchable.field.autocomplete.item.component.d.ts

@@ -0,0 +1,20 @@
+import { OnInit, ViewContainerRef } from '@angular/core';
+import { SearchableFieldDisplayComponent, SearchableValueFieldDisplayValue } from './searchable';
+import * as i0 from "@angular/core";
+export declare class DbxSearchableFieldAutocompleteItemComponent<T> implements OnInit {
+    content: ViewContainerRef;
+    displayValue?: SearchableValueFieldDisplayValue<T>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxSearchableFieldAutocompleteItemComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxSearchableFieldAutocompleteItemComponent<any>, "dbx-searchable-field-autocomplete-item", never, { "displayValue": "displayValue"; }, {}, never, never>;
+}
+export declare class DbxDefaultSearchableFieldDisplayComponent<T> implements SearchableFieldDisplayComponent<T> {
+    displayValue: SearchableValueFieldDisplayValue<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxDefaultSearchableFieldDisplayComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxDefaultSearchableFieldDisplayComponent<any>, "dbx-default-searchable-field-display", never, { "displayValue": "displayValue"; }, {}, never, never>;
+}
+export declare class DbxDefaultSearchableAnchorFieldDisplayComponent<T> implements SearchableFieldDisplayComponent<T> {
+    displayValue: SearchableValueFieldDisplayValue<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxDefaultSearchableAnchorFieldDisplayComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxDefaultSearchableAnchorFieldDisplayComponent<any>, "ng-component", never, { "displayValue": "displayValue"; }, {}, never, never>;
+}

package/lib/formly/field/selection/searchable/searchable.field.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import { FieldConfig } from '../../field';
+import { SearchableValueFieldDisplayFn, SearchableValueFieldDisplayValue, SearchableValueFieldValue } from './searchable';
+import { SearchableChipValueFieldsFieldConfig, SearchableChipValueFieldsFormlyFieldConfig } from './searchable.chip.field.component';
+import { SearchableTextValueFieldsFieldConfig, SearchableTextValueFieldsFormlyFieldConfig } from './searchable.text.field.component';
+export declare function makeMetaFilterSearchableFieldValueDisplayFn<T = string | number>(loadMetaForValues: (values: SearchableValueFieldValue<T>[]) => Observable<SearchableValueFieldValue<T>[]>, makeDisplayForValues: (values: SearchableValueFieldValue<T>[]) => SearchableValueFieldDisplayValue<T>[]): SearchableValueFieldDisplayFn<T>;
+export interface SearchableChipFieldConfig<T = any> extends FieldConfig, SearchableChipValueFieldsFieldConfig<T> {
+}
+export interface SearchableChipFieldFormlyConfig<T = any> extends Omit<SearchableChipValueFieldsFormlyFieldConfig<T>, 'type'> {
+}
+export declare function searchableChipField<C extends SearchableChipFieldFormlyConfig<any>>(config: C): C;
+export interface SearchableTextFieldConfig<T = any> extends FieldConfig, SearchableTextValueFieldsFieldConfig<T> {
+}
+export interface SearchableTextFieldFormlyConfig<T = any> extends Omit<SearchableTextValueFieldsFormlyFieldConfig<T>, 'type'> {
+}
+export declare function searchableTextField<C extends SearchableTextFieldFormlyConfig<any>>(config: C): C;

package/lib/formly/field/selection/searchable/searchable.field.directive.d.ts

@@ -0,0 +1,131 @@
+import { SubscriptionObject, LoadingState, LoadingStateContextInstance } from '@dereekb/rxjs';
+import { ElementRef, OnDestroy, OnInit, Type } from '@angular/core';
+import { AbstractControl, FormControl, ValidatorFn } from '@angular/forms';
+import { FieldType, FormlyFieldConfig } from '@ngx-formly/core';
+import { Observable } from 'rxjs';
+import { SearchableValueFieldHashFn, SearchableValueFieldStringSearchFn, SearchableValueFieldDisplayFn, SearchableValueFieldDisplayValue, SearchableValueFieldValue, SearchableFieldDisplayComponent, SearchableValueFieldAnchorFn } from './searchable';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export interface StringValueFieldsFieldConfig {
+    /**
+     * Custom input validators.
+     */
+    textInputValidator?: ValidatorFn | ValidatorFn[];
+    /**
+     * Optional description/hint to display.
+     */
+    description?: string;
+}
+export interface StringValueFieldsFormlyFieldConfig extends StringValueFieldsFieldConfig, FormlyFieldConfig {
+}
+export interface SearchableValueFieldsFieldConfig<T> extends StringValueFieldsFieldConfig {
+    /**
+     * Whether or not to allow string values to be used directly, or if values can only be chosen from searching.
+     */
+    allowStringValues?: boolean;
+    /**
+     * Optional conversion function. If provided, allowStringValues is considered true.
+     */
+    convertStringValue?: (text: string) => T;
+    /**
+     * Used for hashing display values and omitting repeat values.
+     *
+     * If hashForValue is not provided, the value's value will be used as is.
+     */
+    hashForValue?: SearchableValueFieldHashFn<T>;
+    /**
+     * Performs a search.
+     */
+    search: SearchableValueFieldStringSearchFn<T>;
+    /**
+     * Whether or not to allow searches on empty text. Is false by default.
+     */
+    searchOnEmptyText?: boolean;
+    /**
+     * Custom component class to use by default.
+     */
+    componentClass?: Type<SearchableFieldDisplayComponent<T>>;
+    /**
+     * Used for building a display value given the input.
+     */
+    displayForValue: SearchableValueFieldDisplayFn<T>;
+    /**
+     * Whether or not to use the anchor field on value elements.
+     *
+     * This has no default effect if a component class is provided.
+     */
+    useAnchor?: boolean;
+    /**
+     * Used for retrieving an anchor value for values that have no anchor value set.
+     *
+     * Only used when useAnchor is true.
+     */
+    anchorForValue?: SearchableValueFieldAnchorFn<T>;
+}
+export interface SearchableValueFieldsFormlyFieldConfig<T> extends SearchableValueFieldsFieldConfig<T>, FormlyFieldConfig {
+}
+/**
+ * Abstract searchable field that provides a feature for searching for values, and for displaying values using Observables.
+ *
+ * Display values are cached for performance.
+ */
+export declare abstract class AbstractDbxSearchableValueFieldDirective<T, C extends SearchableValueFieldsFormlyFieldConfig<T>> extends FieldType<C> implements OnInit, OnDestroy {
+    /**
+     * Whether or not to set/get values as an array.
+     */
+    multiSelect: boolean;
+    defaultComponentClass?: Type<SearchableFieldDisplayComponent<T>>;
+    textInput: ElementRef<HTMLInputElement>;
+    readonly inputCtrl: FormControl;
+    private _formControlObs;
+    readonly formControl$: Observable<AbstractControl>;
+    private _displayHashMap;
+    readonly inputValue$: Observable<string>;
+    readonly inputValueString$: Observable<string>;
+    readonly searchResultsState$: Observable<LoadingState<any> | LoadingState<SearchableValueFieldDisplayValue<T, any>[]>>;
+    readonly singleValueSyncSubscription: SubscriptionObject;
+    readonly searchContext: LoadingStateContextInstance<any, LoadingState<any> | LoadingState<SearchableValueFieldDisplayValue<T, any>[]>>;
+    readonly searchResults$: Observable<SearchableValueFieldDisplayValue<T>[]>;
+    readonly _formControlValue: Observable<T | T[]>;
+    readonly values$: Observable<T[]>;
+    readonly displayValuesState$: Observable<LoadingState<SearchableValueFieldDisplayValue<T>[]>>;
+    readonly displayValues$: Observable<SearchableValueFieldDisplayValue<T>[]>;
+    get name(): string;
+    get label(): Maybe<string>;
+    get readonly(): Maybe<boolean>;
+    get searchOnEmptyText(): boolean;
+    get required(): Maybe<boolean>;
+    get autocomplete(): string;
+    get placeholder(): string;
+    get description(): Maybe<string>;
+    get hashForValue(): SearchableValueFieldHashFn<T>;
+    get displayForValue(): SearchableValueFieldDisplayFn<T>;
+    get useAnchor(): Maybe<boolean>;
+    get anchorForValue(): Maybe<SearchableValueFieldAnchorFn<T>>;
+    get componentClass(): Maybe<Type<SearchableFieldDisplayComponent<T>>>;
+    get search(): SearchableValueFieldStringSearchFn<T>;
+    get values(): T[];
+    get allowStringValues(): boolean;
+    get convertStringValue(): Maybe<(text: string) => T>;
+    loadDisplayValuesForValues(values: T[]): Observable<LoadingState<SearchableValueFieldDisplayValue<T>[]>>;
+    loadDisplayValuesForFieldValues(values: SearchableValueFieldValue<T>[]): Observable<LoadingState<SearchableValueFieldDisplayValue<T>[]>>;
+    getDisplayValuesForFieldValues(values: SearchableValueFieldValue<T>[]): Observable<SearchableValueFieldDisplayValue<T>[]>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Used to sync the input control with the selected value.
+     *
+     * Only used when multiSelect is false.
+     */
+    protected _syncSingleValue(value: SearchableValueFieldDisplayValue<T>): void;
+    protected _addWithTextValue(text: string): void;
+    addWithDisplayValue(displayValue: SearchableValueFieldDisplayValue<T>): void;
+    removeWithDisplayValue(displayValue: SearchableValueFieldDisplayValue<T>): void;
+    addValue(value: T): void;
+    removeValue(value: T): void;
+    setValues(values: T[]): void;
+    protected _getValueOnFormControl(valueOnFormControl: any): T[];
+    protected _setValueOnFormControl(values: T[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxSearchableValueFieldDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxSearchableValueFieldDirective<any, any>, never, never, {}, {}, never>;
+}

package/lib/formly/field/selection/searchable/searchable.field.module.d.ts

@@ -0,0 +1,21 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./searchable.chip.field.component";
+import * as i2 from "./searchable.text.field.component";
+import * as i3 from "./searchable.field.autocomplete.item.component";
+import * as i4 from "@angular/common";
+import * as i5 from "@dereekb/dbx-web";
+import * as i6 from "@angular/forms";
+import * as i7 from "@angular/material/button";
+import * as i8 from "@angular/material/input";
+import * as i9 from "@angular/material/form-field";
+import * as i10 from "@angular/material/autocomplete";
+import * as i11 from "@angular/material/list";
+import * as i12 from "@dereekb/dbx-core";
+import * as i13 from "@angular/material/chips";
+import * as i14 from "@angular/material/icon";
+import * as i15 from "@ngx-formly/core";
+export declare class DbxFormFormlySearchableFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlySearchableFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlySearchableFieldModule, [typeof i1.DbxSearchableChipFieldComponent, typeof i2.DbxSearchableTextFieldComponent, typeof i3.DbxSearchableFieldAutocompleteItemComponent, typeof i3.DbxDefaultSearchableFieldDisplayComponent, typeof i3.DbxDefaultSearchableAnchorFieldDisplayComponent], [typeof i4.CommonModule, typeof i5.DbxTextModule, typeof i5.DbxLoadingModule, typeof i5.DbxButtonModule, typeof i6.FormsModule, typeof i7.MatButtonModule, typeof i8.MatInputModule, typeof i9.MatFormFieldModule, typeof i6.ReactiveFormsModule, typeof i10.MatAutocompleteModule, typeof i11.MatListModule, typeof i12.DbxDatePipeModule, typeof i5.DbxAnchorModule, typeof i13.MatChipsModule, typeof i14.MatIconModule, typeof i12.DbxInjectedComponentModule, typeof i15.FormlyModule], [typeof i1.DbxSearchableChipFieldComponent, typeof i2.DbxSearchableTextFieldComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlySearchableFieldModule>;
+}

package/lib/formly/field/selection/searchable/searchable.text.field.component.d.ts

@@ -0,0 +1,15 @@
+import { AbstractDbxSearchableValueFieldDirective, SearchableValueFieldsFieldConfig, SearchableValueFieldsFormlyFieldConfig } from './searchable.field.directive';
+import * as i0 from "@angular/core";
+export interface SearchableTextValueFieldsFieldConfig<T> extends SearchableValueFieldsFieldConfig<T> {
+}
+export interface SearchableTextValueFieldsFormlyFieldConfig<T> extends SearchableTextValueFieldsFieldConfig<T>, SearchableValueFieldsFormlyFieldConfig<T> {
+}
+/**
+ * Display component for selecting a single item/value.
+ */
+export declare class DbxSearchableTextFieldComponent<T> extends AbstractDbxSearchableValueFieldDirective<T, SearchableTextValueFieldsFormlyFieldConfig<T>> {
+    readonly multiSelect = false;
+    selected(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxSearchableTextFieldComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxSearchableTextFieldComponent<any>, "ng-component", never, {}, {}, never, never>;
+}

package/lib/formly/field/selection/searchable/text.chip.field.d.ts

@@ -0,0 +1,9 @@
+import { FormlyFieldConfig } from "@ngx-formly/core";
+import { FieldConfig } from "../../field";
+import { StringValueFieldsFieldConfig, StringValueFieldsFormlyFieldConfig } from "./searchable.field.directive";
+export interface ChipTextFieldConfig extends FieldConfig, StringValueFieldsFieldConfig {
+}
+export interface ChipTextFieldFormlyConfig extends StringValueFieldsFormlyFieldConfig, FormlyFieldConfig {
+    caseSensitive?: boolean;
+}
+export declare function chipTextField<C extends ChipTextFieldFormlyConfig>(config: C): C;

package/lib/formly/field/selection/selection.d.ts

@@ -0,0 +1,25 @@
+import { Maybe } from "@dereekb/util";
+export interface SelectionValue<T, M = any> {
+    /**
+   * Value associated with this field.
+   */
+    value: T;
+    /**
+     * Optional metadata on the field.
+     */
+    meta?: Maybe<M>;
+}
+/**
+ * Displayed value.
+ */
+export interface SelectionDisplayValue<T, M = any> extends SelectionValue<T, M> {
+    label: string;
+    /**
+     * Whether or not the value is known.
+     */
+    isUnknown?: Maybe<boolean>;
+}
+/**
+ * Used to hash the value from the input pickable value.
+ */
+export declare type SelectionValueHashFn<T> = (value: T) => any;

package/lib/formly/field/value/array/array.field.component.d.ts

@@ -0,0 +1,22 @@
+import { Maybe } from '@dereekb/util';
+import { FieldArrayType, FormlyTemplateOptions } from '@ngx-formly/core';
+import * as i0 from "@angular/core";
+export interface FormRepeatSectionConfig {
+    itemLabel?: string;
+    addText?: string;
+    removeText?: string;
+}
+export interface FormRepeatTypeTemplateOptions extends FormlyTemplateOptions, FormRepeatSectionConfig {
+    repeatSection?: FormRepeatSectionConfig;
+}
+export declare class DbxFormRepeatTypeComponent extends FieldArrayType {
+    get repeatSection(): FormRepeatSectionConfig;
+    get itemLabel(): string;
+    get addText(): string;
+    get removeText(): string;
+    get max(): Maybe<number>;
+    get count(): number;
+    get canAdd(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormRepeatTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormRepeatTypeComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/formly/field/value/array/array.field.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./array.field.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/form-field";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/material/divider";
+import * as i6 from "@dereekb/dbx-web";
+import * as i7 from "@ngx-formly/core";
+export declare class DbxFormFormlyArrayFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyArrayFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyArrayFieldModule, [typeof i1.DbxFormRepeatTypeComponent], [typeof i2.CommonModule, typeof i3.MatFormFieldModule, typeof i4.ReactiveFormsModule, typeof i5.MatDividerModule, typeof i6.DbxButtonModule, typeof i7.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyArrayFieldModule>;
+}

package/lib/formly/field/value/array/index.d.ts

@@ -0,0 +1,2 @@
+export * from './array.field.component';
+export * from './array.field.module';

package/lib/formly/field/value/boolean/boolean.field.d.ts

@@ -0,0 +1,8 @@
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { FieldConfig, DefaultValueFieldConfig, DescriptionFieldConfig } from '../../field';
+export interface ToggleFieldConfig extends Omit<FieldConfig, 'placeholder' | 'autocomplete'>, DefaultValueFieldConfig<boolean>, DescriptionFieldConfig {
+}
+export declare function toggleField({ key, label, description, defaultValue, required, readonly }: ToggleFieldConfig): FormlyFieldConfig;
+export interface CheckboxFieldConfig extends FieldConfig, DefaultValueFieldConfig<boolean>, DescriptionFieldConfig {
+}
+export declare function checkboxField({ key, label, placeholder, defaultValue, required, readonly, autocomplete }: CheckboxFieldConfig): FormlyFieldConfig;

package/lib/formly/field/value/boolean/boolean.field.module.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class DbxFormFormlyBooleanFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyBooleanFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyBooleanFieldModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyBooleanFieldModule>;
+}

package/lib/formly/field/value/boolean/index.d.ts

@@ -0,0 +1,2 @@
+export * from './boolean.field.module';
+export * from './boolean.field';

package/lib/formly/field/value/date/date.field.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+import { FieldConfig } from '../../field';
+import { DbxDateTimeFieldConfig, DateTimeFormlyFieldConfig, DateTimePickerConfiguration } from './datetime.field.component';
+export interface DateTimeFieldConfig extends FieldConfig, DbxDateTimeFieldConfig {
+}
+export interface TimeFieldConfig extends Omit<DateTimeFieldConfig, 'showDate'> {
+}
+export declare const TAKE_NEXT_UPCOMING_TIME_CONFIG_OBS: () => Observable<DateTimePickerConfiguration>;
+/**
+ * Same as DateTime field but with the Date input hidden by default.
+ */
+export declare function timeOnlyField(config: Partial<TimeFieldConfig>): DateTimeFormlyFieldConfig;
+export declare function dateTimeField({ key, label, placeholder, description, timeMode, fullDayFieldName, getConfigObs, timeOnly, required }: Partial<DateTimeFieldConfig>): DateTimeFormlyFieldConfig;

package/lib/formly/field/value/date/date.field.module.d.ts

@@ -0,0 +1,21 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./datetime.field.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/material/input";
+import * as i5 from "@angular/material/divider";
+import * as i6 from "@angular/material/form-field";
+import * as i7 from "@angular/material/button";
+import * as i8 from "@angular/material/datepicker";
+import * as i9 from "@angular/material/core";
+import * as i10 from "@angular/material/menu";
+import * as i11 from "@dereekb/dbx-core";
+import * as i12 from "@angular/material/chips";
+import * as i13 from "@angular/material/icon";
+import * as i14 from "@angular/flex-layout";
+import * as i15 from "@ngx-formly/core";
+export declare class DbxFormFormlyDateFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyDateFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyDateFieldModule, [typeof i1.DbxDateTimeFieldComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.MatInputModule, typeof i5.MatDividerModule, typeof i6.MatFormFieldModule, typeof i7.MatButtonModule, typeof i8.MatDatepickerModule, typeof i9.MatNativeDateModule, typeof i10.MatMenuModule, typeof i3.ReactiveFormsModule, typeof i11.DbxDatePipeModule, typeof i12.MatChipsModule, typeof i13.MatIconModule, typeof i14.FlexLayoutModule, typeof i15.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyDateFieldModule>;
+}

package/lib/formly/field/value/date/datetime.field.component.d.ts

@@ -0,0 +1,105 @@
+import { DateTimeMinuteConfig } from '@dereekb/date';
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { AbstractControl, FormControl } from '@angular/forms';
+import { FieldType, FormlyFieldConfig } from '@ngx-formly/core';
+import { Observable } from 'rxjs';
+import { Maybe, ReadableTimeString } from '@dereekb/util';
+import { MatDatepickerInputEvent } from '@angular/material/datepicker';
+import * as i0 from "@angular/core";
+export declare enum DateTimeFieldTimeMode {
+    /**
+     * Time is required.
+     */
+    REQUIRED = "required",
+    /**
+     * Time is optional.
+     */
+    OPTIONAL = "optional",
+    /**
+     * Time is permenantly off.
+     */
+    NONE = "none"
+}
+export interface DateTimePickerConfiguration extends Omit<DateTimeMinuteConfig, 'date'> {
+}
+export interface DbxDateTimeFieldConfig {
+    /**
+     * Whether or not the date is hidden, and automatically uses today/input date.
+     */
+    timeOnly?: boolean;
+    /**
+     * Whether or not the time can be added/removed optionally.
+     *
+     * This is ignored if timeOnly is specified.
+     */
+    timeMode?: DateTimeFieldTimeMode;
+    /**
+     * Other form contro for enabling/disabling whether or not it is a full day.
+     *
+     * This field is only used if time is optional.
+     *
+     * When time is off, the field is set to true.
+     */
+    fullDayFieldName?: string;
+    /**
+     * Whether or not to pass the date value as a UTC date, or a date in the current timezone.
+     */
+    fullDayInUTC?: boolean;
+    /**
+     * Used for returning the configuration observable.
+     */
+    getConfigObs?: () => Observable<DateTimePickerConfiguration>;
+    /**
+     * Optional description/hint to display.
+     */
+    description?: string;
+}
+export interface DateTimeFormlyFieldConfig extends DbxDateTimeFieldConfig, FormlyFieldConfig {
+}
+export declare class DbxDateTimeFieldComponent extends FieldType<DateTimeFormlyFieldConfig> implements OnInit, OnDestroy {
+    private readonly cdRef;
+    private _sub;
+    private _valueSub;
+    private _fullDayInputCtrl?;
+    private _fullDayControlObs;
+    readonly fullDayControl$: Observable<AbstractControl>;
+    private _offset;
+    private _formControlObs;
+    readonly formControl$: Observable<AbstractControl>;
+    private _updateTime;
+    readonly value$: Observable<any>;
+    /**
+     * Used to trigger/display visual updates (specifically on timeDistance, etc.).
+     */
+    readonly displayValue$: Observable<any>;
+    readonly timeString$: Observable<ReadableTimeString>;
+    readonly timeInputCtrl: FormControl;
+    private _date;
+    private _config;
+    get timeOnly(): Maybe<boolean>;
+    get showDateInput(): boolean;
+    get timeMode(): DateTimeFieldTimeMode;
+    get description(): Maybe<string>;
+    readonly fullDay$: Observable<boolean>;
+    readonly showTimeInput$: Observable<boolean>;
+    readonly showAddTime$: Observable<boolean>;
+    readonly date$: Observable<Date>;
+    readonly dateValue$: Observable<Date>;
+    readonly timeInput$: Observable<ReadableTimeString>;
+    readonly config$: Observable<DateTimePickerConfiguration>;
+    readonly rawDateTime$: Observable<Date>;
+    readonly timeOutput$: Observable<Date>;
+    constructor(cdRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    datePicked(event: MatDatepickerInputEvent<Date>): void;
+    setTime(time: ReadableTimeString): void;
+    keydownOnInput(event: KeyboardEvent): void;
+    focusTime(): void;
+    focusOutTime(): void;
+    addTime(): void;
+    removeTime(): void;
+    setFullDay(fullDay: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxDateTimeFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxDateTimeFieldComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/formly/field/value/date/index.d.ts

@@ -0,0 +1,3 @@
+export * from './date.field.module';
+export * from './date.field';
+export * from './datetime.field.component';

package/lib/formly/field/value/enum/enum.d.ts

@@ -0,0 +1,4 @@
+export interface EnumValueFieldOption<T> {
+    value: T;
+    label: string;
+}

package/lib/formly/field/value/enum/enum.field.d.ts

@@ -0,0 +1,14 @@
+import { DescriptionFieldConfig, FieldConfig } from '../../field';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { EnumValueFieldOption } from './enum';
+export interface StaticEnumFieldConfig<T> extends FieldConfig, DescriptionFieldConfig {
+    /**
+     * Whether or not multiple values can be selected.
+     */
+    multiple?: boolean;
+    /**
+     * Options
+     */
+    options: EnumValueFieldOption<T>[];
+}
+export declare function staticEnumField<T = any>({ key, label, placeholder, description, multiple, required, options }: StaticEnumFieldConfig<T>): FormlyFieldConfig;

package/lib/formly/field/value/enum/index.d.ts

@@ -0,0 +1,2 @@
+export * from './enum';
+export * from './enum.field';

package/lib/formly/field/value/hidden.field.d.ts

@@ -0,0 +1,5 @@
+import { FormlyFieldConfig } from '@ngx-formly/core/lib/core';
+import { FieldConfig } from '../field';
+export interface HiddenFieldConfig extends Pick<FieldConfig, 'key' | 'required'> {
+}
+export declare function hiddenField({ key, required }: HiddenFieldConfig): FormlyFieldConfig;

package/lib/formly/field/value/index.d.ts

@@ -0,0 +1,7 @@
+export * from './array';
+export * from './boolean';
+export * from './date';
+export * from './enum';
+export * from './phone';
+export * from './text';
+export * from './hidden.field';

package/lib/formly/field/value/phone/index.d.ts

@@ -0,0 +1,3 @@
+export * from './phone.field.component';
+export * from './phone.field.module';
+export * from './phone.field';

package/lib/formly/field/value/phone/phone.field.component.d.ts

@@ -0,0 +1,24 @@
+import { ValidationErrors, FormGroup } from '@angular/forms';
+import { FieldType, FormlyFieldConfig } from '@ngx-formly/core';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export interface DbxInternationalPhoneFieldConfig {
+    preferredCountries?: string[];
+    onlyCountries?: string[];
+}
+export interface InternationalPhoneFormlyFieldConfig extends DbxInternationalPhoneFieldConfig, FormlyFieldConfig {
+}
+export declare const DEFAULT_PREFERRED_COUNTRIES: string[];
+export declare class DbxInternationalPhoneFieldComponent extends FieldType<InternationalPhoneFormlyFieldConfig> {
+    get fieldInputKey(): string;
+    get fieldFormGroup(): FormGroup;
+    get label(): Maybe<string>;
+    get placeholder(): Maybe<string>;
+    get description(): Maybe<string>;
+    get preferredCountries(): string[];
+    get onlyCountries(): string[];
+    get required(): boolean;
+    get errors(): Maybe<ValidationErrors>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxInternationalPhoneFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxInternationalPhoneFieldComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/formly/field/value/phone/phone.field.d.ts

@@ -0,0 +1,26 @@
+import { TextFieldConfig } from '../text/text.field';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { FieldConfig } from '../../field';
+import { DbxInternationalPhoneFieldConfig, InternationalPhoneFormlyFieldConfig } from './phone.field.component';
+export interface InternationalPhoneFieldConfig extends FieldConfig, DbxInternationalPhoneFieldConfig {
+}
+export declare function internationalPhoneField({ key, label, placeholder, required }: Partial<InternationalPhoneFieldConfig>): InternationalPhoneFormlyFieldConfig;
+export interface PhoneFormlyFieldsConfig {
+    phoneField?: InternationalPhoneFieldConfig;
+    labelField?: TextFieldConfig;
+}
+export declare function phoneAndLabelFields({ phoneField: phone, labelField: label }: PhoneFormlyFieldsConfig): FormlyFieldConfig[];
+export interface PhoneAndLabelFieldGroupConfig extends PhoneFormlyFieldsConfig {
+    key?: string;
+    label?: string;
+    required?: boolean;
+}
+export declare function phoneAndLabelFieldGroup({ key, label, required, phoneField, labelField }: PhoneAndLabelFieldGroupConfig): FormlyFieldConfig;
+export interface PhoneListFieldConfig extends PhoneAndLabelFieldGroupConfig {
+    maxPhones?: number;
+    repeatSection?: {
+        addText: string;
+        removeText: string;
+    };
+}
+export declare function phoneListField({ key, label, repeatSection, required, maxPhones, phoneField, labelField }: PhoneListFieldConfig): FormlyFieldConfig;