@dereekb/dbx-form 12.6.21 → 13.0.0

package/types/dereekb-dbx-form.d.ts

@@ -0,0 +1,3050 @@
+import * as i0 from '@angular/core';
+import { Type, Provider, OnInit, OnDestroy, ElementRef, InjectionToken, EnvironmentProviders } from '@angular/core';
+import { Transition, HookResult } from '@uirouter/core';
+import * as _dereekb_dbx_web from '@dereekb/dbx-web';
+import { DbxActionTransitionSafetyDirective, DbxActionTransitionSafetyType, AbstractDialogDirective, DbxButtonStyle, DbxSectionHeaderConfig, ScreenMediaWidthType, AbstractDbxSelectionListWrapperDirective, DbxValueListItemDecisionFunction, ListSelectionState, DbxValueListItem, AbstractDbxSelectionListViewDirective, DbxListSelectionMode, AbstractDbxValueListViewItemComponent, DbxFlexSize } from '@dereekb/dbx-web';
+import * as _dereekb_rxjs from '@dereekb/rxjs';
+import { LockSet, IsValidFunction, IsEqualFunction, IsModifiedFunction, ObservableOrValue, ObservableOrValueGetter, MaybeObservableOrValueGetter, WorkUsingContext, MaybeObservableOrValue, LoadingState, SubscriptionObject, SimpleLoadingContext, ListLoadingState, LoadingStateWithDefinedValue } from '@dereekb/rxjs';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject } from 'rxjs';
+import * as _dereekb_dbx_core from '@dereekb/dbx-core';
+import { DbxActionContextStoreSourceInstance, DbxActionValueGetterResult, DbxButtonDisplay, ClickableAnchor, DbxInjectionComponentConfig } from '@dereekb/dbx-core';
+import * as _dereekb_util from '@dereekb/util';
+import { BooleanStringKeyArray, Maybe, MapFunction, IsValid, IsModified, Destroyable, MaybeSo, ArrayOrValue, GeneralFilterFromPOJOFunction, FilterKeyValueTuplesInput, KeyValueTransformMap, PrimativeKey, ReadKeyFunction, LabelRef, LabeledValue, SearchStringFilterFunction, FactoryWithRequiredInput, Factory, TransformStringFunctionConfigRef, TransformStringFunctionConfig, IndexRef, DecisionFunction, GetterOrValue, LogicalDate, ReadableTimeString, Getter, ISO8601DayString, TimezoneString, DateOrDayString, Milliseconds, ISO8601DateString, TransformNumberFunctionConfigRef, WebsiteDomain, KeyValueTupleFilter, EqualityComparatorFunction } from '@dereekb/util';
+import { FormControlStatus, AbstractControl, FormGroup, ValidationErrors, ValidatorFn, AsyncValidatorFn, FormControl } from '@angular/forms';
+import * as _angular_material_core from '@angular/material/core';
+import { ErrorStateMatcher } from '@angular/material/core';
+import * as _angular_material_progress_spinner from '@angular/material/progress-spinner';
+import * as _ngx_formly_core from '@ngx-formly/core';
+import { FormlyFieldConfig, ConfigOption, FieldTypeConfig, FormlyFieldProps, FieldType, FieldWrapper, FieldArrayType, FieldArrayTypeConfig, FormlyForm, FormlyFormOptions } from '@ngx-formly/core';
+import { MatDialogConfig, MatDialog, MatDialogRef } from '@angular/material/dialog';
+import * as i1 from '@ngx-formly/material';
+import { FieldType as FieldType$1 } from '@ngx-formly/material';
+import { FormlyFieldProps as FormlyFieldProps$1, FieldType as FieldType$2 } from '@ngx-formly/material/form-field';
+import { MatInput } from '@angular/material/input';
+import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
+import { MatChipInputEvent } from '@angular/material/chips';
+import * as _dereekb_dbx_form from '@dereekb/dbx-form';
+import { Editor } from '@bobbyquantum/ngx-editor';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import * as i2 from '@ngx-formly/material/checkbox';
+import * as i3 from '@ngx-formly/material/toggle';
+import * as _dereekb_date from '@dereekb/date';
+import { DateRangeWithDateOrStringValue, DateTimezoneUtcNormalInstance, DateTimeMinuteConfig, DateTimeMinuteInstance, DateRangeInput, DateRange, TimezoneInfo } from '@dereekb/date';
+import { MatDatepickerInputEvent, MatCalendar, DateRange as DateRange$1, MatDateRangeSelectionStrategy } from '@angular/material/datepicker';
+import * as i2$1 from '@ngx-formly/material/slider';
+import * as i3$1 from '@ngx-formly/material/input';
+
+/**
+ * Current state of a DbxForm
+ */
+declare enum DbxFormState {
+    /**
+     * Form is not finished initializing.
+     */
+    INITIALIZING = -1,
+    /**
+     * Form is initialized but has not yet used.
+     */
+    RESET = 0,
+    /**
+     * Form has been used.
+     */
+    USED = 1
+}
+/**
+ * Unique key for disabling/enabling.
+ */
+type DbxFormDisabledKey = string;
+declare const DEFAULT_FORM_DISABLED_KEY = "dbx_form_disabled";
+interface DbxFormStateRef {
+    readonly state: DbxFormState;
+}
+/**
+ * DbxForm stream event
+ */
+interface DbxFormEvent extends DbxFormStateRef {
+    readonly isComplete: boolean;
+    readonly status: FormControlStatus;
+    readonly pristine?: boolean;
+    readonly untouched?: boolean;
+    readonly lastResetAt?: Date;
+    readonly changesCount?: number;
+    /**
+     * Whether or not the form is disabled.
+     */
+    readonly isDisabled?: boolean;
+    /**
+     * Current disabled state keys.
+     */
+    readonly disabled?: BooleanStringKeyArray;
+}
+/**
+ * Form that has an event stream, value, and state items.
+ */
+declare abstract class DbxForm<T = unknown> {
+    abstract readonly stream$: Observable<DbxFormEvent>;
+    /**
+     * Returns an observable that returns the current state of the form.
+     */
+    abstract getValue(): Observable<T>;
+    /**
+     * Returns an observable that returns the current disabled keys.
+     */
+    abstract getDisabled(): Observable<BooleanStringKeyArray>;
+}
+declare abstract class DbxMutableForm<T = unknown> extends DbxForm<T> {
+    /**
+     * LockSet for the form.
+     */
+    abstract readonly lockSet?: LockSet;
+    /**
+     * Sets the initial value of the form, and resets the form.
+     *
+     * @param value
+     */
+    abstract setValue(value: Maybe<Partial<T>>): void;
+    /**
+     * Resets the form to the initial value.
+     */
+    abstract resetForm(): void;
+    /**
+     * Disables the form
+     *
+     * @param disabled
+     */
+    abstract setDisabled(key?: DbxFormDisabledKey, disabled?: boolean): void;
+    /**
+     * Force the form to update itself as if it was changed.
+     */
+    abstract forceFormUpdate(): void;
+}
+declare function provideDbxForm<S extends DbxForm>(sourceType: Type<S>): Provider[];
+declare function provideDbxMutableForm<S extends DbxMutableForm>(sourceType: Type<S>): Provider[];
+declare function toggleDisableFormControl(form: AbstractControl<any>, isDisabled: boolean, config?: Parameters<AbstractControl['disable']>[0]): void;
+
+declare const APP_ACTION_FORM_DISABLED_KEY = "dbx_action_form";
+type DbxActionFormMapValueFunction<T, O> = MapFunction<T, ObservableOrValue<DbxActionValueGetterResult<O>>>;
+/**
+ * Used with an action to bind a form to an action as it's value source.
+ *
+ * If the form has errors when the action is trigger, it will reject the action.
+ *
+ * If the source is not considered modified, the trigger will be ignored.
+ */
+declare class DbxActionFormDirective<T = object, O = T> implements OnInit {
+    readonly form: DbxMutableForm<any>;
+    readonly source: DbxActionContextStoreSourceInstance<O, unknown>;
+    readonly lockSet: _dereekb_rxjs.LockSet;
+    /**
+     * Whether or not to disable the form while the action is working.
+     *
+     * Defaults to true.
+     */
+    readonly dbxActionFormDisabledOnWorking: i0.InputSignal<Maybe<boolean>>;
+    /**
+     * Optional validator that checks whether or not the value is
+     * ready to send before the context store is marked enabled.
+     */
+    readonly dbxActionFormIsValid: i0.InputSignal<Maybe<IsValidFunction<T>>>;
+    /**
+     * Optional function that checks whether or not the value is still the same/equal.
+     */
+    readonly dbxActionFormIsEqual: i0.InputSignal<Maybe<IsEqualFunction<T>>>;
+    /**
+     * Optional function that checks whether or not the value has been modified.
+     *
+     * If dbxActionFormIsEqual is provided, this will be ignored.
+     */
+    readonly dbxActionFormIsModified: i0.InputSignal<Maybe<IsModifiedFunction<T>>>;
+    /**
+     * Optional function that maps the form's value to the source's value.
+     */
+    readonly dbxActionFormMapValue: i0.InputSignal<Maybe<DbxActionFormMapValueFunction<T, O>>>;
+    readonly dbxActionFormDisabledOnWorking$: Observable<Maybe<boolean>>;
+    readonly isValidFunction$: Observable<IsValidFunction<T>>;
+    readonly isModifiedFunction$: Observable<IsModifiedFunction<T>>;
+    readonly mapValueFunction$: Observable<Maybe<DbxActionFormMapValueFunction<T, O>>>;
+    private readonly _triggeredSub;
+    private readonly _isCompleteSub;
+    private readonly _isWorkingSub;
+    constructor();
+    ngOnInit(): void;
+    checkIsValidAndIsModified(value: T, overrides?: CheckValidAndModifiedOverrides<T>): Observable<[IsValid, IsModified]>;
+    protected preCheckReadyValue(value: T): Observable<[IsValid, IsModified]>;
+    protected readyValue(value: T): Observable<DbxActionValueGetterResult<O>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionFormDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionFormDirective<any, any>, "[dbxActionForm]", never, { "dbxActionFormDisabledOnWorking": { "alias": "dbxActionFormDisabledOnWorking"; "required": false; "isSignal": true; }; "dbxActionFormIsValid": { "alias": "dbxActionFormIsValid"; "required": false; "isSignal": true; }; "dbxActionFormIsEqual": { "alias": "dbxActionFormIsEqual"; "required": false; "isSignal": true; }; "dbxActionFormIsModified": { "alias": "dbxActionFormIsModified"; "required": false; "isSignal": true; }; "dbxActionFormMapValue": { "alias": "dbxActionFormMapValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+interface CheckValidAndModifiedOverrides<T> {
+    isModifiedFunction?: Maybe<IsModifiedFunction<T>>;
+    isValidFunction?: Maybe<IsValidFunction<T>>;
+}
+
+/**
+ * Extension of DbxActionTransitionSafetyDirective that forces the form to update first.
+ *
+ * NOTE: Only works with UIRouter
+ */
+declare class DbxActionFormSafetyDirective<T, O> extends DbxActionTransitionSafetyDirective<T, O> {
+    readonly dbxActionForm: DbxActionFormDirective<T, T>;
+    readonly dbxActionFormSafety: i0.InputSignal<DbxActionTransitionSafetyType>;
+    protected readonly _dbxActionFormSafetyUpdateEffect: i0.EffectRef;
+    protected _handleOnBeforeTransition(transition: Transition): HookResult;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionFormSafetyDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionFormSafetyDirective<any, any>, "[dbxActionFormSafety]", never, { "dbxActionFormSafety": { "alias": "dbxActionFormSafety"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface DbxFormlyInitialize<T> {
+    fields: Observable<FormlyFieldConfig[]>;
+    initialDisabled: BooleanStringKeyArray;
+    initialValue: Maybe<Partial<T>>;
+}
+/**
+ * DbxFormlyContext delegate.
+ *
+ * This is usually the component or element that contains the form itself.
+ */
+interface DbxFormlyContextDelegate<T = unknown> extends Omit<DbxMutableForm<T>, 'lockSet'> {
+    readonly stream$: Observable<DbxFormEvent>;
+    init(initialize: DbxFormlyInitialize<T>): void;
+}
+/**
+ * Allows a directive to provide a formly context and form.
+ */
+declare function provideFormlyContext(): Provider[];
+/**
+ * DbxForm Instance that registers a delegate and manages the state of that form/delegate.
+ */
+declare class DbxFormlyContext<T = unknown> implements DbxForm<T>, Destroyable, OnDestroy {
+    private static INITIAL_STATE;
+    readonly lockSet: LockSet;
+    private readonly _fields;
+    private readonly _initialValue;
+    private readonly _disabled;
+    private readonly _delegate;
+    readonly fields$: Observable<FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
+        [additionalProperties: string]: any;
+    }>[]>;
+    readonly disabled$: Observable<string[]>;
+    readonly stream$: Observable<DbxFormEvent>;
+    ngOnDestroy(): void;
+    destroy(): void;
+    setDelegate(delegate?: DbxFormlyContextDelegate<T>): void;
+    clearDelegate(delegate: DbxFormlyContextDelegate<T>): void;
+    get fields(): Maybe<FormlyFieldConfig[]>;
+    set fields(fields: Maybe<FormlyFieldConfig[]>);
+    getValue(): Observable<T>;
+    setValue(value: Partial<T>): void;
+    isDisabled(): boolean;
+    get disabled(): BooleanStringKeyArray;
+    getDisabled(): Observable<BooleanStringKeyArray>;
+    setDisabled(key?: DbxFormDisabledKey, disabled?: boolean): void;
+    resetForm(): void;
+    forceFormUpdate(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormlyContext<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFormlyContext<any>>;
+}
+
+interface DbxFormActionDialogComponentButtonConfig extends DbxButtonDisplay, DbxButtonStyle {
+}
+interface DbxFormActionDialogComponentConfig<O> {
+    /**
+     * Header text for the dialog.
+     */
+    readonly header: string;
+    /**
+     * Used for retrieving the fields to display in the dialog.
+     */
+    readonly fields: ObservableOrValueGetter<FormlyFieldConfig[]>;
+    /**
+     * Initial value for the form.
+     */
+    readonly initialValue?: MaybeObservableOrValueGetter<O>;
+    /**
+     * Text/Icon for the submit button.
+     */
+    readonly submitButtonConfig?: DbxFormActionDialogComponentButtonConfig;
+    /**
+     * Dialog-specific configuration
+     */
+    readonly dialog?: Omit<MatDialogConfig, 'data'>;
+}
+/**
+ *
+ */
+declare class DbxFormActionDialogComponent<O> extends AbstractDialogDirective<O, DbxFormActionDialogComponentConfig<O>> implements OnInit {
+    private readonly _fieldsSub;
+    readonly context: DbxFormlyContext<O>;
+    readonly fields$: rxjs.Observable<FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
+        [additionalProperties: string]: any;
+    }>[]>;
+    readonly initialValue$: rxjs.Observable<O | null | undefined>;
+    readonly header: string;
+    readonly submitButtonConfig: {
+        icon?: Maybe<string>;
+        text: string | null;
+        type?: _dereekb_dbx_web.DbxButtonType;
+        mode?: _angular_material_progress_spinner.ProgressSpinnerMode;
+        color?: _angular_material_core.ThemePalette | _dereekb_dbx_web.DbxThemeColor;
+        spinnerColor?: _angular_material_core.ThemePalette | _dereekb_dbx_web.DbxThemeColor;
+        customButtonColor?: string;
+        customTextColor?: string;
+        customSpinnerColor?: string;
+        fab?: boolean;
+    };
+    ngOnInit(): void;
+    readonly handleSubmitValue: WorkUsingContext<O>;
+    static openDialogWithForm<O>(matDialog: MatDialog, config: DbxFormActionDialogComponentConfig<O>): MatDialogRef<DbxFormActionDialogComponent<O>, Maybe<O>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormActionDialogComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormActionDialogComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare function dbxFormSourceObservable<T>(form: DbxMutableForm, inputObs: ObservableOrValue<T>, modeObs: Observable<DbxFormSourceDirectiveMode>): Observable<T>;
+declare function dbxFormSourceObservableFromStream<T>(streamObs: Observable<DbxFormStateRef>, inputObs: ObservableOrValue<T>, modeObs: ObservableOrValue<DbxFormSourceDirectiveMode>): Observable<T>;
+/**
+ * DbxFormSourceDirective modes that define when to copy data from the source.
+ *
+ * - reset: only copy data when the form is reset.
+ * - always: always copy data when the data observable emits a value. Has a throttle of 20ms to prevent too many emissions. If emissions occur in a manner that appears to be a loop (more than 30 emissions in 1 second), then an error is thrown and warning printed to the console.
+ * - every: equal to always, but has no throttle or error message warning.
+ */
+type DbxFormSourceDirectiveMode = 'reset' | 'always' | 'every';
+/**
+ * Used with a FormComponent to set the value based on the input value.
+ */
+declare class DbxFormSourceDirective<T = unknown> {
+    readonly form: DbxMutableForm<any>;
+    readonly dbxFormSourceMode: i0.InputSignal<Maybe<DbxFormSourceDirectiveMode>>;
+    readonly dbxFormSource: i0.InputSignal<Maybe<ObservableOrValue<Maybe<Partial<T>>>>>;
+    protected readonly _effectSub: _dereekb_rxjs.SubscriptionObject<rxjs.Unsubscribable>;
+    protected readonly _setFormSourceObservableEffect: i0.EffectRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormSourceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFormSourceDirective<any>, "[dbxFormSource]", never, { "dbxFormSourceMode": { "alias": "dbxFormSourceMode"; "required": false; "isSignal": true; }; "dbxFormSource": { "alias": "dbxFormSource"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Used with a FormComponent to set the value from a LoadingState when the value is available.
+ *
+ * Only passes non-null values from the source.
+ */
+declare class DbxFormLoadingSourceDirective<T extends object = object> {
+    readonly form: DbxMutableForm<any>;
+    readonly dbxFormLoadingSourceMode: i0.InputSignalWithTransform<DbxFormSourceDirectiveMode, Maybe<DbxFormSourceDirectiveMode>>;
+    readonly dbxFormLoadingSource: i0.InputSignal<MaybeObservableOrValue<LoadingState<T>>>;
+    readonly mode$: Observable<DbxFormSourceDirectiveMode>;
+    readonly source$: Observable<Maybe<T>>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormLoadingSourceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFormLoadingSourceDirective<any>, "[dbxFormLoadingSource]", never, { "dbxFormLoadingSourceMode": { "alias": "dbxFormLoadingSourceMode"; "required": false; "isSignal": true; }; "dbxFormLoadingSource": { "alias": "dbxFormLoadingSource"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Used to see form value changes.
+ *
+ * Emits undefined when the form is incomplete, and the value when the form is complete.
+ */
+declare class DbxFormValueChangeDirective<T> implements OnInit {
+    readonly form: DbxForm<any>;
+    readonly dbxFormValueChange: i0.OutputEmitterRef<Maybe<T>>;
+    protected readonly _sub: _dereekb_rxjs.SubscriptionObject<rxjs.Unsubscribable>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormValueChangeDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFormValueChangeDirective<any>, "[dbxFormValueChange]", never, {}, { "dbxFormValueChange": "dbxFormValueChange"; }, never, never, true, never>;
+}
+
+/**
+ * A FormGroup/AbstractControl path to a specific control.
+ */
+type FormControlPath = string;
+/**
+ * Streams a value from the input control at the given path. If no path is specified, streams the value from the control.
+ *
+ * @param fromControl
+ * @param path
+ * @returns
+ */
+declare function streamValueFromControl<T>(fromControl: AbstractControl, path?: FormControlPath): Maybe<Observable<T>>;
+
+declare class DbxFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormModule>;
+}
+
+type ValidationMessageOption = MaybeSo<ConfigOption['validationMessages']>[number];
+
+declare function minLengthValidationMessage(err: unknown, field: FieldTypeConfig): string;
+declare function maxLengthValidationMessage(err: unknown, field: FieldTypeConfig): string;
+declare function minValidationMessage(err: unknown, field: FieldTypeConfig): string;
+declare function maxValidationMessage(err: unknown, field: FieldTypeConfig): string;
+declare const REQUIRED_VALIDATION_MESSAGE: {
+    name: string;
+    message: string;
+};
+declare const MIN_LENGTH_VALIDATION_MESSAGE: ValidationMessageOption;
+declare const MAX_LENGTH_VALIDATION_MESSAGE: ValidationMessageOption;
+declare const MIN_VALIDATION_MESSAGE: ValidationMessageOption;
+declare const MAX_VALIDATION_MESSAGE: ValidationMessageOption;
+declare const INVALID_PHONE_NUMBER_MESSAGE: {
+    name: string;
+    message: string;
+};
+declare const INVALID_PHONE_NUMBER_EXTENSION_MESSAGE: {
+    name: string;
+    message: string;
+};
+declare function defaultValidationMessages(): ValidationMessageOption[];
+
+interface ChecklistItemDisplayContent<T = unknown> {
+    /**
+     * Label to display.
+     */
+    readonly label?: Maybe<string>;
+    /**
+     * Secondary label/value to display. May be used as the string value.
+     */
+    readonly sublabel?: Maybe<string>;
+    /**
+     * Hint/description to display.
+     */
+    readonly description?: Maybe<string>;
+    /**
+     * Whether or not to display the ripple. Is true by default if the anchor is present.
+     */
+    readonly ripple?: Maybe<boolean>;
+    /**
+     * Optional anchor to apply on the visible content.
+     */
+    readonly anchor?: Maybe<ClickableAnchor>;
+    /**
+     * Value metadata. How it is used depends on the display component used.
+     */
+    readonly meta?: Maybe<T>;
+}
+/**
+ * Component used for rendering checklist content.
+ *
+ * Content is injected.
+ */
+interface ChecklistItemFieldDisplayComponent<T = unknown> {
+    setDisplayContent(displayContent: ChecklistItemDisplayContent<T>): void;
+}
+
+declare class DbxChecklistItemContentComponent<T = unknown> {
+    readonly checklistItemFieldComponent: DbxChecklistItemFieldComponent<any>;
+    readonly config: DbxInjectionComponentConfig<ChecklistItemFieldDisplayComponent<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxChecklistItemContentComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxChecklistItemContentComponent<any>, "dbx-checklist-item-content-component", never, {}, {}, never, never, true, never>;
+}
+interface DbxChecklistItemFieldProps<T = unknown> extends FormlyFieldProps {
+    /**
+     * Observable used to retrieve content to display for the item.
+     */
+    readonly displayContent: Observable<ChecklistItemDisplayContent<T>>;
+    /**
+     * Custom component class to use by default.
+     */
+    readonly componentClass?: Type<ChecklistItemFieldDisplayComponent<T>>;
+}
+declare class DbxChecklistItemFieldComponent<T = unknown> extends FieldType<FieldTypeConfig<DbxChecklistItemFieldProps<T>>> implements OnInit {
+    private readonly _displayContentObs;
+    readonly displayContent$: Observable<ChecklistItemDisplayContent<T>>;
+    readonly anchor$: Observable<Maybe<_dereekb_dbx_core.ClickableAnchor>>;
+    readonly rippleDisabled$: Observable<boolean>;
+    readonly anchorSignal: i0.Signal<Maybe<_dereekb_dbx_core.ClickableAnchor>>;
+    readonly rippleDisabledSignal: i0.Signal<boolean>;
+    get formGroup(): FormGroup;
+    get formControlName(): string;
+    get label(): Maybe<string>;
+    get description(): Maybe<string>;
+    get required(): Maybe<boolean>;
+    get checklistField(): DbxChecklistItemFieldProps<T>;
+    get errors(): Maybe<ValidationErrors>;
+    get componentClass(): Type<ChecklistItemFieldDisplayComponent<T>>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxChecklistItemFieldComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxChecklistItemFieldComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxDefaultChecklistItemFieldDisplayComponent<T = unknown> implements ChecklistItemFieldDisplayComponent<T> {
+    readonly _displayContentSignal: i0.WritableSignal<Maybe<ChecklistItemDisplayContent<T>>>;
+    readonly displayContentSignal: i0.Signal<Maybe<ChecklistItemDisplayContent<T>>>;
+    setDisplayContent(displayContent: ChecklistItemDisplayContent<T>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxDefaultChecklistItemFieldDisplayComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxDefaultChecklistItemFieldDisplayComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Wrapper than sets the field to "touched" when the value changes and the field is not pristine.
+ */
+declare class AutoTouchFieldWrapperComponent extends FieldWrapper<FieldTypeConfig> implements OnInit {
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoTouchFieldWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AutoTouchFieldWrapperComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+type DbxFormSectionConfig = DbxSectionHeaderConfig;
+declare class DbxFormSectionWrapperComponent extends FieldWrapper<FormlyFieldConfig<DbxFormSectionConfig>> {
+    get headerConfig(): Maybe<DbxSectionHeaderConfig>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormSectionWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormSectionWrapperComponent, "dbx-form-section-wrapper", never, {}, {}, never, never, true, never>;
+}
+
+type DbxFormSubsectionConfig = DbxSectionHeaderConfig;
+declare class DbxFormSubsectionWrapperComponent extends FieldWrapper<FieldTypeConfig<DbxFormSubsectionConfig>> {
+    get headerConfig(): Maybe<DbxSectionHeaderConfig>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormSubsectionWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormSubsectionWrapperComponent, "dbx-form-subsection-wrapper", never, {}, {}, never, never, true, never>;
+}
+
+interface DbxFormInfoConfig extends FormlyFieldProps {
+    readonly onInfoClick: () => void;
+}
+declare class DbxFormInfoWrapperComponent extends FieldWrapper<FormlyFieldConfig<DbxFormInfoConfig>> {
+    get infoWrapper(): DbxFormInfoConfig;
+    onInfoClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormInfoWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormInfoWrapperComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+interface AbstractFormExpandSectionConfig<T extends object = object> extends Pick<FormlyFieldProps, 'label'> {
+    expandLabel?: string;
+    /**
+     * Optional function to use for checking value existence.
+     */
+    hasValueFn?: (value: T) => boolean;
+}
+declare const DEFAULT_HAS_VALUE_FN: (x: object) => boolean;
+declare class AbstractFormExpandSectionWrapperDirective<T extends object = object, S extends AbstractFormExpandSectionConfig<T> = AbstractFormExpandSectionConfig<T>> extends FieldWrapper<FormlyFieldConfig<S>> implements OnInit, OnDestroy {
+    protected readonly _formControlObs: BehaviorSubject<Maybe<AbstractControl<any, any, any>>>;
+    protected readonly _toggleOpen: BehaviorSubject<Maybe<boolean>>;
+    readonly formControl$: rxjs.Observable<AbstractControl<any, any, any>>;
+    readonly show$: rxjs.Observable<boolean>;
+    readonly hasValue$: rxjs.Observable<boolean>;
+    readonly showSignal: i0.Signal<boolean>;
+    readonly hasValueSignal: i0.Signal<boolean>;
+    get expandSection(): S;
+    get hasValueFn(): (value: T) => boolean;
+    get expandLabel(): Maybe<string>;
+    open(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractFormExpandSectionWrapperDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractFormExpandSectionWrapperDirective<any, any>, never, never, {}, {}, never, never, true, never>;
+}
+
+type DbxFormExpandWrapperButtonType = 'button' | 'text';
+interface DbxFormExpandWrapperConfig<T extends object = object> extends AbstractFormExpandSectionConfig<T> {
+    readonly buttonType?: DbxFormExpandWrapperButtonType;
+}
+/**
+ * Section that is expandable by a button until a value is set, or the button is pressed.
+ */
+declare class DbxFormExpandWrapperComponent<T extends object = object> extends AbstractFormExpandSectionWrapperDirective<T, DbxFormExpandWrapperConfig<T>> {
+    get buttonType(): DbxFormExpandWrapperButtonType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormExpandWrapperComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormExpandWrapperComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+interface DbxFormToggleWrapperConfig<T extends object = object> extends AbstractFormExpandSectionConfig<T> {
+    toggleLabelObs?: (open: Maybe<boolean>) => Observable<string>;
+}
+/**
+ * Section that can be expanded by a button until a value is set, or the button is pressed.
+ */
+declare class DbxFormToggleWrapperComponent<T extends object = object> extends AbstractFormExpandSectionWrapperDirective<T, DbxFormToggleWrapperConfig> {
+    readonly slideLabel$: Observable<Maybe<string>>;
+    readonly slideLabelSignal: i0.Signal<Maybe<string>>;
+    onToggleChange(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormToggleWrapperComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormToggleWrapperComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+interface DbxFlexWrapperConfig {
+    /**
+     * Breakpoint based on the screen width.
+     */
+    readonly breakpoint?: ScreenMediaWidthType;
+    /**
+     * Whether or not to use relative sizing.
+     */
+    readonly relative?: boolean;
+    /**
+     * Whether or not to break to a new column when the breakpoint is reached.
+     */
+    readonly breakToColumn?: boolean;
+}
+declare class DbxFormFlexWrapperComponent extends FieldWrapper<FormlyFieldConfig<DbxFlexWrapperConfig>> {
+    get flexWrapper(): DbxFlexWrapperConfig;
+    get breakpoint(): ScreenMediaWidthType | undefined;
+    get relative(): boolean;
+    get breakToColumn(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFlexWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormFlexWrapperComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+type DbxFormStyleObject = {
+    [styleClass: string]: any;
+};
+interface DbxFormStyleWrapperConfig {
+    styleGetter?: Maybe<ObservableOrValue<DbxFormStyleObject>>;
+    classGetter?: Maybe<ObservableOrValue<string>>;
+}
+declare class DbxFormStyleWrapperComponent extends FieldWrapper<FormlyFieldConfig<DbxFormStyleWrapperConfig>> implements OnInit, OnDestroy {
+    private readonly _style;
+    private readonly _class;
+    readonly style$: Observable<Maybe<{}>>;
+    readonly class$: Observable<Maybe<string>>;
+    readonly styleSignal: i0.Signal<Maybe<{}>>;
+    readonly classSignal: i0.Signal<Maybe<string>>;
+    get styleGetter(): Maybe<ObservableOrValue<DbxFormStyleObject>>;
+    get classGetter(): Maybe<ObservableOrValue<string>>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormStyleWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormStyleWrapperComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * No configurable value for now.
+ */
+type DbxFormWorkingWrapperConfig = object;
+/**
+ * Adds a loading bar to help signify asynchronous work is occuring.
+ *
+ * By default shows loading during asynchronous validation of a field (FormControl status is "PENDING")
+ */
+declare class DbxFormWorkingWrapperComponent extends FieldWrapper<FormlyFieldConfig<DbxFormWorkingWrapperConfig>> implements OnInit, OnDestroy {
+    readonly sub: SubscriptionObject<rxjs.Unsubscribable>;
+    readonly workingContext: SimpleLoadingContext;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormWorkingWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormWorkingWrapperComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFormFormlyWrapperModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyWrapperModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyWrapperModule, never, [typeof AutoTouchFieldWrapperComponent, typeof DbxFormSectionWrapperComponent, typeof DbxFormSubsectionWrapperComponent, typeof DbxFormInfoWrapperComponent, typeof DbxFormExpandWrapperComponent, typeof DbxFormToggleWrapperComponent, typeof DbxFormFlexWrapperComponent, typeof DbxFormStyleWrapperComponent, typeof DbxFormWorkingWrapperComponent, typeof _ngx_formly_core.FormlyModule, typeof i1.FormlyMaterialModule, typeof _ngx_formly_core.FormlyModule], [typeof AutoTouchFieldWrapperComponent, typeof DbxFormSectionWrapperComponent, typeof DbxFormSubsectionWrapperComponent, typeof DbxFormInfoWrapperComponent, typeof DbxFormExpandWrapperComponent, typeof DbxFormToggleWrapperComponent, typeof DbxFormFlexWrapperComponent, typeof DbxFormStyleWrapperComponent, typeof DbxFormWorkingWrapperComponent, typeof _ngx_formly_core.FormlyModule, typeof i1.FormlyMaterialModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyWrapperModule>;
+}
+
+declare class DbxFormFormlyChecklistItemFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyChecklistItemFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyChecklistItemFieldModule, never, [typeof DbxChecklistItemFieldComponent, typeof DbxChecklistItemContentComponent, typeof DbxDefaultChecklistItemFieldDisplayComponent, typeof DbxFormFormlyWrapperModule, typeof _ngx_formly_core.FormlyModule], [typeof DbxChecklistItemFieldComponent, typeof DbxChecklistItemContentComponent, typeof DbxDefaultChecklistItemFieldDisplayComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyChecklistItemFieldModule>;
+}
+
+type FormlyValueParser<I = any, O = any> = MapFunction<I, O>;
+interface FieldConfigParsersRef {
+    parsers: FormlyValueParser[];
+}
+interface FieldConfig extends Pick<FormlyFieldConfig, 'expressions' | 'parsers'>, Partial<FieldConfigParsersRef> {
+    key: string;
+    required?: boolean;
+    readonly?: boolean;
+}
+interface FieldConfigWithParsers {
+    parsers?: FormlyValueParser[];
+}
+type DisableAutocompleteForField = false;
+interface LabeledFieldConfig extends FieldConfig {
+    key: string;
+    label?: string;
+    placeholder?: string;
+    required?: boolean;
+    readonly?: boolean;
+    /**
+     * Sets the autocomplete values.
+     */
+    autocomplete?: string | DisableAutocompleteForField;
+}
+interface DefaultValueFieldConfig<T = unknown> {
+    defaultValue?: T;
+}
+interface AttributesFieldConfig {
+    attributes?: {
+        [key: string]: string | number;
+    };
+}
+interface DescriptionFieldConfig {
+    description?: string;
+}
+type PartialPotentialFieldConfig = Partial<FieldConfig> & Partial<LabeledFieldConfig> & Partial<AttributesFieldConfig> & Partial<DescriptionFieldConfig>;
+/**
+ * Validates the configuration on the input field.
+ */
+declare function formlyField<T extends FormlyFieldConfig = FormlyFieldConfig>(fieldConfig: T): T;
+/**
+ * Creates an object with propers, expressions, and parsers properly configured from the input FieldConfig.
+ *
+ * @param fieldConfig
+ * @param override
+ * @returns
+ */
+declare function propsAndConfigForFieldConfig<O extends object = object>(fieldConfig: Partial<FieldConfig> & Partial<LabeledFieldConfig> & Partial<AttributesFieldConfig> & Partial<DescriptionFieldConfig>, override?: PartialPotentialFieldConfig & O): {
+    props: Partial<FormlyFieldProps> & Partial<FieldConfig> & Partial<LabeledFieldConfig> & Partial<AttributesFieldConfig> & Partial<DescriptionFieldConfig> & O;
+    expressions: ({
+        [property: string]: string | rxjs.Observable<any> | ((field: FormlyFieldConfig) => any);
+    } & {
+        className?: string | rxjs.Observable<string> | ((field: FormlyFieldConfig) => string);
+        hide?: string | rxjs.Observable<boolean> | ((field: FormlyFieldConfig) => boolean);
+        'props.disabled'?: string | rxjs.Observable<boolean> | ((field: FormlyFieldConfig) => boolean);
+        'props.required'?: string | rxjs.Observable<boolean> | ((field: FormlyFieldConfig) => boolean);
+    }) | undefined;
+    parsers: ((value: any) => any)[] | undefined;
+};
+declare const partialPotentialFieldConfigKeys: (keyof PartialPotentialFieldConfig)[];
+declare const partialPotentialFieldConfigKeysFilter: FilterKeyValueTuplesInput<PartialPotentialFieldConfig>;
+declare const mergePropsValueObjects: _dereekb_util.MergeObjectsFunction<PartialPotentialFieldConfig>;
+declare const filterPartialPotentialFieldConfigValuesFromObject: GeneralFilterFromPOJOFunction<PartialPotentialFieldConfig>;
+declare function propsValueForFieldConfig<T extends FormlyFieldProps, O extends object = object>(fieldConfig: PartialPotentialFieldConfig, override?: PartialPotentialFieldConfig & O): Partial<T> & O;
+/**
+ * Returns configuration for a formlyField that will disable autofill/autocomplete for a field.
+ */
+declare function disableFormlyFieldAutofillAttributes(): {
+    name: string;
+    autocomplete: string;
+};
+type FormlyMessageProperties = {
+    [messageProperties: string]: ValidationMessageOption['message'];
+};
+interface ValidatorsForFieldConfigInput {
+    validators?: ArrayOrValue<ValidatorFn>;
+    asyncValidators?: ArrayOrValue<AsyncValidatorFn>;
+    messages?: Maybe<FormlyMessageProperties>;
+}
+type ValidatorsForFieldConfig = {
+    validation?: {
+        messages?: FormlyMessageProperties;
+    };
+    validators?: {
+        validation: ValidatorFn[];
+    };
+    asyncValidators?: {
+        validation: AsyncValidatorFn[];
+    };
+};
+declare function validatorsForFieldConfig(input: ValidatorsForFieldConfigInput): Maybe<ValidatorsForFieldConfig>;
+interface MaterialFormFieldConfig {
+    readonly materialFormField?: Partial<Pick<FormlyFieldProps$1, 'prefix' | 'suffix' | 'hideLabel' | 'hideRequiredMarker' | 'hideFieldUnderline' | 'floatLabel' | 'appearance' | 'color' | 'hintStart' | 'hintEnd'>>;
+}
+
+interface ChecklistItemFieldConfig<T = unknown> extends LabeledFieldConfig, DbxChecklistItemFieldProps<T> {
+}
+type ChecklistItemFieldBuilderInput<T = unknown> = Partial<ChecklistItemFieldConfig<T>> & Pick<ChecklistItemFieldConfig<T>, 'key' | 'displayContent'>;
+declare function checklistItemField<T = unknown>(config: ChecklistItemFieldBuilderInput<T>): FormlyFieldConfig<DbxChecklistItemFieldProps<T>>;
+
+type ChecklistItemFieldDataSetFieldKey<D> = keyof D & string;
+type ChecklistItemFieldDataSetFieldValueForKey<D, K extends keyof D = keyof D> = D[K];
+type ChecklistType<D> = KeyValueTransformMap<D, boolean>;
+type ChecklistItemFieldDataSetBuilderInput<D, T> = {
+    key: ChecklistItemFieldDataSetFieldKey<D>;
+} & ChecklistItemFieldBuilderInput<T>;
+interface ChecklistItemFieldDataSetItem<D, T extends ChecklistType<D>> {
+    /**
+     * Key for the field.
+     */
+    readonly key: ChecklistItemFieldDataSetFieldKey<T>;
+    /**
+     * Base field configuration to use.
+     */
+    readonly field: ChecklistItemFieldBuilderInput<T>;
+}
+/**
+ * Used for building a set of configurations for a data-type object that has as second object that is used as a checklist.
+ */
+declare class ChecklistItemFieldDataSetBuilder<D extends object, C extends ChecklistType<D> = ChecklistType<D>> {
+    private readonly _fields;
+    readonly dataObs$: Observable<D>;
+    constructor(dataObs: Observable<D>);
+    /**
+     * Merges the input config with existing configuration.
+     *
+     * The displayContentObs, if provided, will merge with the existing observable and the two objects merged.
+     */
+    merge<T>(key: ChecklistItemFieldDataSetFieldKey<D>, config: Partial<ChecklistItemFieldBuilderInput<T>>): void;
+    override<T>(key: ChecklistItemFieldDataSetFieldKey<D>, config: Partial<ChecklistItemFieldBuilderInput<T>>): void;
+    _assertFieldExists(key: ChecklistItemFieldDataSetFieldKey<D>): ChecklistItemFieldDataSetItem<D, any>;
+    showValueFieldArrayCount<T extends ChecklistItemFieldDataSetFieldValueForKey<D> & Array<unknown>>(key: ChecklistItemFieldDataSetFieldKey<D>, config?: Partial<ChecklistItemFieldDataSetBuilderInput<D, T>>): void;
+    showValueField<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: ChecklistItemFieldDataSetFieldKey<D>, config?: Partial<ChecklistItemFieldDataSetBuilderInput<D, T>>, labelFn?: (value: T) => Maybe<string>): void;
+    field<T>(config: ChecklistItemFieldDataSetBuilderInput<D, T>): void;
+    build(): FormlyFieldConfig[];
+    customContentFromData<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(mapFn: (data: D) => ChecklistItemDisplayContent<T>): Observable<ChecklistItemDisplayContent<T>>;
+    contentWithValueFromData<K extends keyof D = keyof D, T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: K, contentFn?: (value: T) => ChecklistItemDisplayContent<T>): Observable<ChecklistItemDisplayContent<T>>;
+    contentWithDisplayValueFromData<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: ChecklistItemFieldDataSetFieldKey<D>, labelFn?: (value: T) => Maybe<string>): Observable<ChecklistItemDisplayContent<T>>;
+}
+
+type DbxFormComponentFieldConfig<T> = DbxInjectionComponentConfig<T>;
+interface DbxFormComponentFormlyFieldConfig<T = unknown> extends FormlyFieldConfig {
+    componentField: DbxFormComponentFieldConfig<T>;
+}
+declare class DbxFormComponentFieldComponent<T = unknown> extends FieldType<DbxFormComponentFormlyFieldConfig<T>> {
+    get config(): DbxInjectionComponentConfig<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormComponentFieldComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormComponentFieldComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFormFormlyComponentFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyComponentFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyComponentFieldModule, never, [typeof DbxFormComponentFieldComponent, typeof _ngx_formly_core.FormlyModule], [typeof DbxFormComponentFieldComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyComponentFieldModule>;
+}
+
+type ComponentFieldConfig<T = unknown> = DbxFormComponentFieldConfig<T>;
+declare function componentField<T = unknown>(config: ComponentFieldConfig<T>): DbxFormComponentFormlyFieldConfig<T>;
+
+interface DbxItemListFieldProps<T = unknown, C extends AbstractDbxSelectionListWrapperDirective<T> = AbstractDbxSelectionListWrapperDirective<T>, K extends PrimativeKey = PrimativeKey> extends Pick<FormlyFieldProps, 'label' | 'description'> {
+    /**
+     * List to render components from
+     */
+    readonly listComponentClass: Observable<Type<C>>;
+    /**
+     * Read key function to read the identifier from the input
+     */
+    readonly readKey: ReadKeyFunction<T, K>;
+    /**
+     * Observable that provides the items to select.
+     */
+    readonly state$: Observable<ListLoadingState<T>>;
+    /**
+     * Function that signals to load more items.
+     */
+    readonly loadMore?: () => void;
+}
+/**
+ * Used for picking items by identifier from a DbxList component.
+ */
+declare class DbxItemListFieldComponent<T = unknown, C extends AbstractDbxSelectionListWrapperDirective<T> = AbstractDbxSelectionListWrapperDirective<T>, K extends PrimativeKey = PrimativeKey> extends FieldType<FieldTypeConfig<DbxItemListFieldProps<T, C, K>>> implements OnInit, OnDestroy {
+    private readonly _selectionEventSub;
+    private readonly _loadMoreSub;
+    private readonly _formControlObs;
+    readonly formControl$: Observable<AbstractControl<any, any, any>>;
+    readonly _formControlValue$: Observable<Maybe<K[]>>;
+    readonly values$: Observable<K[]>;
+    private readonly _listComponentClassObs;
+    readonly listComponentClass$: Observable<Type<C>>;
+    readonly config$: Observable<DbxInjectionComponentConfig<C>>;
+    readonly isSelectedModifierFunction$: Observable<DbxValueListItemDecisionFunction<T>>;
+    readonly configSignal: i0.Signal<DbxInjectionComponentConfig<C> | undefined>;
+    readonly isSelectedModifierFunctionSignal: i0.Signal<DbxValueListItemDecisionFunction<T> | undefined>;
+    get label(): string | undefined;
+    get description(): string | undefined;
+    get listComponentClass(): Observable<Type<C>>;
+    get readKey(): ReadKeyFunction<T, K>;
+    get loadMore(): (() => void) | undefined;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    updateForSelection(list: ListSelectionState<T>): void;
+    setValues(values: Maybe<K[]>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxItemListFieldComponent<any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxItemListFieldComponent<any, any, any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+interface DbxListFieldConfig<T = unknown, C extends AbstractDbxSelectionListWrapperDirective<T> = AbstractDbxSelectionListWrapperDirective<T>, K extends PrimativeKey = PrimativeKey> extends LabeledFieldConfig, DbxItemListFieldProps<T, C, K> {
+}
+declare function dbxListField<T = unknown, C extends AbstractDbxSelectionListWrapperDirective<T> = AbstractDbxSelectionListWrapperDirective<T>, K extends PrimativeKey = PrimativeKey>(config: DbxListFieldConfig<T, C, K>): FormlyFieldConfig;
+
+declare class DbxFormFormlyDbxListFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyDbxListFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyDbxListFieldModule, never, [typeof DbxItemListFieldComponent, typeof _ngx_formly_core.FormlyModule], [typeof DbxItemListFieldComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyDbxListFieldModule>;
+}
+
+interface SelectionValue<T, M = unknown> {
+    /**
+     * Value associated with this field.
+     */
+    readonly value: T;
+    /**
+     * Optional metadata on the field.
+     */
+    readonly meta?: Maybe<M>;
+}
+/**
+ * Displayed value.
+ */
+interface SelectionDisplayValue<T, M = unknown> extends SelectionValue<T, M>, LabelRef {
+    readonly sublabel?: string;
+    readonly icon?: string;
+    /**
+     * Whether or not the value is known.
+     */
+    readonly isUnknown?: Maybe<boolean>;
+}
+/**
+ * Used to hash the value from the input pickable value.
+ */
+type SelectionValueHashFunction<T, H extends PrimativeKey = PrimativeKey> = MapFunction<T, H>;
+
+type PickableValueFieldValue<T, M = unknown> = SelectionValue<T, M>;
+type PickableValueFieldDisplayValue<T, M = unknown> = SelectionDisplayValue<T, M>;
+/**
+ * PickableValueField function for retrieving all values.
+ */
+type PickableValueFieldLoadValuesFunction<T, M = unknown> = () => Observable<PickableValueFieldValue<T, M>[]>;
+/**
+ * PickableValueField function that allows the values a chance to go through another observable for any changes.
+ *
+ * Values may not have metadata on them in some cases, where the value may infact be an unknown value.
+ * The returned value should be marked as unknown, or if it has no meta but is known, isUnknown should be marked false.
+ *
+ * The value itself should not change. All other fields on the value may change, however.
+ */
+type PickableValueFieldDisplayFunction<T, M = unknown> = (values: PickableValueFieldValue<T, M>[]) => Observable<PickableValueFieldDisplayValue<T, M>[]>;
+/**
+ * Used for filtering the values that should be displayed.
+ */
+type PickableValueFieldFilterFunction<T, M = unknown> = (flterText: Maybe<string>, values: PickableValueFieldDisplayValue<T, M>[]) => Observable<T[]>;
+/**
+ * Used to hash the value from the input pickable value.
+ */
+type PickableValueFieldHashFunction<T, H extends PrimativeKey = PrimativeKey> = SelectionValueHashFunction<T, H>;
+
+/**
+ * Wraps the selected state with the items.
+ */
+type PickableItemFieldItem<T, M = unknown> = DbxValueListItem<PickableValueFieldDisplayValue<T, M>>;
+type PickableItemFieldItemSortFn<T, M = unknown> = (items: PickableItemFieldItem<T, M>[]) => PickableItemFieldItem<T, M>[];
+interface PickableValueFieldsFieldProps<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends FormlyFieldProps {
+    /**
+     * Loads all pickable values.
+     */
+    readonly loadValues: PickableValueFieldLoadValuesFunction<T, M>;
+    /**
+     * Used for building a display value given the input.
+     */
+    readonly displayForValue: PickableValueFieldDisplayFunction<T, M>;
+    /**
+     * Used for hashing display values and omitting repeat values.
+     *
+     * If hashForValue is not provided, the value's value will be used as is.
+     */
+    readonly hashForValue?: PickableValueFieldHashFunction<T, H>;
+    /**
+     * Used for filtering values via the search text.
+     */
+    readonly filterValues?: PickableValueFieldFilterFunction<T, M>;
+    /**
+     * Used for sorting the items before they are displayed.
+     *
+     * Should only be used to sort values.
+     */
+    readonly sortItems?: PickableItemFieldItemSortFn<T, M>;
+    /**
+     * Whether or not to allow multiple items to be selected.
+     */
+    readonly multiSelect?: boolean;
+    /**
+     * Whether or not to set/get values as an array or a single value. If set false, multiSelect is ignored.
+     */
+    readonly asArrayValue?: boolean;
+    /**
+     * Whether or not to show the text filter. True by default if filterValues is provided.
+     */
+    readonly showTextFilter?: boolean;
+    /**
+     * Whether or not to skip the filter function when the input is empty.
+     *
+     * True by default.
+     */
+    readonly skipFilterFnOnEmpty?: boolean;
+    /**
+     * Filter Label
+     */
+    readonly filterLabel?: string;
+    /**
+     * The maximum number of values that can be picked
+     */
+    readonly maxPicks?: number;
+    /**
+     * Optional description/hint to display.
+     */
+    readonly description?: string;
+    /**
+     * Footer Display
+     */
+    readonly footerConfig?: DbxInjectionComponentConfig;
+    /**
+     * Changes the selection mode of the list to "view" mode on disabled, hiding the selection boxes.
+     */
+    readonly changeSelectionModeToViewOnDisabled?: boolean;
+    /**
+     * (Optional) observable that will trigger the clearing of all cached display values.
+     */
+    readonly refreshDisplayValues$?: Observable<unknown>;
+}
+/**
+ * Displayed value with the computed hash.
+ */
+interface PickableValueFieldDisplayValueWithHash<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends PickableValueFieldDisplayValue<T, M> {
+    _hash: H;
+}
+/**
+ * Used for picking pre-set values using items as the presentation.
+ */
+declare class AbstractDbxPickableItemFieldDirective<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends FieldType$1<FieldTypeConfig<PickableValueFieldsFieldProps<T, M, H>>> implements OnInit, OnDestroy {
+    readonly filterMatInput: i0.Signal<MatInput | undefined>;
+    readonly inputCtrl: FormControl<string | null>;
+    private readonly _formControlObs;
+    readonly formControl$: Observable<AbstractControl<any, any, any>>;
+    private readonly _clearDisplayHashMapSub;
+    private readonly _displayHashMap;
+    readonly filterInputValue$: Observable<Maybe<string>>;
+    readonly filterInputValueString$: Observable<Maybe<string>>;
+    readonly loadResultsDisplayValuesState$: Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T, M, H>[]>>;
+    readonly _formControlValue$: Observable<T | T[]>;
+    readonly loadResultsDisplayValues$: Observable<PickableValueFieldDisplayValueWithHash<T, M, H>[]>;
+    /**
+     * Current values in the form control.
+     */
+    readonly values$: Observable<T[]>;
+    /**
+     * Current values with their display value.
+     */
+    readonly displayValuesState$: Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T, M, H>[]>>;
+    /**
+     * Results to be displayed if filtered.
+     */
+    readonly filteredSearchResultsState$: Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T, M, H>[]>>;
+    readonly filteredSearchResults$: Observable<PickableValueFieldDisplayValueWithHash<T, M, H>[]>;
+    readonly items$: Observable<PickableItemFieldItem<T, M>[]>;
+    readonly itemsLoadingState$: Observable<LoadingState<PickableItemFieldItem<T>[]>>;
+    /**
+     * Context used for managing the loading of items, or when the current results change.
+     */
+    readonly context: _dereekb_rxjs.MutableListLoadingStateContext<unknown, LoadingState<PickableItemFieldItem<T, unknown>[]>>;
+    readonly filterItemsLoadingState$: Observable<LoadingState<PickableItemFieldItem<T>[]>>;
+    readonly noItemsAvailable$: Observable<boolean>;
+    /**
+     * Context used for searching/filtering.
+     */
+    readonly filterResultsContext: _dereekb_rxjs.MutableListLoadingStateContext<unknown, LoadingState<PickableValueFieldDisplayValueWithHash<T, M, H>[]>>;
+    readonly itemsSignal: i0.Signal<PickableItemFieldItem<T, M>[] | undefined>;
+    readonly noItemsAvailableSignal: i0.Signal<boolean | undefined>;
+    get readonly(): Maybe<boolean>;
+    get isReadonlyOrDisabled(): boolean;
+    get pickableField(): PickableValueFieldsFieldProps<T, M, H>;
+    get multiSelect(): boolean;
+    get asArrayValue(): boolean;
+    get pickOnlyOne(): boolean;
+    get filterLabel(): Maybe<string>;
+    get name(): string;
+    get label(): Maybe<string>;
+    get autocomplete(): string;
+    get changeSelectionModeToViewOnDisabled(): boolean;
+    get sortItems(): Maybe<PickableItemFieldItemSortFn<T, M>>;
+    get hashForValue(): PickableValueFieldHashFunction<T, H>;
+    get displayForValue(): PickableValueFieldDisplayFunction<T, M>;
+    get showFilterInput(): boolean;
+    get filterValuesFn(): PickableValueFieldFilterFunction<T, M>;
+    get skipFilterFnOnEmpty(): boolean;
+    get _filterValues(): PickableValueFieldFilterFunction<T, M>;
+    get showTextFilter(): boolean;
+    get loadValuesFn(): PickableValueFieldLoadValuesFunction<T, M>;
+    get values(): T[];
+    get footerConfig(): Maybe<DbxInjectionComponentConfig>;
+    get refreshDisplayValues$(): Observable<unknown> | undefined;
+    loadDisplayValuesForValues(values: T[]): Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T, M, H>[]>>;
+    loadDisplayValuesForFieldValues(values: PickableValueFieldValue<T, M>[]): Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T, M, H>[]>>;
+    getDisplayValuesForFieldValues(values: PickableValueFieldValue<T, M>[]): Observable<PickableValueFieldDisplayValueWithHash<T, M, H>[]>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected _getValueOnFormControl(valueOnFormControl: ArrayOrValue<T>): T[];
+    addValue(value: T): void;
+    removeValue(value: T): void;
+    setValues(values: T[]): void;
+    protected _setValueOnFormControl(values: T[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxPickableItemFieldDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxPickableItemFieldDirective<any, any, any>, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Used for picking pre-set values using chips as the presentation.
+ */
+declare class DbxPickableChipListFieldComponent<T> extends AbstractDbxPickableItemFieldDirective<T> {
+    itemClicked(item: PickableItemFieldItem<T>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxPickableChipListFieldComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxPickableChipListFieldComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxPickableListFieldItemListComponent<T> extends AbstractDbxSelectionListWrapperDirective<PickableItemFieldItem<T>> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxPickableListFieldItemListComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxPickableListFieldItemListComponent<any>, "dbx-form-pickable-item-field-item-list", never, {}, {}, never, ["[top]", "[bottom]", "[empty]", "[emptyLoading]", "[end]"], true, never>;
+}
+/**
+ * NOTE: Values input are PickableItemFieldItem<T>, but output values are PickableValueFieldDisplayValue<T>.
+ */
+declare class DbxPickableListFieldItemListViewComponent<T> extends AbstractDbxSelectionListViewDirective<any> {
+    readonly dbxPickableListFieldComponent: DbxPickableListFieldComponent<T>;
+    readonly config: DbxInjectionComponentConfig;
+    get multiple(): boolean;
+    get selectionMode(): Maybe<DbxListSelectionMode>;
+    readonly items$: rxjs.Observable<any[]>;
+    readonly itemsSignal: i0.Signal<any[] | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxPickableListFieldItemListViewComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxPickableListFieldItemListViewComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+declare class DbxPickableListFieldItemListViewItemComponent<T> extends AbstractDbxValueListViewItemComponent<PickableValueFieldDisplayValue<T>> {
+    readonly label: string;
+    readonly sublabel: string | undefined;
+    readonly icon: string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxPickableListFieldItemListViewItemComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxPickableListFieldItemListViewItemComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Used for picking pre-set values using a selection list as the presentation.
+ */
+declare class DbxPickableListFieldComponent<T> extends AbstractDbxPickableItemFieldDirective<T> {
+    onSelectionChange(event: unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxPickableListFieldComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxPickableListFieldComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFormFormlyPickableFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyPickableFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyPickableFieldModule, never, [typeof DbxPickableChipListFieldComponent, typeof DbxPickableListFieldComponent, typeof DbxPickableListFieldItemListComponent, typeof DbxPickableListFieldItemListViewComponent, typeof DbxPickableListFieldItemListViewItemComponent, typeof _ngx_formly_core.FormlyModule], [typeof DbxPickableChipListFieldComponent, typeof DbxPickableListFieldComponent, typeof DbxPickableListFieldItemListComponent, typeof DbxPickableListFieldItemListViewComponent, typeof DbxPickableListFieldItemListViewItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyPickableFieldModule>;
+}
+
+interface PickableItemFieldConfig<T = unknown, M = unknown> extends LabeledFieldConfig, PickableValueFieldsFieldProps<T, M>, MaterialFormFieldConfig {
+}
+declare function pickableItemChipField<T = unknown, M = unknown>(config: PickableItemFieldConfig<T, M>): FormlyFieldConfig;
+declare function pickableItemListField<T = unknown, M = unknown>(config: PickableItemFieldConfig<T, M>): FormlyFieldConfig;
+
+declare const filterPickableItemFieldValuesByLabelFilterFunction: SearchStringFilterFunction<PickableValueFieldDisplayValue<any>>;
+declare function filterPickableItemFieldValuesByLabel<T>(filterText: Maybe<string>, values: PickableValueFieldDisplayValue<T>[]): Observable<T[]>;
+declare const sortPickableItemsByLabelStringFunction: _dereekb_util.SortByStringFunction<PickableItemFieldItem<any>>;
+declare function sortPickableItemsByLabel<T>(chips: PickableItemFieldItem<T>[]): PickableItemFieldItem<T>[];
+type PickableValueFieldValuesConfigForStaticLabeledValues<T, M extends LabeledValue<T>> = Pick<PickableValueFieldsFieldProps<T, M>, 'loadValues' | 'displayForValue' | 'filterValues'>;
+interface PickableValueFieldValuesConfigForStaticLabeledValuesConfig<T, M extends LabeledValue<T>> {
+    readonly allOptions: M[];
+    readonly unknownOptionLabel?: string;
+}
+declare function pickableValueFieldValuesConfigForStaticLabeledValues<T, M extends LabeledValue<T>>(input: M[] | PickableValueFieldValuesConfigForStaticLabeledValuesConfig<T, M>): PickableValueFieldValuesConfigForStaticLabeledValues<T, M>;
+
+interface SearchableValueFieldValue<T, M = unknown> extends SelectionValue<T, M> {
+    /**
+     * Optional anchor metadata on the field.
+     */
+    readonly anchor?: ClickableAnchor;
+}
+/**
+ * Displayed value.
+ */
+interface SearchableValueFieldDisplayValue<T, M = unknown> extends SelectionDisplayValue<T, M>, SearchableValueFieldValue<T, M> {
+    /**
+     * Display override configuration
+     */
+    readonly display?: Partial<DbxInjectionComponentConfig>;
+}
+interface ConfiguredSearchableValueFieldDisplayValue<T, M = unknown> extends Omit<SearchableValueFieldDisplayValue<T, M>, 'display'> {
+    readonly display: DbxInjectionComponentConfig;
+}
+/**
+ * SearchableValueField function for searching values.
+ */
+type SearchableValueFieldStringSearchFn<T, M = unknown> = MapFunction<string, Observable<SearchableValueFieldValue<T, M>[]>>;
+/**
+ * SearchableValueField function that allows the values a chance to go through another observable for unknown 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.
+ */
+type SearchableValueFieldDisplayFn<T, M = unknown> = MapFunction<SearchableValueFieldValue<T, M>[], Observable<SearchableValueFieldDisplayValue<T, M>[]>>;
+/**
+ * SearchableValueField function for setting anchor values on a field value.
+ */
+type SearchableValueFieldAnchorFn<T, M = unknown> = MapFunction<SearchableValueFieldValue<T, M>, ClickableAnchor>;
+type SearchableValueFieldHashFn<T, H extends PrimativeKey = PrimativeKey> = SelectionValueHashFunction<T, H>;
+
+interface StringValueFieldsFieldProps extends FormlyFieldProps {
+    /**
+     * Custom input validators.
+     */
+    readonly textInputValidator?: ValidatorFn | ValidatorFn[];
+}
+interface SearchableValueFieldsFieldProps<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends FormlyFieldProps, StringValueFieldsFieldProps {
+    /**
+     * Whether or not to allow string values to be used directly, or if values can only be chosen from searching.
+     */
+    readonly allowStringValues?: boolean;
+    /**
+     * Whether or not to set/get values as an array or a single value. If set false, multiSelect is ignored.
+     */
+    readonly asArrayValue?: boolean;
+    /**
+     * Optional conversion function. If provided, allowStringValues is considered true.
+     */
+    readonly 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.
+     */
+    readonly hashForValue?: SearchableValueFieldHashFn<T, H>;
+    /**
+     * Performs a search.
+     */
+    readonly search: SearchableValueFieldStringSearchFn<T, M>;
+    /**
+     * Whether or not to allow searches on empty text. Is false by default.
+     */
+    readonly searchOnEmptyText?: boolean;
+    /**
+     * Default injected config to use for display values.
+     */
+    readonly display?: Partial<DbxInjectionComponentConfig>;
+    /**
+     * Used for building a display value given the input.
+     */
+    readonly displayForValue: SearchableValueFieldDisplayFn<T, M>;
+    /**
+     * Whether or not to use the anchor field on value elements.
+     *
+     * This has no default effect if a component class is provided.
+     */
+    readonly useAnchor?: boolean;
+    /**
+     * Used for retrieving an anchor value for values that have no anchor value set.
+     *
+     * Only used when useAnchor is true.
+     */
+    readonly anchorForValue?: SearchableValueFieldAnchorFn<T, M>;
+    /**
+     * Whether or not to show "Clear" in the autcomplete list.
+     */
+    readonly showClearValue?: boolean;
+    /**
+     * Label for the search input.
+     *
+     * Defaults to "Search"
+     */
+    readonly searchLabel?: string;
+    /**
+     * (Optional) observable that will trigger the clearing of all cached display values.
+     */
+    readonly refreshDisplayValues$?: Observable<unknown>;
+}
+/**
+ * Abstract searchable field that provides a feature for searching for values, and for displaying values using Observables.
+ *
+ * Display values are cached for performance.
+ */
+declare abstract class AbstractDbxSearchableValueFieldDirective<T, M = unknown, H extends PrimativeKey = PrimativeKey, C extends SearchableValueFieldsFieldProps<T, M, H> = SearchableValueFieldsFieldProps<T, M, H>> extends FieldType$1<FieldTypeConfig<C>> implements OnInit, OnDestroy {
+    /**
+     * Whether or not to set/get values as an array.
+     */
+    abstract get multiSelect(): boolean;
+    /**
+     * Optional override set by the parent class for whether or not to allow the current value to sync to the input.
+     */
+    allowSyncValueToInput: boolean;
+    /**
+     * Default placeholder text to use when searchOnEmptyText is false.
+     */
+    defaultSearchInputPlaceholder?: Maybe<string>;
+    readonly textInput: i0.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly inputCtrl: FormControl<string | null>;
+    private readonly _formControlObs;
+    readonly formControl$: Observable<AbstractControl<any, any, any>>;
+    private readonly _clearDisplayHashMapSub;
+    private readonly _displayHashMap;
+    readonly inputValue$: Observable<string>;
+    readonly inputValueString$: Observable<string>;
+    readonly searchResultsState$: Observable<LoadingState<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>>;
+    private readonly _singleValueSyncSub;
+    readonly searchContext: _dereekb_rxjs.MutableListLoadingStateContext<unknown, LoadingState<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>>;
+    readonly searchResults$: Observable<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>;
+    readonly isLoadingSearchResults$: Observable<boolean>;
+    readonly _formControlValue$: Observable<T | T[]>;
+    readonly values$: Observable<T[]>;
+    readonly displayValuesState$: Observable<LoadingState<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>>;
+    readonly displayValues$: Observable<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>;
+    readonly inputValueSignal: i0.Signal<string | undefined>;
+    readonly searchResultsSignal: i0.Signal<ConfiguredSearchableValueFieldDisplayValue<T, M>[] | undefined>;
+    readonly displayValuesSignal: i0.Signal<ConfiguredSearchableValueFieldDisplayValue<T, M>[] | undefined>;
+    readonly isLoadingSearchResultsSignal: i0.Signal<boolean | undefined>;
+    get name(): string;
+    get label(): Maybe<string>;
+    get readonly(): Maybe<boolean>;
+    get isReadonlyOrDisabled(): boolean;
+    get searchableField(): SearchableValueFieldsFieldProps<T, M, H>;
+    get asArrayValue(): boolean;
+    get pickOnlyOne(): boolean;
+    get searchOnEmptyText(): boolean;
+    get searchInputPlaceholder(): string | '';
+    get autocomplete(): string;
+    get hashForValue(): SearchableValueFieldHashFn<T, H>;
+    get displayForValue(): SearchableValueFieldDisplayFn<T, M>;
+    get useAnchor(): Maybe<boolean>;
+    get anchorForValue(): Maybe<SearchableValueFieldAnchorFn<T, M>>;
+    get display(): Maybe<Partial<DbxInjectionComponentConfig>>;
+    get search(): SearchableValueFieldStringSearchFn<T, M>;
+    get values(): T[];
+    get allowStringValues(): boolean;
+    get convertStringValue(): Maybe<(text: string) => T>;
+    get showClearValue(): boolean;
+    get searchLabel(): string;
+    get refreshDisplayValues$(): Observable<unknown> | undefined;
+    loadDisplayValuesForValues(values: T[]): Observable<LoadingState<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>>;
+    loadDisplayValuesForFieldValues(values: SearchableValueFieldValue<T, M>[]): Observable<LoadingState<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>>;
+    getDisplayValuesForFieldValues(values: SearchableValueFieldValue<T, M>[]): Observable<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>;
+    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;
+    _tryAddCurrentInputValue(): boolean;
+    addValue(value: T): void;
+    removeValue(value: T): void;
+    clearValues(): void;
+    setValues(values: T[]): void;
+    protected _getValueOnFormControl(valueOnFormControl: ArrayOrValue<T>): T[];
+    protected _setValueOnFormControl(values: T[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxSearchableValueFieldDirective<any, any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxSearchableValueFieldDirective<any, any, any, any>, never, never, {}, {}, never, never, true, never>;
+}
+
+interface SearchableChipValueFieldsFieldProps<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends SearchableValueFieldsFieldProps<T, M, H> {
+    /**
+     * Whether or not to allow multiple items to be selected.
+     */
+    readonly multiSelect?: boolean;
+}
+declare class DbxSearchableChipFieldComponent<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends AbstractDbxSearchableValueFieldDirective<T, M, H, SearchableChipValueFieldsFieldProps<T, M, H>> implements OnInit, OnDestroy {
+    get multiSelect(): boolean;
+    private readonly _blur;
+    private readonly _blurSub;
+    readonly separatorKeysCodes: number[];
+    selected(event: MatAutocompleteSelectedEvent): void;
+    tabPressedOnInput(event: KeyboardEvent): boolean;
+    addChip(event: MatChipInputEvent): void;
+    protected _syncSingleValue(value: SearchableValueFieldDisplayValue<T>): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxSearchableChipFieldComponent<any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxSearchableChipFieldComponent<any, any, any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare const DBX_SEARCHABLE_FIELD_COMPONENT_DATA_TOKEN: InjectionToken<unknown>;
+declare class DbxSearchableFieldAutocompleteItemComponent<T> {
+    readonly displayValue: i0.InputSignal<ConfiguredSearchableValueFieldDisplayValue<T, unknown>>;
+    readonly configSignal: i0.Signal<DbxInjectionComponentConfig<unknown>>;
+    readonly anchorSignal: i0.Signal<_dereekb_dbx_core.ClickableAnchor | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxSearchableFieldAutocompleteItemComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxSearchableFieldAutocompleteItemComponent<any>, "dbx-searchable-field-autocomplete-item", never, { "displayValue": { "alias": "displayValue"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare abstract class AbstractDbxSearchableFieldDisplayDirective<T> {
+    readonly displayValue: ConfiguredSearchableValueFieldDisplayValue<T, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxSearchableFieldDisplayDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxSearchableFieldDisplayDirective<any>, never, never, {}, {}, never, never, true, never>;
+}
+declare class DbxDefaultSearchableFieldDisplayComponent<T> extends AbstractDbxSearchableFieldDisplayDirective<T> {
+    readonly icon: string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxDefaultSearchableFieldDisplayComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxDefaultSearchableFieldDisplayComponent<any>, "dbx-default-searchable-field-display", never, {}, {}, never, never, true, never>;
+}
+
+interface SearchableTextValueFieldsFieldProps<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends SearchableValueFieldsFieldProps<T, M, H> {
+    readonly showSelectedValue?: boolean;
+}
+/**
+ * Display component for selecting a single item/value.
+ */
+declare class DbxSearchableTextFieldComponent<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends AbstractDbxSearchableValueFieldDirective<T, M, H, SearchableTextValueFieldsFieldProps<T, M, H>> implements OnInit, OnDestroy {
+    allowSyncValueToInput: boolean;
+    readonly selectedDisplayValue$: rxjs.Observable<_dereekb_dbx_form.ConfiguredSearchableValueFieldDisplayValue<T, M>>;
+    readonly selectedDisplayValueSignal: i0.Signal<_dereekb_dbx_form.ConfiguredSearchableValueFieldDisplayValue<T, M> | undefined>;
+    readonly hasValueSignal: i0.Signal<boolean>;
+    readonly showSelectedDisplayValueSignal: i0.Signal<boolean>;
+    get searchableField(): SearchableTextValueFieldsFieldProps<T, M, H>;
+    get showSelectedValue(): boolean;
+    get multiSelect(): boolean;
+    selected(event: MatAutocompleteSelectedEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxSearchableTextFieldComponent<any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxSearchableTextFieldComponent<any, any, any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Used to create a SearchableValueFieldDisplayFn function that will retrieve the metadata for items that are missing their metadata so they can be displayed properly.
+ *
+ * @param param0
+ * @returns
+ */
+declare function makeMetaFilterSearchableFieldValueDisplayFn<T extends string | number = string | number, M = unknown>({ loadMetaForValues, makeDisplayForValues }: {
+    loadMetaForValues: (values: SearchableValueFieldValue<T, M>[]) => Observable<SearchableValueFieldValue<T, M>[]>;
+    makeDisplayForValues: (values: SearchableValueFieldValue<T, M>[]) => Observable<SearchableValueFieldDisplayValue<T, M>[]>;
+}): SearchableValueFieldDisplayFn<T, M>;
+type StringSearchableChipFieldConfig<M = unknown> = Omit<SearchableChipFieldConfig<string, M>, 'allowStringValues'>;
+declare function searchableStringChipField<M = unknown>(config: StringSearchableChipFieldConfig<M>): FormlyFieldConfig;
+interface SearchableChipFieldConfig<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends LabeledFieldConfig, DescriptionFieldConfig, MaterialFormFieldConfig, SearchableChipValueFieldsFieldProps<T, M, H> {
+}
+declare function searchableChipField<T, M = unknown, H extends PrimativeKey = PrimativeKey>(config: SearchableChipFieldConfig<T, M, H>): FormlyFieldConfig;
+interface SearchableTextFieldConfig<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends LabeledFieldConfig, DescriptionFieldConfig, MaterialFormFieldConfig, SearchableTextValueFieldsFieldProps<T, M, H> {
+}
+declare function searchableTextField<T, M = unknown, H extends PrimativeKey = PrimativeKey>(config: SearchableTextFieldConfig<T, M, H>): FormlyFieldConfig;
+
+declare class DbxFormFormlySearchableFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlySearchableFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlySearchableFieldModule, never, [typeof DbxSearchableChipFieldComponent, typeof DbxSearchableTextFieldComponent, typeof DbxSearchableFieldAutocompleteItemComponent, typeof DbxDefaultSearchableFieldDisplayComponent, typeof _ngx_formly_core.FormlyModule], [typeof DbxSearchableChipFieldComponent, typeof DbxSearchableTextFieldComponent, typeof DbxSearchableFieldAutocompleteItemComponent, typeof DbxDefaultSearchableFieldDisplayComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlySearchableFieldModule>;
+}
+
+interface ChipTextFieldConfig extends LabeledFieldConfig, StringValueFieldsFieldProps {
+    caseSensitive?: boolean;
+}
+declare function chipTextField(config: ChipTextFieldConfig): _ngx_formly_core.FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
+    [additionalProperties: string]: any;
+}>;
+
+interface SourceSelectValue<T extends PrimativeKey = PrimativeKey, M = unknown> {
+    value: T;
+    meta: M;
+}
+/**
+ * Group of SourceSelectValues with a label.
+ */
+interface SourceSelectValueGroup<T extends PrimativeKey = PrimativeKey, M = unknown> {
+    /**
+     * Label for this source.
+     */
+    readonly label: string;
+    /**
+     * Values
+     */
+    readonly values: SourceSelectValue<T, M>[];
+}
+/**
+ * Display value configuration for a SourceSelectValue.
+ */
+type SourceSelectDisplayValue<T extends PrimativeKey = PrimativeKey, M = unknown> = Omit<SelectionDisplayValue<T, M>, 'meta'> & Pick<SourceSelectValue<T, M>, 'meta'>;
+/**
+ * Display value configuration for a SourceSelectValue.
+ */
+interface SourceSelectDisplayValueGroup<T extends PrimativeKey = PrimativeKey, M = unknown> {
+    /**
+     * Label for this source.
+     */
+    readonly label: string;
+    /**
+     * Values
+     */
+    readonly values: SourceSelectDisplayValue<T, M>[];
+}
+/**
+ * Options for a SourceSelect input.
+ */
+interface SourceSelectOptions<T extends PrimativeKey = PrimativeKey, M = unknown> {
+    readonly nonGroupedValues: SourceSelectDisplayValue<T, M>[];
+    readonly groupedValues: SourceSelectDisplayValueGroup<T, M>[];
+}
+/**
+ * Returns an observable that loads all the display info for the input values.
+ */
+type SourceSelectDisplayFunction<T extends PrimativeKey = PrimativeKey, M = unknown> = MapFunction<SourceSelectValue<T, M>[], Observable<SourceSelectDisplayValue<T, M>[]>>;
+/**
+ * Reads the value from the input meta value. Should always return the same value.
+ */
+type SourceSelectMetaValueReader<T extends PrimativeKey = PrimativeKey, M = unknown> = MapFunction<M, T>;
+/**
+ * Returns an observable that loads the metadata of the input values.
+ */
+type SourceSelectValueMetaLoader<T extends PrimativeKey = PrimativeKey, M = unknown> = FactoryWithRequiredInput<Observable<M[]>, T[]>;
+interface SourceSelectOpenFunctionParams {
+    /**
+     * Origin of the button for the SourceSelect
+     */
+    readonly origin: ElementRef;
+}
+/**
+ * Returns an observable that returns an array of meta values to be added to the selection.
+ */
+type SourceSelectOpenFunction<M = unknown> = FactoryWithRequiredInput<Observable<SourceSelectOpenSourceResult<M>>, SourceSelectOpenFunctionParams>;
+/**
+ * Returns an observable that returns an array of meta values to be added to the selection.
+ */
+interface SourceSelectOpenSourceResult<M = unknown> {
+    /**
+     * The values to set entirely, clearing the current selection.
+     *
+     * If null/undefined, current values will not be replaced.
+     */
+    readonly set?: Maybe<M[]>;
+    /**
+     * New values to add to the selection, if applicable.
+     *
+     * If null/undefined, no values will be added to selection.
+     *
+     * Is ignored if "set" value is provided.
+     */
+    readonly select?: Maybe<M[]>;
+    /**
+     * New options to make available for selection, but are not automatically selected.
+     *
+     * If null/undefined, no options will be added.
+     */
+    readonly options?: Maybe<M[]>;
+}
+/**
+ * Function used to return an observable for an array of SourceSelectLoadSource values.
+ */
+type SourceSelectLoadSourcesFunction<M = unknown> = Factory<Observable<SourceSelectLoadSource<M>[]>>;
+/**
+ * Source that has a label and an observable of meta values.
+ */
+interface SourceSelectLoadSource<M = unknown> {
+    /**
+     * Label for this source.
+     */
+    readonly label: string;
+    /**
+     * Metadata loaded from this source.
+     */
+    readonly meta: Observable<LoadingState<M[]>>;
+}
+interface SourceSelectLoadSourceLoadingState<M = unknown> extends LoadingState<M[]> {
+    /**
+     * Label for this source.
+     */
+    readonly label: string;
+}
+
+interface SourceSelectFieldProps<T extends PrimativeKey = PrimativeKey, M = unknown> extends FormlyFieldProps$1 {
+    /**
+     * Function to open the source and request values.
+     */
+    readonly openSource?: SourceSelectOpenFunction<M>;
+    /**
+     * Loads the sources to display entries from.
+     */
+    readonly loadSources?: SourceSelectLoadSourcesFunction<M>;
+    /**
+     * Reads the value from a meta value.
+     */
+    readonly valueReader: SourceSelectMetaValueReader<T, M>;
+    /**
+     * Loads metadata for the input values.
+     */
+    readonly metaLoader: SourceSelectValueMetaLoader<T, M>;
+    /**
+     * Used for building a display value given the input.
+     */
+    readonly displayForValue: SourceSelectDisplayFunction<T, M>;
+    /**
+     * Select button icon
+     */
+    readonly selectButtonIcon?: string;
+    /**
+     * Whether or not the selection is as an array.
+     */
+    readonly multiple?: boolean;
+    /**
+     * (Optional) observable that will trigger the clearing of all cached display values.
+     */
+    readonly refreshDisplayValues$?: Observable<unknown>;
+}
+/**
+ * Component that displays a select view (multi or not)
+ */
+declare class DbxFormSourceSelectFieldComponent<T extends PrimativeKey = PrimativeKey, M = unknown> extends FieldType$2<FieldTypeConfig<SourceSelectFieldProps<T, M>>> implements OnInit, OnDestroy {
+    private readonly _cacheMetaSub;
+    private readonly _clearDisplayHashMapSub;
+    private readonly _valueMetaHashMap;
+    private readonly _displayHashMap;
+    private readonly _formControlObs;
+    private readonly _fromOpenSource;
+    private readonly _loadSources;
+    readonly buttonElement: i0.Signal<ElementRef<HTMLElement> | undefined>;
+    readonly formControl$: Observable<AbstractControl<T[], T[], any>>;
+    readonly currentFormControlValue$: Observable<T[]>;
+    readonly values$: Observable<T[]>;
+    readonly allValuesEverSelected$: Observable<T[]>;
+    readonly sourceSelectValuesFromValuesState$: Observable<LoadingState<SourceSelectValue<T, M>[]>>;
+    readonly loadSources$: Observable<LoadingState<SourceSelectValueGroup<T, M>[]>>;
+    readonly fromOpenSource$: Observable<SourceSelectValueGroup<T, M>>;
+    readonly valueGroupsFromSourcesState$: Observable<LoadingStateWithDefinedValue<SourceSelectValueGroup<T, M>[]>>;
+    readonly allValueGroupsState$: Observable<LoadingState<SourceSelectValueGroup<T, M>[]>>;
+    readonly allOptionGroupsState$: Observable<LoadingState<SourceSelectDisplayValueGroup<T, M>[]>>;
+    readonly allOptionGroups$: Observable<SourceSelectDisplayValueGroup<T, M>[]>;
+    readonly options$: Observable<SourceSelectOptions<T, M>>;
+    readonly nonGroupedValues$: Observable<SourceSelectDisplayValue<T, M>[]>;
+    readonly groupedOptions$: Observable<SourceSelectDisplayValueGroup<T, M>[]>;
+    readonly nonGroupedValuesSignal: i0.Signal<SourceSelectDisplayValue<T, M>[] | undefined>;
+    readonly groupedOptionsSignal: i0.Signal<SourceSelectDisplayValueGroup<T, M>[] | undefined>;
+    get sourceSelectField(): SourceSelectFieldProps<T, M>;
+    get openSource(): SourceSelectOpenFunction<M> | undefined;
+    get showOpenSourceButton(): boolean;
+    get loadSources(): SourceSelectLoadSourcesFunction<M> | undefined;
+    get valueReader(): SourceSelectMetaValueReader<T, M>;
+    get metaLoader(): SourceSelectValueMetaLoader<T, M>;
+    get displayForValue(): SourceSelectDisplayFunction<T, M>;
+    get selectButtonIcon(): string;
+    get multiple(): boolean;
+    get refreshDisplayValues$(): Observable<unknown> | undefined;
+    loadSourceSelectValueForValues(values: T[]): Observable<LoadingState<SourceSelectValue<T, M>[]>>;
+    getSourceSelectValueForValues(values: T[]): Observable<SourceSelectValue<T, M>[]>;
+    loadDisplayValuesForSelectValues(values: SourceSelectValue<T, M>[]): Observable<LoadingState<SourceSelectDisplayValue<T, M>[]>>;
+    getDisplayValuesForSelectValues(values: SourceSelectValue<T, M>[]): Observable<SourceSelectDisplayValue<T, M>[]>;
+    readonly context: _dereekb_rxjs.MutableLoadingStateContext<unknown, LoadingState<SourceSelectDisplayValueGroup<T, M>[]>, _dereekb_rxjs.LoadingContextEvent & LoadingState<SourceSelectDisplayValueGroup<T, M>[]>>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    readonly handleSelectOptions: WorkUsingContext<unknown>;
+    private addToOpenSourceMap;
+    private addToCurrentValue;
+    private setCurrentValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormSourceSelectFieldComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormSourceSelectFieldComponent<any, any>, "dbx-form-sourceselectfield", never, {}, {}, never, never, true, never>;
+}
+
+interface SourceSelectFieldConfig<T extends PrimativeKey = PrimativeKey, M = unknown> extends LabeledFieldConfig, DescriptionFieldConfig, MaterialFormFieldConfig, SourceSelectFieldProps<T, M> {
+}
+declare function sourceSelectField<T extends PrimativeKey = PrimativeKey, M = unknown>(config: SourceSelectFieldConfig<T, M>): FormlyFieldConfig;
+
+declare class DbxFormFormlySourceSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlySourceSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlySourceSelectModule, never, [typeof DbxFormSourceSelectFieldComponent, typeof _ngx_formly_core.FormlyModule], [typeof DbxFormSourceSelectFieldComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlySourceSelectModule>;
+}
+
+interface ValueSelectionOptionWithValue<T> extends LabeledValue<T> {
+    disabled?: boolean;
+}
+interface ValueSelectionOptionClear {
+    label?: string;
+    clear: true;
+}
+type ValueSelectionOption<T> = ValueSelectionOptionWithValue<T> | ValueSelectionOptionClear;
+interface ValueSelectionFieldConfig<T> extends LabeledFieldConfig, DescriptionFieldConfig, MaterialFormFieldConfig {
+    /**
+     * Whether or not to use the native select.
+     *
+     * Be sure to import FormlyMatNativeSelectModule.
+     */
+    readonly native?: boolean;
+    /**
+     * Whether or not to add a clear option to the input values.
+     */
+    readonly addClearOption?: string | boolean;
+    /**
+     * Values to select from.
+     */
+    readonly options: ObservableOrValue<ValueSelectionOption<T>[]>;
+    /**
+     * Allow selecting multiple values and return an array.
+     */
+    readonly multiple?: boolean;
+    /**
+     * The select all option configuration.
+     */
+    readonly selectAllOption?: true | string;
+}
+declare function valueSelectionField<T>(config: ValueSelectionFieldConfig<T>): FormlyFieldConfig;
+declare function addValueSelectionOptionFunction<T>(label?: string | undefined): (options: ValueSelectionOption<T>[]) => ValueSelectionOption<T>[];
+
+type TextEditorComponentFieldProps = FormlyFieldProps;
+declare class DbxTextEditorFieldComponent<T extends TextEditorComponentFieldProps = TextEditorComponentFieldProps> extends FieldType$1<FieldTypeConfig<T>> implements OnInit, OnDestroy {
+    private readonly _compactContextStore;
+    private _editor;
+    private readonly _sub;
+    readonly compactClass$: rxjs.Observable<string>;
+    readonly compactClassSignal: i0.Signal<string>;
+    get formGroupName(): string;
+    get formGroup(): FormGroup;
+    get editor(): Editor;
+    get label(): Maybe<string>;
+    get description(): Maybe<string>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTextEditorFieldComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTextEditorFieldComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFormFormlyTextEditorFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyTextEditorFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyTextEditorFieldModule, never, [typeof DbxTextEditorFieldComponent, typeof _ngx_formly_core.FormlyModule], [typeof DbxTextEditorFieldComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyTextEditorFieldModule>;
+}
+
+interface TextFieldLengthConfig {
+    minLength?: number;
+    maxLength?: number;
+}
+interface TextFieldPatternConfig {
+    pattern?: string | RegExp;
+}
+type TextFieldInputType = 'text' | 'password' | 'email';
+interface TextFieldConfig extends LabeledFieldConfig, DescriptionFieldConfig, TextFieldPatternConfig, TextFieldLengthConfig, AttributesFieldConfig, Partial<TransformStringFunctionConfigRef>, MaterialFormFieldConfig {
+    inputType?: TextFieldInputType;
+    transform?: TransformStringFunctionConfig;
+}
+declare function textFieldTransformParser(config: Partial<FieldConfigParsersRef> & Partial<TransformStringFunctionConfigRef>): FormlyValueParser[] | undefined;
+declare function textField(config: TextFieldConfig): FormlyFieldConfig;
+interface TextAreaFieldConfig extends LabeledFieldConfig, DescriptionFieldConfig, TextFieldPatternConfig, TextFieldLengthConfig, AttributesFieldConfig, Partial<TransformStringFunctionConfigRef>, MaterialFormFieldConfig {
+    rows?: number;
+}
+declare function textAreaField(config: TextAreaFieldConfig): FormlyFieldConfig;
+
+interface TextEditorFieldConfig extends LabeledFieldConfig, DescriptionFieldConfig, TextFieldLengthConfig, MaterialFormFieldConfig {
+}
+declare function textEditorField(config: TextEditorFieldConfig): FormlyFieldConfig;
+
+interface DbxFormRepeatArrayPair<T = unknown> extends IndexRef {
+    readonly value?: T | undefined;
+}
+interface DbxFormRepeatArrayFieldConfigPair<T = unknown> extends Partial<DbxFormRepeatArrayPair<T>> {
+    readonly fieldConfig: FormlyFieldConfig;
+}
+type DbxFormRepeatArrayAddTemplateFunction<T> = FactoryWithRequiredInput<Partial<Maybe<T>>, number>;
+interface DbxFormRepeatArrayConfig<T = unknown> extends Pick<FormlyFieldProps, 'maxLength' | 'label' | 'description'> {
+    readonly labelForField?: string | FactoryWithRequiredInput<string, DbxFormRepeatArrayFieldConfigPair<T>>;
+    /**
+     * Text for the add button.
+     */
+    readonly addText?: string;
+    /**
+     * Optional template function to create a new template when using the add button.
+     */
+    readonly addTemplate?: DbxFormRepeatArrayAddTemplateFunction<T>;
+    /**
+     * Text for the duplicate button.
+     */
+    readonly duplicateText?: string;
+    /**
+     * Text for the remove button.
+     */
+    readonly removeText?: string;
+    /**
+     * Whethe or not to disable rearranging items.
+     *
+     * False by default.
+     */
+    readonly disableRearrange?: boolean;
+    /**
+     * Wether or not to show the add button.
+     *
+     * True by default.
+     */
+    readonly allowAdd?: boolean;
+    /**
+     * Whether or not to allow duplicateing items. Can optionally pass a decision function that decides whether or not a specific item can be removed.
+     */
+    readonly allowDuplicate?: boolean | DecisionFunction<DbxFormRepeatArrayPair<T>>;
+    /**
+     * Whether or not to allow removing items. Can optionally pass a decision function that decides whether or not a specific item can be removed.
+     */
+    readonly allowRemove?: boolean | DecisionFunction<DbxFormRepeatArrayPair<T>>;
+    /**
+     * Adds the duplicate to the end of the values
+     */
+    readonly addDuplicateToEnd?: boolean;
+}
+declare class DbxFormRepeatArrayTypeComponent<T = unknown> extends FieldArrayType<FieldArrayTypeConfig<DbxFormRepeatArrayConfig>> {
+    private readonly _labelForField;
+    private readonly _allowRemove;
+    private readonly _allowDuplicate;
+    get repeatArrayField(): DbxFormRepeatArrayConfig;
+    get label(): string;
+    get description(): Maybe<string>;
+    get duplicateText(): string;
+    get addText(): string;
+    get addTemplate(): DbxFormRepeatArrayAddTemplateFunction<unknown> | undefined;
+    get removeText(): string;
+    get max(): Maybe<number>;
+    get count(): number;
+    get disableRearrange(): boolean;
+    get allowAdd(): boolean;
+    get addDuplicateToEnd(): boolean;
+    allowRemove(i: number): boolean;
+    allowDuplicate(i: number): boolean;
+    get addItemDisabled(): boolean;
+    get canAddItem(): boolean;
+    /**
+     * Moves the target index up one value.
+     *
+     * @param index
+     */
+    moveUp(index: number): void;
+    moveDown(index: number): void;
+    addClicked(): void;
+    duplicate(index: number): void;
+    swapIndexes(currentIndex: number, targetIndex: number): void;
+    drop(event: CdkDragDrop<unknown>): void;
+    labelForItem(fieldConfig: FormlyFieldConfig, i: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormRepeatArrayTypeComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormRepeatArrayTypeComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFormFormlyArrayFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyArrayFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyArrayFieldModule, never, [typeof DbxFormRepeatArrayTypeComponent, typeof _ngx_formly_core.FormlyModule], [typeof DbxFormRepeatArrayTypeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyArrayFieldModule>;
+}
+
+interface RepeatArrayFieldConfig<T = unknown> extends DbxFormRepeatArrayConfig<T>, FieldConfig {
+    repeatFieldGroup: ArrayOrValue<FormlyFieldConfig>;
+}
+declare function repeatArrayField<T = unknown>(config: RepeatArrayFieldConfig<T>): {
+    fieldArray: {
+        fieldGroup: FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
+            [additionalProperties: string]: any;
+        }>[];
+    };
+    props: Partial<_ngx_formly_core.FormlyFieldProps> & Partial<FieldConfig> & Partial<_dereekb_dbx_form.LabeledFieldConfig> & Partial<_dereekb_dbx_form.AttributesFieldConfig> & Partial<_dereekb_dbx_form.DescriptionFieldConfig> & {
+        label: string | undefined;
+        description: string | undefined;
+        maxLength: number | undefined;
+        labelForField: string | _dereekb_util.FactoryWithRequiredInput<string, _dereekb_dbx_form.DbxFormRepeatArrayFieldConfigPair<T>> | undefined;
+        addText: string | undefined;
+        addTemplate: _dereekb_dbx_form.DbxFormRepeatArrayAddTemplateFunction<T> | undefined;
+        removeText: string | undefined;
+        duplicateText: string | undefined;
+        disableRearrange: boolean | undefined;
+        allowAdd: boolean | undefined;
+        allowRemove: boolean | _dereekb_util.DecisionFunction<_dereekb_dbx_form.DbxFormRepeatArrayPair<T>> | undefined;
+        allowDuplicate: boolean | _dereekb_util.DecisionFunction<_dereekb_dbx_form.DbxFormRepeatArrayPair<T>> | undefined;
+        addDuplicateToEnd: boolean | undefined;
+    };
+    expressions: ({
+        [property: string]: string | rxjs.Observable<any> | ((field: FormlyFieldConfig) => any);
+    } & {
+        className?: string | rxjs.Observable<string> | ((field: FormlyFieldConfig) => string);
+        hide?: string | rxjs.Observable<boolean> | ((field: FormlyFieldConfig) => boolean);
+        'props.disabled'?: string | rxjs.Observable<boolean> | ((field: FormlyFieldConfig) => boolean);
+        'props.required'?: string | rxjs.Observable<boolean> | ((field: FormlyFieldConfig) => boolean);
+    }) | undefined;
+    parsers: ((value: any) => any)[] | undefined;
+    key: string;
+    type: string;
+};
+
+declare class DbxFormFormlyBooleanFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyBooleanFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyBooleanFieldModule, never, [typeof i1.FormlyMaterialModule, typeof i2.FormlyMatCheckboxModule, typeof i3.FormlyMatToggleModule], [typeof i1.FormlyMaterialModule, typeof i2.FormlyMatCheckboxModule, typeof i3.FormlyMatToggleModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyBooleanFieldModule>;
+}
+
+interface ToggleFieldConfig extends Omit<LabeledFieldConfig, 'placeholder' | 'autocomplete'>, DefaultValueFieldConfig<boolean>, DescriptionFieldConfig, MaterialFormFieldConfig {
+}
+declare function toggleField(config: ToggleFieldConfig): FormlyFieldConfig;
+interface CheckboxFieldConfig extends LabeledFieldConfig, DefaultValueFieldConfig<boolean>, DescriptionFieldConfig, MaterialFormFieldConfig {
+}
+declare function checkboxField(config: CheckboxFieldConfig): FormlyFieldConfig;
+
+/**
+ * A pair of either a logical date or a time string.
+ */
+interface DateTimePresetValue {
+    /**
+     * Logical date to provide.
+     */
+    logicalDate?: Maybe<LogicalDate>;
+    /**
+     * Time string value. Ignored if logical date is provided.
+     */
+    timeString?: Maybe<ReadableTimeString>;
+}
+/**
+ * Configuration for a DateTimePreset
+ */
+interface DateTimePresetConfiguration {
+    /**
+     * Label
+     */
+    label: GetterOrValue<string>;
+    /**
+     * Whether or not the value should be retrieved each time or can be cached.
+     *
+     * Only relevant if a getter is used.
+     */
+    dynamic?: boolean;
+    /**
+     * Logical time to provide.
+     */
+    logicalDate?: Maybe<GetterOrValue<LogicalDate>>;
+    /**
+     * Time string to return. Ignored if logicalDate is provided.
+     */
+    timeString?: Maybe<GetterOrValue<ReadableTimeString>>;
+}
+/**
+ * A label and value getter.
+ */
+interface DateTimePreset {
+    /**
+     * Getter for the label
+     */
+    label: Getter<string>;
+    /**
+     * Getter for the value
+     */
+    value: Getter<DateTimePresetValue>;
+}
+/**
+ * Creates a DateTimePreset from a DateTimePresetConfiguration
+ *
+ * @param config
+ */
+declare function dateTimePreset(config: DateTimePresetConfiguration): DateTimePreset;
+
+declare enum DbxDateTimeValueMode {
+    /**
+     * Value is returned/parsed as a Date.
+     */
+    DATE = 0,
+    /**
+     * Value is returned/parsed as an ISO8601DateString
+     */
+    DATE_STRING = 1,
+    /**
+     * Value is returned/parsed as an ISO8601DayString, relative to the current timezone.
+     */
+    DAY_STRING = 2,
+    /**
+     * Value is returned/parsed as a Unix timestamp, relative to the current timezone.
+     */
+    UNIX_TIMESTAMP = 3,
+    /**
+     * Value is returned/parsed as a minute of the day, relative to the current timezone.
+     */
+    MINUTE_OF_DAY = 4,
+    /**
+     * Value is returned/parsed as a minute of the day, relative to the system timezone.
+     */
+    SYSTEM_MINUTE_OF_DAY = 5
+}
+declare function dbxDateTimeInputValueParseFactory(mode: DbxDateTimeValueMode, timezoneInstance: Maybe<DateTimezoneUtcNormalInstance>): (date: Maybe<Date | string | number>) => Maybe<Date>;
+declare function dbxDateTimeOutputValueFactory(mode: DbxDateTimeValueMode, timezoneInstance: Maybe<DateTimezoneUtcNormalInstance>): (date: Maybe<Date>) => Maybe<Date | string | number>;
+declare function dbxDateTimeIsSameDateTimeFieldValue(a: Maybe<Date | ISO8601DayString | number>, b: Maybe<Date | ISO8601DayString | number>): boolean;
+declare function dbxDateRangeIsSameDateRangeFieldValue(a: Maybe<DateRangeWithDateOrStringValue>, b: Maybe<DateRangeWithDateOrStringValue>): boolean;
+
+declare enum DbxDateTimeFieldTimeMode {
+    /**
+     * Time is required.
+     */
+    REQUIRED = "required",
+    /**
+     * Time is optional.
+     */
+    OPTIONAL = "optional",
+    /**
+     * Time is permenantly off.
+     */
+    NONE = "none"
+}
+type DbxDateTimePickerConfiguration = Omit<DateTimeMinuteConfig, 'date'>;
+type DbxDateTimeFieldSyncType = 'before' | 'after';
+interface DbxDateTimeFieldSyncField {
+    /**
+     * Field key/path to sync with/against.
+     */
+    readonly syncWith: string;
+    /**
+     * How to sync against the other field.
+     */
+    readonly syncType: DbxDateTimeFieldSyncType;
+}
+/**
+ * Configuration for the time date field that has a reference and optional map function to map the value.
+ */
+interface DbxDateTimeFieldTimeDateConfig<I = unknown> {
+    readonly path: FormControlPath;
+    readonly mapValue?: MapFunction<I, Maybe<DateOrDayString>>;
+}
+declare function isDbxDateTimeFieldTimeDateConfig(input: unknown): input is DbxDateTimeFieldTimeDateConfig;
+interface DbxDateTimeFieldProps extends FormlyFieldProps {
+    /**
+     * Custom date label.
+     *
+     * Defaults to Date
+     */
+    readonly dateLabel?: string;
+    /**
+     * Custom time label.
+     *
+     * Defaults to Time
+     */
+    readonly timeLabel?: string;
+    /**
+     * Label to use for the date hint for "All Day". Defaults to "All Day".
+     */
+    readonly allDayLabel?: string;
+    /**
+     * Label to use for the date hint for "At". Defaults to "At".
+     */
+    readonly atTimeLabel?: string;
+    /**
+     * Value mode.
+     *
+     * Defaults to DATE
+     */
+    readonly valueMode?: DbxDateTimeValueMode;
+    /**
+     * Whether or not the date is hidden, and automatically uses today/input date.
+     */
+    readonly timeOnly?: boolean;
+    /**
+     * Only applicable when timeOnly is false.
+     *
+     * Whether or not to always show the date input even when there is only a single date that can be selected.
+     *
+     * Defaults to true.
+     */
+    readonly alwaysShowDateInput?: boolean;
+    /**
+     * Whether or not to autofill the date when time is picked.
+     *
+     * Defaults to false.
+     */
+    readonly autofillDateWhenTimeIsPicked?: boolean;
+    /**
+     * Whether or not the time can be added/removed optionally.
+     *
+     * This is ignored if timeOnly is specified.
+     */
+    readonly timeMode?: DbxDateTimeFieldTimeMode;
+    /**
+     * Other form control 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.
+     */
+    readonly fullDayFieldName?: string;
+    /**
+     * Whether or not to pass the date value as a UTC date, or a date in the current timezone.
+     */
+    readonly fullDayInUTC?: boolean;
+    /**
+     * Whether or not ot hide the date hint info content.
+     *
+     * False by default
+     */
+    readonly hideDateHint?: boolean;
+    /**
+     * Whether or not to hide the date/calendar picker.
+     */
+    readonly hideDatePicker?: boolean;
+    /**
+     * Custom picker configuration
+     */
+    readonly pickerConfig?: ObservableOrValueGetter<DbxDateTimePickerConfiguration>;
+    /**
+     * Used for syncing with one or more fields with a Date value.
+     */
+    readonly getSyncFieldsObs?: () => Observable<ArrayOrValue<DbxDateTimeFieldSyncField>>;
+    /**
+     * (Optional) The input timezone to default to.
+     *
+     * Ignored if fullDayInUTC is true.
+     */
+    readonly timezone?: Maybe<ObservableOrValueGetter<Maybe<TimezoneString>>>;
+    /**
+     * (Optional) The date to apply the time to.
+     *
+     * The timezone abbrviation will also use this date when using the time-only mode.
+     */
+    readonly timeDate?: Maybe<ObservableOrValueGetter<Maybe<DbxDateTimeFieldTimeDateConfig | FormControlPath | DateOrDayString>>>;
+    /**
+     * Whether or not to display the timezone. True by default.
+     */
+    readonly showTimezone?: Maybe<boolean>;
+    /**
+     * Custom presets to show in the dropdown.
+     */
+    readonly presets?: ObservableOrValueGetter<DateTimePresetConfiguration[]>;
+    /**
+     * The time in ms to prevent output from going out when the input value changes.
+     */
+    readonly inputOutputDebounceTime?: Milliseconds;
+    /**
+     * Whether or not to display the clear date button. True by default.
+     */
+    readonly showClearButton?: Maybe<boolean>;
+    /**
+     * The number of minutes to add/subtract when using the arrow keys.
+     */
+    readonly minuteStep?: Maybe<number>;
+}
+interface DbxDateTimeFieldSyncParsedField extends Pick<DbxDateTimeFieldSyncField, 'syncType'> {
+    readonly control: AbstractControl<Maybe<Date | ISO8601DateString>>;
+}
+declare function syncConfigValueObs(parseConfigsObs: Observable<DbxDateTimeFieldSyncParsedField[]>, type: DbxDateTimeFieldSyncType): Observable<Date | null>;
+/**
+ * Error code used when the selected date is not in the schedule.
+ */
+declare const DBX_DATE_TIME_FIELD_DATE_NOT_IN_SCHEDULE_ERROR = "dateTimeFieldDateNotInSchedule";
+/**
+ * Error code used when the selected time/time input is not in the limited range.
+ */
+declare const DBX_DATE_TIME_FIELD_TIME_NOT_IN_RANGE_ERROR = "dateTimeFieldTimeNotInRange";
+declare class DbxDateTimeFieldComponent extends FieldType$1<FieldTypeConfig<DbxDateTimeFieldProps>> implements OnInit, OnDestroy {
+    private readonly dbxDateTimeFieldConfigService;
+    private readonly _sub;
+    private readonly _valueSub;
+    private readonly _autoFillDateSync;
+    private readonly _config;
+    readonly latestConfig$: Observable<Maybe<DbxDateTimePickerConfiguration>>;
+    private readonly _syncConfigObs;
+    private readonly _defaultTimezone;
+    private readonly _timeDate;
+    private readonly _presets;
+    /**
+     * Alternative/backup full day control if not defined in the Formly form.
+     */
+    private readonly _fullDayInputCtrl;
+    private readonly _fullDayControlObs;
+    readonly fullDayControl$: Observable<AbstractControl<boolean, boolean, any>>;
+    private readonly _offset;
+    private readonly _formControlObs;
+    readonly formControl$: Observable<AbstractControl<Maybe<Date>, Maybe<Date>, any>>;
+    private readonly _cleared;
+    private readonly _updateTime;
+    private readonly _resyncTimeInputSub;
+    private readonly _resyncTimeInput;
+    readonly timeErrorStateMatcher: ErrorStateMatcher;
+    readonly resyncTimeInput$: Observable<void>;
+    private readonly _configUpdateTimeSync;
+    readonly timezone$: Observable<Maybe<TimezoneString>>;
+    readonly timezoneInstance$: Observable<Maybe<DateTimezoneUtcNormalInstance>>;
+    readonly timeDate$: Observable<Maybe<Date>>;
+    readonly valueInSystemTimezone$: Observable<Maybe<Date>>;
+    readonly refreshInteral$: Observable<number>;
+    /**
+     * Used to trigger/display visual updates (specifically on timeDistance, etc.).
+     */
+    readonly displayValue$: Observable<Maybe<Date>>;
+    readonly timeString$: Observable<ReadableTimeString | ''>;
+    readonly dateInputCtrl: FormControl<Maybe<Date>>;
+    readonly timeInputCtrl: FormControl<Maybe<string>>;
+    get dateLabel(): string;
+    get timeLabel(): string;
+    get allDayLabel(): string;
+    get atTimeLabel(): string;
+    get dateOnly(): boolean;
+    get dateTimeField(): DbxDateTimeFieldProps;
+    get timeOnly(): Maybe<boolean>;
+    get alwaysShowDateInput(): boolean;
+    get autofillDateWhenTimeIsPicked(): boolean;
+    get showDateInput(): boolean;
+    get valueMode(): DbxDateTimeValueMode;
+    get timeMode(): DbxDateTimeFieldTimeMode;
+    get isDateRequired(): boolean;
+    get isTimeRequired(): boolean;
+    get description(): Maybe<string>;
+    get hideDateHint(): boolean;
+    get hideDatePicker(): boolean;
+    get timezone(): Maybe<ObservableOrValueGetter<Maybe<string>>>;
+    get timeDate(): Maybe<ObservableOrValueGetter<Maybe<DateOrDayString | DbxDateTimeFieldTimeDateConfig<unknown>>>>;
+    get showTimezone(): boolean;
+    get presets(): ObservableOrValueGetter<DateTimePresetConfiguration[]> | undefined;
+    get showClearButton(): Maybe<boolean>;
+    get minuteStep(): number;
+    readonly fullDay$: Observable<boolean>;
+    readonly showTimeInput$: Observable<boolean>;
+    readonly showAddTime$: Observable<boolean>;
+    readonly currentDate$: Observable<Maybe<Date>>;
+    readonly date$: Observable<Date>;
+    readonly timezoneAbbreviation$: Observable<string>;
+    readonly dateValue$: Observable<Maybe<Date>>;
+    readonly timeInput$: Observable<ReadableTimeString>;
+    readonly syncConfigObs$: Observable<Maybe<DbxDateTimeFieldSyncField | DbxDateTimeFieldSyncField[]>>;
+    readonly parsedSyncConfigs$: Observable<DbxDateTimeFieldSyncParsedField[]>;
+    readonly syncConfigBeforeValue$: Observable<Date | null>;
+    readonly syncConfigAfterValue$: Observable<Date | null>;
+    readonly isTimeCleared$: Observable<boolean>;
+    protected readonly _rawDateTimeDateValue$: Observable<Maybe<Date>>;
+    protected readonly _rawDateTimeTimeValue$: Observable<Maybe<ReadableTimeString>>;
+    readonly rawDateTime$: Observable<Maybe<Date>>;
+    readonly dateTimePickerConfig$: Observable<Maybe<DbxDateTimePickerConfiguration>>;
+    readonly dateInputMin$: Observable<Date | null>;
+    readonly dateInputMax$: Observable<Date | null>;
+    /**
+     * Whether or not there is a limited min/max date range applied/available.
+     */
+    readonly hasRestrictedDateRange$: Observable<boolean>;
+    readonly dateMinAndMaxIsSameDay$: Observable<boolean>;
+    readonly pickerFilter$: Observable<DecisionFunction<Date | null>>;
+    readonly defaultPickerFilter: DecisionFunction<Date | null>;
+    readonly timeOutput$: Observable<Maybe<Date>>;
+    readonly dateTimePickerInstance$: Observable<DateTimeMinuteInstance>;
+    readonly hasEmptyDisplayValue$: Observable<boolean>;
+    readonly allPresets$: Observable<DateTimePreset[]>;
+    readonly _presetsPickerFilter$: Observable<(x: Date | null) => boolean>;
+    readonly presets$: Observable<DateTimePreset[]>;
+    readonly showClearButton$: Observable<boolean>;
+    readonly canAutofillDateWithOnlyAvailableDate$: Observable<boolean>;
+    readonly showDateInput$: Observable<boolean>;
+    readonly currentErrorMessage$: Observable<string | undefined>;
+    readonly hasError$: Observable<boolean>;
+    readonly dateValueSignal: i0.Signal<Maybe<Date>>;
+    readonly displayValueSignal: i0.Signal<Maybe<Date>>;
+    readonly pickerFilterSignal: i0.Signal<DecisionFunction<Date | null>>;
+    readonly dateInputMinSignal: i0.Signal<Date | null>;
+    readonly dateInputMaxSignal: i0.Signal<Date | null>;
+    readonly showDateInputSignal: i0.Signal<boolean | undefined>;
+    readonly showTimeInputSignal: i0.Signal<boolean | undefined>;
+    readonly showAddTimeSignal: i0.Signal<boolean | undefined>;
+    readonly fullDaySignal: i0.Signal<boolean | undefined>;
+    readonly timezoneAbbreviationSignal: i0.Signal<string | undefined>;
+    readonly hasEmptyDisplayValueSignal: i0.Signal<boolean | undefined>;
+    readonly currentErrorMessageSignal: i0.Signal<string | undefined>;
+    readonly showClearButtonSignal: i0.Signal<boolean | undefined>;
+    readonly presetsSignal: i0.Signal<DateTimePreset[] | undefined>;
+    readonly hasErrorSignal: i0.Signal<boolean | undefined>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    selectPreset(preset: DateTimePreset): void;
+    datePicked(event: MatDatepickerInputEvent<Date>): void;
+    setLogicalTime(time: LogicalDate): void;
+    setDateInputValue(date: Date): void;
+    setTimeFromDate(timeDate: Date): void;
+    setTime(time: ReadableTimeString): void;
+    keydownOnDateInput(event: KeyboardEvent): void;
+    keydownOnTimeInput(event: KeyboardEvent): void;
+    focusTime(): void;
+    focusOutTime(): void;
+    addTime(): void;
+    removeTime(): void;
+    setFullDay(fullDay: boolean): void;
+    clearValue(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxDateTimeFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxDateTimeFieldComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+type DbxFixedDateRangeDateRangeInput = Omit<DateRangeInput, 'date'>;
+type DbxFixedDateRangePickerConfiguration = Omit<DateTimeMinuteConfig, 'date'>;
+type DbxFixedDateRangeSelectionMode = 'single' | 'normal' | 'arbitrary' | 'arbitrary_quick';
+type DbxFixedDateRangePicking = 'start' | 'end';
+interface DbxFixedDateRangeFieldProps extends FormlyFieldProps {
+    /**
+     * Date range input to build the date range.
+     */
+    readonly dateRangeInput: ObservableOrValueGetter<DbxFixedDateRangeDateRangeInput>;
+    /**
+     * Selection mode to use when picking dates on the calendar.
+     */
+    readonly selectionMode?: Maybe<ObservableOrValueGetter<DbxFixedDateRangeSelectionMode>>;
+    /**
+     * Value mode for the dates in the output DateRange.
+     *
+     * Defaults to DATE
+     */
+    readonly valueMode?: DbxDateTimeValueMode;
+    /**
+     * Whether or not to pass the date value as a UTC date, or a date in the current timezone.
+     */
+    readonly fullDayInUTC?: boolean;
+    /**
+     * Custom picker configuration
+     */
+    readonly pickerConfig?: ObservableOrValueGetter<DbxFixedDateRangePickerConfiguration>;
+    /**
+     * (Optional) The input timezone to default to.
+     *
+     * Ignored if fullDayInUTC is true.
+     */
+    readonly timezone?: Maybe<ObservableOrValueGetter<Maybe<TimezoneString>>>;
+    /**
+     * Whether or not to display the timezone. True by default.
+     */
+    readonly showTimezone?: boolean;
+    /**
+     * Custom presets to show in the dropdown.
+     */
+    readonly presets?: ObservableOrValueGetter<DateTimePresetConfiguration[]>;
+    /**
+     * Whether or not to show the range input. Defaults to true.
+     */
+    readonly showRangeInput?: boolean;
+}
+type FixedDateRangeScanType = 'start' | 'end' | 'startRepeat';
+interface FixedDateRangeScan {
+    /**
+     * Picked the start or end of the range on the last pick.
+     */
+    readonly lastPickType?: Maybe<FixedDateRangeScanType>;
+    /**
+     * The latest date passed, if applicable.
+     */
+    readonly lastDateRange?: Maybe<Partial<DateRange>>;
+    /**
+     * The generated boundary range.
+     */
+    readonly boundary?: DateRange;
+    /**
+     * New Date Range
+     */
+    readonly range?: DateRange;
+}
+type SelectedDateEventType = 'calendar' | 'input';
+declare class DbxFixedDateRangeFieldComponent extends FieldType$1<FieldTypeConfig<DbxFixedDateRangeFieldProps>> implements OnInit, OnDestroy {
+    private readonly dbxDateTimeFieldMenuPresetsService;
+    readonly calendar: i0.Signal<MatCalendar<Date>>;
+    readonly startDateInputElement: i0.Signal<ElementRef<any> | undefined>;
+    readonly endDateInputElement: i0.Signal<ElementRef<any> | undefined>;
+    readonly currentDateRangeInputSignal: i0.WritableSignal<Maybe<DbxFixedDateRangeDateRangeInput>>;
+    readonly currentSelectionModeSignal: i0.WritableSignal<DbxFixedDateRangeSelectionMode>;
+    private readonly _sub;
+    private readonly _inputRangeFormSub;
+    private readonly _inputRangeFormValueSub;
+    private readonly _dateRangeInputSub;
+    private readonly _currentSelectionModeSub;
+    private readonly _latestBoundarySub;
+    private readonly _disableEndSub;
+    private readonly _activeDateSub;
+    private readonly _config;
+    private readonly _selectionMode;
+    private readonly _dateRangeInput;
+    private readonly _timezone;
+    private readonly _presets;
+    private readonly _selectionEvent;
+    readonly selectedDateRange$: Observable<Maybe<Partial<DateRange>>>;
+    private readonly _formControlObs;
+    readonly formControl$: Observable<AbstractControl<Maybe<DateRange>, Maybe<DateRange>, any>>;
+    readonly config$: Observable<DbxFixedDateRangePickerConfiguration>;
+    readonly limitDateTimeInstance$: Observable<_dereekb_date.LimitDateTimeInstance>;
+    readonly selectionMode$: Observable<DbxFixedDateRangeSelectionMode>;
+    readonly dateRangeInput$: Observable<Maybe<DbxFixedDateRangeDateRangeInput>>;
+    readonly timezone$: Observable<Maybe<TimezoneString>>;
+    readonly timezoneInstance$: Observable<Maybe<DateTimezoneUtcNormalInstance>>;
+    readonly valueInSystemTimezone$: Observable<Maybe<DateRange>>;
+    dateRangeSelectionForMode(mode: DbxFixedDateRangeSelectionMode): Observable<Maybe<DateRange>>;
+    readonly fullBoundary$: Observable<Maybe<DateRange>>;
+    readonly latestBoundary$: Observable<Maybe<DateRange>>;
+    /**
+     * Focuses on the date any time the selection event from the picker occured, otherwise use the system value
+     */
+    readonly calendarFocusDate$: Observable<Date>;
+    readonly dateRangeSelection$: Observable<Maybe<DateRange>>;
+    readonly calendarSelection$: Observable<DateRange$1<Date> | null>;
+    readonly endDisabled$: Observable<boolean>;
+    readonly inputRangeForm: FormGroup<{
+        start: FormControl<Maybe<Date>>;
+        end: FormControl<Maybe<Date>>;
+    }>;
+    get fixedDateRangeField(): DbxFixedDateRangeFieldProps;
+    get selectionMode(): Maybe<ObservableOrValueGetter<DbxFixedDateRangeSelectionMode>>;
+    get valueMode(): DbxDateTimeValueMode;
+    get description(): Maybe<string>;
+    get timezone(): Maybe<ObservableOrValueGetter<Maybe<string>>>;
+    get showTimezone(): boolean;
+    get presets(): ObservableOrValueGetter<DateTimePresetConfiguration[]> | undefined;
+    get showRangeInput(): boolean;
+    readonly minMaxRange$: Observable<Maybe<Partial<DateRange>>>;
+    readonly min$: Observable<Date | null>;
+    readonly max$: Observable<Date | null>;
+    readonly pickerFilter$: Observable<DecisionFunction<Date | null>>;
+    readonly defaultPickerFilter: DecisionFunction<Date | null>;
+    readonly minDateSignal: i0.Signal<Date | null>;
+    readonly maxDateSignal: i0.Signal<Date | null>;
+    readonly endDisabledSignal: i0.Signal<boolean | undefined>;
+    readonly latestBoundarySignal: i0.Signal<Maybe<DateRange>>;
+    readonly calendarSelectionSignal: i0.Signal<DateRange$1<Date> | null>;
+    readonly pickerFilterSignal: i0.Signal<DecisionFunction<Date | null>>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    selectedChange(date: Maybe<Date>): void;
+    setDateRange(range: Maybe<Partial<DateRange>>, type: SelectedDateEventType): void;
+    _createDateRange(date: Maybe<Date>): Maybe<DateRange>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFixedDateRangeFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFixedDateRangeFieldComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+declare class DbxFixedDateRangeFieldSelectionStrategy<D> implements MatDateRangeSelectionStrategy<D> {
+    private readonly _dateAdapter;
+    readonly dbxFixedDateRangeFieldComponent: DbxFixedDateRangeFieldComponent;
+    selectionFinished(date: D | null, currentRange: DateRange$1<D>, event: Event): DateRange$1<D>;
+    createPreview(activeDate: D | null, currentRange: DateRange$1<D>, event: Event): DateRange$1<D>;
+    private _createDateRangeWithDate;
+    private _createDateRange;
+    dateFromAdapterDate(input: D): Date;
+    adapterDateFromDate(date: Date): D;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFixedDateRangeFieldSelectionStrategy<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFixedDateRangeFieldSelectionStrategy<any>>;
+}
+
+declare class DbxFormFormlyDateFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyDateFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyDateFieldModule, never, [typeof DbxDateTimeFieldComponent, typeof DbxFixedDateRangeFieldComponent, typeof DbxFormFormlyWrapperModule, typeof _ngx_formly_core.FormlyModule], [typeof DbxDateTimeFieldComponent, typeof DbxFixedDateRangeFieldComponent, typeof DbxFormFormlyWrapperModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyDateFieldModule>;
+}
+
+interface DateTimeFieldConfig extends LabeledFieldConfig, DescriptionFieldConfig, DbxDateTimeFieldProps, MaterialFormFieldConfig {
+}
+type TimeFieldConfig = Omit<DateTimeFieldConfig, 'showDate' | 'timeOnly'>;
+declare const TAKE_NEXT_UPCOMING_TIME_CONFIG_OBS: () => Observable<DbxDateTimePickerConfiguration>;
+/**
+ * Same as DateTime field but with the Date input hidden by default.
+ */
+declare function timeOnlyField(config?: Partial<TimeFieldConfig>): FormlyFieldConfig;
+declare function dateTimeField(config?: Partial<DateTimeFieldConfig>): FormlyFieldConfig<DbxDateTimeFieldProps>;
+type DateDateRangeFieldDateConfig = Omit<DateTimeFieldConfig, 'dateLabel' | 'timeOnly' | 'timeMode' | 'getSyncFieldsObs'>;
+interface DateDateRangeFieldConfig extends Pick<DateTimeFieldConfig, 'timeDate' | 'timezone' | 'showTimezone' | 'presets' | 'valueMode' | 'minuteStep'> {
+    required?: boolean;
+    start?: Partial<DateDateRangeFieldDateConfig>;
+    end?: Partial<DateDateRangeFieldDateConfig>;
+}
+declare function dateRangeField(config?: DateDateRangeFieldConfig): FormlyFieldConfig;
+type DateTimeRangeFieldTimeConfig = Omit<DateDateRangeFieldDateConfig, 'allDayLabel' | 'fullDayFieldName' | 'fullDayInUTC'>;
+interface DateDateTimeRangeFieldConfig extends Pick<DateTimeFieldConfig, 'timeDate' | 'timezone' | 'showTimezone' | 'presets' | 'valueMode' | 'minuteStep'> {
+    required?: boolean;
+    start?: Partial<DateTimeRangeFieldTimeConfig>;
+    end?: Partial<DateTimeRangeFieldTimeConfig>;
+}
+declare function dateTimeRangeField(inputConfig?: DateDateTimeRangeFieldConfig): FormlyFieldConfig;
+interface FixedDateRangeFieldConfig extends LabeledFieldConfig, DescriptionFieldConfig, DbxFixedDateRangeFieldProps, MaterialFormFieldConfig {
+}
+declare function fixedDateRangeField(config?: Partial<FixedDateRangeFieldConfig>): FormlyFieldConfig<DbxDateTimeFieldProps>;
+
+declare const DBX_DATE_TIME_FIELD_MENU_PRESETS_TOKEN: InjectionToken<unknown>;
+declare class DbxDateTimeFieldMenuPresetsService {
+    private readonly _configurations;
+    readonly configurations$: rxjs.Observable<DateTimePresetConfiguration[]>;
+    get configurations(): DateTimePresetConfiguration[];
+    set configurations(configurations: DateTimePresetConfiguration[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxDateTimeFieldMenuPresetsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxDateTimeFieldMenuPresetsService>;
+}
+
+declare const DEFAULT_DATE_TIME_FIELD_MENU_PRESETS_PRESETS: DateTimePresetConfiguration[];
+
+interface NumberFieldNumberConfig {
+    readonly min?: number;
+    readonly max?: number;
+    readonly step?: number;
+    readonly enforceStep?: boolean;
+}
+type NumberFieldInputType = 'number';
+interface NumberFieldConfig extends LabeledFieldConfig, DescriptionFieldConfig, NumberFieldNumberConfig, AttributesFieldConfig, Partial<TransformNumberFunctionConfigRef>, MaterialFormFieldConfig {
+    readonly inputType?: NumberFieldInputType;
+}
+declare function numberFieldTransformParser(config: Partial<FieldConfigParsersRef> & Partial<TransformNumberFunctionConfigRef>): FormlyValueParser[] | undefined;
+declare function numberField(config: NumberFieldConfig): FormlyFieldConfig;
+interface NumberSliderFieldConfig extends NumberFieldConfig {
+    /**
+     * Max value. Required for the slider.
+     */
+    readonly max: number;
+    /**
+     * Whether or not to show the thumb label while sliding.
+     *
+     * Defaults to true.
+     *
+     * Corresponds to "discrete" in Material.
+     */
+    readonly thumbLabel?: boolean;
+    /**
+     * Whether or not to invert the selection line.
+     */
+    readonly invertSelectionColoring?: boolean;
+    /**
+     * Tick interval. If not provided defaults to the step value, if provided. If false, the ticks are disabled.
+     *
+     * The tick interval is the number of "steps" to show between ticks.
+     *
+     * For example, a tick interval of 5 show a tick every 5 steps. If steps are 10, it will show a tick at every number divisible by 50 (5 * 10).
+     */
+    readonly tickInterval?: false | number;
+    /**
+     * Custom display with function for the thumbLabel.
+     */
+    readonly displayWith?: (value: number) => string;
+}
+declare function numberSliderField(config: NumberSliderFieldConfig): FormlyFieldConfig;
+type DollarAmountFieldConfig = Omit<NumberFieldConfig, 'roundToStep' | 'precision'>;
+declare function dollarAmountField(config: DollarAmountFieldConfig): FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
+    [additionalProperties: string]: any;
+}>;
+
+declare class DbxFormFormlyNumberFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyNumberFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyNumberFieldModule, never, [typeof i1.FormlyMaterialModule, typeof i2$1.FormlyMatSliderModule], [typeof i1.FormlyMaterialModule, typeof i2$1.FormlyMatSliderModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyNumberFieldModule>;
+}
+
+interface InternationalPhoneFormlyFieldProps extends FormlyFieldProps {
+    readonly preferredCountries?: Maybe<string[]>;
+    readonly onlyCountries?: Maybe<string[]>;
+    /**
+     * Whether or not to enable the search feature. True by default.
+     */
+    readonly enableSearch?: boolean;
+    /**
+     * Whether or not to allow adding an extension. False by default.
+     */
+    readonly allowExtension?: boolean;
+}
+declare const DEFAULT_PREFERRED_COUNTRIES: string[];
+declare class DbxPhoneFieldComponent extends FieldType$1<FieldTypeConfig<InternationalPhoneFormlyFieldProps>> implements OnInit, OnDestroy {
+    readonly inputSync: SubscriptionObject<rxjs.Unsubscribable>;
+    readonly outputSync: SubscriptionObject<rxjs.Unsubscribable>;
+    readonly extensionErrorSync: SubscriptionObject<rxjs.Unsubscribable>;
+    readonly phoneErrorSync: SubscriptionObject<rxjs.Unsubscribable>;
+    readonly phoneCtrl: FormControl<string | null>;
+    readonly extensionCtrl: FormControl<string | null>;
+    readonly inputFormGroup: FormGroup<{
+        phone: FormControl<string | null>;
+        extension: FormControl<string | null>;
+    }>;
+    get enableSearch(): boolean;
+    get preferredCountries(): string[];
+    get onlyCountries(): string[];
+    get allowExtension(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxPhoneFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxPhoneFieldComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxFormFormlyPhoneFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyPhoneFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyPhoneFieldModule, never, [typeof DbxPhoneFieldComponent, typeof _ngx_formly_core.FormlyModule], [typeof DbxPhoneFieldComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyPhoneFieldModule>;
+}
+
+interface InternationalPhoneFieldConfig extends LabeledFieldConfig, InternationalPhoneFormlyFieldProps {
+}
+declare function phoneField(config?: Partial<InternationalPhoneFieldConfig>): FormlyFieldConfig<InternationalPhoneFormlyFieldProps>;
+interface WrappedPhoneAndLabelFieldConfig {
+    readonly phoneField?: Partial<InternationalPhoneFieldConfig>;
+    readonly labelField?: TextFieldConfig;
+}
+/**
+ * Puts a phone and
+ * @param param0
+ * @returns
+ */
+declare function wrappedPhoneAndLabelField({ phoneField: phone, labelField: label }?: WrappedPhoneAndLabelFieldConfig): FormlyFieldConfig;
+interface PhoneAndLabelFieldSectionConfig extends DbxFormSectionConfig, WrappedPhoneAndLabelFieldConfig {
+    readonly key?: string;
+}
+declare function phoneAndLabelSectionField({ key, header, hint, phoneField, labelField }?: PhoneAndLabelFieldSectionConfig): FormlyFieldConfig;
+interface PhoneListFieldConfig extends Omit<RepeatArrayFieldConfig, 'repeatFieldGroup'> {
+    phoneAndLabel?: WrappedPhoneAndLabelFieldConfig;
+    repeatFieldGroup?: FormlyFieldConfig[];
+}
+declare function phoneListField(repeatConfig?: Partial<PhoneListFieldConfig>): FormlyFieldConfig;
+
+declare const PHONE_LABEL_MAX_LENGTH = 100;
+declare const LABEL_STRING_MAX_LENGTH = 100;
+declare const SEARCH_STRING_MAX_LENGTH = 100;
+declare function nameField(config?: Partial<TextFieldConfig>): FormlyFieldConfig;
+interface EmailFieldConfig extends Partial<LabeledFieldConfig>, DescriptionFieldConfig {
+    readonly rows?: number;
+}
+declare function emailField(config?: EmailFieldConfig): FormlyFieldConfig;
+type CityFieldConfig = Partial<TextFieldConfig>;
+declare function cityField(config?: CityFieldConfig): FormlyFieldConfig;
+interface StateFieldConfig extends Partial<TextFieldConfig> {
+    readonly asCode?: boolean;
+}
+declare function stateField(config?: StateFieldConfig): FormlyFieldConfig;
+type CountryFieldConfig = Partial<TextFieldConfig>;
+declare function countryField(config?: CountryFieldConfig): FormlyFieldConfig;
+type ZipCodeFieldConfig = Partial<TextFieldConfig>;
+declare function zipCodeField(config?: ZipCodeFieldConfig): FormlyFieldConfig;
+declare const DEFAULT_LAT_LNG_TEXT_FIELD_PLACEHOLDER = "12.345,-67.8910";
+declare const DEFAULT_LAT_LNG_TEXT_FIELD_PATTERN_MESSAGE = "Invalid/unknown coordinates";
+declare function latLngTextField({ key }?: Partial<TextFieldConfig>): FormlyFieldConfig;
+
+interface AddressFormlyFieldsConfig {
+    readonly line1Field?: CityFieldConfig;
+    readonly line2Field?: CityFieldConfig;
+    readonly cityField?: CityFieldConfig;
+    readonly stateField?: StateFieldConfig;
+    readonly zipCodeField?: ZipCodeFieldConfig;
+    readonly countryField?: CountryFieldConfig;
+    /**
+     * Whether or not to make required fields required.
+     *
+     * True by default.
+     */
+    readonly required?: boolean;
+    /**
+     * Whether or not to include the second address line.
+     *
+     * True by default.
+     */
+    readonly includeLine2?: boolean;
+    /**
+     * Whether or not to include the country.
+     *
+     * True by default.
+     */
+    readonly includeCountry?: boolean;
+}
+interface AddressLineFieldConfig extends Partial<TextFieldConfig> {
+    readonly line?: 0 | 1 | 2;
+}
+declare function addressLineField(config?: AddressLineFieldConfig): FormlyFieldConfig;
+declare function addressFormlyFields(config?: AddressFormlyFieldsConfig): FormlyFieldConfig[];
+interface AddressFieldConfig extends Readonly<FieldConfig>, DbxFormSectionConfig, AddressFormlyFieldsConfig {
+}
+declare function addressField(config?: Partial<AddressFieldConfig>): FormlyFieldConfig;
+interface AddressListFieldConfig extends Readonly<FieldConfig>, AddressFormlyFieldsConfig {
+    readonly maxAddresses?: number;
+}
+declare function addressListField(config?: Partial<AddressListFieldConfig>): FormlyFieldConfig;
+
+declare class DbxFormFormlyTextFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyTextFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyTextFieldModule, never, [typeof DbxFormFormlyArrayFieldModule, typeof i1.FormlyMaterialModule, typeof i3$1.FormlyMatInputModule, typeof DbxFormFormlyWrapperModule], [typeof DbxFormFormlyArrayFieldModule, typeof i1.FormlyMaterialModule, typeof i3$1.FormlyMatInputModule, typeof DbxFormFormlyWrapperModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyTextFieldModule>;
+}
+
+type HiddenFieldConfig = Pick<LabeledFieldConfig, 'key' | 'required'>;
+declare function hiddenField({ key, required }: HiddenFieldConfig): FormlyFieldConfig;
+
+type WrapperFormlyFieldConfig<P, C extends FormlyFieldConfig> = FormlyFieldConfig<P> & {
+    wrappers: string[];
+    props: P;
+    fieldGroup: [C];
+};
+declare function addWrapperToFormlyFieldConfig<C extends FormlyFieldConfig, P extends object>(fieldConfig: C, wrapperKey: string, wrapperProps: P): WrapperFormlyFieldConfig<P, C>;
+declare function autoTouchWrapper<T extends object, C extends FormlyFieldConfig>(fieldConfig: C, autoTouchWrapper?: DbxFormExpandWrapperConfig<T>): WrapperFormlyFieldConfig<DbxFormExpandWrapperConfig<T>, C>;
+declare function expandWrapper<T extends object, C extends FormlyFieldConfig>(fieldConfig: C, expandWrapper?: DbxFormExpandWrapperConfig<T>): WrapperFormlyFieldConfig<DbxFormExpandWrapperConfig<T>, C>;
+declare function toggleWrapper<C extends FormlyFieldConfig>(fieldConfig: C, toggleWrapper?: DbxFormToggleWrapperConfig): WrapperFormlyFieldConfig<DbxFormToggleWrapperConfig<object>, C>;
+declare function sectionWrapper<C extends FormlyFieldConfig>(fieldConfig: C, sectionWrapper?: DbxFormSectionConfig): WrapperFormlyFieldConfig<_dereekb_dbx_web.DbxSectionHeaderConfig, C>;
+declare function subsectionWrapper<C extends FormlyFieldConfig>(fieldConfig: C, subsectionWrapper?: DbxFormSubsectionConfig): WrapperFormlyFieldConfig<_dereekb_dbx_web.DbxSectionHeaderConfig, C>;
+declare function infoWrapper<C extends FormlyFieldConfig>(fieldConfig: C, infoWrapper: DbxFormInfoConfig): WrapperFormlyFieldConfig<DbxFormInfoConfig, C>;
+declare function styleWrapper<C extends FormlyFieldConfig>(fieldConfig: C, styleWrapper: DbxFormStyleWrapperConfig): WrapperFormlyFieldConfig<DbxFormStyleWrapperConfig, C>;
+declare function workingWrapper<C extends FormlyFieldConfig>(fieldConfig: C, workingWrapper?: DbxFormWorkingWrapperConfig): WrapperFormlyFieldConfig<object, C>;
+interface DbxFlexLayoutWrapperGroupFieldConfig {
+    field: FormlyFieldConfig;
+    /**
+     * Flex space sizing for the field. If undefined it will default to the provided default size.
+     */
+    size?: DbxFlexSize;
+}
+interface DbxFlexLayoutWrapperGroupFieldConfigDefaults extends DbxFlexWrapperConfig, Omit<DbxFlexLayoutWrapperGroupFieldConfig, 'field'> {
+}
+declare function checkIsFieldFlexLayoutGroupFieldConfig(input: FormlyFieldConfig | DbxFlexLayoutWrapperGroupFieldConfig): input is DbxFlexLayoutWrapperGroupFieldConfig;
+declare function flexLayoutWrapper(fieldConfigs: (FormlyFieldConfig | DbxFlexLayoutWrapperGroupFieldConfig)[], { relative, breakpoint, breakToColumn, size: defaultSize }?: DbxFlexLayoutWrapperGroupFieldConfigDefaults): FormlyFieldConfig<DbxFlexWrapperConfig>;
+
+declare class DbxFormFormlyFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyFieldModule, never, [typeof DbxFormFormlyChecklistItemFieldModule, typeof DbxFormFormlyComponentFieldModule, typeof DbxFormFormlyTextEditorFieldModule, typeof DbxFormFormlyWrapperModule], [typeof DbxFormFormlyChecklistItemFieldModule, typeof DbxFormFormlyComponentFieldModule, typeof DbxFormFormlyTextEditorFieldModule, typeof DbxFormFormlyWrapperModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyFieldModule>;
+}
+
+interface DbxFormSearchFormFieldsValue {
+    readonly search: string;
+}
+interface DbxFormSearchFormFieldsConfig extends MaterialFormFieldConfig {
+    readonly label?: string;
+    readonly placeholder?: string;
+}
+declare function dbxFormSearchFormFields(config: Maybe<DbxFormSearchFormFieldsConfig>): FormlyFieldConfig[];
+
+/**
+ * Abstract component for wrapping a DbxFormlyContext.
+ *
+ * The implementing component should use provideFormlyContext() to provide the DbxFormlyContext specific to this directive. The context is injected using only self.
+ */
+declare abstract class AbstractFormlyFormDirective<T> {
+    readonly context: DbxFormlyContext<T>;
+    readonly disabled: i0.InputSignal<boolean>;
+    protected readonly _disabledEffect: i0.EffectRef;
+    getValue(): Observable<T>;
+    setValue(value: Partial<T>): void;
+    resetForm(): void;
+    clearValue(): void;
+    setDisabled(key?: DbxFormDisabledKey, disabled?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractFormlyFormDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractFormlyFormDirective<any>, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Abstract component for wrapping a form.
+ */
+declare abstract class AbstractSyncFormlyFormDirective<T> extends AbstractFormlyFormDirective<T> implements OnInit {
+    abstract fields: FormlyFieldConfig[];
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractSyncFormlyFormDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractSyncFormlyFormDirective<any>, never, never, {}, {}, never, never, true, never>;
+}
+/**
+ * Abstract component for wrapping an asyncrhronously-configured form.
+ */
+declare abstract class AbstractAsyncFormlyFormDirective<T> extends AbstractFormlyFormDirective<T> implements OnInit {
+    /**
+     * Used to provide fields to the context.
+     */
+    abstract readonly fields$: Observable<Maybe<FormlyFieldConfig[]>>;
+    protected readonly _fieldSub: _dereekb_rxjs.SubscriptionObject<rxjs.Unsubscribable>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractAsyncFormlyFormDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractAsyncFormlyFormDirective<any>, never, never, {}, {}, never, never, true, never>;
+}
+declare abstract class AbstractConfigAsyncFormlyFormDirective<T, C> extends AbstractAsyncFormlyFormDirective<T> {
+    readonly config: i0.InputSignal<MaybeObservableOrValue<C>>;
+    readonly currentConfig$: Observable<Maybe<C>>;
+    readonly config$: Observable<C>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractConfigAsyncFormlyFormDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractConfigAsyncFormlyFormDirective<any, any>, never, never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DbxFormSearchFormComponent extends AbstractConfigAsyncFormlyFormDirective<DbxFormSearchFormFieldsValue, DbxFormSearchFormFieldsConfig> {
+    readonly search: i0.OutputEmitterRef<string>;
+    readonly fields$: Observable<FormlyFieldConfig[]>;
+    searchChanged(value: DbxFormSearchFormFieldsValue): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormSearchFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormSearchFormComponent, "dbx-form-search-form", never, {}, { "search": "search"; }, never, never, true, never>;
+}
+
+declare const FIELD_VALUE_IS_AVAILABLE_VALIDATION_KEY = "fieldValueIsAvailable";
+declare const FIELD_VALUE_IS_AVAILABLE_ERROR_VALIDATION_KEY = "fieldValueIsAvailableError";
+type FieldValueIsAvailableValidatorFunction<T> = (value: T) => Observable<boolean>;
+interface FieldValueIsAvailableValidatorConfig<T> {
+    /**
+     * How long to wait in between value changes.
+     */
+    throttle?: number;
+    /**
+     * Returns an observable that checks whether or not the value is currently available.
+     *
+     * @param value
+     */
+    readonly checkValueIsAvailable: FieldValueIsAvailableValidatorFunction<T>;
+    /**
+     * Custom message for this validator.
+     */
+    message?: string;
+}
+/**
+ * Validator for validating all values within an object.
+ *
+ * This is useful for validating a control group where two or more values are expected to be the same, such as a password and a password verification field.
+ *
+ * @param config
+ * @returns
+ */
+declare function fieldValueIsAvailableValidator<T>(config: FieldValueIsAvailableValidatorConfig<T>): AsyncValidatorFn;
+
+interface TextAvailableFieldConfig extends TextFieldConfig, Omit<FieldValueIsAvailableValidatorConfig<string>, 'message'> {
+    readonly isNotAvailableErrorMessage?: string;
+}
+declare function textIsAvailableField(config: TextAvailableFieldConfig): FormlyFieldConfig;
+
+declare class DbxFormTextAvailableFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormTextAvailableFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormTextAvailableFieldModule, never, [typeof DbxFormFormlyTextFieldModule, typeof DbxFormFormlyWrapperModule], [typeof DbxFormFormlyTextFieldModule, typeof DbxFormFormlyWrapperModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormTextAvailableFieldModule>;
+}
+
+/**
+ * Convenience interface for the password parameters configuration for a TextPasswordField.
+ */
+type TextPasswordFieldPasswordParameters = Partial<Pick<TextFieldConfig, 'maxLength' | 'minLength' | 'pattern'>>;
+/**
+ * textPasswordField() configuration.
+ */
+interface TextPasswordFieldConfig extends Omit<TextFieldConfig, 'inputType' | 'key'>, Partial<Pick<TextFieldConfig, 'key' | 'materialFormField'>> {
+}
+/**
+ * Configured simple text password field.
+ *
+ * @param config
+ * @returns
+ */
+declare function textPasswordField(config?: TextPasswordFieldConfig): FormlyFieldConfig;
+/**
+ * Configured verify field for a password.
+ *
+ * @param config
+ * @returns
+ */
+declare function textVerifyPasswordField(config?: TextPasswordFieldConfig): FormlyFieldConfig;
+interface TextPasswordWithVerifyFieldConfig {
+    readonly password?: TextPasswordFieldConfig;
+    readonly verifyPassword?: TextPasswordFieldConfig;
+}
+declare function textPasswordWithVerifyFieldGroup(config: TextPasswordWithVerifyFieldConfig): FormlyFieldConfig;
+interface UsernameLoginFieldUsernameConfig {
+    readonly email?: Omit<EmailFieldConfig, 'key'>;
+    readonly username?: Omit<TextFieldConfig, 'key'>;
+}
+type UsernameLoginFieldUsernameConfigInput = 'email' | 'username' | UsernameLoginFieldUsernameConfig;
+/**
+ * usernamePasswordLoginFields() configuration.
+ */
+interface UsernameLoginFieldsConfig {
+    readonly username: UsernameLoginFieldUsernameConfigInput;
+    readonly password?: TextPasswordFieldConfig;
+    readonly verifyPassword?: Maybe<boolean | TextPasswordFieldConfig>;
+}
+/**
+ * Value type exported by usernameLoginFields()
+ */
+interface DefaultUsernameLoginFieldsValue extends DefaultUsernameLoginFieldValue {
+    readonly password: string;
+    readonly verifyPassword?: string;
+}
+/**
+ * Template for login field that takes in a username and password.
+ *
+ * @param param0
+ * @returns
+ */
+declare function usernamePasswordLoginFields({ username, password, verifyPassword }: UsernameLoginFieldsConfig): FormlyFieldConfig[];
+/**
+ * Value type exported by usernameLoginField()
+ */
+interface DefaultUsernameLoginFieldValue {
+    readonly username: string;
+}
+declare function usernameLoginField(username: UsernameLoginFieldUsernameConfigInput): FormlyFieldConfig;
+
+declare class DbxFormLoginFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormLoginFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormLoginFieldModule, never, [typeof DbxFormFormlyTextFieldModule], [typeof DbxFormFormlyTextFieldModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormLoginFieldModule>;
+}
+
+type TestStringSearchFunction = (text: string) => string[];
+declare function timezoneStringSearchFunction(): SearchableValueFieldStringSearchFn<string, TimezoneInfo>;
+declare const DISPLAY_FOR_TIMEZONE_STRING_VALUE: SearchableValueFieldDisplayFn<string, TimezoneInfo>;
+/**
+ * textPasswordField() configuration.
+ */
+interface TimezoneStringFieldConfig extends Omit<SearchableTextFieldConfig<TimezoneString, TimezoneInfo>, 'inputType' | 'searchOnEmptyText' | 'search' | 'displayForValue' | 'key'>, Partial<Pick<SearchableTextFieldConfig<TimezoneString, TimezoneInfo>, 'key' | 'materialFormField'>> {
+}
+/**
+ * Template for a searchable text field for a timezone.
+ *
+ * @param param0
+ * @returns
+ */
+declare function timezoneStringField(config?: TimezoneStringFieldConfig): FormlyFieldConfig;
+
+declare class DbxFormTimezoneStringFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormTimezoneStringFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormTimezoneStringFieldModule, never, [typeof DbxFormFormlySearchableFieldModule], [typeof DbxFormFormlySearchableFieldModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormTimezoneStringFieldModule>;
+}
+
+declare const IS_NOT_WEBSITE_URL_VALIDATION_KEY = "isNotWebsiteUrl";
+declare const IS_NOT_WEBSITE_URL_WITH_PREFIX_VALIDATION_KEY = "isNotWebsiteUrlWithPrefix";
+declare const IS_NOT_WEBSITE_URL_WITH_EXPECTED_DOMAIN_VALIDATION_KEY = "isNotWebsiteUrlWithExpectedDomain";
+interface IsNotWebsiteUrlErrorData {
+    readonly value: string;
+    readonly isPrefixRequired: boolean;
+    readonly message: string;
+}
+interface IsWebsiteUrlValidatorConfig {
+    /**
+     * Whether or not to require an http/https prefix.
+     *
+     * Defaults to true.
+     */
+    readonly requirePrefix?: Maybe<boolean>;
+    /**
+     * Valid domains to accept.
+     *
+     * Defaults to undefined.
+     */
+    readonly validDomains?: Maybe<ArrayOrValue<WebsiteDomain>>;
+}
+/**
+ * Angular Form ValidationFn for checking isDivisibleBy the input divisor.
+ *
+ * @param divisor
+ * @returns
+ */
+declare function isWebsiteUrlValidator(config?: IsWebsiteUrlValidatorConfig): ValidatorFn;
+
+/**
+ * websiteUrlField() configuration.
+ */
+interface WebsiteUrlFieldConfig extends Omit<TextFieldConfig, 'inputType' | 'key'>, Partial<Pick<TextFieldConfig, 'key' | 'materialFormField'>>, IsWebsiteUrlValidatorConfig {
+}
+/**
+ * Configured simple text password field.
+ *
+ * @param config
+ * @returns
+ */
+declare function websiteUrlField(config?: WebsiteUrlFieldConfig): FormlyFieldConfig;
+
+/**
+ * Provides an DbxFormlyContext and has an input for fields.
+ */
+declare class DbxFormlyFieldsContextDirective<T = unknown> extends AbstractAsyncFormlyFormDirective<T> {
+    readonly fields: i0.InputSignal<Maybe<FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
+        [additionalProperties: string]: any;
+    }>[]>>;
+    readonly fields$: rxjs.Observable<Maybe<FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
+        [additionalProperties: string]: any;
+    }>[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormlyFieldsContextDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFormlyFieldsContextDirective<any>, "[dbxFormlyFields]", never, { "fields": { "alias": "dbxFormlyFields"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface DbxFormlyFormState {
+    changesSinceLastResetCount: number;
+    isFormValid: boolean;
+    isFormDisabled: boolean;
+}
+/**
+ * Used for rending a form from a DbxFormlyContext.
+ */
+declare class DbxFormlyComponent<T> implements DbxForm, DbxFormlyContextDelegate<T>, OnInit {
+    private readonly _dbxFormlyContext;
+    readonly formlyForm: i0.Signal<FormlyForm | undefined>;
+    private readonly _fields;
+    private readonly _events;
+    private readonly _disabled;
+    private readonly _reset;
+    private readonly _forceUpdate;
+    private readonly _disabledSub;
+    private readonly _enforceDisabledSub;
+    readonly form: FormGroup<{}>;
+    readonly modelSignal: i0.WritableSignal<T>;
+    readonly options: FormlyFormOptions;
+    readonly fields$: Observable<FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
+        [additionalProperties: string]: any;
+    }>[]>;
+    readonly stream$: Observable<DbxFormEvent>;
+    private readonly _fieldsSignal;
+    readonly fieldsSignal: i0.Signal<FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
+        [additionalProperties: string]: any;
+    }>[]>;
+    constructor();
+    ngOnInit(): void;
+    init(initialize: DbxFormlyInitialize<T>): void;
+    getValue(): Observable<T>;
+    setValue(value: T): void;
+    resetForm(): void;
+    get isDisabled(): boolean;
+    get disabled(): BooleanStringKeyArray;
+    getDisabled(): Observable<BooleanStringKeyArray>;
+    setDisabled(key?: DbxFormDisabledKey, disabled?: boolean): void;
+    forceFormUpdate(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormlyComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormlyComponent<any>, "dbx-formly", ["formly"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Default template for a view that extends AbstractFormlyFormDirective.
+ */
+declare const DBX_FORMLY_FORM_COMPONENT_TEMPLATE = "<dbx-formly></dbx-formly>";
+/**
+ * Default providers for a view that extends AbstractFormlyFormDirective.
+ */
+declare const dbxFormlyFormComponentProviders: typeof provideFormlyContext;
+/**
+ * Default imports module for a view that extends AbstractFormlyFormDirective.
+ */
+declare class DbxFormlyFormComponentImportsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormlyFormComponentImportsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormlyFormComponentImportsModule, never, [typeof DbxFormlyComponent], [typeof DbxFormlyComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormlyFormComponentImportsModule>;
+}
+
+declare function provideDbxFormFormlyFieldDeclarations(): i0.EnvironmentProviders;
+
+/**
+ * Provides vertical spacing after a form.
+ */
+declare class DbxFormSpacerDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormSpacerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFormSpacerDirective, "dbx-form-spacer,[dbxFormSpacer],.dbx-form-spacer", never, {}, {}, never, never, true, never>;
+}
+
+declare function isTruthy(): ValidatorFn;
+
+declare function isDomain(): ValidatorFn;
+
+declare const FIELD_VALUES_ARE_EQUAL_VALIDATION_KEY = "fieldValuesAreEqual";
+interface FieldValuesAreEqualValidatorConfig<T extends object = object> {
+    /**
+     * Keys of the value to match on.
+     *
+     * If none are defined, then all fields from the control are matched.
+     */
+    keysFilter?: (keyof T)[];
+    /**
+     * Full filter to use, if defined.
+     */
+    valuesFilter?: KeyValueTupleFilter<T>;
+    /**
+     * Optional equivalence comparator.
+     */
+    isEqual?: EqualityComparatorFunction<T>;
+    /**
+     * Custom message for this validator.
+     */
+    message?: string;
+}
+/**
+ * Validator for validating all values within an object.
+ *
+ * This is useful for validating a control group where two or more values are expected to be the same, such as a password and a password verification field.
+ *
+ * @param config
+ * @returns
+ */
+declare function fieldValuesAreEqualValidator<T extends object = object>(config?: FieldValuesAreEqualValidatorConfig<T>): ValidatorFn;
+
+/**
+ * Merges the use of the min and max validator.
+ *
+ * @param min
+ * @param max
+ * @returns
+ */
+declare function isInRange(min?: number, max?: number): ValidatorFn;
+declare const IS_DIVISIBLE_BY_VALIDATION_KEY = "isDivisibleBy";
+interface IsDivisibleByError {
+    value: number;
+    nearest: number;
+    divisor: number;
+    message: string;
+}
+/**
+ * Angular Form ValidationFn for checking isDivisibleBy the input divisor.
+ *
+ * @param divisor
+ * @returns
+ */
+declare function isDivisibleBy(divisor: number): ValidatorFn;
+
+/**
+ * Angular Form ValidationFn for checking isE164PhoneNumber the input divisor.
+ *
+ * @param divisor
+ * @returns
+ */
+declare function isE164PhoneNumber(allowExtension: boolean): ValidatorFn;
+/**
+ * Angular Form ValidationFn for checking the input is a valid phone extension. Empty values return true.
+ *
+ * @param divisor
+ * @returns
+ */
+declare function isPhoneExtension(): ValidatorFn;
+declare function isE164PhoneNumberWithValidExtension(): ValidatorFn;
+
+declare class DbxFormExtensionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormExtensionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormExtensionModule, never, never, [typeof DbxFormModule, typeof DbxFormFormlyFieldModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormExtensionModule>;
+}
+
+interface ProvideDbxFormConfigurationConfig {
+    readonly provideDateAdapter?: boolean;
+    readonly defaultDateTimePresets?: Maybe<DateTimePresetConfiguration[]>;
+}
+declare function provideDbxFormConfiguration(config?: ProvideDbxFormConfigurationConfig): EnvironmentProviders;
+
+export { APP_ACTION_FORM_DISABLED_KEY, AbstractAsyncFormlyFormDirective, AbstractConfigAsyncFormlyFormDirective, AbstractDbxPickableItemFieldDirective, AbstractDbxSearchableFieldDisplayDirective, AbstractDbxSearchableValueFieldDirective, AbstractFormExpandSectionWrapperDirective, AbstractFormlyFormDirective, AbstractSyncFormlyFormDirective, AutoTouchFieldWrapperComponent, ChecklistItemFieldDataSetBuilder, DBX_DATE_TIME_FIELD_DATE_NOT_IN_SCHEDULE_ERROR, DBX_DATE_TIME_FIELD_MENU_PRESETS_TOKEN, DBX_DATE_TIME_FIELD_TIME_NOT_IN_RANGE_ERROR, DBX_FORMLY_FORM_COMPONENT_TEMPLATE, DBX_SEARCHABLE_FIELD_COMPONENT_DATA_TOKEN, DEFAULT_DATE_TIME_FIELD_MENU_PRESETS_PRESETS, DEFAULT_FORM_DISABLED_KEY, DEFAULT_HAS_VALUE_FN, DEFAULT_LAT_LNG_TEXT_FIELD_PATTERN_MESSAGE, DEFAULT_LAT_LNG_TEXT_FIELD_PLACEHOLDER, DEFAULT_PREFERRED_COUNTRIES, DISPLAY_FOR_TIMEZONE_STRING_VALUE, DbxActionFormDirective, DbxActionFormSafetyDirective, DbxChecklistItemContentComponent, DbxChecklistItemFieldComponent, DbxDateTimeFieldComponent, DbxDateTimeFieldMenuPresetsService, DbxDateTimeFieldTimeMode, DbxDateTimeValueMode, DbxDefaultChecklistItemFieldDisplayComponent, DbxDefaultSearchableFieldDisplayComponent, DbxFixedDateRangeFieldComponent, DbxFixedDateRangeFieldSelectionStrategy, DbxForm, DbxFormActionDialogComponent, DbxFormComponentFieldComponent, DbxFormExpandWrapperComponent, DbxFormExtensionModule, DbxFormFlexWrapperComponent, DbxFormFormlyArrayFieldModule, DbxFormFormlyBooleanFieldModule, DbxFormFormlyChecklistItemFieldModule, DbxFormFormlyComponentFieldModule, DbxFormFormlyDateFieldModule, DbxFormFormlyDbxListFieldModule, DbxFormFormlyFieldModule, DbxFormFormlyNumberFieldModule, DbxFormFormlyPhoneFieldModule, DbxFormFormlyPickableFieldModule, DbxFormFormlySearchableFieldModule, DbxFormFormlySourceSelectModule, DbxFormFormlyTextEditorFieldModule, DbxFormFormlyTextFieldModule, DbxFormFormlyWrapperModule, DbxFormInfoWrapperComponent, DbxFormLoadingSourceDirective, DbxFormLoginFieldModule, DbxFormModule, DbxFormRepeatArrayTypeComponent, DbxFormSearchFormComponent, DbxFormSectionWrapperComponent, DbxFormSourceDirective, DbxFormSourceSelectFieldComponent, DbxFormSpacerDirective, DbxFormState, DbxFormStyleWrapperComponent, DbxFormSubsectionWrapperComponent, DbxFormTextAvailableFieldModule, DbxFormTimezoneStringFieldModule, DbxFormToggleWrapperComponent, DbxFormValueChangeDirective, DbxFormWorkingWrapperComponent, DbxFormlyComponent, DbxFormlyContext, DbxFormlyFieldsContextDirective, DbxFormlyFormComponentImportsModule, DbxItemListFieldComponent, DbxMutableForm, DbxPhoneFieldComponent, DbxPickableChipListFieldComponent, DbxPickableListFieldComponent, DbxPickableListFieldItemListComponent, DbxPickableListFieldItemListViewComponent, DbxPickableListFieldItemListViewItemComponent, DbxSearchableChipFieldComponent, DbxSearchableFieldAutocompleteItemComponent, DbxSearchableTextFieldComponent, DbxTextEditorFieldComponent, FIELD_VALUES_ARE_EQUAL_VALIDATION_KEY, FIELD_VALUE_IS_AVAILABLE_ERROR_VALIDATION_KEY, FIELD_VALUE_IS_AVAILABLE_VALIDATION_KEY, INVALID_PHONE_NUMBER_EXTENSION_MESSAGE, INVALID_PHONE_NUMBER_MESSAGE, IS_DIVISIBLE_BY_VALIDATION_KEY, IS_NOT_WEBSITE_URL_VALIDATION_KEY, IS_NOT_WEBSITE_URL_WITH_EXPECTED_DOMAIN_VALIDATION_KEY, IS_NOT_WEBSITE_URL_WITH_PREFIX_VALIDATION_KEY, LABEL_STRING_MAX_LENGTH, MAX_LENGTH_VALIDATION_MESSAGE, MAX_VALIDATION_MESSAGE, MIN_LENGTH_VALIDATION_MESSAGE, MIN_VALIDATION_MESSAGE, PHONE_LABEL_MAX_LENGTH, REQUIRED_VALIDATION_MESSAGE, SEARCH_STRING_MAX_LENGTH, TAKE_NEXT_UPCOMING_TIME_CONFIG_OBS, addValueSelectionOptionFunction, addWrapperToFormlyFieldConfig, addressField, addressFormlyFields, addressLineField, addressListField, autoTouchWrapper, checkIsFieldFlexLayoutGroupFieldConfig, checkboxField, checklistItemField, chipTextField, cityField, componentField, countryField, dateRangeField, dateTimeField, dateTimePreset, dateTimeRangeField, dbxDateRangeIsSameDateRangeFieldValue, dbxDateTimeInputValueParseFactory, dbxDateTimeIsSameDateTimeFieldValue, dbxDateTimeOutputValueFactory, dbxFormSearchFormFields, dbxFormSourceObservable, dbxFormSourceObservableFromStream, dbxFormlyFormComponentProviders, dbxListField, defaultValidationMessages, disableFormlyFieldAutofillAttributes, dollarAmountField, emailField, expandWrapper, fieldValueIsAvailableValidator, fieldValuesAreEqualValidator, filterPartialPotentialFieldConfigValuesFromObject, filterPickableItemFieldValuesByLabel, filterPickableItemFieldValuesByLabelFilterFunction, fixedDateRangeField, flexLayoutWrapper, formlyField, hiddenField, infoWrapper, isDbxDateTimeFieldTimeDateConfig, isDivisibleBy, isDomain, isE164PhoneNumber, isE164PhoneNumberWithValidExtension, isInRange, isPhoneExtension, isTruthy, isWebsiteUrlValidator, latLngTextField, makeMetaFilterSearchableFieldValueDisplayFn, maxLengthValidationMessage, maxValidationMessage, mergePropsValueObjects, minLengthValidationMessage, minValidationMessage, nameField, numberField, numberFieldTransformParser, numberSliderField, partialPotentialFieldConfigKeys, partialPotentialFieldConfigKeysFilter, phoneAndLabelSectionField, phoneField, phoneListField, pickableItemChipField, pickableItemListField, pickableValueFieldValuesConfigForStaticLabeledValues, propsAndConfigForFieldConfig, propsValueForFieldConfig, provideDbxForm, provideDbxFormConfiguration, provideDbxFormFormlyFieldDeclarations, provideDbxMutableForm, provideFormlyContext, repeatArrayField, searchableChipField, searchableStringChipField, searchableTextField, sectionWrapper, sortPickableItemsByLabel, sortPickableItemsByLabelStringFunction, sourceSelectField, stateField, streamValueFromControl, styleWrapper, subsectionWrapper, syncConfigValueObs, textAreaField, textEditorField, textField, textFieldTransformParser, textIsAvailableField, textPasswordField, textPasswordWithVerifyFieldGroup, textVerifyPasswordField, timeOnlyField, timezoneStringField, timezoneStringSearchFunction, toggleDisableFormControl, toggleField, toggleWrapper, usernameLoginField, usernamePasswordLoginFields, validatorsForFieldConfig, valueSelectionField, websiteUrlField, workingWrapper, wrappedPhoneAndLabelField, zipCodeField };
+export type { AbstractFormExpandSectionConfig, AddressFieldConfig, AddressFormlyFieldsConfig, AddressLineFieldConfig, AddressListFieldConfig, AttributesFieldConfig, CheckboxFieldConfig, ChecklistItemDisplayContent, ChecklistItemFieldBuilderInput, ChecklistItemFieldConfig, ChecklistItemFieldDataSetBuilderInput, ChecklistItemFieldDataSetFieldKey, ChecklistItemFieldDataSetFieldValueForKey, ChecklistItemFieldDataSetItem, ChecklistItemFieldDisplayComponent, ChecklistType, ChipTextFieldConfig, CityFieldConfig, ComponentFieldConfig, ConfiguredSearchableValueFieldDisplayValue, CountryFieldConfig, DateDateRangeFieldConfig, DateDateRangeFieldDateConfig, DateDateTimeRangeFieldConfig, DateTimeFieldConfig, DateTimePreset, DateTimePresetConfiguration, DateTimePresetValue, DateTimeRangeFieldTimeConfig, DbxActionFormMapValueFunction, DbxChecklistItemFieldProps, DbxDateTimeFieldProps, DbxDateTimeFieldSyncField, DbxDateTimeFieldSyncParsedField, DbxDateTimeFieldSyncType, DbxDateTimeFieldTimeDateConfig, DbxDateTimePickerConfiguration, DbxFixedDateRangeDateRangeInput, DbxFixedDateRangeFieldProps, DbxFixedDateRangePickerConfiguration, DbxFixedDateRangePicking, DbxFixedDateRangeSelectionMode, DbxFlexLayoutWrapperGroupFieldConfig, DbxFlexLayoutWrapperGroupFieldConfigDefaults, DbxFlexWrapperConfig, DbxFormActionDialogComponentButtonConfig, DbxFormActionDialogComponentConfig, DbxFormComponentFieldConfig, DbxFormComponentFormlyFieldConfig, DbxFormDisabledKey, DbxFormEvent, DbxFormExpandWrapperButtonType, DbxFormExpandWrapperConfig, DbxFormInfoConfig, DbxFormRepeatArrayAddTemplateFunction, DbxFormRepeatArrayConfig, DbxFormRepeatArrayFieldConfigPair, DbxFormRepeatArrayPair, DbxFormSearchFormFieldsConfig, DbxFormSearchFormFieldsValue, DbxFormSectionConfig, DbxFormSourceDirectiveMode, DbxFormStateRef, DbxFormStyleObject, DbxFormStyleWrapperConfig, DbxFormSubsectionConfig, DbxFormToggleWrapperConfig, DbxFormWorkingWrapperConfig, DbxFormlyContextDelegate, DbxFormlyFormState, DbxFormlyInitialize, DbxItemListFieldProps, DbxListFieldConfig, DefaultUsernameLoginFieldValue, DefaultUsernameLoginFieldsValue, DefaultValueFieldConfig, DescriptionFieldConfig, DisableAutocompleteForField, DollarAmountFieldConfig, EmailFieldConfig, FieldConfig, FieldConfigParsersRef, FieldConfigWithParsers, FieldValueIsAvailableValidatorConfig, FieldValueIsAvailableValidatorFunction, FieldValuesAreEqualValidatorConfig, FixedDateRangeFieldConfig, FixedDateRangeScan, FixedDateRangeScanType, FormControlPath, FormlyMessageProperties, FormlyValueParser, HiddenFieldConfig, InternationalPhoneFieldConfig, InternationalPhoneFormlyFieldProps, IsDivisibleByError, IsNotWebsiteUrlErrorData, IsWebsiteUrlValidatorConfig, LabeledFieldConfig, MaterialFormFieldConfig, NumberFieldConfig, NumberFieldInputType, NumberFieldNumberConfig, NumberSliderFieldConfig, PartialPotentialFieldConfig, PhoneAndLabelFieldSectionConfig, PhoneListFieldConfig, PickableItemFieldConfig, PickableItemFieldItem, PickableItemFieldItemSortFn, PickableValueFieldDisplayFunction, PickableValueFieldDisplayValue, PickableValueFieldDisplayValueWithHash, PickableValueFieldFilterFunction, PickableValueFieldHashFunction, PickableValueFieldLoadValuesFunction, PickableValueFieldValue, PickableValueFieldValuesConfigForStaticLabeledValues, PickableValueFieldValuesConfigForStaticLabeledValuesConfig, PickableValueFieldsFieldProps, ProvideDbxFormConfigurationConfig, RepeatArrayFieldConfig, SearchableChipFieldConfig, SearchableChipValueFieldsFieldProps, SearchableTextFieldConfig, SearchableTextValueFieldsFieldProps, SearchableValueFieldAnchorFn, SearchableValueFieldDisplayFn, SearchableValueFieldDisplayValue, SearchableValueFieldHashFn, SearchableValueFieldStringSearchFn, SearchableValueFieldValue, SearchableValueFieldsFieldProps, SelectionDisplayValue, SelectionValue, SelectionValueHashFunction, SourceSelectDisplayFunction, SourceSelectDisplayValue, SourceSelectDisplayValueGroup, SourceSelectFieldConfig, SourceSelectFieldProps, SourceSelectLoadSource, SourceSelectLoadSourceLoadingState, SourceSelectLoadSourcesFunction, SourceSelectMetaValueReader, SourceSelectOpenFunction, SourceSelectOpenFunctionParams, SourceSelectOpenSourceResult, SourceSelectOptions, SourceSelectValue, SourceSelectValueGroup, SourceSelectValueMetaLoader, StateFieldConfig, StringSearchableChipFieldConfig, StringValueFieldsFieldProps, TestStringSearchFunction, TextAreaFieldConfig, TextAvailableFieldConfig, TextEditorComponentFieldProps, TextEditorFieldConfig, TextFieldConfig, TextFieldInputType, TextFieldLengthConfig, TextFieldPatternConfig, TextPasswordFieldConfig, TextPasswordFieldPasswordParameters, TextPasswordWithVerifyFieldConfig, TimeFieldConfig, TimezoneStringFieldConfig, ToggleFieldConfig, UsernameLoginFieldUsernameConfig, UsernameLoginFieldUsernameConfigInput, UsernameLoginFieldsConfig, ValidatorsForFieldConfig, ValidatorsForFieldConfigInput, ValueSelectionFieldConfig, ValueSelectionOption, ValueSelectionOptionClear, ValueSelectionOptionWithValue, WebsiteUrlFieldConfig, WrappedPhoneAndLabelFieldConfig, WrapperFormlyFieldConfig, ZipCodeFieldConfig };