@dereekb/dbx-form 13.2.2 → 13.3.0

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

@@ -56,7 +56,13 @@ declare enum DbxFormState {
  * Unique key for disabling/enabling.
  */
 type DbxFormDisabledKey = string;
+/**
+ * Default key used when disabling/enabling a form without specifying a custom key.
+ */
 declare const DEFAULT_FORM_DISABLED_KEY = "dbx_form_disabled";
+/**
+ * Reference to the current state of a form.
+ */
 interface DbxFormStateRef {
     readonly state: DbxFormState;
 }
@@ -93,6 +99,11 @@ declare abstract class DbxForm<T = unknown> {
      */
     abstract getDisabled(): Observable<BooleanStringKeyArray>;
 }
+/**
+ * Mutable extension of {@link DbxForm} that supports setting values, resetting, and disabling the form.
+ *
+ * @typeParam T - The form value type.
+ */
 declare abstract class DbxMutableForm<T = unknown> extends DbxForm<T> {
     /**
      * LockSet for the form.
@@ -119,11 +130,38 @@ declare abstract class DbxMutableForm<T = unknown> extends DbxForm<T> {
      */
     abstract forceFormUpdate(): void;
 }
+/**
+ * Provides the given type as a {@link DbxForm} in Angular's dependency injection system.
+ *
+ * @param sourceType - The concrete form type to register as a provider.
+ * @returns An array of Angular providers.
+ */
 declare function provideDbxForm<S extends DbxForm>(sourceType: Type<S>): Provider[];
+/**
+ * Provides the given type as both a {@link DbxForm} and {@link DbxMutableForm} in Angular's dependency injection system.
+ *
+ * @param sourceType - The concrete mutable form type to register as a provider.
+ * @returns An array of Angular providers.
+ */
 declare function provideDbxMutableForm<S extends DbxMutableForm>(sourceType: Type<S>): Provider[];
+/**
+ * Enables or disables an Angular form control based on the provided flag.
+ *
+ * @param form - The Angular abstract control to enable or disable.
+ * @param isDisabled - Whether to disable (`true`) or enable (`false`) the control.
+ * @param config - Optional configuration passed to the control's `disable()` or `enable()` methods.
+ */
 declare function toggleDisableFormControl(form: AbstractControl<any>, isDisabled: boolean, config?: Parameters<AbstractControl['disable']>[0]): void;
 
+/**
+ * Disabled key used by {@link DbxActionFormDirective} to manage the form's disabled state during action processing.
+ */
 declare const APP_ACTION_FORM_DISABLED_KEY = "dbx_action_form";
+/**
+ * Function that maps a form's value of type `T` to an action value result of type `O`.
+ *
+ * Used by {@link DbxActionFormDirective} to transform form output before passing it to the action source.
+ */
 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.
@@ -131,6 +169,11 @@ type DbxActionFormMapValueFunction<T, O> = MapFunction<T, ObservableOrValue<DbxA
  * 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.
+ *
+ * @selector `[dbxActionForm]`
+ *
+ * @typeParam T - The form value type.
+ * @typeParam O - The output value type passed to the action source.
  */
 declare class DbxActionFormDirective<T = object, O = T> implements OnInit {
     readonly form: DbxMutableForm<any>;
@@ -170,24 +213,61 @@ declare class DbxActionFormDirective<T = object, O = T> implements OnInit {
     private readonly _isWorkingSub;
     constructor();
     ngOnInit(): void;
+    /**
+     * Checks whether the given form value is both valid and modified, optionally applying override functions.
+     *
+     * @param value - The current form value to check.
+     * @param overrides - Optional override functions for the validity and modification checks.
+     * @returns An observable emitting a tuple of `[isValid, isModified]`.
+     */
     checkIsValidAndIsModified(value: T, overrides?: CheckValidAndModifiedOverrides<T>): Observable<[IsValid, IsModified]>;
+    /**
+     * Pre-checks whether the form value is valid and modified before marking it as ready.
+     *
+     * @param value - The current form value.
+     * @returns An observable emitting a tuple of `[isValid, isModified]`.
+     */
     protected preCheckReadyValue(value: T): Observable<[IsValid, IsModified]>;
+    /**
+     * Transforms the form value into an action value result, applying the optional map function if provided.
+     *
+     * @param value - The validated form value.
+     * @returns An observable emitting the action value getter result.
+     */
     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>;
 }
+/**
+ * Optional overrides for the validity and modification check functions
+ * used by {@link DbxActionFormDirective.checkIsValidAndIsModified}.
+ */
 interface CheckValidAndModifiedOverrides<T> {
+    /** Override function for the modification check. */
     isModifiedFunction?: Maybe<IsModifiedFunction<T>>;
+    /** Override function for the validity check. */
     isValidFunction?: Maybe<IsValidFunction<T>>;
 }
 
 /**
- * Extension of DbxActionTransitionSafetyDirective that forces the form to update first.
+ * Extension of {@link DbxActionTransitionSafetyDirective} that forces the form to update before
+ * evaluating transition safety. This ensures the latest form state is considered when deciding
+ * whether to block or allow a route transition.
+ *
+ * NOTE: Only works with UIRouter.
+ *
+ * @selector `[dbxActionFormSafety]`
  *
- * NOTE: Only works with UIRouter
+ * @typeParam T - The form value type.
+ * @typeParam O - The output value type passed to the action source.
  */
 declare class DbxActionFormSafetyDirective<T, O> extends DbxActionTransitionSafetyDirective<T, O> {
     readonly dbxActionForm: DbxActionFormDirective<T, T>;
+    /**
+     * The safety type that controls when transitions are blocked.
+     *
+     * Defaults to `'auto'`, which blocks transitions when the form has unsaved changes.
+     */
     readonly dbxActionFormSafety: i0.InputSignal<DbxActionTransitionSafetyType>;
     protected readonly _dbxActionFormSafetyUpdateEffect: i0.EffectRef;
     protected _handleOnBeforeTransition(transition: Transition): HookResult;
@@ -246,8 +326,20 @@ declare class DbxFormlyContext<T = unknown> implements DbxForm<T>, Destroyable,
     static ɵprov: i0.ɵɵInjectableDeclaration<DbxFormlyContext<any>>;
 }
 
+/**
+ * Button configuration for the submit button in a {@link DbxFormActionDialogComponent}.
+ *
+ * Combines display properties (text, icon) with style properties (color, raised, etc.).
+ */
 interface DbxFormActionDialogComponentButtonConfig extends DbxButtonDisplay, DbxButtonStyle {
 }
+/**
+ * Configuration for opening a {@link DbxFormActionDialogComponent}.
+ *
+ * Defines the dialog header, form fields, initial values, submit button, and dialog options.
+ *
+ * @typeParam O - The form value type produced by the dialog.
+ */
 interface DbxFormActionDialogComponentConfig<O> {
     /**
      * Header text for the dialog.
@@ -271,7 +363,14 @@ interface DbxFormActionDialogComponentConfig<O> {
     readonly dialog?: Omit<MatDialogConfig, 'data'>;
 }
 /**
+ * A standalone dialog component that renders a dynamic Formly form within a Material dialog.
+ *
+ * Provides a header, a configurable form, and a submit button wired to an action handler.
+ * The dialog closes with the submitted form value on success, or `undefined` if dismissed.
+ *
+ * Use {@link DbxFormActionDialogComponent.openDialogWithForm} to open the dialog programmatically.
  *
+ * @typeParam O - The form value type produced by the dialog.
  */
 declare class DbxFormActionDialogComponent<O> extends AbstractDialogDirective<O, DbxFormActionDialogComponentConfig<O>> implements OnInit {
     private readonly _fieldsSub;
@@ -294,28 +393,76 @@ declare class DbxFormActionDialogComponent<O> extends AbstractDialogDirective<O,
         fab?: boolean;
     };
     ngOnInit(): void;
+    /**
+     * Action handler that marks the action as successful and closes the dialog with the submitted value.
+     */
     readonly handleSubmitValue: WorkUsingContext<O>;
+    /**
+     * Opens a new dialog with a dynamic Formly form using the provided configuration.
+     *
+     * @param matDialog - The Angular Material dialog service.
+     * @param config - Configuration for the dialog, including fields, header, and initial value.
+     * @returns A reference to the opened dialog, which resolves to the submitted value or `undefined`.
+     */
     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>;
 }
 
+/**
+ * Creates an observable that pipes input values to a form based on the specified mode.
+ *
+ * This is a convenience wrapper around {@link dbxFormSourceObservableFromStream} that
+ * extracts the stream from the form instance.
+ *
+ * @param form - The mutable form to derive stream state from.
+ * @param inputObs - The source observable or value to pipe into the form.
+ * @param modeObs - Observable controlling when values are forwarded (reset, always, or every).
+ * @returns An observable of values to be set on the form.
+ */
 declare function dbxFormSourceObservable<T>(form: DbxMutableForm, inputObs: ObservableOrValue<T>, modeObs: Observable<DbxFormSourceDirectiveMode>): Observable<T>;
+/**
+ * Creates an observable that pipes input values to a form based on the form's stream state and the specified mode.
+ *
+ * - `'reset'`: Only forwards the value when the form enters the RESET state.
+ * - `'always'`: Forwards values while not initializing, with throttling and loop detection.
+ * - `'every'`: Forwards values while not initializing, without throttling or loop protection.
+ *
+ * @param streamObs - Observable of the form's state stream.
+ * @param inputObs - The source observable or value to pipe into the form.
+ * @param modeObs - Observable or value controlling when values are forwarded.
+ * @returns An observable of values to be set on the form.
+ */
 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.
+ * Modes that define when to copy data from the source to the form.
  *
- * - 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.
+ * - `'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.
+ * Directive that sets a form's value based on an input observable or value source.
+ *
+ * Supports different modes for when the value is forwarded to the form:
+ * - `'reset'` (default): Only sets the form value when the form is reset.
+ * - `'always'`: Sets the form value on every emission, with throttling and loop detection.
+ * - `'every'`: Sets the form value on every emission, without throttling.
+ *
+ * @selector `[dbxFormSource]`
+ *
+ * @typeParam T - The form value type.
  */
 declare class DbxFormSourceDirective<T = unknown> {
     readonly form: DbxMutableForm<any>;
+    /**
+     * The mode controlling when the source value is forwarded to the form.
+     */
     readonly dbxFormSourceMode: i0.InputSignal<Maybe<DbxFormSourceDirectiveMode>>;
+    /**
+     * The source value or observable to pipe into the form.
+     */
     readonly dbxFormSource: i0.InputSignal<Maybe<ObservableOrValue<Maybe<Partial<T>>>>>;
     protected readonly _effectSub: _dereekb_rxjs.SubscriptionObject<rxjs.Unsubscribable>;
     protected readonly _setFormSourceObservableEffect: i0.EffectRef;
@@ -324,13 +471,26 @@ declare class DbxFormSourceDirective<T = unknown> {
 }
 
 /**
- * Used with a FormComponent to set the value from a LoadingState when the value is available.
+ * Directive that sets a form's value from a {@link LoadingState} source once loading is complete.
  *
- * Only passes non-null values from the source.
+ * Only passes non-null values from the source. Extracts the value from the finished loading state
+ * and forwards it to the form using the configured mode.
+ *
+ * @selector `[dbxFormLoadingSource]`
+ *
+ * @typeParam T - The form value type (must extend object).
  */
 declare class DbxFormLoadingSourceDirective<T extends object = object> {
     readonly form: DbxMutableForm<any>;
+    /**
+     * The mode controlling when the loading source value is forwarded to the form.
+     *
+     * Defaults to `'reset'`.
+     */
     readonly dbxFormLoadingSourceMode: i0.InputSignalWithTransform<DbxFormSourceDirectiveMode, Maybe<DbxFormSourceDirectiveMode>>;
+    /**
+     * The loading state source to observe. The form value is set once loading finishes with a non-null value.
+     */
     readonly dbxFormLoadingSource: i0.InputSignal<MaybeObservableOrValue<LoadingState<T>>>;
     readonly mode$: Observable<DbxFormSourceDirectiveMode>;
     readonly source$: Observable<Maybe<T>>;
@@ -340,12 +500,20 @@ declare class DbxFormLoadingSourceDirective<T extends object = object> {
 }
 
 /**
- * Used to see form value changes.
+ * Directive that observes form value changes and emits the current value when the form is complete/valid,
+ * or `undefined` when the form is incomplete.
+ *
+ * Subscribes to the form's stream during `ngOnInit` to ensure the first emission occurs after initialization.
  *
- * Emits undefined when the form is incomplete, and the value when the form is complete.
+ * @selector `[dbxFormValueChange]`
+ *
+ * @typeParam T - The form value type.
  */
 declare class DbxFormValueChangeDirective<T> implements OnInit {
     readonly form: DbxForm<any>;
+    /**
+     * Emits the current form value when the form is complete/valid, or `undefined` when incomplete.
+     */
     readonly dbxFormValueChange: i0.OutputEmitterRef<Maybe<T>>;
     protected readonly _sub: _dereekb_rxjs.SubscriptionObject<rxjs.Unsubscribable>;
     ngOnInit(): void;
@@ -360,12 +528,25 @@ 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
+ * Returns `undefined` if the control at the given path does not exist.
+ *
+ * @param fromControl - The root control to retrieve the target control from.
+ * @param path - Optional dot-delimited path to a nested control.
+ * @returns An observable of the control's value changes (starting with the current value), or `undefined` if the control was not found.
+ *
+ * @example
+ * ```ts
+ * const name$ = streamValueFromControl<string>(formGroup, 'user.name');
+ * ```
  */
 declare function streamValueFromControl<T>(fromControl: AbstractControl, path?: FormControlPath): Maybe<Observable<T>>;
 
+/**
+ * Root Angular module for the dbx-form library.
+ *
+ * Serves as the base module for form-related functionality. Import this module
+ * to access the core form features provided by the library.
+ */
 declare class DbxFormModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormModule, never, never, never>;
@@ -374,28 +555,88 @@ declare class DbxFormModule {
 
 type ValidationMessageOption = MaybeSo<ConfigOption['validationMessages']>[number];
 
+/**
+ * Returns a validation message indicating the minimum character length was not met.
+ *
+ * @param err - The validation error object.
+ * @param field - The Formly field configuration containing `minLength` in its props.
+ * @returns A human-readable validation message string.
+ */
 declare function minLengthValidationMessage(err: unknown, field: FieldTypeConfig): string;
+/**
+ * Returns a validation message indicating the maximum character length was exceeded.
+ *
+ * @param err - The validation error object.
+ * @param field - The Formly field configuration containing `maxLength` in its props.
+ * @returns A human-readable validation message string.
+ */
 declare function maxLengthValidationMessage(err: unknown, field: FieldTypeConfig): string;
+/**
+ * Returns a validation message indicating the value is below the minimum allowed.
+ *
+ * @param err - The validation error object.
+ * @param field - The Formly field configuration containing `min` in its props.
+ * @returns A human-readable validation message string.
+ */
 declare function minValidationMessage(err: unknown, field: FieldTypeConfig): string;
+/**
+ * Returns a validation message indicating the value exceeds the maximum allowed.
+ *
+ * @param err - The validation error object.
+ * @param field - The Formly field configuration containing `max` in its props.
+ * @returns A human-readable validation message string.
+ */
 declare function maxValidationMessage(err: unknown, field: FieldTypeConfig): string;
+/**
+ * Validation message option for required fields.
+ */
 declare const REQUIRED_VALIDATION_MESSAGE: {
     name: string;
     message: string;
 };
+/**
+ * Validation message option for minimum length violations.
+ */
 declare const MIN_LENGTH_VALIDATION_MESSAGE: ValidationMessageOption;
+/**
+ * Validation message option for maximum length violations.
+ */
 declare const MAX_LENGTH_VALIDATION_MESSAGE: ValidationMessageOption;
+/**
+ * Validation message option for minimum value violations.
+ */
 declare const MIN_VALIDATION_MESSAGE: ValidationMessageOption;
+/**
+ * Validation message option for maximum value violations.
+ */
 declare const MAX_VALIDATION_MESSAGE: ValidationMessageOption;
+/**
+ * Validation message option for invalid phone numbers.
+ */
 declare const INVALID_PHONE_NUMBER_MESSAGE: {
     name: string;
     message: string;
 };
+/**
+ * Validation message option for invalid phone number extensions.
+ */
 declare const INVALID_PHONE_NUMBER_EXTENSION_MESSAGE: {
     name: string;
     message: string;
 };
+/**
+ * Returns the full set of default validation messages used by the form system.
+ *
+ * Includes messages for: required, minLength, maxLength, min, max, phone number, and phone number extension.
+ *
+ * @returns An array of {@link ValidationMessageOption} objects.
+ */
 declare function defaultValidationMessages(): ValidationMessageOption[];
 
+/**
+ * Display content configuration for a single checklist item, controlling the label,
+ * sublabel, description, anchor link, and optional metadata.
+ */
 interface ChecklistItemDisplayContent<T = unknown> {
     /**
      * Label to display.
@@ -431,12 +672,20 @@ interface ChecklistItemFieldDisplayComponent<T = unknown> {
     setDisplayContent(displayContent: ChecklistItemDisplayContent<T>): void;
 }
 
+/**
+ * Wrapper component that injects dynamic display content into a checklist item
+ * via {@link DbxInjectionComponent}. Subscribes to the parent field's display content observable.
+ */
 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>;
 }
+/**
+ * Formly field properties for a checklist item, providing the display content observable
+ * and an optional custom display component class.
+ */
 interface DbxChecklistItemFieldProps<T = unknown> extends FormlyFieldProps {
     /**
      * Observable used to retrieve content to display for the item.
@@ -447,6 +696,13 @@ interface DbxChecklistItemFieldProps<T = unknown> extends FormlyFieldProps {
      */
     readonly componentClass?: Type<ChecklistItemFieldDisplayComponent<T>>;
 }
+/**
+ * Formly field component that renders a single checklist item with a checkbox,
+ * optional anchor link, and dynamic display content.
+ *
+ * The display content is provided as an observable and rendered via a configurable
+ * component class (defaults to {@link DbxDefaultChecklistItemFieldDisplayComponent}).
+ */
 declare class DbxChecklistItemFieldComponent<T = unknown> extends FieldType<FieldTypeConfig<DbxChecklistItemFieldProps<T>>> implements OnInit {
     private readonly _displayContentObs;
     readonly displayContent$: Observable<ChecklistItemDisplayContent<T>>;
@@ -467,6 +723,11 @@ declare class DbxChecklistItemFieldComponent<T = unknown> extends FieldType<Fiel
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxChecklistItemFieldComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Default display component for checklist items.
+ *
+ * Renders label, sublabel, and description text from the injected {@link ChecklistItemDisplayContent}.
+ */
 declare class DbxDefaultChecklistItemFieldDisplayComponent<T = unknown> implements ChecklistItemFieldDisplayComponent<T> {
     readonly _displayContentSignal: i0.WritableSignal<Maybe<ChecklistItemDisplayContent<T>>>;
     readonly displayContentSignal: i0.Signal<Maybe<ChecklistItemDisplayContent<T>>>;
@@ -484,23 +745,55 @@ declare class AutoTouchFieldWrapperComponent extends FieldWrapper<FieldTypeConfi
     static ɵcmp: i0.ɵɵComponentDeclaration<AutoTouchFieldWrapperComponent, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Configuration for the section wrapper, using the standard section header config.
+ */
 type DbxFormSectionConfig = DbxSectionHeaderConfig;
+/**
+ * Formly wrapper that renders the wrapped field inside a `dbx-section` layout
+ * with an optional header and hint text.
+ *
+ * Registered as Formly wrapper `'section'`.
+ *
+ * @selector dbx-form-section-wrapper
+ */
 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>;
 }
 
+/**
+ * Configuration for the subsection wrapper, using the standard section header config.
+ */
 type DbxFormSubsectionConfig = DbxSectionHeaderConfig;
+/**
+ * Formly wrapper that renders the wrapped field inside a `dbx-subsection` layout
+ * with an optional header and hint text.
+ *
+ * Registered as Formly wrapper `'subsection'`.
+ *
+ * @selector dbx-form-subsection-wrapper
+ */
 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>;
 }
 
+/**
+ * Configuration for the info wrapper that adds an info icon button beside the field.
+ */
 interface DbxFormInfoConfig extends FormlyFieldProps {
+    /** Callback invoked when the info button is clicked. */
     readonly onInfoClick: () => void;
 }
+/**
+ * Formly wrapper that renders a Material info icon button beside the wrapped field.
+ * Clicking the button invokes the configured `onInfoClick` callback.
+ *
+ * Registered as Formly wrapper `'info'`.
+ */
 declare class DbxFormInfoWrapperComponent extends FieldWrapper<FormlyFieldConfig<DbxFormInfoConfig>> {
     get infoWrapper(): DbxFormInfoConfig;
     onInfoClick(): void;
@@ -508,14 +801,31 @@ declare class DbxFormInfoWrapperComponent extends FieldWrapper<FormlyFieldConfig
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormInfoWrapperComponent, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Base configuration for expandable form section wrappers.
+ *
+ * Controls the label displayed on the expand trigger and an optional custom
+ * function to determine whether the field's value is "populated" (which auto-expands the section).
+ */
 interface AbstractFormExpandSectionConfig<T extends object = object> extends Pick<FormlyFieldProps, 'label'> {
+    /** Label shown on the expand trigger. Falls back to the field label or first child field label. */
     expandLabel?: string;
     /**
      * Optional function to use for checking value existence.
      */
     hasValueFn?: (value: T) => boolean;
 }
+/**
+ * Default value existence check that returns `true` if the object is non-empty.
+ */
 declare const DEFAULT_HAS_VALUE_FN: (x: object) => boolean;
+/**
+ * Abstract base directive for expandable form section wrappers.
+ *
+ * Manages the show/hide state based on whether the field has a value or
+ * whether the user manually opened the section. Subclasses provide the
+ * specific UI (expand button, toggle, etc.).
+ */
 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>>;
@@ -534,8 +844,14 @@ declare class AbstractFormExpandSectionWrapperDirective<T extends object = objec
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractFormExpandSectionWrapperDirective<any, any>, never, never, {}, {}, never, never, true, never>;
 }
 
+/** The visual style of the expand button: a styled button or plain text link. */
 type DbxFormExpandWrapperButtonType = 'button' | 'text';
+/**
+ * Configuration for the expand wrapper, extending the base expand section config
+ * with an optional button type.
+ */
 interface DbxFormExpandWrapperConfig<T extends object = object> extends AbstractFormExpandSectionConfig<T> {
+    /** Visual style of the expand trigger. Defaults to `'button'`. */
     readonly buttonType?: DbxFormExpandWrapperButtonType;
 }
 /**
@@ -547,7 +863,13 @@ declare class DbxFormExpandWrapperComponent<T extends object = object> extends A
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormExpandWrapperComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Configuration for the toggle wrapper that uses a Material slide toggle to
+ * show/hide content. Extends the base expand section config with an optional
+ * reactive label function.
+ */
 interface DbxFormToggleWrapperConfig<T extends object = object> extends AbstractFormExpandSectionConfig<T> {
+    /** Optional function that returns an observable of the toggle label based on open state. */
     toggleLabelObs?: (open: Maybe<boolean>) => Observable<string>;
 }
 /**
@@ -561,6 +883,10 @@ declare class DbxFormToggleWrapperComponent<T extends object = object> extends A
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormToggleWrapperComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Configuration for the flex layout wrapper that arranges child fields
+ * in a responsive horizontal layout using the dbx flex group system.
+ */
 interface DbxFlexWrapperConfig {
     /**
      * Breakpoint based on the screen width.
@@ -575,6 +901,12 @@ interface DbxFlexWrapperConfig {
      */
     readonly breakToColumn?: boolean;
 }
+/**
+ * Formly wrapper that arranges child fields in a responsive flex layout
+ * using the `dbxFlexGroup` directive.
+ *
+ * Registered as Formly wrapper `'flex'`.
+ */
 declare class DbxFormFlexWrapperComponent extends FieldWrapper<FormlyFieldConfig<DbxFlexWrapperConfig>> {
     get flexWrapper(): DbxFlexWrapperConfig;
     get breakpoint(): ScreenMediaWidthType | undefined;
@@ -584,13 +916,26 @@ declare class DbxFormFlexWrapperComponent extends FieldWrapper<FormlyFieldConfig
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormFlexWrapperComponent, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/** A map of CSS style properties to their values, used with `[ngStyle]`. */
 type DbxFormStyleObject = {
     [styleClass: string]: any;
 };
+/**
+ * Configuration for the style wrapper that applies dynamic CSS classes and inline styles.
+ */
 interface DbxFormStyleWrapperConfig {
+    /** Observable or static value providing inline styles via `[ngStyle]`. */
     styleGetter?: Maybe<ObservableOrValue<DbxFormStyleObject>>;
+    /** Observable or static value providing CSS class names via `[ngClass]`. */
     classGetter?: Maybe<ObservableOrValue<string>>;
 }
+/**
+ * Formly wrapper that applies dynamic CSS classes and inline styles to the wrapped field.
+ *
+ * Supports both static values and reactive observables for `[ngClass]` and `[ngStyle]`.
+ *
+ * Registered as Formly wrapper `'style'`.
+ */
 declare class DbxFormStyleWrapperComponent extends FieldWrapper<FormlyFieldConfig<DbxFormStyleWrapperConfig>> implements OnInit, OnDestroy {
     private readonly _style;
     private readonly _class;
@@ -624,30 +969,48 @@ declare class DbxFormWorkingWrapperComponent extends FieldWrapper<FormlyFieldCon
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormWorkingWrapperComponent, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/** Registers all Formly field wrapper types (section, flex, expand, toggle, style, info, working, autotouch, subsection). */
 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>;
 }
 
+/** Registers the `checklistitem` Formly field type with wrapper support. */
 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>;
 }
 
+/**
+ * A value parser function that transforms a form field's value from one type to another.
+ */
 type FormlyValueParser<I = any, O = any> = MapFunction<I, O>;
+/**
+ * Reference to an array of value parsers applied to a field's value.
+ */
 interface FieldConfigParsersRef {
     parsers: FormlyValueParser[];
 }
+/**
+ * Base configuration for a Formly field, providing the key, required/readonly flags,
+ * expressions, and optional value parsers.
+ */
 interface FieldConfig extends Pick<FormlyFieldConfig, 'expressions' | 'parsers'>, Partial<FieldConfigParsersRef> {
     key: string;
     required?: boolean;
     readonly?: boolean;
 }
+/**
+ * Optional reference to value parsers for a field.
+ */
 interface FieldConfigWithParsers {
     parsers?: FormlyValueParser[];
 }
+/**
+ * Sentinel type to disable autocomplete on a field. Pass `false` to the autocomplete property.
+ */
 type DisableAutocompleteForField = false;
 interface LabeledFieldConfig extends FieldConfig {
     key: string;
@@ -660,17 +1023,30 @@ interface LabeledFieldConfig extends FieldConfig {
      */
     autocomplete?: string | DisableAutocompleteForField;
 }
+/**
+ * Configuration mixin that provides a default value for a form field.
+ */
 interface DefaultValueFieldConfig<T = unknown> {
     defaultValue?: T;
 }
+/**
+ * Configuration mixin for arbitrary HTML attributes on a form field element.
+ */
 interface AttributesFieldConfig {
     attributes?: {
         [key: string]: string | number;
     };
 }
+/**
+ * Configuration mixin for a field description/help text.
+ */
 interface DescriptionFieldConfig {
     description?: string;
 }
+/**
+ * Union of all partial field config types, used as a generic input type
+ * for functions that accept any combination of field properties.
+ */
 type PartialPotentialFieldConfig = Partial<FieldConfig> & Partial<LabeledFieldConfig> & Partial<AttributesFieldConfig> & Partial<DescriptionFieldConfig>;
 /**
  * Validates the configuration on the input field.
@@ -695,10 +1071,24 @@ declare function propsAndConfigForFieldConfig<O extends object = object>(fieldCo
     }) | undefined;
     parsers: ((value: any) => any)[] | undefined;
 };
+/** Keys from {@link PartialPotentialFieldConfig} that are merged into Formly props. */
 declare const partialPotentialFieldConfigKeys: (keyof PartialPotentialFieldConfig)[];
+/** Filter configuration for extracting field config keys from objects. */
 declare const partialPotentialFieldConfigKeysFilter: FilterKeyValueTuplesInput<PartialPotentialFieldConfig>;
+/** Merge function that combines multiple partial field configs, picking only the recognized keys. */
 declare const mergePropsValueObjects: _dereekb_util.MergeObjectsFunction<PartialPotentialFieldConfig>;
+/** Filter function that extracts only the recognized field config keys from an object. */
 declare const filterPartialPotentialFieldConfigValuesFromObject: GeneralFilterFromPOJOFunction<PartialPotentialFieldConfig>;
+/**
+ * Builds a Formly props object from a field config and optional overrides.
+ *
+ * Merges label, placeholder, required, readonly, description, attributes, and autocomplete
+ * settings. When autocomplete is `false`, disables browser autofill via special attributes.
+ *
+ * @param fieldConfig - Base field configuration
+ * @param override - Optional property overrides
+ * @returns Merged props object suitable for use in a {@link FormlyFieldConfig}
+ */
 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.
@@ -707,14 +1097,25 @@ declare function disableFormlyFieldAutofillAttributes(): {
     name: string;
     autocomplete: string;
 };
+/**
+ * Map of validation message keys to their message strings or functions.
+ */
 type FormlyMessageProperties = {
     [messageProperties: string]: ValidationMessageOption['message'];
 };
+/**
+ * Input for building a Formly-compatible validator configuration from Angular validators
+ * and custom validation messages.
+ */
 interface ValidatorsForFieldConfigInput {
     validators?: ArrayOrValue<ValidatorFn>;
     asyncValidators?: ArrayOrValue<AsyncValidatorFn>;
     messages?: Maybe<FormlyMessageProperties>;
 }
+/**
+ * Formly-compatible validator configuration structure with validators, async validators,
+ * and validation messages.
+ */
 type ValidatorsForFieldConfig = {
     validation?: {
         messages?: FormlyMessageProperties;
@@ -726,22 +1127,69 @@ type ValidatorsForFieldConfig = {
         validation: AsyncValidatorFn[];
     };
 };
+/**
+ * Converts Angular validators, async validators, and validation messages into the
+ * Formly-compatible validator configuration format.
+ *
+ * @param input - Validators, async validators, and messages to convert
+ * @returns A Formly-compatible validator config, or undefined if no validators provided
+ *
+ * @example
+ * ```typescript
+ * const config = validatorsForFieldConfig({
+ *   validators: [Validators.required],
+ *   messages: { required: 'This field is required' }
+ * });
+ * ```
+ */
 declare function validatorsForFieldConfig(input: ValidatorsForFieldConfigInput): Maybe<ValidatorsForFieldConfig>;
+/**
+ * Configuration mixin for Material form field styling options (prefix, suffix, appearance, etc.).
+ */
 interface MaterialFormFieldConfig {
     readonly materialFormField?: Partial<Pick<FormlyFieldProps$1, 'prefix' | 'suffix' | 'hideLabel' | 'hideRequiredMarker' | 'hideFieldUnderline' | 'floatLabel' | 'appearance' | 'color' | 'hintStart' | 'hintEnd'>>;
 }
 
+/**
+ * Full configuration for a single checklist item field.
+ */
 interface ChecklistItemFieldConfig<T = unknown> extends LabeledFieldConfig, DbxChecklistItemFieldProps<T> {
 }
+/**
+ * Builder input for creating a checklist item field. Requires `key` and `displayContent`;
+ * all other properties are optional.
+ */
 type ChecklistItemFieldBuilderInput<T = unknown> = Partial<ChecklistItemFieldConfig<T>> & Pick<ChecklistItemFieldConfig<T>, 'key' | 'displayContent'>;
+/**
+ * Creates a Formly field configuration for a single checklist item with a checkbox
+ * and display content (label, sublabel, description, anchor).
+ *
+ * @param config - Checklist item configuration with key and display content
+ * @returns A validated {@link FormlyFieldConfig} with type `'checklistitem'`
+ *
+ * @example
+ * ```typescript
+ * const field = checklistItemField({
+ *   key: 'emailNotifications',
+ *   displayContent: of({ label: 'Email Notifications', description: 'Receive updates via email' })
+ * });
+ * ```
+ */
 declare function checklistItemField<T = unknown>(config: ChecklistItemFieldBuilderInput<T>): FormlyFieldConfig<DbxChecklistItemFieldProps<T>>;
 
+/** A field key from the data set type, constrained to string keys. */
 type ChecklistItemFieldDataSetFieldKey<D> = keyof D & string;
+/** The value type for a specific key in the data set. */
 type ChecklistItemFieldDataSetFieldValueForKey<D, K extends keyof D = keyof D> = D[K];
+/** Maps all keys of a data type to boolean values, representing a checklist. */
 type ChecklistType<D> = KeyValueTransformMap<D, boolean>;
+/** Input for adding a checklist item to the data set builder, combining a key with field builder input. */
 type ChecklistItemFieldDataSetBuilderInput<D, T> = {
     key: ChecklistItemFieldDataSetFieldKey<D>;
 } & ChecklistItemFieldBuilderInput<T>;
+/**
+ * A configured item in a checklist data set, pairing a key with its field builder configuration.
+ */
 interface ChecklistItemFieldDataSetItem<D, T extends ChecklistType<D>> {
     /**
      * Key for the field.
@@ -776,25 +1224,50 @@ declare class ChecklistItemFieldDataSetBuilder<D extends object, C extends Check
     contentWithDisplayValueFromData<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: ChecklistItemFieldDataSetFieldKey<D>, labelFn?: (value: T) => Maybe<string>): Observable<ChecklistItemDisplayContent<T>>;
 }
 
+/** Configuration for the custom component to inject into the form field. Alias for {@link DbxInjectionComponentConfig}. */
 type DbxFormComponentFieldConfig<T> = DbxInjectionComponentConfig<T>;
+/** Formly field config extended with a {@link DbxFormComponentFieldConfig} for custom component rendering. */
 interface DbxFormComponentFormlyFieldConfig<T = unknown> extends FormlyFieldConfig {
     componentField: DbxFormComponentFieldConfig<T>;
 }
+/**
+ * Formly field component that renders a custom Angular component via dynamic injection.
+ *
+ * Uses {@link DbxInjectionComponent} to instantiate the component class specified in the field's
+ * `componentField` configuration.
+ */
 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>;
 }
 
+/** Registers the `component` Formly field type for custom Angular component injection. */
 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>;
 }
 
+/** Configuration for a custom Angular component embedded as a Formly field. */
 type ComponentFieldConfig<T = unknown> = DbxFormComponentFieldConfig<T>;
+/**
+ * Creates a Formly field configuration that renders a custom Angular component.
+ *
+ * @param config - Component field configuration
+ * @returns A {@link DbxFormComponentFormlyFieldConfig} with type `'component'`
+ *
+ * @example
+ * ```typescript
+ * const field = componentField({ componentClass: MyCustomFormComponent });
+ * ```
+ */
 declare function componentField<T = unknown>(config: ComponentFieldConfig<T>): DbxFormComponentFormlyFieldConfig<T>;
 
+/**
+ * Formly field properties for an item list selection field that renders items
+ * via a custom {@link AbstractDbxSelectionListWrapperDirective} component.
+ */
 interface DbxItemListFieldProps<T = unknown, C extends AbstractDbxSelectionListWrapperDirective<T> = AbstractDbxSelectionListWrapperDirective<T>, K extends PrimativeKey = PrimativeKey> extends Pick<FormlyFieldProps, 'label' | 'description'> {
     /**
      * List to render components from
@@ -814,7 +1287,10 @@ interface DbxItemListFieldProps<T = unknown, C extends AbstractDbxSelectionListW
     readonly loadMore?: () => void;
 }
 /**
- * Used for picking items by identifier from a DbxList component.
+ * Formly field component that allows picking items by identifier from a dynamic DbxList component.
+ *
+ * The list component class is provided as an observable, enabling lazy loading. Selected items
+ * are tracked by key and synchronized with the form control value.
  */
 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;
@@ -842,16 +1318,42 @@ declare class DbxItemListFieldComponent<T = unknown, C extends AbstractDbxSelect
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxItemListFieldComponent<any, any, any>, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Configuration for a dbx list selection field that displays items in a selection list component.
+ */
 interface DbxListFieldConfig<T = unknown, C extends AbstractDbxSelectionListWrapperDirective<T> = AbstractDbxSelectionListWrapperDirective<T>, K extends PrimativeKey = PrimativeKey> extends LabeledFieldConfig, DbxItemListFieldProps<T, C, K> {
 }
+/**
+ * Creates a Formly field configuration for a dbx selection list field.
+ *
+ * @param config - List field configuration including the list component class and state observable
+ * @returns A validated {@link FormlyFieldConfig} with type `'dbxlistfield'`
+ *
+ * @example
+ * ```typescript
+ * const field = dbxListField({
+ *   key: 'selectedItems',
+ *   label: 'Items',
+ *   listComponentClass: MyListComponent,
+ *   state$: items$
+ * });
+ * ```
+ */
 declare function dbxListField<T = unknown, C extends AbstractDbxSelectionListWrapperDirective<T> = AbstractDbxSelectionListWrapperDirective<T>, K extends PrimativeKey = PrimativeKey>(config: DbxListFieldConfig<T, C, K>): FormlyFieldConfig;
 
+/** Registers the `dbxlistfield` Formly field type for item list selection. */
 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>;
 }
 
+/**
+ * A selectable value paired with optional metadata.
+ *
+ * @typeParam T - The underlying value type
+ * @typeParam M - Optional metadata type associated with the value
+ */
 interface SelectionValue<T, M = unknown> {
     /**
      * Value associated with this field.
@@ -878,7 +1380,9 @@ interface SelectionDisplayValue<T, M = unknown> extends SelectionValue<T, M>, La
  */
 type SelectionValueHashFunction<T, H extends PrimativeKey = PrimativeKey> = MapFunction<T, H>;
 
+/** A pickable field value wrapping a {@link SelectionValue}. */
 type PickableValueFieldValue<T, M = unknown> = SelectionValue<T, M>;
+/** A pickable field display value wrapping a {@link SelectionDisplayValue}. */
 type PickableValueFieldDisplayValue<T, M = unknown> = SelectionDisplayValue<T, M>;
 /**
  * PickableValueField function for retrieving all values.
@@ -903,10 +1407,16 @@ type PickableValueFieldFilterFunction<T, M = unknown> = (flterText: Maybe<string
 type PickableValueFieldHashFunction<T, H extends PrimativeKey = PrimativeKey> = SelectionValueHashFunction<T, H>;
 
 /**
- * Wraps the selected state with the items.
+ * A list item wrapping a {@link PickableValueFieldDisplayValue} with selection state.
  */
 type PickableItemFieldItem<T, M = unknown> = DbxValueListItem<PickableValueFieldDisplayValue<T, M>>;
+/** Sort function for ordering pickable items before display. */
 type PickableItemFieldItemSortFn<T, M = unknown> = (items: PickableItemFieldItem<T, M>[]) => PickableItemFieldItem<T, M>[];
+/**
+ * Formly field properties for configuring a pickable value selection field.
+ *
+ * Supports single/multi-select, text filtering, hash-based deduplication, and custom display rendering.
+ */
 interface PickableValueFieldsFieldProps<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends FormlyFieldProps {
     /**
      * Loads all pickable values.
@@ -966,6 +1476,12 @@ interface PickableValueFieldsFieldProps<T, M = unknown, H extends PrimativeKey =
      * Footer Display
      */
     readonly footerConfig?: DbxInjectionComponentConfig;
+    /**
+     * Whether to show an "All" toggle button that selects or deselects all visible items.
+     *
+     * Only applies when `multiSelect` is true (the default).
+     */
+    readonly showSelectAllButton?: boolean;
     /**
      * Changes the selection mode of the list to "view" mode on disabled, hiding the selection boxes.
      */
@@ -976,13 +1492,16 @@ interface PickableValueFieldsFieldProps<T, M = unknown, H extends PrimativeKey =
     readonly refreshDisplayValues$?: Observable<unknown>;
 }
 /**
- * Displayed value with the computed hash.
+ * A display value augmented with its computed hash for deduplication and lookup.
  */
 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.
+ * Abstract base directive for pickable item fields that manages value loading,
+ * display caching, text filtering, and selection state.
+ *
+ * Subclasses provide the specific UI presentation (chips, lists, etc.).
  */
 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>;
@@ -1023,6 +1542,10 @@ declare class AbstractDbxPickableItemFieldDirective<T, M = unknown, H extends Pr
     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>;
+    /**
+     * Signal that is true when all visible items are currently selected.
+     */
+    readonly allSelectedSignal: i0.Signal<boolean>;
     get readonly(): Maybe<boolean>;
     get isReadonlyOrDisabled(): boolean;
     get pickableField(): PickableValueFieldsFieldProps<T, M, H>;
@@ -1034,6 +1557,7 @@ declare class AbstractDbxPickableItemFieldDirective<T, M = unknown, H extends Pr
     get label(): Maybe<string>;
     get autocomplete(): string;
     get changeSelectionModeToViewOnDisabled(): boolean;
+    get showSelectAllButton(): boolean;
     get sortItems(): Maybe<PickableItemFieldItemSortFn<T, M>>;
     get hashForValue(): PickableValueFieldHashFunction<T, H>;
     get displayForValue(): PickableValueFieldDisplayFunction<T, M>;
@@ -1054,6 +1578,18 @@ declare class AbstractDbxPickableItemFieldDirective<T, M = unknown, H extends Pr
     protected _getValueOnFormControl(valueOnFormControl: ArrayOrValue<T>): T[];
     addValue(value: T): void;
     removeValue(value: T): void;
+    /**
+     * Selects all currently visible items.
+     */
+    selectAll(): void;
+    /**
+     * Deselects all currently visible items.
+     */
+    deselectAll(): void;
+    /**
+     * Toggles between selecting all and deselecting all visible items.
+     */
+    toggleAll(): void;
     setValues(values: T[]): void;
     protected _setValueOnFormControl(values: T[]): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxPickableItemFieldDirective<any, any, any>, never>;
@@ -1061,7 +1597,9 @@ declare class AbstractDbxPickableItemFieldDirective<T, M = unknown, H extends Pr
 }
 
 /**
- * Used for picking pre-set values using chips as the presentation.
+ * Formly field component that renders pickable values as Material chips.
+ *
+ * Clicking a chip toggles its selection state unless the field is readonly or disabled.
  */
 declare class DbxPickableChipListFieldComponent<T> extends AbstractDbxPickableItemFieldDirective<T> {
     itemClicked(item: PickableItemFieldItem<T>): void;
@@ -1069,13 +1607,18 @@ declare class DbxPickableChipListFieldComponent<T> extends AbstractDbxPickableIt
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxPickableChipListFieldComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Wrapper component for the pickable item selection list, providing the list view container.
+ */
 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>.
+ * List view component that renders pickable items with selection support.
+ *
+ * Input values are {@link PickableItemFieldItem}, but output selection events emit {@link PickableValueFieldDisplayValue}.
  */
 declare class DbxPickableListFieldItemListViewComponent<T> extends AbstractDbxSelectionListViewDirective<any> {
     readonly dbxPickableListFieldComponent: DbxPickableListFieldComponent<T>;
@@ -1095,7 +1638,10 @@ declare class DbxPickableListFieldItemListViewItemComponent<T> extends AbstractD
     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.
+ * Formly field component that renders pickable values as a selectable list.
+ *
+ * Delegates to {@link DbxPickableListFieldItemListComponent} for list rendering and
+ * handles selection change events to update the form control value.
  */
 declare class DbxPickableListFieldComponent<T> extends AbstractDbxPickableItemFieldDirective<T> {
     onSelectionChange(event: unknown): void;
@@ -1103,28 +1649,104 @@ declare class DbxPickableListFieldComponent<T> extends AbstractDbxPickableItemFi
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxPickableListFieldComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/** Registers the `pickablechipfield` and `pickablelistfield` Formly field types. */
 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>;
 }
 
+/**
+ * Configuration for a pickable item field that displays selected values as chips or a list.
+ */
 interface PickableItemFieldConfig<T = unknown, M = unknown> extends LabeledFieldConfig, PickableValueFieldsFieldProps<T, M>, MaterialFormFieldConfig {
 }
+/**
+ * Creates a Formly field configuration for a pickable chip field that displays
+ * selected values as Material chips.
+ *
+ * @param config - Pickable item configuration including load and display functions
+ * @returns A validated {@link FormlyFieldConfig} with type `'pickablechipfield'`
+ *
+ * @example
+ * ```typescript
+ * const field = pickableItemChipField({
+ *   key: 'tags',
+ *   label: 'Tags',
+ *   loadValues: () => tags$,
+ *   hashForValue: (tag) => tag.id
+ * });
+ * ```
+ */
 declare function pickableItemChipField<T = unknown, M = unknown>(config: PickableItemFieldConfig<T, M>): FormlyFieldConfig;
+/**
+ * Creates a Formly field configuration for a pickable list field that displays
+ * selected values in a selection list.
+ *
+ * @param config - Pickable item configuration including load and display functions
+ * @returns A validated {@link FormlyFieldConfig} with type `'pickablelistfield'`
+ *
+ * @example
+ * ```typescript
+ * const field = pickableItemListField({
+ *   key: 'categories',
+ *   label: 'Categories',
+ *   loadValues: () => categories$,
+ *   hashForValue: (cat) => cat.id
+ * });
+ * ```
+ */
 declare function pickableItemListField<T = unknown, M = unknown>(config: PickableItemFieldConfig<T, M>): FormlyFieldConfig;
 
+/** Case-insensitive filter function that matches pickable display values by their label using indexOf. */
 declare const filterPickableItemFieldValuesByLabelFilterFunction: SearchStringFilterFunction<PickableValueFieldDisplayValue<any>>;
+/**
+ * Filters pickable display values by label text, returning their underlying values.
+ *
+ * Returns all values when filter text is empty.
+ *
+ * @param filterText - Text to filter by
+ * @param values - Display values to filter
+ * @returns Observable emitting the filtered value array
+ */
 declare function filterPickableItemFieldValuesByLabel<T>(filterText: Maybe<string>, values: PickableValueFieldDisplayValue<T>[]): Observable<T[]>;
+/** String sort comparator that orders pickable items alphabetically by label. */
 declare const sortPickableItemsByLabelStringFunction: _dereekb_util.SortByStringFunction<PickableItemFieldItem<any>>;
+/**
+ * Sorts pickable items alphabetically by their label.
+ *
+ * @param chips - Items to sort
+ * @returns The sorted array (mutated in place)
+ */
 declare function sortPickableItemsByLabel<T>(chips: PickableItemFieldItem<T>[]): PickableItemFieldItem<T>[];
+/** Subset of {@link PickableValueFieldsFieldProps} needed for static labeled value configuration. */
 type PickableValueFieldValuesConfigForStaticLabeledValues<T, M extends LabeledValue<T>> = Pick<PickableValueFieldsFieldProps<T, M>, 'loadValues' | 'displayForValue' | 'filterValues'>;
+/** Configuration for creating a pickable field from a static set of labeled values. */
 interface PickableValueFieldValuesConfigForStaticLabeledValuesConfig<T, M extends LabeledValue<T>> {
     readonly allOptions: M[];
     readonly unknownOptionLabel?: string;
 }
+/**
+ * Creates `loadValues`, `displayForValue`, and `filterValues` functions from a static array of labeled values.
+ *
+ * Simplifies pickable field setup when all options are known upfront.
+ *
+ * @param input - Array of labeled values or a config object with options and unknown label
+ * @returns Props subset for configuring a pickable field
+ *
+ * @example
+ * ```typescript
+ * const config = pickableValueFieldValuesConfigForStaticLabeledValues([
+ *   { value: 'a', label: 'Option A' },
+ *   { value: 'b', label: 'Option B' }
+ * ]);
+ * ```
+ */
 declare function pickableValueFieldValuesConfigForStaticLabeledValues<T, M extends LabeledValue<T>>(input: M[] | PickableValueFieldValuesConfigForStaticLabeledValuesConfig<T, M>): PickableValueFieldValuesConfigForStaticLabeledValues<T, M>;
 
+/**
+ * A searchable field value extending {@link SelectionValue} with an optional anchor for navigation.
+ */
 interface SearchableValueFieldValue<T, M = unknown> extends SelectionValue<T, M> {
     /**
      * Optional anchor metadata on the field.
@@ -1140,6 +1762,9 @@ interface SearchableValueFieldDisplayValue<T, M = unknown> extends SelectionDisp
      */
     readonly display?: Partial<DbxInjectionComponentConfig>;
 }
+/**
+ * A searchable display value with a required (non-optional) display configuration.
+ */
 interface ConfiguredSearchableValueFieldDisplayValue<T, M = unknown> extends Omit<SearchableValueFieldDisplayValue<T, M>, 'display'> {
     readonly display: DbxInjectionComponentConfig;
 }
@@ -1159,14 +1784,22 @@ type SearchableValueFieldDisplayFn<T, M = unknown> = MapFunction<SearchableValue
  * SearchableValueField function for setting anchor values on a field value.
  */
 type SearchableValueFieldAnchorFn<T, M = unknown> = MapFunction<SearchableValueFieldValue<T, M>, ClickableAnchor>;
+/** Hash function for searchable field values, used to identify and deduplicate selections. */
 type SearchableValueFieldHashFn<T, H extends PrimativeKey = PrimativeKey> = SelectionValueHashFunction<T, H>;
 
+/** Formly field properties for text input with optional custom validators. */
 interface StringValueFieldsFieldProps extends FormlyFieldProps {
     /**
      * Custom input validators.
      */
     readonly textInputValidator?: ValidatorFn | ValidatorFn[];
 }
+/**
+ * Formly field properties for configuring a searchable value selection field.
+ *
+ * Supports search-as-you-type with autocomplete, display value caching via hash,
+ * optional string value input, anchor links, and custom display components.
+ */
 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.
@@ -1302,6 +1935,10 @@ declare abstract class AbstractDbxSearchableValueFieldDirective<T, M = unknown,
      */
     protected _syncSingleValue(value: SearchableValueFieldDisplayValue<T>): void;
     protected _addWithTextValue(text: string): void;
+    /**
+     * Returns the first validation error message from the input control, if any.
+     */
+    get inputErrorMessage(): string | undefined;
     addWithDisplayValue(displayValue: SearchableValueFieldDisplayValue<T>): void;
     removeWithDisplayValue(displayValue: SearchableValueFieldDisplayValue<T>): void;
     _tryAddCurrentInputValue(): boolean;
@@ -1315,12 +1952,24 @@ declare abstract class AbstractDbxSearchableValueFieldDirective<T, M = unknown,
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxSearchableValueFieldDirective<any, any, any, any>, never, never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Formly field properties for the searchable chip selection field.
+ *
+ * Extends the base searchable props with optional multi-select support.
+ */
 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;
 }
+/**
+ * Formly field component that combines a search autocomplete with Material chips
+ * for selecting multiple values.
+ *
+ * Supports adding values by typing (if string values are allowed), selecting from
+ * autocomplete results, and removing chips. Handles tab and blur events to auto-add text input.
+ */
 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;
@@ -1337,7 +1986,14 @@ declare class DbxSearchableChipFieldComponent<T, M = unknown, H extends Primativ
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxSearchableChipFieldComponent<any, any, any>, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/** Injection token providing the {@link ConfiguredSearchableValueFieldDisplayValue} to autocomplete item display components. */
 declare const DBX_SEARCHABLE_FIELD_COMPONENT_DATA_TOKEN: InjectionToken<unknown>;
+/**
+ * Renders a single autocomplete suggestion item using dynamic component injection.
+ *
+ * Wraps the display component in a {@link DbxAnchorComponent} and provides the display
+ * value data via {@link DBX_SEARCHABLE_FIELD_COMPONENT_DATA_TOKEN}.
+ */
 declare class DbxSearchableFieldAutocompleteItemComponent<T> {
     readonly displayValue: i0.InputSignal<ConfiguredSearchableValueFieldDisplayValue<T, unknown>>;
     readonly configSignal: i0.Signal<DbxInjectionComponentConfig<unknown>>;
@@ -1345,22 +2001,40 @@ declare class DbxSearchableFieldAutocompleteItemComponent<T> {
     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>;
 }
+/**
+ * Abstract base directive for custom searchable field display components.
+ *
+ * Injects the {@link ConfiguredSearchableValueFieldDisplayValue} via the
+ * {@link DBX_SEARCHABLE_FIELD_COMPONENT_DATA_TOKEN} for use in custom templates.
+ */
 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>;
 }
+/**
+ * Default display component for searchable field autocomplete items.
+ *
+ * Renders an optional icon, a label, and an optional sublabel in a horizontal flex layout.
+ */
 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>;
 }
 
+/**
+ * Formly field properties for the searchable text field, extending the base searchable props
+ * with an option to show the currently selected value.
+ */
 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.
+ * Formly field component for selecting a single value via text search with autocomplete.
+ *
+ * Syncs the selected value's label back to the text input. Supports optional display
+ * of the currently selected value and clear functionality.
  */
 declare class DbxSearchableTextFieldComponent<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends AbstractDbxSearchableValueFieldDirective<T, M, H, SearchableTextValueFieldsFieldProps<T, M, H>> implements OnInit, OnDestroy {
     allowSyncValueToInput: boolean;
@@ -1386,28 +2060,91 @@ declare function makeMetaFilterSearchableFieldValueDisplayFn<T extends string |
     loadMetaForValues: (values: SearchableValueFieldValue<T, M>[]) => Observable<SearchableValueFieldValue<T, M>[]>;
     makeDisplayForValues: (values: SearchableValueFieldValue<T, M>[]) => Observable<SearchableValueFieldDisplayValue<T, M>[]>;
 }): SearchableValueFieldDisplayFn<T, M>;
+/** Configuration for a searchable chip field that uses string values directly. */
 type StringSearchableChipFieldConfig<M = unknown> = Omit<SearchableChipFieldConfig<string, M>, 'allowStringValues'>;
+/**
+ * Creates a searchable chip field pre-configured for string values.
+ *
+ * @param config - String-specific searchable chip field configuration
+ * @returns A {@link FormlyFieldConfig} with type `'searchablechipfield'`
+ *
+ * @example
+ * ```typescript
+ * const field = searchableStringChipField({ key: 'tags', label: 'Tags', search: searchFn });
+ * ```
+ */
 declare function searchableStringChipField<M = unknown>(config: StringSearchableChipFieldConfig<M>): FormlyFieldConfig;
+/**
+ * Full configuration for a searchable chip field combining labeling, description,
+ * Material styling, and searchable chip behavior.
+ */
 interface SearchableChipFieldConfig<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends LabeledFieldConfig, DescriptionFieldConfig, MaterialFormFieldConfig, SearchableChipValueFieldsFieldProps<T, M, H> {
 }
+/**
+ * Creates a Formly field configuration for a searchable chip field where users
+ * can search for and select values displayed as Material chips.
+ *
+ * @param config - Searchable chip field configuration
+ * @returns A validated {@link FormlyFieldConfig} with type `'searchablechipfield'`
+ *
+ * @example
+ * ```typescript
+ * const field = searchableChipField({ key: 'skills', label: 'Skills', search: searchFn, hashForValue: (s) => s.id });
+ * ```
+ */
 declare function searchableChipField<T, M = unknown, H extends PrimativeKey = PrimativeKey>(config: SearchableChipFieldConfig<T, M, H>): FormlyFieldConfig;
+/**
+ * Full configuration for a searchable text field with autocomplete.
+ */
 interface SearchableTextFieldConfig<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends LabeledFieldConfig, DescriptionFieldConfig, MaterialFormFieldConfig, SearchableTextValueFieldsFieldProps<T, M, H> {
 }
+/**
+ * Creates a Formly field configuration for a searchable text field with autocomplete
+ * dropdown for selecting values.
+ *
+ * @param config - Searchable text field configuration
+ * @returns A validated {@link FormlyFieldConfig} with type `'searchabletextfield'`
+ *
+ * @example
+ * ```typescript
+ * const field = searchableTextField({ key: 'assignee', label: 'Assignee', search: searchFn });
+ * ```
+ */
 declare function searchableTextField<T, M = unknown, H extends PrimativeKey = PrimativeKey>(config: SearchableTextFieldConfig<T, M, H>): FormlyFieldConfig;
 
+/** Registers the `searchablechipfield` and `searchabletextfield` Formly field types. */
 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>;
 }
 
+/**
+ * Configuration for a plain text chip field that allows freeform string entry.
+ */
 interface ChipTextFieldConfig extends LabeledFieldConfig, StringValueFieldsFieldProps {
+    /** Whether text values are case-sensitive. Defaults to false (lowercased). */
     caseSensitive?: boolean;
 }
+/**
+ * Creates a searchable chip field for freeform text entry where each entered string
+ * becomes a chip. Values are lowercased by default unless `caseSensitive` is true.
+ *
+ * @param config - Text chip field configuration
+ * @returns A {@link FormlyFieldConfig} for text chip input
+ *
+ * @example
+ * ```typescript
+ * const field = chipTextField({ key: 'tags', label: 'Tags' });
+ * ```
+ */
 declare function chipTextField(config: ChipTextFieldConfig): _ngx_formly_core.FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
     [additionalProperties: string]: any;
 }>;
 
+/**
+ * A source-select value with its associated metadata.
+ */
 interface SourceSelectValue<T extends PrimativeKey = PrimativeKey, M = unknown> {
     value: T;
     meta: M;
@@ -1513,6 +2250,9 @@ interface SourceSelectLoadSource<M = unknown> {
      */
     readonly meta: Observable<LoadingState<M[]>>;
 }
+/**
+ * Loading state for a source-select data source, including the source's label.
+ */
 interface SourceSelectLoadSourceLoadingState<M = unknown> extends LoadingState<M[]> {
     /**
      * Label for this source.
@@ -1520,6 +2260,12 @@ interface SourceSelectLoadSourceLoadingState<M = unknown> extends LoadingState<M
     readonly label: string;
 }
 
+/**
+ * Formly field properties for the source-select field.
+ *
+ * Configures how values are loaded from external sources, how metadata is resolved,
+ * and how display values are rendered in the select dropdown.
+ */
 interface SourceSelectFieldProps<T extends PrimativeKey = PrimativeKey, M = unknown> extends FormlyFieldProps$1 {
     /**
      * Function to open the source and request values.
@@ -1555,7 +2301,11 @@ interface SourceSelectFieldProps<T extends PrimativeKey = PrimativeKey, M = unkn
     readonly refreshDisplayValues$?: Observable<unknown>;
 }
 /**
- * Component that displays a select view (multi or not)
+ * Formly field component that renders a Material select dropdown populated from
+ * multiple data sources (open source dialogs, loaded sources, and form control values).
+ *
+ * Merges values from all sources, deduplicates by value key, groups options by label,
+ * and caches display values and metadata for performance.
  */
 declare class DbxFormSourceSelectFieldComponent<T extends PrimativeKey = PrimativeKey, M = unknown> extends FieldType$2<FieldTypeConfig<SourceSelectFieldProps<T, M>>> implements OnInit, OnDestroy {
     private readonly _cacheMetaSub;
@@ -1607,23 +2357,53 @@ declare class DbxFormSourceSelectFieldComponent<T extends PrimativeKey = Primati
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormSourceSelectFieldComponent<any, any>, "dbx-form-sourceselectfield", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Configuration for a source-select field that loads values from external sources.
+ */
 interface SourceSelectFieldConfig<T extends PrimativeKey = PrimativeKey, M = unknown> extends LabeledFieldConfig, DescriptionFieldConfig, MaterialFormFieldConfig, SourceSelectFieldProps<T, M> {
 }
+/**
+ * Creates a Formly field configuration for a source-select field that loads and
+ * displays selectable values from one or more external data sources.
+ *
+ * @param config - Source-select field configuration
+ * @returns A validated {@link FormlyFieldConfig} with type `'sourceselectfield'`
+ *
+ * @example
+ * ```typescript
+ * const field = sourceSelectField({
+ *   key: 'source',
+ *   label: 'Source',
+ *   loadSources: () => sources$,
+ *   metaReader: (meta) => meta.id
+ * });
+ * ```
+ */
 declare function sourceSelectField<T extends PrimativeKey = PrimativeKey, M = unknown>(config: SourceSelectFieldConfig<T, M>): FormlyFieldConfig;
 
+/** Registers the `sourceselectfield` Formly field type. */
 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>;
 }
 
+/**
+ * A selectable option with a value, label, and optional disabled state.
+ */
 interface ValueSelectionOptionWithValue<T> extends LabeledValue<T> {
     disabled?: boolean;
 }
+/**
+ * A special "clear" option that resets the selection when chosen.
+ */
 interface ValueSelectionOptionClear {
     label?: string;
     clear: true;
 }
+/**
+ * A selectable option: either a value option or a clear option.
+ */
 type ValueSelectionOption<T> = ValueSelectionOptionWithValue<T> | ValueSelectionOptionClear;
 interface ValueSelectionFieldConfig<T> extends LabeledFieldConfig, DescriptionFieldConfig, MaterialFormFieldConfig {
     /**
@@ -1649,10 +2429,40 @@ interface ValueSelectionFieldConfig<T> extends LabeledFieldConfig, DescriptionFi
      */
     readonly selectAllOption?: true | string;
 }
+/**
+ * Creates a Formly select field configuration with support for native/material select,
+ * clear option, multiple selection, and "select all".
+ *
+ * @param config - Selection field configuration
+ * @returns A validated {@link FormlyFieldConfig} with type `'select'` or `'native-select'`
+ *
+ * @example
+ * ```typescript
+ * const field = valueSelectionField({
+ *   key: 'color',
+ *   label: 'Color',
+ *   options: [{ label: 'Red', value: 'red' }, { label: 'Blue', value: 'blue' }]
+ * });
+ * ```
+ */
 declare function valueSelectionField<T>(config: ValueSelectionFieldConfig<T>): FormlyFieldConfig;
+/**
+ * Creates a function that prepends a "clear" option to the selection options array
+ * if one doesn't already exist.
+ *
+ * @param label - Optional label for the clear option
+ * @returns A function that transforms selection options by prepending a clear option
+ */
 declare function addValueSelectionOptionFunction<T>(label?: string | undefined): (options: ValueSelectionOption<T>[]) => ValueSelectionOption<T>[];
 
+/** Formly field properties for the text editor component. */
 type TextEditorComponentFieldProps = FormlyFieldProps;
+/**
+ * Formly field component providing a rich text editor powered by ngx-editor.
+ *
+ * Outputs HTML format and marks the form control dirty on editor value changes
+ * while focused. Supports compact mode via {@link CompactContextStore}.
+ */
 declare class DbxTextEditorFieldComponent<T extends TextEditorComponentFieldProps = TextEditorComponentFieldProps> extends FieldType$1<FieldTypeConfig<T>> implements OnInit, OnDestroy {
     private readonly _compactContextStore;
     private _editor;
@@ -1670,42 +2480,128 @@ declare class DbxTextEditorFieldComponent<T extends TextEditorComponentFieldProp
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxTextEditorFieldComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/** Registers the `texteditor` Formly field type for rich text editing. */
 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>;
 }
 
+/**
+ * Configuration for minimum and maximum text length constraints.
+ */
 interface TextFieldLengthConfig {
     minLength?: number;
     maxLength?: number;
 }
+/**
+ * Configuration for regex pattern validation on a text field.
+ */
 interface TextFieldPatternConfig {
     pattern?: string | RegExp;
 }
+/**
+ * HTML input type for a text field.
+ */
 type TextFieldInputType = 'text' | 'password' | 'email';
+/**
+ * Full configuration for a single-line text input field.
+ *
+ * Combines labeling, validation (pattern, length), string transformation,
+ * and Material form field styling into one config object.
+ */
 interface TextFieldConfig extends LabeledFieldConfig, DescriptionFieldConfig, TextFieldPatternConfig, TextFieldLengthConfig, AttributesFieldConfig, Partial<TransformStringFunctionConfigRef>, MaterialFormFieldConfig {
+    /** HTML input type. Defaults to `'text'`. */
     inputType?: TextFieldInputType;
+    /** String transformation applied as a value parser (e.g., trim, uppercase). */
     transform?: TransformStringFunctionConfig;
 }
+/**
+ * Builds an array of value parsers for a text field, incorporating any configured
+ * string transformation (e.g., trim, lowercase) as a parser prepended to existing parsers.
+ *
+ * @param config - Parser and transform configuration
+ * @returns Array of value parsers, or undefined if none configured
+ *
+ * @example
+ * ```typescript
+ * const parsers = textFieldTransformParser({ transform: { trim: true, toLowercase: true } });
+ * ```
+ */
 declare function textFieldTransformParser(config: Partial<FieldConfigParsersRef> & Partial<TransformStringFunctionConfigRef>): FormlyValueParser[] | undefined;
+/**
+ * Creates a Formly field configuration for a single-line text input.
+ *
+ * @param config - Text field configuration including key, label, validation, and transform options
+ * @returns A validated {@link FormlyFieldConfig} with type `'input'`
+ *
+ * @example
+ * ```typescript
+ * const field = textField({ key: 'username', label: 'Username', maxLength: 50, required: true });
+ * ```
+ */
 declare function textField(config: TextFieldConfig): FormlyFieldConfig;
+/**
+ * Configuration for a multi-line textarea input field.
+ */
 interface TextAreaFieldConfig extends LabeledFieldConfig, DescriptionFieldConfig, TextFieldPatternConfig, TextFieldLengthConfig, AttributesFieldConfig, Partial<TransformStringFunctionConfigRef>, MaterialFormFieldConfig {
+    /** Number of visible text rows. Defaults to 3. */
     rows?: number;
 }
+/**
+ * Creates a Formly field configuration for a multi-line textarea input.
+ *
+ * @param config - Textarea field configuration including key, label, rows, and validation options
+ * @returns A validated {@link FormlyFieldConfig} with type `'textarea'`
+ *
+ * @example
+ * ```typescript
+ * const field = textAreaField({ key: 'bio', label: 'Biography', rows: 5, maxLength: 500 });
+ * ```
+ */
 declare function textAreaField(config: TextAreaFieldConfig): FormlyFieldConfig;
 
+/**
+ * Configuration for a rich text editor field with optional length constraints.
+ */
 interface TextEditorFieldConfig extends LabeledFieldConfig, DescriptionFieldConfig, TextFieldLengthConfig, MaterialFormFieldConfig {
 }
+/**
+ * Creates a Formly field configuration for a rich text editor.
+ *
+ * The field defaults to an empty string and updates the model on blur events.
+ *
+ * @param config - Text editor field configuration
+ * @returns A validated {@link FormlyFieldConfig} with type `'texteditor'`
+ *
+ * @example
+ * ```typescript
+ * const field = textEditorField({ key: 'bio', label: 'Biography', maxLength: 2000 });
+ * ```
+ */
 declare function textEditorField(config: TextEditorFieldConfig): FormlyFieldConfig;
 
+/**
+ * Represents an item in a repeat array with its index and optional value.
+ */
 interface DbxFormRepeatArrayPair<T = unknown> extends IndexRef {
     readonly value?: T | undefined;
 }
+/**
+ * Extends {@link DbxFormRepeatArrayPair} with the Formly field configuration for the item.
+ */
 interface DbxFormRepeatArrayFieldConfigPair<T = unknown> extends Partial<DbxFormRepeatArrayPair<T>> {
     readonly fieldConfig: FormlyFieldConfig;
 }
+/**
+ * Factory function that creates a template value for a new repeat array item,
+ * given the current count of items.
+ */
 type DbxFormRepeatArrayAddTemplateFunction<T> = FactoryWithRequiredInput<Partial<Maybe<T>>, number>;
+/**
+ * Configuration for the repeat array field component, controlling add/remove/duplicate
+ * behavior, drag-and-drop rearranging, and item labeling.
+ */
 interface DbxFormRepeatArrayConfig<T = unknown> extends Pick<FormlyFieldProps, 'maxLength' | 'label' | 'description'> {
     readonly labelForField?: string | FactoryWithRequiredInput<string, DbxFormRepeatArrayFieldConfigPair<T>>;
     /**
@@ -1749,6 +2645,14 @@ interface DbxFormRepeatArrayConfig<T = unknown> extends Pick<FormlyFieldProps, '
      */
     readonly addDuplicateToEnd?: boolean;
 }
+/**
+ * Formly custom field type for dynamically repeatable arrays of field groups.
+ *
+ * Renders a list of field groups that users can add to, remove from, duplicate,
+ * and rearrange via drag-and-drop. Enforces an optional maximum item count.
+ *
+ * Registered as Formly type `'repeatarray'`.
+ */
 declare class DbxFormRepeatArrayTypeComponent<T = unknown> extends FieldArrayType<FieldArrayTypeConfig<DbxFormRepeatArrayConfig>> {
     private readonly _labelForField;
     private readonly _allowRemove;
@@ -1785,15 +2689,40 @@ declare class DbxFormRepeatArrayTypeComponent<T = unknown> extends FieldArrayTyp
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxFormRepeatArrayTypeComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/** Registers the `repeatarray` Formly field type for dynamic array fields. */
 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>;
 }
 
+/**
+ * Configuration for a repeat-array field that allows users to dynamically add/remove
+ * groups of fields (e.g., multiple addresses, phone numbers).
+ */
 interface RepeatArrayFieldConfig<T = unknown> extends DbxFormRepeatArrayConfig<T>, FieldConfig {
+    /** Field group template that is repeated for each array entry. */
     repeatFieldGroup: ArrayOrValue<FormlyFieldConfig>;
 }
+/**
+ * Creates a Formly field configuration for a repeatable array of field groups.
+ *
+ * Users can dynamically add, remove, duplicate, and rearrange entries.
+ *
+ * @param config - Repeat array configuration including the template field group
+ * @returns A validated {@link FormlyFieldConfig} with type `'repeatarray'`
+ *
+ * @example
+ * ```typescript
+ * const field = repeatArrayField({
+ *   key: 'items',
+ *   label: 'Items',
+ *   addText: 'Add Item',
+ *   removeText: 'Remove Item',
+ *   repeatFieldGroup: [textField({ key: 'name', label: 'Name' })]
+ * });
+ * ```
+ */
 declare function repeatArrayField<T = unknown>(config: RepeatArrayFieldConfig<T>): {
     fieldArray: {
         fieldGroup: FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
@@ -1828,17 +2757,50 @@ declare function repeatArrayField<T = unknown>(config: RepeatArrayFieldConfig<T>
     type: string;
 };
 
+/** Provides Formly Material checkbox and toggle field support. */
 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>;
 }
 
+/**
+ * Configuration for a Material toggle (slide toggle) field.
+ */
 interface ToggleFieldConfig extends Omit<LabeledFieldConfig, 'placeholder' | 'autocomplete'>, DefaultValueFieldConfig<boolean>, DescriptionFieldConfig, MaterialFormFieldConfig {
 }
+/**
+ * Creates a Formly field configuration for a Material slide toggle.
+ *
+ * Defaults to `false` when no default value is specified. Uses auto-touch and style wrappers.
+ *
+ * @param config - Toggle field configuration
+ * @returns A validated {@link FormlyFieldConfig} with type `'toggle'`
+ *
+ * @example
+ * ```typescript
+ * const field = toggleField({ key: 'active', label: 'Active', defaultValue: true });
+ * ```
+ */
 declare function toggleField(config: ToggleFieldConfig): FormlyFieldConfig;
+/**
+ * Configuration for a Material checkbox field.
+ */
 interface CheckboxFieldConfig extends LabeledFieldConfig, DefaultValueFieldConfig<boolean>, DescriptionFieldConfig, MaterialFormFieldConfig {
 }
+/**
+ * Creates a Formly field configuration for a Material checkbox.
+ *
+ * Defaults to `false` when no default value is specified. Uses a style wrapper.
+ *
+ * @param config - Checkbox field configuration
+ * @returns A validated {@link FormlyFieldConfig} with type `'checkbox'`
+ *
+ * @example
+ * ```typescript
+ * const field = checkboxField({ key: 'agree', label: 'I agree to the terms' });
+ * ```
+ */
 declare function checkboxField(config: CheckboxFieldConfig): FormlyFieldConfig;
 
 /**
@@ -1923,9 +2885,57 @@ declare enum DbxDateTimeValueMode {
      */
     SYSTEM_MINUTE_OF_DAY = 5
 }
+/**
+ * Creates a parser function that converts raw form input values (Date, string, or number)
+ * into JavaScript Date objects based on the specified value mode.
+ *
+ * Handles timezone conversion when a timezone instance is provided and the mode requires it.
+ *
+ * @param mode - Determines how the input value is interpreted
+ * @param timezoneInstance - Optional timezone converter for UTC-normal date handling
+ * @returns A function that parses input values to Date objects
+ *
+ * @example
+ * ```typescript
+ * const parser = dbxDateTimeInputValueParseFactory(DbxDateTimeValueMode.DATE_STRING, timezoneInstance);
+ * const date = parser('2024-01-15T10:00:00Z');
+ * ```
+ */
 declare function dbxDateTimeInputValueParseFactory(mode: DbxDateTimeValueMode, timezoneInstance: Maybe<DateTimezoneUtcNormalInstance>): (date: Maybe<Date | string | number>) => Maybe<Date>;
+/**
+ * Creates a formatter function that converts JavaScript Date objects into the appropriate
+ * output format (Date, ISO string, timestamp, or minute-of-day) based on the specified value mode.
+ *
+ * Handles timezone conversion when a timezone instance is provided and the mode requires it.
+ *
+ * @param mode - Determines the output format
+ * @param timezoneInstance - Optional timezone converter for UTC-normal date handling
+ * @returns A function that formats Date objects to the target output type
+ *
+ * @example
+ * ```typescript
+ * const formatter = dbxDateTimeOutputValueFactory(DbxDateTimeValueMode.DAY_STRING, null);
+ * const dayString = formatter(new Date()); // e.g., '2024-01-15'
+ * ```
+ */
 declare function dbxDateTimeOutputValueFactory(mode: DbxDateTimeValueMode, timezoneInstance: Maybe<DateTimezoneUtcNormalInstance>): (date: Maybe<Date>) => Maybe<Date | string | number>;
+/**
+ * Compares two date-time field values for equality, handling Date, ISO8601DayString, and number (timestamp/minute) types.
+ *
+ * For string and number types, performs strict equality. For Date objects, compares hours and minutes.
+ *
+ * @param a - First date-time value
+ * @param b - Second date-time value
+ * @returns Whether the two values represent the same date-time
+ */
 declare function dbxDateTimeIsSameDateTimeFieldValue(a: Maybe<Date | ISO8601DayString | number>, b: Maybe<Date | ISO8601DayString | number>): boolean;
+/**
+ * Compares two date range field values for equality by comparing both start and end values.
+ *
+ * @param a - First date range value
+ * @param b - Second date range value
+ * @returns Whether the two date ranges represent the same range
+ */
 declare function dbxDateRangeIsSameDateRangeFieldValue(a: Maybe<DateRangeWithDateOrStringValue>, b: Maybe<DateRangeWithDateOrStringValue>): boolean;
 
 declare enum DbxDateTimeFieldTimeMode {
@@ -1942,8 +2952,17 @@ declare enum DbxDateTimeFieldTimeMode {
      */
     NONE = "none"
 }
+/**
+ * Picker configuration for the date-time field, derived from {@link DateTimeMinuteConfig} without the `date` property.
+ */
 type DbxDateTimePickerConfiguration = Omit<DateTimeMinuteConfig, 'date'>;
+/**
+ * Direction of synchronization between date-time fields.
+ */
 type DbxDateTimeFieldSyncType = 'before' | 'after';
+/**
+ * Configuration for synchronizing this date-time field with another field in the same form.
+ */
 interface DbxDateTimeFieldSyncField {
     /**
      * Field key/path to sync with/against.
@@ -1961,6 +2980,9 @@ interface DbxDateTimeFieldTimeDateConfig<I = unknown> {
     readonly path: FormControlPath;
     readonly mapValue?: MapFunction<I, Maybe<DateOrDayString>>;
 }
+/**
+ * Type guard that checks whether the input is a {@link DbxDateTimeFieldTimeDateConfig}.
+ */
 declare function isDbxDateTimeFieldTimeDateConfig(input: unknown): input is DbxDateTimeFieldTimeDateConfig;
 interface DbxDateTimeFieldProps extends FormlyFieldProps {
     /**
@@ -2076,9 +3098,20 @@ interface DbxDateTimeFieldProps extends FormlyFieldProps {
      */
     readonly minuteStep?: Maybe<number>;
 }
+/**
+ * A parsed sync field configuration with a resolved form control reference.
+ */
 interface DbxDateTimeFieldSyncParsedField extends Pick<DbxDateTimeFieldSyncField, 'syncType'> {
     readonly control: AbstractControl<Maybe<Date | ISO8601DateString>>;
 }
+/**
+ * Creates an observable that emits the current Date value from a synced field control
+ * matching the specified sync type ('before' or 'after').
+ *
+ * @param parseConfigsObs - Observable of parsed sync field configurations
+ * @param type - The sync direction to filter for
+ * @returns Observable of the synced date value, or null if no matching sync config
+ */
 declare function syncConfigValueObs(parseConfigsObs: Observable<DbxDateTimeFieldSyncParsedField[]>, type: DbxDateTimeFieldSyncType): Observable<Date | null>;
 /**
  * Error code used when the selected date is not in the schedule.
@@ -2088,6 +3121,15 @@ declare const DBX_DATE_TIME_FIELD_DATE_NOT_IN_SCHEDULE_ERROR = "dateTimeFieldDat
  * 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";
+/**
+ * Formly custom field type for date and time selection.
+ *
+ * Supports date-only, time-only, and combined date-time modes. Handles timezone conversion,
+ * sync with other date fields, configurable presets, and keyboard navigation (arrow keys for
+ * incrementing date/time).
+ *
+ * Registered as Formly type `'datetime'`.
+ */
 declare class DbxDateTimeFieldComponent extends FieldType$1<FieldTypeConfig<DbxDateTimeFieldProps>> implements OnInit, OnDestroy {
     private readonly dbxDateTimeFieldConfigService;
     private readonly _sub;
@@ -2222,9 +3264,24 @@ declare class DbxDateTimeFieldComponent extends FieldType$1<FieldTypeConfig<DbxD
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxDateTimeFieldComponent, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Date range input configuration without the `date` property, which is set by user selection.
+ */
 type DbxFixedDateRangeDateRangeInput = Omit<DateRangeInput, 'date'>;
+/**
+ * Picker configuration for the fixed date range field.
+ */
 type DbxFixedDateRangePickerConfiguration = Omit<DateTimeMinuteConfig, 'date'>;
+/**
+ * Selection mode for the fixed date range picker.
+ *
+ * - `'single'` — Picks one date, range is computed from the date range input config.
+ * - `'normal'` — Standard start/end range picking with two clicks.
+ * - `'arbitrary'` — Free-form range selection within a boundary.
+ * - `'arbitrary_quick'` — Like arbitrary, but immediately sets the value on first click.
+ */
 type DbxFixedDateRangeSelectionMode = 'single' | 'normal' | 'arbitrary' | 'arbitrary_quick';
+/** Whether the user is currently picking the start or end of a range. */
 type DbxFixedDateRangePicking = 'start' | 'end';
 interface DbxFixedDateRangeFieldProps extends FormlyFieldProps {
     /**
@@ -2268,7 +3325,11 @@ interface DbxFixedDateRangeFieldProps extends FormlyFieldProps {
      */
     readonly showRangeInput?: boolean;
 }
+/** Type of the most recent date range pick action. */
 type FixedDateRangeScanType = 'start' | 'end' | 'startRepeat';
+/**
+ * Internal scan state used to track the progressive date range selection process.
+ */
 interface FixedDateRangeScan {
     /**
      * Picked the start or end of the range on the last pick.
@@ -2288,6 +3349,15 @@ interface FixedDateRangeScan {
     readonly range?: DateRange;
 }
 type SelectedDateEventType = 'calendar' | 'input';
+/**
+ * Formly custom field type for selecting a fixed date range using an inline calendar.
+ *
+ * Supports multiple selection modes (single date, normal range, arbitrary range),
+ * timezone conversion, date range input configuration, and optional text inputs for
+ * start/end dates.
+ *
+ * Registered as Formly type `'fixeddaterange'`.
+ */
 declare class DbxFixedDateRangeFieldComponent extends FieldType$1<FieldTypeConfig<DbxFixedDateRangeFieldProps>> implements OnInit, OnDestroy {
     private readonly dbxDateTimeFieldMenuPresetsService;
     readonly calendar: i0.Signal<MatCalendar<Date>>;
@@ -2360,6 +3430,12 @@ declare class DbxFixedDateRangeFieldComponent extends FieldType$1<FieldTypeConfi
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFixedDateRangeFieldComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxFixedDateRangeFieldComponent, "ng-component", never, {}, {}, never, never, true, never>;
 }
+/**
+ * Custom Material date range selection strategy for the fixed date range field.
+ *
+ * Provides preview highlighting on the calendar based on the current selection mode
+ * and boundary constraints.
+ */
 declare class DbxFixedDateRangeFieldSelectionStrategy<D> implements MatDateRangeSelectionStrategy<D> {
     private readonly _dateAdapter;
     readonly dbxFixedDateRangeFieldComponent: DbxFixedDateRangeFieldComponent;
@@ -2373,40 +3449,121 @@ declare class DbxFixedDateRangeFieldSelectionStrategy<D> implements MatDateRange
     static ɵprov: i0.ɵɵInjectableDeclaration<DbxFixedDateRangeFieldSelectionStrategy<any>>;
 }
 
+/** Registers the `datetime` and `fixeddaterange` Formly field types with style and form-field wrappers. */
 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>;
 }
 
+/**
+ * Full configuration for a date-time picker field combining date and time selection.
+ */
 interface DateTimeFieldConfig extends LabeledFieldConfig, DescriptionFieldConfig, DbxDateTimeFieldProps, MaterialFormFieldConfig {
 }
+/**
+ * Configuration for a time-only field (date selection is hidden).
+ */
 type TimeFieldConfig = Omit<DateTimeFieldConfig, 'showDate' | 'timeOnly'>;
+/**
+ * Factory that returns an observable of a date-time picker configuration
+ * that automatically selects the next upcoming time, rounded down to the nearest minute.
+ */
 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;
+/**
+ * Creates a Formly field configuration for a date-time picker with optional time selection,
+ * timezone awareness, and preset values.
+ *
+ * @param config - Optional overrides; defaults to key `'date'`, time mode `REQUIRED`
+ * @returns A validated {@link FormlyFieldConfig} with type `'datetime'`
+ *
+ * @example
+ * ```typescript
+ * const field = dateTimeField({ key: 'startDate', label: 'Start', required: true });
+ * ```
+ */
 declare function dateTimeField(config?: Partial<DateTimeFieldConfig>): FormlyFieldConfig<DbxDateTimeFieldProps>;
+/** Configuration for a single date within a date range (no time mode or sync). */
 type DateDateRangeFieldDateConfig = Omit<DateTimeFieldConfig, 'dateLabel' | 'timeOnly' | 'timeMode' | 'getSyncFieldsObs'>;
+/**
+ * Configuration for a date range field with separate start and end date pickers.
+ */
 interface DateDateRangeFieldConfig extends Pick<DateTimeFieldConfig, 'timeDate' | 'timezone' | 'showTimezone' | 'presets' | 'valueMode' | 'minuteStep'> {
     required?: boolean;
     start?: Partial<DateDateRangeFieldDateConfig>;
     end?: Partial<DateDateRangeFieldDateConfig>;
 }
+/**
+ * Creates a pair of date pickers for selecting a date range (start and end dates)
+ * arranged in a flex layout. The pickers are synchronized so the start date stays before the end date.
+ *
+ * @param config - Date range configuration with optional start/end overrides
+ * @returns A {@link FormlyFieldConfig} containing the start and end date field pair
+ *
+ * @example
+ * ```typescript
+ * const field = dateRangeField({ required: true, start: { key: 'from' }, end: { key: 'to' } });
+ * ```
+ */
 declare function dateRangeField(config?: DateDateRangeFieldConfig): FormlyFieldConfig;
+/** Configuration for a single time within a date-time range (no full-day options). */
 type DateTimeRangeFieldTimeConfig = Omit<DateDateRangeFieldDateConfig, 'allDayLabel' | 'fullDayFieldName' | 'fullDayInUTC'>;
+/**
+ * Configuration for a date-time range field with separate start and end time pickers.
+ */
 interface DateDateTimeRangeFieldConfig extends Pick<DateTimeFieldConfig, 'timeDate' | 'timezone' | 'showTimezone' | 'presets' | 'valueMode' | 'minuteStep'> {
     required?: boolean;
     start?: Partial<DateTimeRangeFieldTimeConfig>;
     end?: Partial<DateTimeRangeFieldTimeConfig>;
 }
+/**
+ * Creates a pair of time-only pickers for selecting a time range (start and end times)
+ * arranged in a flex layout.
+ *
+ * @param inputConfig - Time range configuration with optional start/end overrides
+ * @returns A {@link FormlyFieldConfig} containing the start and end time field pair
+ *
+ * @example
+ * ```typescript
+ * const field = dateTimeRangeField({ required: true });
+ * ```
+ */
 declare function dateTimeRangeField(inputConfig?: DateDateTimeRangeFieldConfig): FormlyFieldConfig;
+/**
+ * Configuration for a fixed date range field that uses a calendar-style range picker.
+ */
 interface FixedDateRangeFieldConfig extends LabeledFieldConfig, DescriptionFieldConfig, DbxFixedDateRangeFieldProps, MaterialFormFieldConfig {
 }
+/**
+ * Creates a Formly field configuration for a fixed date range picker.
+ *
+ * @param config - Optional overrides; defaults to key `'dateRange'`
+ * @returns A validated {@link FormlyFieldConfig} with type `'fixeddaterange'`
+ *
+ * @example
+ * ```typescript
+ * const field = fixedDateRangeField({ key: 'eventDates', required: true });
+ * ```
+ */
 declare function fixedDateRangeField(config?: Partial<FixedDateRangeFieldConfig>): FormlyFieldConfig<DbxDateTimeFieldProps>;
 
+/**
+ * Injection token for providing default date-time field menu presets application-wide.
+ */
 declare const DBX_DATE_TIME_FIELD_MENU_PRESETS_TOKEN: InjectionToken<unknown>;
+/**
+ * Service that manages default date-time preset configurations for all date-time fields.
+ *
+ * Presets are shown in the date-time field dropdown menu and allow users to quickly
+ * select common date/time values (e.g., "Now", "Start of day").
+ *
+ * Provide default presets via {@link DBX_DATE_TIME_FIELD_MENU_PRESETS_TOKEN}, or set them
+ * dynamically via the `configurations` setter.
+ */
 declare class DbxDateTimeFieldMenuPresetsService {
     private readonly _configurations;
     readonly configurations$: rxjs.Observable<DateTimePresetConfiguration[]>;
@@ -2418,17 +3575,54 @@ declare class DbxDateTimeFieldMenuPresetsService {
 
 declare const DEFAULT_DATE_TIME_FIELD_MENU_PRESETS_PRESETS: DateTimePresetConfiguration[];
 
+/**
+ * Numeric constraint configuration for number fields.
+ */
 interface NumberFieldNumberConfig {
     readonly min?: number;
     readonly max?: number;
+    /** Step increment for the input. */
     readonly step?: number;
+    /** When true, adds a validator that enforces the value is divisible by `step`. */
     readonly enforceStep?: boolean;
 }
+/** HTML input type for number fields. */
 type NumberFieldInputType = 'number';
+/**
+ * Full configuration for a numeric input field.
+ *
+ * Combines labeling, numeric constraints (min/max/step), number transformation,
+ * and Material form field styling.
+ */
 interface NumberFieldConfig extends LabeledFieldConfig, DescriptionFieldConfig, NumberFieldNumberConfig, AttributesFieldConfig, Partial<TransformNumberFunctionConfigRef>, MaterialFormFieldConfig {
     readonly inputType?: NumberFieldInputType;
 }
+/**
+ * Builds an array of value parsers for a number field, incorporating any configured
+ * number transformation (e.g., precision, rounding) as a parser prepended to existing parsers.
+ *
+ * @param config - Parser and transform configuration
+ * @returns Array of value parsers, or undefined if none configured
+ *
+ * @example
+ * ```typescript
+ * const parsers = numberFieldTransformParser({ transform: { precision: 2 } });
+ * ```
+ */
 declare function numberFieldTransformParser(config: Partial<FieldConfigParsersRef> & Partial<TransformNumberFunctionConfigRef>): FormlyValueParser[] | undefined;
+/**
+ * Creates a Formly field configuration for a numeric input.
+ *
+ * Adds a divisibility validator when both `step` and `enforceStep` are set.
+ *
+ * @param config - Number field configuration
+ * @returns A validated {@link FormlyFieldConfig} with type `'input'` and input type `'number'`
+ *
+ * @example
+ * ```typescript
+ * const field = numberField({ key: 'quantity', label: 'Quantity', min: 1, max: 100, step: 1 });
+ * ```
+ */
 declare function numberField(config: NumberFieldConfig): FormlyFieldConfig;
 interface NumberSliderFieldConfig extends NumberFieldConfig {
     /**
@@ -2460,20 +3654,49 @@ interface NumberSliderFieldConfig extends NumberFieldConfig {
      */
     readonly displayWith?: (value: number) => string;
 }
+/**
+ * Creates a Formly field configuration for a Material slider input.
+ *
+ * @param config - Slider field configuration including max (required), thumb label, and tick interval
+ * @returns A validated {@link FormlyFieldConfig} with type `'slider'`
+ *
+ * @example
+ * ```typescript
+ * const field = numberSliderField({ key: 'rating', label: 'Rating', min: 0, max: 10, step: 1 });
+ * ```
+ */
 declare function numberSliderField(config: NumberSliderFieldConfig): FormlyFieldConfig;
+/** Configuration for a dollar amount field, which enforces cent-level precision. */
 type DollarAmountFieldConfig = Omit<NumberFieldConfig, 'roundToStep' | 'precision'>;
+/**
+ * Creates a number field pre-configured for dollar amount input with cent-level precision.
+ *
+ * @param config - Number field configuration (precision is overridden to dollar amount precision)
+ * @returns A {@link FormlyFieldConfig} for dollar amount input
+ *
+ * @example
+ * ```typescript
+ * const field = dollarAmountField({ key: 'price', label: 'Price', min: 0, required: true });
+ * ```
+ */
 declare function dollarAmountField(config: DollarAmountFieldConfig): FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
     [additionalProperties: string]: any;
 }>;
 
+/** Provides Formly Material number input and slider support. */
 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>;
 }
 
+/**
+ * Formly field props for the international phone number component.
+ */
 interface InternationalPhoneFormlyFieldProps extends FormlyFieldProps {
+    /** ISO country codes for countries shown first in the dropdown. */
     readonly preferredCountries?: Maybe<string[]>;
+    /** ISO country codes to restrict the dropdown to. */
     readonly onlyCountries?: Maybe<string[]>;
     /**
      * Whether or not to enable the search feature. True by default.
@@ -2484,7 +3707,16 @@ interface InternationalPhoneFormlyFieldProps extends FormlyFieldProps {
      */
     readonly allowExtension?: boolean;
 }
+/** Default preferred countries shown at the top of the phone country dropdown. */
 declare const DEFAULT_PREFERRED_COUNTRIES: string[];
+/**
+ * Formly custom field type for international phone number input with optional extension support.
+ *
+ * Uses ngx-mat-input-tel for the country-aware phone input and manages E.164 phone number
+ * formatting. Supports splitting phone + extension pairs for storage and display.
+ *
+ * Registered as Formly type `'intphone'`.
+ */
 declare class DbxPhoneFieldComponent extends FieldType$1<FieldTypeConfig<InternationalPhoneFormlyFieldProps>> implements OnInit, OnDestroy {
     readonly inputSync: SubscriptionObject<rxjs.Unsubscribable>;
     readonly outputSync: SubscriptionObject<rxjs.Unsubscribable>;
@@ -2506,57 +3738,208 @@ declare class DbxPhoneFieldComponent extends FieldType$1<FieldTypeConfig<Interna
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxPhoneFieldComponent, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
+/** Registers the `intphone` Formly field type for international phone number input. */
 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>;
 }
 
+/**
+ * Configuration for an international phone number input field.
+ */
 interface InternationalPhoneFieldConfig extends LabeledFieldConfig, InternationalPhoneFormlyFieldProps {
 }
+/**
+ * Creates a Formly field configuration for an international phone number input
+ * with E.164 validation.
+ *
+ * @param config - Optional overrides; defaults to key `'phone'`, label `'Phone Number'`
+ * @returns A validated {@link FormlyFieldConfig} with type `'intphone'`
+ *
+ * @example
+ * ```typescript
+ * const field = phoneField({ preferredCountries: ['us', 'ca'], required: true });
+ * ```
+ */
 declare function phoneField(config?: Partial<InternationalPhoneFieldConfig>): FormlyFieldConfig<InternationalPhoneFormlyFieldProps>;
+/**
+ * Configuration for a phone number field paired with a text label field.
+ */
 interface WrappedPhoneAndLabelFieldConfig {
     readonly phoneField?: Partial<InternationalPhoneFieldConfig>;
     readonly labelField?: TextFieldConfig;
 }
 /**
- * Puts a phone and
- * @param param0
- * @returns
+ * Creates a flex-layout-wrapped pair of a phone number field and a label text field,
+ * useful for collecting named phone numbers (e.g., "Work", "Home").
+ *
+ * @param config - Optional phone and label field configurations
+ * @returns A flex-layout-wrapped {@link FormlyFieldConfig}
+ *
+ * @example
+ * ```typescript
+ * const field = wrappedPhoneAndLabelField({ phoneField: { required: true } });
+ * ```
  */
 declare function wrappedPhoneAndLabelField({ phoneField: phone, labelField: label }?: WrappedPhoneAndLabelFieldConfig): FormlyFieldConfig;
+/**
+ * Configuration for a section-wrapped phone + label field pair.
+ */
 interface PhoneAndLabelFieldSectionConfig extends DbxFormSectionConfig, WrappedPhoneAndLabelFieldConfig {
     readonly key?: string;
 }
+/**
+ * Creates a section-wrapped phone + label field pair with a configurable header.
+ *
+ * @param config - Optional overrides; defaults to header `'Phone Number'`
+ * @returns A section-wrapped {@link FormlyFieldConfig}
+ *
+ * @example
+ * ```typescript
+ * const field = phoneAndLabelSectionField({ header: 'Contact Phone' });
+ * ```
+ */
 declare function phoneAndLabelSectionField({ key, header, hint, phoneField, labelField }?: PhoneAndLabelFieldSectionConfig): FormlyFieldConfig;
+/**
+ * Configuration for a repeatable list of phone + label field pairs.
+ */
 interface PhoneListFieldConfig extends Omit<RepeatArrayFieldConfig, 'repeatFieldGroup'> {
     phoneAndLabel?: WrappedPhoneAndLabelFieldConfig;
     repeatFieldGroup?: FormlyFieldConfig[];
 }
+/**
+ * Creates a repeat-array field that allows the user to add multiple phone number entries.
+ *
+ * @param repeatConfig - Optional overrides; defaults to key `'phones'`, label `'Phone Numbers'`
+ * @returns A {@link FormlyFieldConfig} with repeat-array type for multiple phone entries
+ *
+ * @example
+ * ```typescript
+ * const field = phoneListField({ phoneAndLabel: { phoneField: { preferredCountries: ['us'] } } });
+ * ```
+ */
 declare function phoneListField(repeatConfig?: Partial<PhoneListFieldConfig>): FormlyFieldConfig;
 
+/** Maximum character length for a phone label field. */
 declare const PHONE_LABEL_MAX_LENGTH = 100;
+/** Maximum character length for a generic label string field. */
 declare const LABEL_STRING_MAX_LENGTH = 100;
+/** Maximum character length for a search string field. */
 declare const SEARCH_STRING_MAX_LENGTH = 100;
+/**
+ * Creates a text field pre-configured for a person's full name.
+ *
+ * @param config - Optional overrides; defaults to key `'name'`, label `'Name'`
+ * @returns A {@link FormlyFieldConfig} for name input
+ *
+ * @example
+ * ```typescript
+ * const field = nameField({ required: true });
+ * ```
+ */
 declare function nameField(config?: Partial<TextFieldConfig>): FormlyFieldConfig;
+/**
+ * Configuration for an email address input field.
+ */
 interface EmailFieldConfig extends Partial<LabeledFieldConfig>, DescriptionFieldConfig {
     readonly rows?: number;
 }
+/**
+ * Creates a text field pre-configured for email address input with built-in email validation.
+ *
+ * @param config - Optional overrides; defaults to key `'email'`, label `'Email Address'`
+ * @returns A {@link FormlyFieldConfig} with email validation
+ *
+ * @example
+ * ```typescript
+ * const field = emailField({ required: true });
+ * ```
+ */
 declare function emailField(config?: EmailFieldConfig): FormlyFieldConfig;
+/** Configuration for a city input field. */
 type CityFieldConfig = Partial<TextFieldConfig>;
+/**
+ * Creates a text field pre-configured for city name input with autocomplete support.
+ *
+ * @param config - Optional overrides; defaults to key `'city'`, label `'City'`
+ * @returns A {@link FormlyFieldConfig} for city input
+ *
+ * @example
+ * ```typescript
+ * const field = cityField({ required: true });
+ * ```
+ */
 declare function cityField(config?: CityFieldConfig): FormlyFieldConfig;
+/**
+ * Configuration for a US state input field.
+ */
 interface StateFieldConfig extends Partial<TextFieldConfig> {
+    /** When true, validates and formats as a 2-letter state code (e.g., `'CA'`). */
     readonly asCode?: boolean;
 }
+/**
+ * Creates a text field pre-configured for US state input with optional state code validation.
+ *
+ * When `asCode` is true, enforces the 2-letter state code pattern and auto-uppercases input.
+ *
+ * @param config - Optional overrides; defaults to key `'state'`, label `'State'`
+ * @returns A {@link FormlyFieldConfig} for state input
+ *
+ * @example
+ * ```typescript
+ * const field = stateField({ asCode: true, required: true });
+ * ```
+ */
 declare function stateField(config?: StateFieldConfig): FormlyFieldConfig;
+/** Configuration for a country input field. */
 type CountryFieldConfig = Partial<TextFieldConfig>;
+/**
+ * Creates a text field pre-configured for country name input with autocomplete support.
+ *
+ * @param config - Optional overrides; defaults to key `'country'`, label `'Country'`
+ * @returns A {@link FormlyFieldConfig} for country input
+ *
+ * @example
+ * ```typescript
+ * const field = countryField({ required: true });
+ * ```
+ */
 declare function countryField(config?: CountryFieldConfig): FormlyFieldConfig;
+/** Configuration for a zip/postal code input field. */
 type ZipCodeFieldConfig = Partial<TextFieldConfig>;
+/**
+ * Creates a text field pre-configured for US zip code input with pattern validation.
+ *
+ * @param config - Optional overrides; defaults to key `'zip'`, label `'Zip Code'`
+ * @returns A {@link FormlyFieldConfig} for zip code input
+ *
+ * @example
+ * ```typescript
+ * const field = zipCodeField({ required: true });
+ * ```
+ */
 declare function zipCodeField(config?: ZipCodeFieldConfig): FormlyFieldConfig;
+/** Default placeholder text for a latitude/longitude text field. */
 declare const DEFAULT_LAT_LNG_TEXT_FIELD_PLACEHOLDER = "12.345,-67.8910";
+/** Default validation error message for invalid coordinate input. */
 declare const DEFAULT_LAT_LNG_TEXT_FIELD_PATTERN_MESSAGE = "Invalid/unknown coordinates";
+/**
+ * Creates a text field pre-configured for latitude/longitude coordinate input with pattern validation.
+ *
+ * @param config - Optional overrides; defaults to key `'latLng'`
+ * @returns A {@link FormlyFieldConfig} for coordinate input
+ *
+ * @example
+ * ```typescript
+ * const field = latLngTextField();
+ * ```
+ */
 declare function latLngTextField({ key }?: Partial<TextFieldConfig>): FormlyFieldConfig;
 
+/**
+ * Configuration for a group of address-related form fields (lines, city, state, zip, country).
+ */
 interface AddressFormlyFieldsConfig {
     readonly line1Field?: CityFieldConfig;
     readonly line2Field?: CityFieldConfig;
@@ -2583,42 +3966,163 @@ interface AddressFormlyFieldsConfig {
      */
     readonly includeCountry?: boolean;
 }
+/**
+ * Configuration for a single address line field.
+ */
 interface AddressLineFieldConfig extends Partial<TextFieldConfig> {
+    /** Address line number: 0 for single "Street" line, 1 for "Line 1", 2 for "Line 2". */
     readonly line?: 0 | 1 | 2;
 }
+/**
+ * Creates a text field for a single address line with autocomplete support.
+ *
+ * @param config - Optional overrides; line number determines key and label
+ * @returns A {@link FormlyFieldConfig} for address line input
+ *
+ * @example
+ * ```typescript
+ * const line1 = addressLineField({ line: 1, required: true });
+ * const line2 = addressLineField({ line: 2 });
+ * ```
+ */
 declare function addressLineField(config?: AddressLineFieldConfig): FormlyFieldConfig;
+/**
+ * Creates the full set of address form fields (lines, city, state, zip, and optionally country)
+ * arranged in a flex layout.
+ *
+ * @param config - Address fields configuration
+ * @returns Array of {@link FormlyFieldConfig} for a complete address form section
+ *
+ * @example
+ * ```typescript
+ * const fields = addressFormlyFields({ required: true, includeCountry: false });
+ * ```
+ */
 declare function addressFormlyFields(config?: AddressFormlyFieldsConfig): FormlyFieldConfig[];
+/**
+ * Configuration for a complete address section field wrapped in a form section.
+ */
 interface AddressFieldConfig extends Readonly<FieldConfig>, DbxFormSectionConfig, AddressFormlyFieldsConfig {
 }
+/**
+ * Creates a section-wrapped address field group containing all address sub-fields.
+ *
+ * @param config - Optional overrides; defaults to key `'address'`, header `'Address'`
+ * @returns A section-wrapped {@link FormlyFieldConfig} containing address fields
+ *
+ * @example
+ * ```typescript
+ * const field = addressField({ required: true, includeCountry: true });
+ * ```
+ */
 declare function addressField(config?: Partial<AddressFieldConfig>): FormlyFieldConfig;
+/**
+ * Configuration for a repeatable list of address field groups.
+ */
 interface AddressListFieldConfig extends Readonly<FieldConfig>, AddressFormlyFieldsConfig {
+    /** Maximum number of addresses allowed. Defaults to 6. */
     readonly maxAddresses?: number;
 }
+/**
+ * Creates a repeat-array field that allows the user to add multiple addresses.
+ *
+ * @param config - Optional overrides; defaults to key `'addresses'`, max 6 entries
+ * @returns A {@link FormlyFieldConfig} with repeat-array type for multiple addresses
+ *
+ * @example
+ * ```typescript
+ * const field = addressListField({ maxAddresses: 3, required: true });
+ * ```
+ */
 declare function addressListField(config?: Partial<AddressListFieldConfig>): FormlyFieldConfig;
 
+/** Aggregates Formly Material input, array field, and wrapper modules for text field support. */
 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>;
 }
 
+/**
+ * Configuration for a hidden form field that is not visible to the user.
+ */
 type HiddenFieldConfig = Pick<LabeledFieldConfig, 'key' | 'required'>;
+/**
+ * Creates a Formly field configuration for a hidden field with no visual representation.
+ *
+ * Useful for passing programmatic values through the form model without user interaction.
+ *
+ * @param config - Key and optional required flag
+ * @returns A validated {@link FormlyFieldConfig} with no visible type
+ *
+ * @example
+ * ```typescript
+ * const field = hiddenField({ key: 'userId', required: true });
+ * ```
+ */
 declare function hiddenField({ key, required }: HiddenFieldConfig): FormlyFieldConfig;
 
+/**
+ * A {@link FormlyFieldConfig} that wraps a child field config with a named wrapper and associated props.
+ *
+ * @typeParam P - Wrapper props type
+ * @typeParam C - Child field config type
+ */
 type WrapperFormlyFieldConfig<P, C extends FormlyFieldConfig> = FormlyFieldConfig<P> & {
     wrappers: string[];
     props: P;
     fieldGroup: [C];
 };
+/**
+ * Wraps a Formly field config with a named wrapper and its associated props.
+ *
+ * @param fieldConfig - The field config to wrap
+ * @param wrapperKey - The registered wrapper key
+ * @param wrapperProps - Configuration props for the wrapper
+ * @returns A new field config with the wrapper applied
+ *
+ * @example
+ * ```typescript
+ * const wrapped = addWrapperToFormlyFieldConfig(myField, 'section', { header: 'Details' });
+ * ```
+ */
 declare function addWrapperToFormlyFieldConfig<C extends FormlyFieldConfig, P extends object>(fieldConfig: C, wrapperKey: string, wrapperProps: P): WrapperFormlyFieldConfig<P, C>;
+/**
+ * Wraps a field with the auto-touch wrapper that marks the control as touched on value change.
+ */
 declare function autoTouchWrapper<T extends object, C extends FormlyFieldConfig>(fieldConfig: C, autoTouchWrapper?: DbxFormExpandWrapperConfig<T>): WrapperFormlyFieldConfig<DbxFormExpandWrapperConfig<T>, C>;
+/**
+ * Wraps a field with the expand wrapper that shows/hides the field based on value or user click.
+ */
 declare function expandWrapper<T extends object, C extends FormlyFieldConfig>(fieldConfig: C, expandWrapper?: DbxFormExpandWrapperConfig<T>): WrapperFormlyFieldConfig<DbxFormExpandWrapperConfig<T>, C>;
+/**
+ * Wraps a field with the toggle wrapper that uses a slide toggle to show/hide content.
+ */
 declare function toggleWrapper<C extends FormlyFieldConfig>(fieldConfig: C, toggleWrapper?: DbxFormToggleWrapperConfig): WrapperFormlyFieldConfig<DbxFormToggleWrapperConfig<object>, C>;
+/**
+ * Wraps a field group in a section layout with an optional header and hint.
+ */
 declare function sectionWrapper<C extends FormlyFieldConfig>(fieldConfig: C, sectionWrapper?: DbxFormSectionConfig): WrapperFormlyFieldConfig<_dereekb_dbx_web.DbxSectionHeaderConfig, C>;
+/**
+ * Wraps a field group in a subsection layout with an optional header and hint.
+ */
 declare function subsectionWrapper<C extends FormlyFieldConfig>(fieldConfig: C, subsectionWrapper?: DbxFormSubsectionConfig): WrapperFormlyFieldConfig<_dereekb_dbx_web.DbxSectionHeaderConfig, C>;
+/**
+ * Wraps a field with an info button that triggers a callback when clicked.
+ */
 declare function infoWrapper<C extends FormlyFieldConfig>(fieldConfig: C, infoWrapper: DbxFormInfoConfig): WrapperFormlyFieldConfig<DbxFormInfoConfig, C>;
+/**
+ * Wraps a field with dynamic CSS class and style bindings.
+ */
 declare function styleWrapper<C extends FormlyFieldConfig>(fieldConfig: C, styleWrapper: DbxFormStyleWrapperConfig): WrapperFormlyFieldConfig<DbxFormStyleWrapperConfig, C>;
+/**
+ * Wraps a field with a loading indicator that shows during async validation.
+ */
 declare function workingWrapper<C extends FormlyFieldConfig>(fieldConfig: C, workingWrapper?: DbxFormWorkingWrapperConfig): WrapperFormlyFieldConfig<object, C>;
+/**
+ * Configuration for a single field within a flex layout wrapper group,
+ * pairing a field config with an optional flex size.
+ */
 interface DbxFlexLayoutWrapperGroupFieldConfig {
     field: FormlyFieldConfig;
     /**
@@ -2626,11 +4130,36 @@ interface DbxFlexLayoutWrapperGroupFieldConfig {
      */
     size?: DbxFlexSize;
 }
+/**
+ * Default configuration for a flex layout group, combining flex wrapper settings
+ * with a default size for fields that don't specify their own.
+ */
 interface DbxFlexLayoutWrapperGroupFieldConfigDefaults extends DbxFlexWrapperConfig, Omit<DbxFlexLayoutWrapperGroupFieldConfig, 'field'> {
 }
+/**
+ * Type guard that checks if the input is a {@link DbxFlexLayoutWrapperGroupFieldConfig}
+ * (has a `field` property) rather than a plain {@link FormlyFieldConfig}.
+ */
 declare function checkIsFieldFlexLayoutGroupFieldConfig(input: FormlyFieldConfig | DbxFlexLayoutWrapperGroupFieldConfig): input is DbxFlexLayoutWrapperGroupFieldConfig;
+/**
+ * Creates a flex-layout-wrapped field group that arranges child fields horizontally
+ * with configurable sizing, breakpoints, and responsive behavior.
+ *
+ * @param fieldConfigs - Array of field configs or field config pairs with size overrides
+ * @param options - Flex layout defaults including breakpoint, relative sizing, and default size
+ * @returns A {@link FormlyFieldConfig} with flex wrapper applied
+ *
+ * @example
+ * ```typescript
+ * const layout = flexLayoutWrapper([
+ *   { field: textField({ key: 'first' }), size: 2 },
+ *   { field: textField({ key: 'last' }), size: 2 }
+ * ], { relative: true });
+ * ```
+ */
 declare function flexLayoutWrapper(fieldConfigs: (FormlyFieldConfig | DbxFlexLayoutWrapperGroupFieldConfig)[], { relative, breakpoint, breakToColumn, size: defaultSize }?: DbxFlexLayoutWrapperGroupFieldConfigDefaults): FormlyFieldConfig<DbxFlexWrapperConfig>;
 
+/** Aggregates all custom Formly field type modules (checklist, component, texteditor) and wrappers. */
 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]>;
@@ -2730,11 +4259,43 @@ interface FieldValueIsAvailableValidatorConfig<T> {
  */
 declare function fieldValueIsAvailableValidator<T>(config: FieldValueIsAvailableValidatorConfig<T>): AsyncValidatorFn;
 
+/**
+ * Configuration for a text field that includes an async availability check.
+ *
+ * Extends {@link TextFieldConfig} with availability validation options, allowing consumers
+ * to verify that a text value (e.g., a username) is available before submission.
+ */
 interface TextAvailableFieldConfig extends TextFieldConfig, Omit<FieldValueIsAvailableValidatorConfig<string>, 'message'> {
+    /**
+     * Custom error message displayed when the value is not available.
+     */
     readonly isNotAvailableErrorMessage?: string;
 }
+/**
+ * Creates a text field with an async validator that checks whether the entered value is available.
+ *
+ * The field is wrapped in a working wrapper to display a loading indicator during the async check.
+ *
+ * @param config - Configuration for the text field and availability validation.
+ * @returns A Formly field configuration with async availability validation.
+ *
+ * @example
+ * ```ts
+ * const usernameField = textIsAvailableField({
+ *   key: 'username',
+ *   label: 'Username',
+ *   isAvailable: (value) => checkUsernameAvailable(value),
+ *   isNotAvailableErrorMessage: 'Username is already taken'
+ * });
+ * ```
+ */
 declare function textIsAvailableField(config: TextAvailableFieldConfig): FormlyFieldConfig;
 
+/**
+ * Angular module that provides the dependencies needed for the text availability field template.
+ *
+ * Imports and re-exports the text field and wrapper modules required by {@link textIsAvailableField}.
+ */
 declare class DbxFormTextAvailableFieldModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormTextAvailableFieldModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormTextAvailableFieldModule, never, [typeof DbxFormFormlyTextFieldModule, typeof DbxFormFormlyWrapperModule], [typeof DbxFormFormlyTextFieldModule, typeof DbxFormFormlyWrapperModule]>;
@@ -2751,35 +4312,79 @@ type TextPasswordFieldPasswordParameters = Partial<Pick<TextFieldConfig, 'maxLen
 interface TextPasswordFieldConfig extends Omit<TextFieldConfig, 'inputType' | 'key'>, Partial<Pick<TextFieldConfig, 'key' | 'materialFormField'>> {
 }
 /**
- * Configured simple text password field.
+ * Creates a simple text password field with the input type set to `'password'`.
  *
- * @param config
- * @returns
+ * Defaults to the key `'password'` and label `'Password'` unless overridden.
+ *
+ * @param config - Optional configuration for the password field.
+ * @returns A Formly field configuration for a password input.
  */
 declare function textPasswordField(config?: TextPasswordFieldConfig): FormlyFieldConfig;
 /**
- * Configured verify field for a password.
+ * Creates a verify/confirm password field, typically used alongside a primary password field.
  *
- * @param config
- * @returns
+ * Defaults to the key `'verifyPassword'` and label `'Verify Password'` unless overridden.
+ *
+ * @param config - Optional configuration for the verify password field.
+ * @returns A Formly field configuration for a verify password input.
  */
 declare function textVerifyPasswordField(config?: TextPasswordFieldConfig): FormlyFieldConfig;
+/**
+ * Configuration for a password field group that includes a verification (confirm) password field.
+ */
 interface TextPasswordWithVerifyFieldConfig {
+    /**
+     * Optional configuration for the primary password field.
+     */
     readonly password?: TextPasswordFieldConfig;
+    /**
+     * Optional configuration for the verify/confirm password field.
+     */
     readonly verifyPassword?: TextPasswordFieldConfig;
 }
+/**
+ * Creates a Formly field group containing a password field and a verify password field
+ * with a cross-field validator that ensures both values match.
+ *
+ * @param config - Configuration for the password and verify password fields.
+ * @returns A Formly field group configuration with password matching validation.
+ */
 declare function textPasswordWithVerifyFieldGroup(config: TextPasswordWithVerifyFieldConfig): FormlyFieldConfig;
+/**
+ * Configuration for the username field in a login form, supporting either email or text input.
+ */
 interface UsernameLoginFieldUsernameConfig {
+    /**
+     * Configuration for an email-based username field.
+     */
     readonly email?: Omit<EmailFieldConfig, 'key'>;
+    /**
+     * Configuration for a plain text username field.
+     */
     readonly username?: Omit<TextFieldConfig, 'key'>;
 }
+/**
+ * Input type for the username field configuration.
+ *
+ * Can be the string `'email'` or `'username'` for quick defaults, or a full {@link UsernameLoginFieldUsernameConfig} object for custom configuration.
+ */
 type UsernameLoginFieldUsernameConfigInput = 'email' | 'username' | UsernameLoginFieldUsernameConfig;
 /**
  * usernamePasswordLoginFields() configuration.
  */
 interface UsernameLoginFieldsConfig {
+    /**
+     * Username field configuration. Use `'email'` or `'username'` for defaults, or provide a custom config.
+     */
     readonly username: UsernameLoginFieldUsernameConfigInput;
+    /**
+     * Optional configuration for the password field.
+     */
     readonly password?: TextPasswordFieldConfig;
+    /**
+     * Whether to include a verify password field, or a custom configuration for it.
+     * Set to `true` for defaults, `false`/`undefined` to omit, or pass a config object.
+     */
     readonly verifyPassword?: Maybe<boolean | TextPasswordFieldConfig>;
 }
 /**
@@ -2802,30 +4407,68 @@ declare function usernamePasswordLoginFields({ username, password, verifyPasswor
 interface DefaultUsernameLoginFieldValue {
     readonly username: string;
 }
+/**
+ * Creates a single username field for a login form. Supports email or plain text input
+ * based on the provided configuration.
+ *
+ * @param username - Either `'email'`, `'username'`, or a full {@link UsernameLoginFieldUsernameConfig}.
+ * @returns A Formly field configuration for the username input.
+ */
 declare function usernameLoginField(username: UsernameLoginFieldUsernameConfigInput): FormlyFieldConfig;
 
+/**
+ * Angular module that provides the dependencies needed for login form field templates.
+ *
+ * Imports and re-exports the text field module required by the username/password login field functions.
+ */
 declare class DbxFormLoginFieldModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormLoginFieldModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormLoginFieldModule, never, [typeof DbxFormFormlyTextFieldModule], [typeof DbxFormFormlyTextFieldModule]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormLoginFieldModule>;
 }
 
+/**
+ * A function that takes a search string and returns matching string results.
+ */
 type TestStringSearchFunction = (text: string) => string[];
+/**
+ * Creates a search function for timezone strings that searches across all known timezone infos.
+ *
+ * When the search string is empty, the system timezone is returned first, followed by all timezones.
+ *
+ * @returns A {@link SearchableValueFieldStringSearchFn} for searching timezone values.
+ */
 declare function timezoneStringSearchFunction(): SearchableValueFieldStringSearchFn<string, TimezoneInfo>;
+/**
+ * Display function for timezone string values in a searchable field.
+ *
+ * Maps each timezone value to a display object with the timezone name as the label
+ * and its abbreviation as the sublabel.
+ */
 declare const DISPLAY_FOR_TIMEZONE_STRING_VALUE: SearchableValueFieldDisplayFn<string, TimezoneInfo>;
 /**
- * textPasswordField() configuration.
+ * Configuration for a timezone string searchable field.
+ *
+ * Omits search-related properties that are internally configured by {@link timezoneStringField}.
  */
 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.
+ * Creates a searchable text field for selecting a timezone.
  *
- * @param param0
- * @returns
+ * Defaults to the key `'timezone'` and label `'Timezone'`. Searches all known timezones
+ * and displays the timezone name with its abbreviation.
+ *
+ * @param config - Optional configuration overrides for the timezone field.
+ * @returns A Formly field configuration for timezone selection.
  */
 declare function timezoneStringField(config?: TimezoneStringFieldConfig): FormlyFieldConfig;
 
+/**
+ * Angular module that provides the dependencies needed for the timezone string field template.
+ *
+ * Imports and re-exports the searchable field module required by {@link timezoneStringField}.
+ */
 declare class DbxFormTimezoneStringFieldModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormTimezoneStringFieldModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormTimezoneStringFieldModule, never, [typeof DbxFormFormlySearchableFieldModule], [typeof DbxFormFormlySearchableFieldModule]>;
@@ -2847,6 +4490,12 @@ interface IsWebsiteUrlValidatorConfig {
      * Defaults to true.
      */
     readonly requirePrefix?: Maybe<boolean>;
+    /**
+     * Whether or not to allow URLs with a port number but no TLD (e.g. http://localhost:9010/path).
+     *
+     * Defaults to false.
+     */
+    readonly allowPorts?: Maybe<boolean>;
     /**
      * Valid domains to accept.
      *
@@ -2863,15 +4512,19 @@ interface IsWebsiteUrlValidatorConfig {
 declare function isWebsiteUrlValidator(config?: IsWebsiteUrlValidatorConfig): ValidatorFn;
 
 /**
- * websiteUrlField() configuration.
+ * Configuration for a website URL text field.
+ *
+ * Extends {@link TextFieldConfig} with URL validation options from {@link IsWebsiteUrlValidatorConfig}.
  */
 interface WebsiteUrlFieldConfig extends Omit<TextFieldConfig, 'inputType' | 'key'>, Partial<Pick<TextFieldConfig, 'key' | 'materialFormField'>>, IsWebsiteUrlValidatorConfig {
 }
 /**
- * Configured simple text password field.
+ * Creates a text field configured for website URL input with URL validation.
  *
- * @param config
- * @returns
+ * Defaults to the key `'website'` and label `'Website Url'` unless overridden in the config.
+ *
+ * @param config - Optional configuration for the website URL field.
+ * @returns A Formly field configuration with website URL validation.
  */
 declare function websiteUrlField(config?: WebsiteUrlFieldConfig): FormlyFieldConfig;
 
@@ -2954,6 +4607,10 @@ declare function provideDbxFormFormlyFieldDeclarations(): i0.EnvironmentProvider
 
 /**
  * Provides vertical spacing after a form.
+ *
+ * Can be used as an element (`<dbx-form-spacer>`), attribute (`[dbxFormSpacer]`), or CSS class (`.dbx-form-spacer`).
+ *
+ * @selector `dbx-form-spacer,[dbxFormSpacer],.dbx-form-spacer`
  */
 declare class DbxFormSpacerDirective {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormSpacerDirective, never>;