import * as _angular_core from '@angular/core';
import { Type, Provider, OnInit, OnDestroy, Signal, InputSignal, ElementRef, ViewContainerRef, InjectionToken, EnvironmentProviders } from '@angular/core';
import { Transition, HookResult } from '@uirouter/core';
import * as _dereekb_dbx_web from '@dereekb/dbx-web';
import { DbxActionTransitionSafetyDirective, DbxActionTransitionSafetyType, AbstractDialogDirective, DbxButtonStyle, DbxChipDisplay, DbxButtonDisplayStylePair, DbxValueListItem, AbstractDbxSelectionListWrapperDirective, DbxValueListItemDecisionFunction, ScreenMediaWidthType, DbxFlexSize, DbxSectionHeaderConfig, AbstractPopoverDirective, DbxPopoverService } from '@dereekb/dbx-web';
import * as _dereekb_dbx_core from '@dereekb/dbx-core';
import { DbxActionContextStoreSourceInstance, DbxActionValueGetterResult, DbxButtonDisplay, ClickableAnchor, DbxInjectionComponentConfig } from '@dereekb/dbx-core';
import * as rxjs from 'rxjs';
import { Observable, BehaviorSubject } from 'rxjs';
import * as _dereekb_rxjs from '@dereekb/rxjs';
import { LockSet, IsValidFunction, IsEqualFunction, IsModifiedFunction, ObservableOrValue, ObservableOrValueGetter, MaybeObservableOrValueGetter, WorkUsingContext, MaybeObservableOrValue, LoadingState, LoadingStateWithDefinedValue, ListLoadingState } from '@dereekb/rxjs';
import * as _dereekb_util from '@dereekb/util';
import { BooleanStringKeyArray, Maybe, MapFunction, IsValid, IsModified, FilterFromPOJOFunction, Milliseconds, ArrayOrValue, Building, MaybeMap, TransformStringFunctionConfig, TransformStringFunctionConfigRef, TransformNumberFunctionConfigRef, TransformNumberFunctionConfig, GetterOrValue, LogicalDate, ReadableTimeString, Getter, ISO8601DayString, TimezoneString, DateOrDayString, DecisionFunction, TimeUnit, IndexNumber, LabeledValue, LabelRef, PrimativeKey, FactoryWithRequiredInput, Factory, ReadKeyFunction, WebsiteDomain, SearchStringFilterFunction, KeyValueTupleFilter, EqualityComparatorFunction } from '@dereekb/util';
import { FormControlStatus, AbstractControl, FormControl, FormGroup, ValidatorFn, AsyncValidatorFn } from '@angular/forms';
import * as _angular_material_core from '@angular/material/core';
import { ErrorStateMatcher } from '@angular/material/core';
import * as _angular_material_progress_spinner from '@angular/material/progress-spinner';
import * as _ng_forge_dynamic_forms from '@ng-forge/dynamic-forms';
import { FormConfig, FieldWithValidation, FieldDef, EvaluationContext, WrapperConfig, ValidatorConfig, CustomValidator, AsyncCustomValidator, FieldMeta, BaseValueField, DynamicText, GroupAllowedChildren, GroupField, ValidationMessages, RowField, ArrayItemDefinitionTemplate, ArrayField, ContainerField, ConditionalExpression, FieldWrapper, DynamicForm, FormOptions, WrapperTypeDefinition } from '@ng-forge/dynamic-forms';
import { MatDialogConfig, MatDialog, MatDialogRef } from '@angular/material/dialog';
import { FieldTree } from '@angular/forms/signals';
import * as _ng_forge_dynamic_forms_material from '@ng-forge/dynamic-forms-material';
import { MatInputProps, MatInputField, MatTextareaField, MatSliderField, MatCheckboxField, MatToggleField, MatDatepickerField, MatSelectProps, MatMultiCheckboxField } from '@ng-forge/dynamic-forms-material';
import * as _dereekb_dbx_form from '@dereekb/dbx-form';
import * as _ng_forge_dynamic_forms_internal from '@ng-forge/dynamic-forms/internal';
import * as _dereekb_date from '@dereekb/date';
import { DateTimeMinuteConfig, DateRangeWithDateOrStringValue, DateTimezoneUtcNormalInstance, DateTimeMinuteInstance, DateRangeInput, DateRange, TimezoneInfo, TimeDurationData } from '@dereekb/date';
import * as _angular_material_form_field from '@angular/material/form-field';
import { MatDatepickerInputEvent, MatCalendar, DateRange as DateRange$1, MatDateRangeSelectionStrategy } from '@angular/material/datepicker';
import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
import { MatChipInputEvent } from '@angular/material/chips';
import { MatSelectionListChange } from '@angular/material/list';
import { Editor } from '@bobbyquantum/ngx-editor';
import { WrapperFieldInputs, ArrayContext, FieldTypeDefinition } from '@ng-forge/dynamic-forms/integration';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { NgPopoverRef } from 'ng-overlay-container';

/**
 * Current state of a DbxForm
 */
declare enum DbxFormState {
    /**
     * Form is not finished initializing.
     */
    INITIALIZING = -1,
    /**
     * Form is initialized but has not yet used.
     */
    RESET = 0,
    /**
     * Form has been used.
     */
    USED = 1
}
/**
 * Unique key for disabling/enabling.
 */
type DbxFormDisabledKey = string;
/**
 * 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;
}
/**
 * DbxForm stream event
 */
interface DbxFormEvent extends DbxFormStateRef {
    readonly isComplete: boolean;
    readonly status: FormControlStatus;
    readonly pristine?: boolean;
    readonly untouched?: boolean;
    readonly lastResetAt?: Date;
    readonly changesCount?: number;
    /**
     * Whether or not the form is disabled.
     */
    readonly isDisabled?: boolean;
    /**
     * Current disabled state keys.
     */
    readonly disabled?: BooleanStringKeyArray;
}
/**
 * Form that has an event stream, value, and state items.
 */
declare abstract class DbxForm<T = unknown> {
    abstract readonly stream$: Observable<DbxFormEvent>;
    /**
     * Returns an observable that emits the form's current value, optionally gated by the
     * implementation's validity rules (e.g. {@link DbxForgeFormContext.requireValid}).
     *
     * Consumers that only want a value once the form passes validation should use this method.
     */
    abstract getValue(): Observable<T>;
    /**
     * Returns an observable that emits the form's current value, regardless of validity gates.
     *
     * Used by infrastructure (e.g. {@link DbxActionFormDirective}) that needs the underlying
     * value to feed user-supplied isValid/isModified functions even while the form is invalid.
     * Defaults to {@link getValue}; implementations that gate {@link getValue} on validity
     * should override this to bypass that gate.
     *
     * @returns An observable of the form's current value, even when validity gates would suppress {@link getValue}.
     */
    currentValue(): Observable<T>;
    /**
     * Returns an observable that returns the current disabled keys.
     */
    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.
     */
    abstract readonly lockSet?: LockSet;
    /**
     * Sets the initial value of the form, and resets the form.
     *
     * @param value
     */
    abstract setValue(value: Maybe<Partial<T>>): void;
    /**
     * Resets the form to the initial value.
     */
    abstract resetForm(): void;
    /**
     * Disables the form
     *
     * @param disabled
     */
    abstract setDisabled(key?: DbxFormDisabledKey, disabled?: boolean): void;
    /**
     * Force the form to update itself as if it was changed.
     */
    abstract forceFormUpdate(): void;
}
/**
 * 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 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 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.
 *
 * 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>;
    readonly source: DbxActionContextStoreSourceInstance<O, unknown>;
    readonly lockSet: _dereekb_dbx_core.CleanLockSet;
    /**
     * Whether or not to disable the form while the action is working.
     *
     * Defaults to true.
     */
    readonly dbxActionFormDisabledOnWorking: _angular_core.InputSignal<Maybe<boolean>>;
    /**
     * Optional validator that checks whether or not the value is
     * ready to send before the context store is marked enabled.
     */
    readonly dbxActionFormIsValid: _angular_core.InputSignal<Maybe<IsValidFunction<T>>>;
    /**
     * Optional function that checks whether or not the value is still the same/equal.
     */
    readonly dbxActionFormIsEqual: _angular_core.InputSignal<Maybe<IsEqualFunction<T>>>;
    /**
     * Optional function that checks whether or not the value has been modified.
     *
     * If dbxActionFormIsEqual is provided, this will be ignored.
     */
    readonly dbxActionFormIsModified: _angular_core.InputSignal<Maybe<IsModifiedFunction<T>>>;
    /**
     * Optional function that maps the form's value to the source's value.
     */
    readonly dbxActionFormMapValue: _angular_core.InputSignal<Maybe<DbxActionFormMapValueFunction<T, O>>>;
    readonly dbxActionFormDisabledOnWorking$: Observable<Maybe<boolean>>;
    readonly isValidFunction$: Observable<IsValidFunction<T>>;
    readonly isModifiedFunction$: Observable<IsModifiedFunction<T>>;
    readonly mapValueFunction$: Observable<Maybe<DbxActionFormMapValueFunction<T, O>>>;
    private readonly _triggeredSub;
    private readonly _isCompleteSub;
    private readonly _isWorkingSub;
    constructor();
    ngOnInit(): void;
    /**
     * 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: _angular_core.ɵɵFactoryDeclaration<DbxActionFormDirective<any, any>, never>;
    static ɵdir: _angular_core.ɵɵ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 {@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]`
 *
 * @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: _angular_core.InputSignal<DbxActionTransitionSafetyType>;
    protected readonly _dbxActionFormSafetyUpdateEffect: _angular_core.EffectRef;
    protected _handleOnBeforeTransition(transition: Transition): HookResult;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxActionFormSafetyDirective<any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DbxActionFormSafetyDirective<any, any>, "[dbxActionFormSafety]", never, { "dbxActionFormSafety": { "alias": "dbxActionFormSafety"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Recursively strips keys that start with `_` from a form value object.
 *
 * ng-forge wrapper/layout fields (sections, toggles, expand, rows) use auto-generated
 * keys prefixed with `_` (e.g. `_section_1`, `_toggle_2`). These are layout artifacts
 * and should not appear in the final form output.
 *
 * - Object values under `_` keys are "unwrapped": their contents are merged into the parent.
 * - Primitive values under `_` keys (e.g. toggle booleans) are dropped entirely.
 * - Non-underscore keys are preserved, with recursive cleaning of nested objects.
 *
 * @param value - The form value object to clean.
 * @returns A new object with internal `_`-prefixed keys stripped and their object values unwrapped.
 *
 * @example
 * ```
 * stripForgeInternalKeys({ _toggle_1: false, _section_6: { name: "Bob" } })
 * // → { name: "Bob" }
 * ```
 */
declare function stripForgeInternalKeys<T>(value: T): T;
/**
 * Recursively strips keys whose values are empty (`null`, `undefined`, `""`, or `NaN`)
 * from a form value object. Also removes keys whose values become empty objects
 * `{}` after recursive stripping.
 *
 * Arrays are recursed into so that empties inside nested objects are stripped,
 * but array length and item indices are preserved — primitive empty values
 * (e.g. `NaN`, `''`) inside an array stay in place, since shifting indices would
 * change the semantics of chip/list-style array fields.
 *
 * This normalizes ng-forge output so the model only includes keys that have
 * been explicitly set by the user.
 *
 * @param value - The form value object to clean.
 * @returns A new object with empty-valued keys removed.
 *
 * @example
 * ```
 * stripEmptyForgeValues({ name: "", age: null, active: false, count: 0 })
 * // → { active: false, count: 0 }
 *
 * stripEmptyForgeValues({ section: { a: "", b: "" } })
 * // → {}
 *
 * stripEmptyForgeValues({ items: [{ amount: NaN, name: 'a' }, { amount: 5 }] })
 * // → { items: [{ name: 'a' }, { amount: 5 }] }
 * ```
 */
declare function stripEmptyForgeValues<T>(value: T): T;
/**
 * Context service managing a ng-forge dynamic form's connection to the DbxForm system.
 *
 * Bridges ng-forge's signal-based form state to the existing DbxForm/DbxMutableForm
 * Observable-based interface — a lightweight implementation with no delegate pattern needed.
 */
declare class DbxForgeFormContext<T = unknown> implements DbxMutableForm<T>, OnDestroy {
    private readonly dbxForgeGlobalDefaultsConfigService;
    private static readonly INITIAL_STATE;
    readonly lockSet: LockSet;
    /**
     * When true (default), {@link getValue} only emits values when the form is valid.
     * Set to false to emit all values regardless of validation state.
     */
    requireValid: boolean;
    /**
     * When true (default), keys starting with `_` are stripped from the form value
     * before it is emitted by {@link getValue}. These keys are layout artifacts from
     * ng-forge wrappers (sections, toggles, expand groups, rows) and are not part of
     * the domain model.
     *
     * Object values under `_` keys are unwrapped (contents merged into parent);
     * primitive `_` values (e.g. toggle booleans) are dropped entirely.
     */
    stripInternalKeys: boolean;
    /**
     * When true (default), keys whose values are empty (`null`, `undefined`, `""`, or `NaN`)
     * are stripped from the form value before emission. This normalizes ng-forge output
     * so the model only includes keys that have been explicitly set by the user.
     *
     * Note: `false`, `0`, and empty arrays are NOT considered empty and are preserved.
     */
    stripEmptyValues: boolean;
    /**
     * Optional custom POJO filter applied during the `formValue` signal's deep-equality
     * comparison. When set, this filter replaces the default filter that strips `_`-prefixed
     * keys and null/undefined values.
     *
     * Useful for testing scenarios where `stripInternalKeys` is `false` and the `_`-prefixed
     * keys must participate in equality checks.
     */
    formValuePojoFilter: Maybe<FilterFromPOJOFunction<unknown>>;
    /**
     * When true (default), the form still reports `isComplete` based on validity even
     * while disabled, so disabling a form only locks inputs but does not suppress the
     * form value.
     *
     * When false, `isComplete` is forced to `false` while disabled, preventing the
     * action system from reading the form value. `false` is the native ng-forge default
     * behavior, where a disabled form does not produce output.
     */
    emitValueWhenDisabled: boolean;
    /**
     * Tracks validity signals from nested wrapper forms (e.g. forgeFormFieldWrapper,
     * section wrapper). These wrappers create isolated DynamicForm instances
     * whose validity is not visible to the parent DynamicForm.valid() signal.
     *
     * Wrapper components register their nested form's validity via {@link registerWrapperValidity},
     * and the combined result is exposed as {@link allWrappersValid}.
     */
    private readonly _wrapperValidSignals;
    private readonly _wrapperValidSignalsVersion;
    /**
     * Computed signal that is `true` when all registered wrapper nested forms are valid.
     * Returns `true` when no wrappers are registered.
     */
    readonly allWrappersValid: Signal<boolean>;
    /**
     * Registers a wrapper's nested form validity signal for tracking.
     *
     * Call this from wrapper content components so that validation errors in nested
     * DynamicForm instances propagate to the parent form's validity state.
     *
     * @param valid - The wrapper's nested form validity signal.
     * @returns A cleanup function that unregisters the signal. Call on component destroy.
     */
    registerWrapperValidity(valid: Signal<boolean>): () => void;
    /**
     * The parent DynamicForm's field tree, set by DbxForgeFormComponent.
     *
     * Allows wrapper field components to write values to sibling hidden fields
     * in the parent form (e.g., for the form-field wrapper's hidden field sync).
     */
    private readonly _parentFormTree;
    readonly parentFormTree: Signal<FieldTree<Record<string, unknown>> | undefined>;
    setParentFormTree(tree: FieldTree<Record<string, unknown>> | undefined): void;
    private readonly _config;
    private readonly _disabled;
    private readonly _formState;
    private readonly _value;
    private readonly _isValid;
    private readonly _setValue;
    private readonly _reset;
    private readonly _internalConfig$;
    readonly config$: Observable<FormConfig>;
    /**
     * Form event stream that restarts on each reset, mirroring the formly form's
     * switchMap-on-reset pattern. This ensures that each resetForm() produces a fresh
     * emission sequence, so dbxFormSource's distinctUntilChanged on state can detect
     * the RESET transition even if the previous state was also RESET.
     */
    readonly stream$: Observable<DbxFormEvent>;
    readonly setValue$: Observable<Maybe<Partial<T>>>;
    readonly disabled$: Observable<BooleanStringKeyArray>;
    readonly reset$: Observable<Date>;
    get config(): Maybe<FormConfig>;
    set config(config: Maybe<FormConfig>);
    updateFormState(state: DbxFormEvent): void;
    updateValue(value: T): void;
    updateIsValid(valid: boolean): void;
    getValue(): Observable<T>;
    /**
     * Emits the current form value regardless of {@link requireValid}. Used by infrastructure
     * that needs the underlying value while the form is invalid (e.g. {@link DbxActionFormDirective}
     * feeding the value into user-supplied isModified functions to drive the action's disabled state).
     *
     * @returns An observable of the latest non-null form value, regardless of validity.
     */
    currentValue(): Observable<T>;
    getDisabled(): Observable<BooleanStringKeyArray>;
    setValue(value: Maybe<Partial<T>>): void;
    resetForm(): void;
    setDisabled(key?: DbxFormDisabledKey, disabled?: boolean): void;
    forceFormUpdate(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeFormContext<any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DbxForgeFormContext<any>>;
}
/**
 * Provides DbxForgeFormContext and registers it as both DbxForm and DbxMutableForm.
 *
 * @returns The providers registering the forge form context for dependency injection.
 */
declare function provideDbxForgeFormContext(): Provider[];

/**
 * Button configuration for the submit button in a {@link DbxForgeActionDialogComponent}.
 *
 * Combines display properties (text, icon) with style properties (color, raised, etc.).
 */
interface DbxForgeActionDialogComponentButtonConfig extends DbxButtonDisplay, DbxButtonStyle {
}
/**
 * Configuration for opening a {@link DbxForgeActionDialogComponent}.
 *
 * Defines the dialog header, form config, initial values, submit button, and dialog options.
 *
 * @typeParam O - The form value type produced by the dialog.
 */
interface DbxForgeActionDialogComponentConfig<O> {
    /**
     * Header text for the dialog.
     */
    readonly header: string;
    /**
     * Used for retrieving the ng-forge FormConfig to display in the dialog.
     */
    readonly config: ObservableOrValueGetter<FormConfig>;
    /**
     * Initial value for the form.
     */
    readonly initialValue?: MaybeObservableOrValueGetter<O>;
    /**
     * Text/Icon for the submit button.
     */
    readonly submitButtonConfig?: DbxForgeActionDialogComponentButtonConfig;
    /**
     * Dialog-specific configuration
     */
    readonly dialog?: Omit<MatDialogConfig, 'data'>;
}
/**
 * A standalone dialog component that renders a dynamic ng-forge 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 DbxForgeActionDialogComponent.openDialogWithForm} to open the dialog programmatically.
 *
 * @typeParam O - The form value type produced by the dialog.
 */
declare class DbxForgeActionDialogComponent<O> extends AbstractDialogDirective<O, DbxForgeActionDialogComponentConfig<O>> implements OnInit {
    private readonly _configSub;
    readonly context: DbxForgeFormContext<O>;
    readonly config$: rxjs.Observable<FormConfig<_ng_forge_dynamic_forms.RegisteredFieldTypes[], {
        [x: string]: unknown[];
    } & {
        [x: string]: unknown[];
    } & {
        [x: string]: unknown[];
    } & {
        [x: string]: unknown[];
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | number | boolean | (string | number | boolean)[];
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string[] | number[] | number[] | number[] | number[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | (string | number | boolean | (string | number | boolean)[])[] | number[] | string[] | string[] | boolean[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | number[] | boolean[] | string[] | string[] | string[] | ({
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | number | boolean | (string | number | boolean)[];
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: unknown[];
        } & {
            [x: string]: unknown[];
        } & {
            [x: string]: unknown[];
        } & {
            [x: string]: unknown[];
        } & {
            [x: string]: Record<string, unknown>;
        } & {
            [x: string]: string | undefined;
        })[];
    } & {
        [x: string]: Record<string, unknown>;
    } & {
        [x: string]: unknown[];
    } & {
        [x: string]: string | undefined;
    }, Record<string, unknown>, unknown>>;
    readonly initialValue$: rxjs.Observable<O | null | undefined>;
    readonly header: string;
    readonly submitButtonConfig: {
        icon?: Maybe<string>;
        text: string | null;
        type?: Maybe<_dereekb_dbx_web.DbxButtonType>;
        mode?: Maybe<_angular_material_progress_spinner.ProgressSpinnerMode>;
        color?: Maybe<_angular_material_core.ThemePalette | _dereekb_dbx_web.DbxColorInput>;
        spinnerColor?: Maybe<_angular_material_core.ThemePalette | _dereekb_dbx_web.DbxThemeColor>;
        customTextColor?: Maybe<string>;
        customSpinnerColor?: Maybe<string>;
        fab?: Maybe<boolean>;
    };
    ngOnInit(): void;
    /**
     * Action handler that marks the action as successful and closes the dialog with the submitted value.
     *
     * @param value - The submitted form value
     * @param context - The action context used to signal success
     */
    readonly handleSubmitValue: WorkUsingContext<O>;
    /**
     * Opens a new dialog with a dynamic ng-forge form using the provided configuration.
     *
     * @param matDialog - The Angular Material dialog service.
     * @param config - Configuration for the dialog, including form config, 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: DbxForgeActionDialogComponentConfig<O>): MatDialogRef<DbxForgeActionDialogComponent<O>, Maybe<O>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeActionDialogComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeActionDialogComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
}

/**
 * Debug directive that logs every form stream event to the console.
 *
 * Subscribes to the parent form's {@link DbxForm.stream$} and prints each event snapshot
 * via `console.log`. Useful during development to inspect the form lifecycle and state transitions.
 *
 * @selector `[dbxFormLogger]`
 *
 * @example
 * ```html
 * <dbx-form>
 *   <ng-container dbxFormLogger></ng-container>
 *   <!-- form fields -->
 * </dbx-form>
 * ```
 */
declare class DbxFormLoggerDirective {
    readonly form: DbxForm<any>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxFormLoggerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DbxFormLoggerDirective, "[dbxFormLogger],[dbxFormStreamLogger]", 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>;
/**
 * Modes that define when to copy data from the source to the form.
 *
 * - `'reset'`: Only copy data when the form is reset or is untouched.
 * - `'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';
/**
 * 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: _angular_core.InputSignal<Maybe<DbxFormSourceDirectiveMode>>;
    /**
     * The source value or observable to pipe into the form.
     */
    readonly dbxFormSource: _angular_core.InputSignal<Maybe<ObservableOrValue<Maybe<Partial<T>>>>>;
    protected readonly _effectSub: _dereekb_rxjs.SubscriptionObject<rxjs.Unsubscribable>;
    protected readonly _setFormSourceObservableEffect: _angular_core.EffectRef;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxFormSourceDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DbxFormSourceDirective<any>, "[dbxFormSource]", never, { "dbxFormSourceMode": { "alias": "dbxFormSourceMode"; "required": false; "isSignal": true; }; "dbxFormSource": { "alias": "dbxFormSource"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Directive that sets a form's value from a {@link LoadingState} source once loading is complete.
 *
 * 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: _angular_core.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: _angular_core.InputSignal<MaybeObservableOrValue<LoadingState<T>>>;
    readonly mode$: Observable<DbxFormSourceDirectiveMode>;
    readonly source$: Observable<Maybe<T>>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxFormLoadingSourceDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DbxFormLoadingSourceDirective<any>, "[dbxFormLoadingSource]", never, { "dbxFormLoadingSourceMode": { "alias": "dbxFormLoadingSourceMode"; "required": false; "isSignal": true; }; "dbxFormLoadingSource": { "alias": "dbxFormLoadingSource"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * 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.
 *
 * @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: _angular_core.OutputEmitterRef<Maybe<T>>;
    protected readonly _sub: _dereekb_rxjs.SubscriptionObject<rxjs.Unsubscribable>;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxFormValueChangeDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DbxFormValueChangeDirective<any>, "[dbxFormValueChange]", never, {}, { "dbxFormValueChange": "dbxFormValueChange"; }, never, never, true, never>;
}

/**
 * A FormGroup/AbstractControl path to a specific control.
 */
type FormControlPath = string;
/**
 * Streams a value from the input control at the given path. If no path is specified, streams the value from the control.
 *
 * 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>>;

/**
 * Includes the validators and validation messages set on a FieldWithValidation.
 */
type DbxForgeFieldValidation = Pick<FieldWithValidation, 'validators' | 'validationMessages'>;

/**
 * A FieldDef that has been augmented with @dereekb/dbx-form specific properties that are passed to a dbx-forge form.
 */
type DbxForgeField<F extends FieldDef<any>> = F & {
    /**
     * Form-level configuration that was generated at a field level.
     *
     * This is read by dbx-forge when importing configuration and is merged into the input FormConfig.
     */
    readonly _formConfig?: Maybe<DbxForgeFieldFormConfig>;
};
/**
 * Contains a reference to hidden sister fields.
 */
interface DbxForgeFieldHiddenFieldsRef {
    readonly _hiddenFields?: (FieldDef<any> & {
        hidden: true;
    })[];
}
/**
 * Form-level configuration that was generated at a field level.
 */
interface DbxForgeFieldFormConfig extends Partial<Pick<FormConfig, 'schemas' | 'externalData' | 'customFnConfig' | 'defaultValidationMessages'>>, DbxForgeFieldHiddenFieldsRef {
}
/**
 * Merges multiple field-level form configs into a single config, layering later inputs on top
 * of earlier ones for `externalData`, `customFnConfig`, and `defaultValidationMessages`, while
 * concatenating `schemas`.
 *
 * Keys whose merged value is empty are dropped from the result (no empty `{}` or `[]` fields).
 *
 * @param input - Field form configs to merge, from lowest to highest priority.
 * @returns A merged config with only populated fields retained.
 */
declare function mergeDbxForgeFieldFormConfig(...input: DbxForgeFieldFormConfig[]): DbxForgeFieldFormConfig;
/**
 * Produces a shallow copy of a `FormConfig.customFnConfig` that clones each inner bucket
 * (validators, derivations, etc.) so downstream merges can mutate the result without
 * leaking writes back to the original form config.
 *
 * @param input - The customFnConfig to copy, or undefined.
 * @returns A new customFnConfig containing only the known buckets, each one a fresh object.
 */
declare function copyFormConfigCustomFnConfig(input: FormConfig['customFnConfig']): FormConfig['customFnConfig'];
interface DbxForgeGlobalFormConfigDefaults extends Pick<FormConfig, 'defaultValidationMessages'> {
}
interface DbxForgeFinalizeFormConfigResult {
    /**
     * The input config that was used to generate the field configs.
     */
    readonly input: FormConfig;
    /**
     * The field configs that were extracted from the input's fields.
     */
    readonly extractedFieldFormConfigs: DbxForgeFieldFormConfig[];
    /**
     * The final output config.
     */
    readonly config: FormConfig;
}
/**
 * Finalizes a `FormConfig` for consumption by dbx-forge by pulling field-level `_formConfig`
 * values up to the form level and appending any `_hiddenFields` so they participate in
 * validation and value wiring without being rendered.
 *
 * The walk is recursive: `_formConfig` declared on a field nested inside a container,
 * group, row, page, or array (full or simplified) is pulled up alongside top-level
 * `_formConfig` so derivations and validators registered by a child field factory
 * (e.g. an idempotent transform on a state field inside an address flex layout) are
 * preserved when the field is composed into a parent layout.
 *
 * Layering order (lowest to highest priority): `globalDefaults`, the input form's own config,
 * then each field's `_formConfig` in pre-order traversal — so a later field can override an
 * earlier field's default validation message.
 *
 * @param input - The FormConfig authored by the caller.
 * @param globalDefaults - Seed values for workspace-wide defaults (e.g. validation messages)
 * @returns The original input, the extracted field form configs, and the finalized config.
 */
declare function dbxForgeFinalizeFormConfig(input: FormConfig, globalDefaults?: DbxForgeGlobalFormConfigDefaults): DbxForgeFinalizeFormConfigResult;

declare const SELF_DEPENDENCY_TOKEN: "$self";
/**
 * Contains a reference to a hint value of some type.
 */
type DbxForgeFieldHintValueRef<T> = {
    hint?: T;
};
/**
 * A field config that includes an optional logic variable.
 */
type DbxForgeFieldLogicValueRef<T> = {
    logic?: T[];
};
/**
 * This is an internal type.
 *
 * @see {@link DbxForgeFieldFunctionDef} instead.
 */
type _DbxForgeFieldFunctionDef<F extends FieldDef<any>> = F extends FieldDef<infer TProps, infer _TMeta> ? TProps extends DbxForgeFieldHintValueRef<infer T> ? Pick<F, 'key'> & Partial<Omit<F, 'key' | 'type'>> & DbxForgeFieldHintValueRef<T> : Pick<F, 'key'> & Partial<Omit<F, 'key' | 'type'>> : never;
/**
 * Represents an @ng-forge/dynamic-forms FieldDef that has been augmented with dbx-form specific properties.
 *
 * Is used in builder functions for a specific FieldDef that already pre-configures the key and type.
 *
 * Branded config type for forge field functions. Intersects DbxForgeFieldFunctionDef<F> with
 * custom config properties C, and carries a phantom __fieldDef property so F can be
 * extracted without conditional type inference.
 */
type DbxForgeFieldFunctionDef<F extends FieldDef<any>, C = unknown> = _DbxForgeFieldFunctionDef<F> & C & {
    readonly __fieldDef?: F;
};
/**
 * Extracts the FieldDef type F from a DbxForgeFieldFunctionConfigDef via the phantom __fieldDef brand.
 */
type ExtractDbxForgeFieldDef<C> = C extends {
    __fieldDef?: infer F extends FieldDef<any>;
} ? F : FieldDef<any>;
/**
 * Represents the array-type of of a FieldDef's logic type.
 */
type DbxForgeFieldFunctionDefLogicValue<C extends DbxForgeFieldFunctionDef<any>> = C extends DbxForgeFieldFunctionDef<infer F> ? (F extends DbxForgeFieldLogicValueRef<infer T> ? T : never) : never;
/**
 * Sync custom function for a derivation logic entry.
 *
 * When provided in addLogic(), the builder auto-registers this function
 * in _formConfig.customFnConfig.derivations under the given (or auto-generated) functionName.
 */
type DbxForgeFieldLogicFn<O = any, I = any> = (ctx: EvaluationContext<I>) => O;
/**
 * Async custom function for a derivation logic entry.
 *
 * When provided in addLogic(), the builder auto-registers this function
 * in _formConfig.customFnConfig.asyncDerivations under the given (or auto-generated) asyncFunctionName.
 */
type DbxForgeFieldLogicAsyncFn<O = any, I = any> = (ctx: EvaluationContext<I>) => Promise<O>;
/**
 * The externalData declared within a logic declaration.
 *
 * Is merged into the final form config later.
 */
type DbxForgeFieldLogicExternalData = DbxForgeFieldFormConfig['externalData'];
/**
 * The result of a DbxForgeFieldFunction.
 */
type DbxForgeFieldFunctionResult<C extends DbxForgeFieldFunctionDef<any>> = C extends DbxForgeFieldFunctionDef<infer F> ? DbxForgeField<F> : never;
/**
 * Creates the target FieldDef value from the input config and optional configure function.
 */
type DbxForgeFieldFunction<C extends DbxForgeFieldFunctionDef<any>, F extends FieldDef<any> = ExtractDbxForgeFieldDef<C>> = (input: C, configure?: Maybe<ArrayOrValue<DbxForgeBuildFieldDefFunction<C>>>) => DbxForgeField<F>;
/**
 * Builds the FieldDef from the input config and props and optional configure function.
 */
type DbxForgeFieldFunctionFieldDefBuilder<C extends DbxForgeFieldFunctionDef<any>, FV = any> = (input: Building<C>, props: C['props'], configure?: Maybe<ArrayOrValue<DbxForgeBuildFieldDefFunction<C, FV>>>) => DbxForgeFieldFunctionResult<C> | void;
/**
 * Generates custom props from the input config.
 *
 * This result is merged with the existing props on the input, if a props variable exists.
 *
 * All undefined values are filtered out. All defined values will override the existing props.
 */
type DbxForgeFieldFunctionConfigPropsBuilder<C extends DbxForgeFieldFunctionDef<any>> = (input: C) => Partial<C['props']>;
/**
 * Config for dbxForgeFieldFunction().
 */
interface DbxForgeFieldFunctionConfig<C extends DbxForgeFieldFunctionDef<any>> {
    /**
     * The type of the field.
     *
     * Should match the registered type.
     */
    readonly type: ExtractDbxForgeFieldDef<C>['type'];
    /**
     * Builds the config for the field. If null is provided, the config from the input config is used directly.
     *
     * @param input - The input config.
     * @returns The config for the field.
     */
    readonly buildFieldDef?: DbxForgeFieldFunctionFieldDefBuilder<C>;
    /**
     * Builds the props for the field. If null is provided, the props from the input config are used directly.
     *
     * @param input - The input config.
     * @returns The props for the field.
     */
    readonly buildProps?: Maybe<DbxForgeFieldFunctionConfigPropsBuilder<C>>;
}
/**
 * Creates a {@link DbxForgeFieldFunction} from a {@link DbxForgeFieldFunctionConfig}.
 *
 * The returned function accepts a field definition config and an optional configure callback,
 * and produces a fully-typed {@link DbxForgeField} with the correct `type` set.
 *
 * @param config - Factory configuration containing the field type and optional builders for props and the field definition.
 * @returns A reusable field factory function.
 *
 * @example
 * ```ts
 * const myTextField = dbxForgeFieldFunction<MyTextFieldDef>({
 *   type: 'my-text',
 *   buildProps: (input) => ({ placeholder: input.placeholder ?? 'Enter text' }),
 *   buildFieldDef: dbxForgeBuildFieldDef((instance) => {
 *     instance.injectDefaultValidation();
 *   })
 * });
 * ```
 *
 * @__NO_SIDE_EFFECTS__
 */
declare function dbxForgeFieldFunction<C extends DbxForgeFieldFunctionDef<F>, F extends FieldDef<any> = ExtractDbxForgeFieldDef<C>>(config: DbxForgeFieldFunctionConfig<C>): DbxForgeFieldFunction<C, F>;
/**
 * Input for adding validation to a field via the builder instance.
 *
 * Accepts validators and optional validation messages that are merged into the field's existing validation.
 */
type DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceAddValidationInput = {
    readonly validators?: Maybe<ArrayOrValue<DbxForgeFieldValidatorInput>>;
    /**
     * Form-level default validation messages merged into `_formConfig.defaultValidationMessages`.
     *
     * Use for messages associated with inline `fn` validators whose error kinds need
     * form-wide resolution. Separate from field-level `validationMessages`.
     */
    readonly formValidationMessages?: Maybe<Record<string, string>>;
} & MaybeMap<Pick<DbxForgeFieldValidation, 'validationMessages'>>;
/**
 * Builder instance provided to {@link DbxForgeBuildFieldDefFunction} callbacks.
 *
 * Exposes methods for reading and mutating a field definition during construction,
 * including validation, meta, logic, and form config.
 */
interface DbxForgeFieldFunctionFieldDefBuilderFunctionInstance<C extends DbxForgeFieldFunctionDef<any>, FV = any> extends DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceLogicBuilder<C, FV>, DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceFormConfigBuilder, DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceWrappersBuilder {
    /**
     * Returns the current fieldDef.
     */
    getFieldDef: () => C;
    /**
     * Returns the current props.
     */
    getProps: () => Building<C['props']>;
    /**
     * Returns the default validation from the default validation source.
     *
     * Does not modify the current config.
     */
    getDefaultValidation(): DbxForgeFieldValidation;
    /**
     * Injects the default validators into the field definition.
     */
    injectDefaultValidation(): void;
    /**
     * Loads all the current validators from the field definition.
     */
    getValidation(): DbxForgeFieldValidation;
    /**
     * Adds/Merges the input validation into the existing field definition.
     */
    addValidation(input: DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceAddValidationInput): void;
    /**
     * Sets the validation for the field definition.
     */
    setValidation(input: DbxForgeFieldValidation): void;
    /**
     * Returns the current meta.
     */
    getMeta(): FieldMeta;
    /**
     * Inserts the input meta into the existing field definition.
     *
     * Null values clear existing values.
     */
    addMeta(meta?: Maybe<FieldMeta>): void;
    /**
     * Sets the meta for the field definition.
     */
    setMeta(meta: FieldMeta): void;
    /**
     * Calls another DbxForgeBuildFieldDefFunction with this instance.
     */
    configure(fn: DbxForgeBuildFieldDefFunction<C, FV>): void;
}
interface DbxForgeFieldLogicExtras {
    readonly dependsOn?: string[];
    readonly externalData?: DbxForgeFieldLogicExternalData;
}
/**
 * Distributive conditional type that augments logic config types with an optional `fn` callback
 * for function-based derivations. Preserves ng-forge's discriminated union structure.
 *
 * - Sync function derivations (`functionName: string`): adds `fn`, makes `functionName` optional when `fn` is provided
 * - Async function derivations (`asyncFunctionName: string`): adds `fn`, makes `asyncFunctionName` optional when `fn` is provided
 * - All other logic types (state, expression, value, http): passed through unchanged
 */
type DbxForgeFieldLogicWithFn<T> = T extends {
    type: 'derivation';
    functionName: string;
} ? (Omit<T, 'dependsOn'> & {
    fn?: DbxForgeFieldLogicFn;
} & DbxForgeFieldLogicExtras) | (Omit<T, 'functionName' | 'dependsOn'> & {
    functionName?: string;
    fn: DbxForgeFieldLogicFn;
} & DbxForgeFieldLogicExtras) : T extends {
    type: 'derivation';
    source: 'asyncFunction';
    asyncFunctionName: string;
} ? (T & {
    fn?: DbxForgeFieldLogicAsyncFn;
} & DbxForgeFieldLogicExtras) | (Omit<T, 'asyncFunctionName' | 'dependsOn'> & {
    asyncFunctionName?: string;
    fn: DbxForgeFieldLogicAsyncFn;
} & DbxForgeFieldLogicExtras) : T;
/**
 * A custom logic type for transforming values.
 *
 * Is transformed into a derivation by the builder instance.
 */
type DbxForgeFieldTransformLogic<FV = unknown> = DbxForgeFieldIdempotentTransformLogic<FV> | DbxForgeFieldAsyncTransformLogic<FV> | DbxForgeFieldDebouncedTransformLogic<FV>;
/**
 * The three types of transforms allowed.
 *
 * - Idempotent: The transform is synchronous. It should return the equivalent output for the equivalent input.
 * - Async: The transform is asynchronous and returns a Promise. Does not have to be idempotent.
 * - Debounced: A synchronous function that has a debounce to it. Does not have to be idempotent.
 */
type DbxForgeFieldTransformType = 'idempotent' | 'async' | 'debounced';
/**
 * Controls when a transform derivation runs.
 *
 * - `'defined'` — only runs when the field value is non-null/defined (default)
 * - `'always'` — runs on every evaluation, including when the value is undefined
 */
type DbxForgeFieldTransformWhen = 'defined' | 'always';
/**
 * Synchronous transform function that receives the current field value and evaluation context.
 */
type DbxForgeFieldTransformFunction<I, O> = (value: I, ctx: EvaluationContext<I>) => O;
/**
 * Asynchronous variant of {@link DbxForgeFieldTransformFunction} that returns a Promise.
 */
type DbxForgeFieldAsyncTransformFunction<I, O> = DbxForgeFieldTransformFunction<I, Promise<O>>;
type DbxForgeFieldIdempotentTransformLogic<FV = unknown> = DbxForgeFieldIdempotentTransformLogicWhenDefined<FV> | DbxForgeFieldIdempotentTransformLogicWhenAlways<FV>;
interface DbxForgeFieldIdempotentTransformLogicWhenDefined<FV = unknown> {
    readonly type: 'transform';
    readonly transformType: 'idempotent';
    readonly when?: 'defined';
    readonly transform: DbxForgeFieldTransformFunction<FV, FV>;
}
interface DbxForgeFieldIdempotentTransformLogicWhenAlways<FV = unknown> {
    readonly type: 'transform';
    readonly transformType: 'idempotent';
    readonly when: 'always';
    readonly transform: DbxForgeFieldTransformFunction<Maybe<FV>, FV>;
}
type DbxForgeFieldAsyncTransformLogic<FV = unknown> = DbxForgeFieldAsyncTransformLogicWhenDefined<FV> | DbxForgeFieldAsyncTransformLogicWhenAlways<FV>;
interface DbxForgeFieldAsyncTransformLogicWhenDefined<FV = unknown> {
    readonly type: 'transform';
    readonly transformType: 'async';
    readonly when?: 'defined';
    readonly transform: DbxForgeFieldAsyncTransformFunction<FV, FV>;
    readonly debounceMs?: Milliseconds;
}
interface DbxForgeFieldAsyncTransformLogicWhenAlways<FV = unknown> {
    readonly type: 'transform';
    readonly transformType: 'async';
    readonly when: 'always';
    readonly transform: DbxForgeFieldAsyncTransformFunction<Maybe<FV>, FV>;
    readonly debounceMs?: Milliseconds;
}
type DbxForgeFieldDebouncedTransformLogic<FV = unknown> = DbxForgeFieldDebouncedTransformLogicWhenDefined<FV> | DbxForgeFieldDebouncedTransformLogicWhenAlways<FV>;
interface DbxForgeFieldDebouncedTransformLogicWhenDefined<FV = unknown> {
    readonly type: 'transform';
    readonly transformType: 'debounced';
    readonly when?: 'defined';
    readonly transform: DbxForgeFieldTransformFunction<FV, FV>;
    readonly debounceMs?: Milliseconds;
}
interface DbxForgeFieldDebouncedTransformLogicWhenAlways<FV = unknown> {
    readonly type: 'transform';
    readonly transformType: 'debounced';
    readonly when: 'always';
    readonly transform: DbxForgeFieldTransformFunction<Maybe<FV>, FV>;
    readonly debounceMs?: Milliseconds;
}
/**
 * Default debounce time applied to debounced transform derivations.
 */
declare const DEFAULT_TRANSFORM_DEBOUNCE_TIME: Milliseconds;
/**
 * A custom validator config with an inline `fn` for auto-registration.
 *
 * When `reusableDefinition` is true, `functionName` is required -- the function is registered
 * once and shared across fields that reference it by name with field-specific `params`.
 *
 * When `reusableDefinition` is false/undefined, `functionName` is optional (auto-generated).
 */
type DbxForgeFieldCustomValidatorWithFn = {
    readonly type: 'custom';
    readonly fn: CustomValidator;
    readonly functionName: string;
    readonly reusableDefinition: true;
    readonly params?: Record<string, unknown>;
    readonly kind?: string;
} | {
    readonly type: 'custom';
    readonly fn: CustomValidator;
    readonly functionName?: string;
    readonly reusableDefinition?: false;
    readonly params?: Record<string, unknown>;
    readonly kind?: string;
};
/**
 * An async validator config with an inline `fn` for auto-registration.
 *
 * When `reusableDefinition` is true, `functionName` is required -- the function is registered
 * once and shared across fields that reference it by name with field-specific `params`.
 *
 * When `reusableDefinition` is false/undefined, `functionName` is optional (auto-generated).
 */
type DbxForgeFieldAsyncValidatorWithFn = {
    readonly type: 'async';
    readonly fn: AsyncCustomValidator;
    readonly functionName: string;
    readonly reusableDefinition: true;
    readonly params?: Record<string, unknown>;
} | {
    readonly type: 'async';
    readonly fn: AsyncCustomValidator;
    readonly functionName?: string;
    readonly reusableDefinition?: false;
    readonly params?: Record<string, unknown>;
};
/**
 * A validator input that can be a standard {@link ValidatorConfig} or one augmented with an inline `fn`.
 *
 * Supports both one-off inline validators (functionName auto-generated) and reusable definitions
 * (functionName required, registered once, referenced by name with field-specific params).
 */
type DbxForgeFieldValidatorInput = ValidatorConfig | DbxForgeFieldCustomValidatorWithFn | DbxForgeFieldAsyncValidatorWithFn;
/**
 * This type allows the builder instance to automatically register a function with the dbx-forge form.
 *
 * Uses distributive conditional types to preserve ng-forge's discriminated union while adding
 * `fn` support only to function-based derivation variants.
 */
type DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceLogicBuilderLogic<C extends DbxForgeFieldFunctionDef<any>, FV = any> = DbxForgeFieldLogicWithFn<DbxForgeFieldFunctionDefLogicValue<C>> | DbxForgeFieldTransformLogic<FV>;
/**
 * Builder methods for reading and mutating the logic configuration on a field definition.
 *
 * Logic entries control conditional field state (hidden, readonly, disabled, required)
 * and value derivation (sync/async functions, transforms).
 */
interface DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceLogicBuilder<C extends DbxForgeFieldFunctionDef<any>, FV = any> {
    /**
     * Returns the current logic configuration, if it exists.
     */
    getLogic(): Maybe<DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceLogicBuilderLogic<C, FV>[]>;
    /**
     * Adds one or more arbitrary logic value(s) to the field definition.
     */
    addLogic(logic: ArrayOrValue<DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceLogicBuilderLogic<C, FV>>): void;
    /**
     * Replaces the logic for the field definition.
     */
    setLogic(logic: ArrayOrValue<DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceLogicBuilderLogic<C, FV>>): void;
}
/**
 * Builder methods for reading and mutating the wrappers configuration on a field definition.
 */
interface DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceWrappersBuilder {
    /**
     * Returns the current wrappers configuration, if it exists.
     */
    getWrappers(): Maybe<WrapperConfig[]>;
    /**
     * Merges the field wrappers into the field definition.
     */
    addWrappers(wrappers: ArrayOrValue<WrapperConfig>): void;
    /**
     * Replaces the field form config for the field definition.
     */
    setWrappers(wrappers: ArrayOrValue<WrapperConfig>): void;
}
/**
 * Builder methods for reading and mutating the form-level config attached to a field definition.
 *
 * Form config includes schemas, external data, and custom function registrations
 * that are merged into the parent {@link DbxForgeFieldFormConfig} at form construction time.
 */
interface DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceFormConfigBuilder {
    /**
     * Returns the current logic configuration, if it exists.
     */
    getFormConfig(): Maybe<DbxForgeFieldFormConfig>;
    /**
     * Merges the field form config into the field definition.
     */
    addFormConfig(formConfig: Maybe<DbxForgeFieldFormConfig>): void;
    /**
     * Replaces the field form config for the field definition.
     */
    setFormConfig(formConfig: Maybe<DbxForgeFieldFormConfig>): void;
}
/**
 * Callback invoked by the builder to configure a field definition.
 *
 * Receives the builder {@link DbxForgeFieldFunctionFieldDefBuilderFunctionInstance} and the in-progress field config.
 */
type DbxForgeBuildFieldDefFunction<C extends DbxForgeFieldFunctionDef<any>, FV = unknown> = (instance: DbxForgeFieldFunctionFieldDefBuilderFunctionInstance<C, FV>, config: Building<C>) => void;
/**
 * Configuration for {@link dbxForgeBuildFieldDef}.
 */
interface DbxForgeBuildFieldDefConfig<C extends DbxForgeFieldFunctionDef<any>> {
}
/**
 * Creates a {@link DbxForgeFieldFunctionFieldDefBuilder} that provides a builder-instance pattern
 * for configuring field definitions.
 *
 * The returned builder runs the `configureFunction` first, then any per-call `inputConfigure` callback,
 * and finally finalizes logic entries (registering custom functions, expanding transforms).
 *
 * @param configureFunction - Primary configure callback applied to every field built by this builder.
 * @param _config - Reserved for future builder-level options.
 * @returns A reusable field definition builder.
 *
 * @example
 * ```ts
 * const buildMyField = dbxForgeBuildFieldDef<MyFieldDef>((instance) => {
 *   instance.injectDefaultValidation();
 *   instance.addLogic({ type: 'transform', transformType: 'idempotent', transform: trimString });
 * });
 * ```
 */
declare function dbxForgeBuildFieldDef<C extends DbxForgeFieldFunctionDef<any>, FV = any>(configureFunction: DbxForgeBuildFieldDefFunction<C, FV>, _config?: Maybe<DbxForgeBuildFieldDefConfig<C>>): DbxForgeFieldFunctionFieldDefBuilder<C, FV>;
/**
 * Creates a single {@link DbxForgeBuildFieldDefFunction} from all the input functions.
 *
 * @param fns - The functions to apply.
 * @returns Applies all of the given functions.
 */
declare function dbxForgeFieldFunctionConfigure<C extends DbxForgeFieldFunctionDef<any>, FV = unknown>(...fns: DbxForgeBuildFieldDefFunction<C, FV>[]): DbxForgeBuildFieldDefFunction<C, FV>;
/**
 * Creates a {@link DbxForgeFieldFunctionConfigPropsBuilder} that automatically copies `hint`
 * from the top-level field config into `props.hint`.
 *
 * Historically the hint lived at the base config level. In `@ng-forge/dynamic-forms` hints are
 * expected under `props`, so this builder bridges that gap.
 *
 * @param makeProps - Optional delegate that produces additional props; its result is merged before the hint is applied.
 * @returns A props builder that includes the hint value.
 *
 * @example
 * ```ts
 * const myField = dbxForgeFieldFunction<MyFieldDef>({
 *   type: 'my-field',
 *   buildProps: dbxForgeFieldFunctionConfigPropsWithHintBuilder()
 * });
 * ```
 */
declare function dbxForgeFieldFunctionConfigPropsWithHintBuilder<C extends DbxForgeFieldFunctionDef<any> & DbxForgeFieldHintValueRef<any>>(makeProps?: DbxForgeFieldFunctionConfigPropsBuilder<C>): DbxForgeFieldFunctionConfigPropsBuilder<C>;

/**
 * Semantic type to disable autocomplete on a field. Pass `false` to the autocomplete property.
 */
type DisableAutocompleteForField = false;
/**
 * Autocomplete configuration/attribute option for an input field.
 *
 * Pass a string for a specific autocomplete value (e.g., `'email'`, `'name'`),
 * or `false` to disable browser autofill.
 */
type FieldAutocompleteAttributeOption = string | DisableAutocompleteForField;
/**
 * Autocomplete configuration/attribute for an input field.
 *
 * @see {FieldAutocompleteAttributeOption}
 */
type FieldAutocompleteAttributeValue = string;
/**
 * Reference to an autocomplete attribute.
 */
interface FieldAutocompleteAttributeOptionRef {
    readonly autocomplete?: FieldAutocompleteAttributeOption;
}
/**
 * The output attributes to apply to an input element.
 */
interface FieldAutocompleteAttributes {
    readonly name?: string;
    readonly autocomplete: FieldAutocompleteAttributeValue;
}
/**
 * Builds a {@link FieldMeta} object for the given autocomplete configuration.
 *
 * When `false`, disables browser autofill by setting `name: 'password'` and `autocomplete: 'off'`
 * (matching the Chrome autofill workaround). When a string, sets the `autocomplete` attribute
 * to that value.
 *
 * @param autocomplete - The autocomplete option to convert into HTML attributes.
 * @returns The corresponding attributes, or undefined when no autocomplete option is provided.
 */
declare function fieldAutocompleteAttributeValue(autocomplete?: Maybe<FieldAutocompleteAttributeOption>): Maybe<FieldAutocompleteAttributes>;
/**
 * Returns the attributes to disable autofill on an input element.
 *
 * @returns Attributes that disable browser autofill when applied to an input element.
 *
 * @see https://stackoverflow.com/questions/15738259/disabling-chrome-autofill
 */
declare function disableAutofillAttributes(): FieldAutocompleteAttributes;

/**
 * Reads the `autocomplete` option from the builder's field def and, when it resolves to a
 * recognized HTML autocomplete token, attaches it to the field as `FieldMeta` so the
 * rendered input emits the corresponding `autocomplete` attribute.
 *
 * Intended to be used inside a field builder function to propagate autocomplete hints from
 * config into the final rendered form control.
 *
 * @param instance - The field builder instance whose field def is inspected and to which metadata is added.
 */
declare function configureForgeAutocompleteFieldMeta<C extends DbxForgeFieldFunctionDef<any> & FieldAutocompleteAttributeOptionRef>(instance: DbxForgeFieldFunctionFieldDefBuilderFunctionInstance<C>): void;

/**
 * Creates a computed signal that reads the disabled state from ng-forge's form-level options.
 *
 * Injects the `FORM_OPTIONS` token provided by ng-forge's `DynamicForm` component and reads
 * `formOptions.disabled`. This is the correct way to check form-level disabled state in
 * custom field components, since `FormOptions.disabled` does not propagate to individual
 * `FieldState.disabled()` signals.
 *
 * Must be called in an injection context (constructor, field initializer, or inject()-capable context).
 *
 * @returns A computed signal that is `true` when the form is disabled.
 *
 * @example
 * ```typescript
 * readonly isDisabled = dbxForgeFieldDisabled();
 * ```
 */
declare function dbxForgeFieldDisabled(): Signal<boolean>;

/**
 * Configuration for minimum and maximum text length constraints.
 */
interface DbxForgeTextFieldLengthConfig {
    readonly minLength?: number;
    readonly maxLength?: number;
}
/**
 * Configuration for regex pattern validation on a text field.
 */
interface DbxForgeTextFieldPatternConfig {
    readonly pattern?: string | RegExp;
}
/**
 * We use this for DbxForgeNumberFieldConfig since MatInputField is a union type for both string and number input.
 */
type DbxForgeStringInputFieldDef = BaseValueField<Omit<MatInputProps, 'type'> & {
    type?: DbxForgeTextFieldInputType;
}, string> & {
    type: 'input';
} & DbxForgeFieldHintValueRef<DynamicText>;
/**
 * HTML input type for a text field.
 */
type DbxForgeTextFieldInputType = 'text' | 'password' | 'email';
/**
 * Full configuration for a single-line text input field in forge.
 *
 * Combines labeling, validation (pattern, length), and string transformation
 * into one config object.
 */
interface DbxForgeTextFieldConfig extends DbxForgeFieldFunctionDef<DbxForgeStringInputFieldDef>, FieldAutocompleteAttributeOptionRef {
    /**
     * HTML input type. Defaults to `'text'`.
     */
    readonly inputType?: DbxForgeTextFieldInputType;
    /**
     * An idempotent string transformation applied as a value parser (e.g., trim, uppercase).
     *
     * For non-idempotent transformations, you should directly configure the `transform` property instead.
     */
    readonly idempotentTransform?: TransformStringFunctionConfig;
}
/**
 * Single-line text input. Supports text/email/password input types, autocomplete attribute, regex pattern validation, and idempotent string transforms (trim, case changes, etc.).
 *
 * @param config - Text field configuration including key, label, validation, and transform options
 * @returns A text input field with type `'input'`
 *
 * @dbxFormField
 * @dbxFormSlug text
 * @dbxFormTier field-factory
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType input
 * @dbxFormWrapperPattern unwrapped
 * @dbxFormConfigInterface DbxForgeTextFieldConfig
 * @example
 * ```typescript
 * const emailField = dbxForgeTextField({
 *   key: 'email',
 *   label: 'Email',
 *   required: true,
 *   inputType: 'email',
 *   props: { placeholder: 'user@example.com' }
 * });
 * ```
 */
declare const dbxForgeTextField: DbxForgeFieldFunction<DbxForgeTextFieldConfig, MatInputField>;

/**
 * Configuration for a multi-line textarea input field in forge.
 */
interface DbxForgeTextAreaFieldConfig extends DbxForgeFieldFunctionDef<MatTextareaField>, FieldAutocompleteAttributeOptionRef, Partial<TransformStringFunctionConfigRef> {
    /**
     * Number of visible text rows. Defaults to 3.
     */
    readonly rows?: number;
    /**
     * Initial value for the textarea. Defaults to empty string.
     */
    readonly defaultValue?: string;
}
/**
 * Multi-line textarea input. Supports row count, autocomplete attribute, pattern validation (RegExp → string conversion), and default value.
 *
 * @param config - Textarea field configuration including key, label, rows, and validation options
 * @returns A textarea field with type `'textarea'`
 *
 * @dbxFormField
 * @dbxFormSlug text-area
 * @dbxFormTier field-factory
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType textarea
 * @dbxFormWrapperPattern unwrapped
 * @dbxFormConfigInterface DbxForgeTextAreaFieldConfig
 * @example
 * ```typescript
 * const bioField = dbxForgeTextAreaField({
 *   key: 'bio',
 *   label: 'Biography',
 *   rows: 5,
 *   maxLength: 500
 * });
 * ```
 */
declare const dbxForgeTextAreaField: _dereekb_dbx_form.DbxForgeFieldFunction<DbxForgeTextAreaFieldConfig, MatTextareaField>;

/**
 * Configuration for a forge name input field.
 */
type DbxForgeNameFieldConfig = Partial<DbxForgeTextFieldConfig>;
/**
 * Pre-configured text field for capturing a full name with sensible min/max length defaults.
 *
 * @param config - Optional overrides; defaults to key `'name'`, label `'Name'`
 * @returns A {@link MatInputField} for name input.
 *
 * @dbxFormSlug name
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormFieldDerivative text
 * @dbxFormConfigInterface DbxForgeNameFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeNameField({ key: 'fullName', label: 'Full Name', required: true })
 * ```
 */
declare function dbxForgeNameField(config?: DbxForgeNameFieldConfig): _dereekb_dbx_form.DbxForgeField<_ng_forge_dynamic_forms_material.MatInputField>;
/**
 * Configuration for a forge email address input field.
 */
interface DbxForgeEmailFieldConfig {
    readonly key?: string;
    readonly label?: string;
    readonly placeholder?: string;
    readonly required?: boolean;
    readonly readonly?: boolean;
    readonly hint?: DynamicText;
    /**
     * Sets the autocomplete attribute on the input. Pass `false` to disable browser autofill.
     */
    readonly autocomplete?: FieldAutocompleteAttributeOption;
}
/**
 * Text field pre-configured with email input type and email validator. Prefer this over configuring `dbxForgeTextField` with `inputType: "email"` directly.
 *
 * Uses the `'email'` input type for built-in browser validation.
 *
 * @param config - Optional overrides; defaults to key `'email'`, label `'Email Address'`
 * @returns A {@link MatInputField} with email input type.
 *
 * @dbxFormSlug email
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormFieldDerivative text
 * @dbxFormConfigInterface DbxForgeEmailFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeEmailField({ key: 'email', label: 'Email', required: true })
 * ```
 */
declare function dbxForgeEmailField(config?: DbxForgeEmailFieldConfig): _dereekb_dbx_form.DbxForgeField<_ng_forge_dynamic_forms_material.MatInputField>;
/**
 * Configuration for a forge city input field.
 */
type DbxForgeCityFieldConfig = Partial<DbxForgeTextFieldConfig>;
/**
 * City name input enforcing `ADDRESS_CITY_MAX_LENGTH`. Typically used inside the address composite set.
 *
 * @param config - Optional overrides; defaults to key `'city'`, label `'City'`
 * @returns A {@link MatInputField} for city input.
 *
 * @dbxFormSlug city
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormFieldDerivative text
 * @dbxFormConfigInterface DbxForgeCityFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeCityField({ required: true })
 * ```
 */
declare function dbxForgeCityField(config?: DbxForgeCityFieldConfig): _dereekb_dbx_form.DbxForgeField<_ng_forge_dynamic_forms_material.MatInputField>;
/**
 * Configuration for a forge US state input field.
 */
interface DbxForgeStateFieldConfig extends Partial<DbxForgeTextFieldConfig> {
    /**
     * When true, validates and formats as a 2-letter state code (e.g., `'CA'`).
     */
    readonly asCode?: boolean;
}
/**
 * US state input. When `asCode: true`, validates two-letter codes and auto-uppercases input via an idempotent transform.
 *
 * @param config - Optional overrides; defaults to key `'state'`, label `'State'`
 * @returns A {@link MatInputField} for state input.
 *
 * @dbxFormSlug state
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormFieldDerivative text
 * @dbxFormConfigInterface DbxForgeStateFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeStateField({ asCode: true, required: true })
 * ```
 */
declare function dbxForgeStateField(config?: DbxForgeStateFieldConfig): _dereekb_dbx_form.DbxForgeField<_ng_forge_dynamic_forms_material.MatInputField>;
/**
 * Configuration for a forge country input field.
 */
type DbxForgeCountryFieldConfig = Partial<DbxForgeTextFieldConfig>;
/**
 * Country name input enforcing `ADDRESS_COUNTRY_MAX_LENGTH`. Typically used inside the address composite set.
 *
 * @param config - Optional overrides; defaults to key `'country'`, label `'Country'`
 * @returns A {@link MatInputField} for country input.
 *
 * @dbxFormSlug country
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormFieldDerivative text
 * @dbxFormConfigInterface DbxForgeCountryFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeCountryField({ required: true })
 * ```
 */
declare function dbxForgeCountryField(config?: DbxForgeCountryFieldConfig): _dereekb_dbx_form.DbxForgeField<_ng_forge_dynamic_forms_material.MatInputField>;
/**
 * Configuration for a forge zip/postal code input field.
 */
type DbxForgeZipCodeFieldConfig = Partial<DbxForgeTextFieldConfig>;
/**
 * US zip code input with pattern validation and max-length enforcement.
 *
 * @param config - Optional overrides; defaults to key `'zip'`, label `'Zip Code'`
 * @returns A {@link MatInputField} for zip code input.
 *
 * @dbxFormSlug zip-code
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormFieldDerivative text
 * @dbxFormConfigInterface DbxForgeZipCodeFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeZipCodeField({ required: true })
 * ```
 */
declare function dbxForgeZipCodeField(config?: DbxForgeZipCodeFieldConfig): _dereekb_dbx_form.DbxForgeField<_ng_forge_dynamic_forms_material.MatInputField>;
/**
 * Default placeholder text for a forge latitude/longitude text field.
 */
declare const DEFAULT_FORGE_LAT_LNG_TEXT_FIELD_PLACEHOLDER = "12.345,-67.8910";
/**
 * Default pattern-validation message for a forge latitude/longitude text field.
 */
declare const DEFAULT_FORGE_LAT_LNG_TEXT_FIELD_PATTERN_MESSAGE = "Invalid/unknown coordinates";
/**
 * Configuration for a forge latitude/longitude text input field.
 */
type DbxForgeLatLngTextFieldConfig = Partial<DbxForgeTextFieldConfig>;
/**
 * Latitude/longitude coordinate input with decimal-degree pattern validation.
 *
 * @param config - Optional overrides; defaults to key `'latLng'`
 * @returns A {@link MatInputField} for coordinate input.
 *
 * @dbxFormSlug lat-lng
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormFieldDerivative text
 * @dbxFormConfigInterface DbxForgeLatLngTextFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeLatLngTextField({ key: 'coords', label: 'Coordinates' })
 * ```
 */
declare function dbxForgeLatLngTextField(config?: DbxForgeLatLngTextFieldConfig): _dereekb_dbx_form.DbxForgeField<_ng_forge_dynamic_forms_material.MatInputField>;

/**
 * Configuration for a group of address-related form fields (lines, city, state, zip, country).
 */
interface DbxForgeAddressFieldsConfig {
    readonly line1Field?: DbxForgeCityFieldConfig;
    readonly line2Field?: DbxForgeCityFieldConfig;
    readonly cityField?: DbxForgeCityFieldConfig;
    readonly stateField?: DbxForgeStateFieldConfig;
    readonly zipCodeField?: DbxForgeZipCodeFieldConfig;
    readonly countryField?: DbxForgeCountryFieldConfig;
    /**
     * Whether or not to make required fields required.
     *
     * True by default.
     */
    readonly required?: boolean;
    /**
     * Whether or not to include the second address line.
     *
     * True by default.
     */
    readonly includeLine2?: boolean;
    /**
     * Whether or not to include the country.
     *
     * True by default.
     */
    readonly includeCountry?: boolean;
}
/**
 * Configuration for a single address line field.
 */
interface DbxForgeAddressLineFieldConfig extends Partial<DbxForgeTextFieldConfig> {
    /**
     * Address line number: 0 for single "Street" line, 1 for "Line 1", 2 for "Line 2".
     */
    readonly line?: 0 | 1 | 2;
}
/**
 * Street address line input. The `line` prop controls which line (1 or 2) — it affects key and label generation.
 *
 * @param config - Optional overrides; line number determines key and label.
 * @returns A {@link MatInputField} for address line input.
 *
 * @dbxFormSlug address-line
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormFieldDerivative text
 * @dbxFormConfigInterface DbxForgeAddressLineFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeAddressLineField({ line: 2 })
 * ```
 */
declare function dbxForgeAddressLineField(config?: DbxForgeAddressLineFieldConfig): DbxForgeField<MatInputField>;
/**
 * Flat array of address fields (line(s), city, state, zip, optional country) with a sensible flex layout. Drop directly into a parent `fields: []`.
 *
 * @param config - Address fields configuration.
 * @returns Array of forge field definitions for a complete address form section.
 *
 * @dbxFormSlug address-fields
 * @dbxFormProduces FieldDef[]
 * @dbxFormArrayOutput no
 * @dbxFormFieldTemplate address-line, city, state, zip-code, country
 * @dbxFormConfigInterface DbxForgeAddressFieldsConfig
 *
 * @example
 * ```typescript
 * dbxForgeAddressFields({ required: true, includeCountry: false })
 * ```
 */
declare function dbxForgeAddressFields(config?: DbxForgeAddressFieldsConfig): GroupAllowedChildren[];
/**
 * Configuration for a complete address group composite.
 */
interface DbxForgeAddressGroupConfig extends DbxForgeAddressFieldsConfig {
    readonly key?: string;
}
/**
 * Wraps `address-fields` in a `GroupField` so the address is stored as a nested object under one key. Prefer this when the rest of the form doesn't want address fields flattened.
 *
 * @param config - Optional overrides; defaults to key `'address'`
 * @returns A {@link GroupField} containing address fields.
 *
 * @dbxFormField
 * @dbxFormSlug address-group
 * @dbxFormTier composite-builder
 * @dbxFormSuffix Group
 * @dbxFormProduces GroupField
 * @dbxFormArrayOutput no
 * @dbxFormConfigInterface DbxForgeAddressGroupConfig
 * @dbxFormComposesFrom address-fields, group
 *
 * @example
 * ```typescript
 * dbxForgeAddressGroup({ key: 'billingAddress' })
 * ```
 */
declare function dbxForgeAddressGroup(config?: Partial<DbxForgeAddressGroupConfig>): GroupField;
/**
 * Configuration for a repeatable list of address field groups.
 */
interface DbxForgeAddressListFieldConfig extends DbxForgeAddressFieldsConfig {
    readonly key?: string;
    /**
     * Maximum number of addresses allowed. Defaults to 6.
     */
    readonly maxAddresses?: number;
}
/**
 * Repeatable array of addresses built on top of `array-field` + `address-group`. Keeps the `Field` suffix because it returns a single composite field whose value is an array of addresses.
 *
 * @param config - Optional overrides; defaults to key `'addresses'`, max 6 entries.
 * @returns A {@link DbxForgeArrayFieldDef} for multiple addresses.
 *
 * @dbxFormField
 * @dbxFormSlug address-list
 * @dbxFormTier composite-builder
 * @dbxFormSuffix Field
 * @dbxFormProduces ArrayField
 * @dbxFormArrayOutput yes
 * @dbxFormConfigInterface DbxForgeAddressListFieldConfig
 * @dbxFormComposesFrom address-group, array-field
 *
 * @example
 * ```typescript
 * dbxForgeAddressListField({ maxAddresses: 3 })
 * ```
 */
declare function dbxForgeAddressListField(config?: Partial<DbxForgeAddressListFieldConfig>): DbxForgeField<_ng_forge_dynamic_forms.ArrayField<readonly _ng_forge_dynamic_forms_internal.ArrayItemDefinition[]>>;

/**
 * Validation error kind used by the `enforceStep` divisibility validator.
 */
declare const FORGE_IS_DIVISIBLE_BY_VALIDATION_KEY = "isDivisibleBy";
/**
 * Numeric constraint configuration for forge number fields.
 */
interface DbxForgeNumberFieldNumberConfig {
    readonly min?: number;
    readonly max?: number;
    /**
     * Step increment for the input.
     */
    readonly step?: number;
    /**
     * When true, validates that the value is divisible by `step`.
     * Requires `step` to be set.
     */
    readonly enforceStep?: boolean;
}
/**
 * We use this for DbxForgeNumberFieldConfig since MatInputField is a union type for both string and number input.
 */
type DbxForgeNumberFieldDef = BaseValueField<Omit<MatInputProps, 'type'> & {
    type?: 'number';
}, number> & {
    type: 'input';
};
/**
 * Full configuration for a numeric input field in forge.
 *
 * Combines labeling, numeric constraints (min/max/step), and number transformation.
 */
interface DbxForgeNumberFieldConfig extends DbxForgeFieldFunctionDef<DbxForgeNumberFieldDef>, FieldAutocompleteAttributeOptionRef, DbxForgeNumberFieldNumberConfig, Partial<TransformNumberFunctionConfigRef> {
    /**
     * An idempotent number transformation applied as a value parser (e.g., rounding, precision, bounds).
     *
     * For non-idempotent transformations, you should directly configure the `transform` property instead.
     */
    readonly idempotentTransform?: TransformNumberFunctionConfig;
}
/**
 * Numeric input (HTML `type="number"`). Supports min/max/step constraints, optional step enforcement (divisibility validator), and idempotent number transforms.
 *
 * When `step` is provided, sets the HTML `step` attribute on the input via `meta`.
 * When both `step` and `enforceStep` are set, adds a custom divisibility validator.
 *
 * @param config - Number field configuration
 * @returns A validated {@link MatInputField} with input type `'number'`
 *
 * @dbxFormField
 * @dbxFormSlug number
 * @dbxFormTier field-factory
 * @dbxFormProduces number
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType input
 * @dbxFormWrapperPattern unwrapped
 * @dbxFormConfigInterface DbxForgeNumberFieldConfig
 * @example
 * ```typescript
 * dbxForgeNumberField({ key: 'quantity', label: 'Quantity', min: 1, max: 100, step: 1, enforceStep: true })
 * ```
 */
declare const dbxForgeNumberField: DbxForgeFieldFunction<DbxForgeNumberFieldConfig, MatInputField>;
/**
 * Configuration for a forge dollar amount field, which enforces cent-level precision.
 */
type DbxForgeDollarAmountFieldConfig = Omit<DbxForgeNumberFieldConfig, 'roundToStep' | 'precision'>;
/**
 * Forge number field pre-configured for dollar amount input with cent-level precision. Pre-sets `transform.precision` to `DOLLAR_AMOUNT_PRECISION` so values round to whole cents.
 *
 * @param config - Number field configuration (precision is overridden to dollar amount precision)
 * @returns A {@link MatInputField} for dollar amount input.
 *
 * @dbxFormFieldDerivative number
 * @dbxFormSlug dollar-amount
 * @dbxFormProduces number
 * @dbxFormArrayOutput no
 * @dbxFormConfigInterface DbxForgeDollarAmountFieldConfig
 *
 * @example
 * ```typescript
 * const field = dbxForgeDollarAmountField({ key: 'price', label: 'Price', min: 0, required: true });
 * ```
 */
declare function dbxForgeDollarAmountField(config: DbxForgeDollarAmountFieldConfig): _dereekb_dbx_form.DbxForgeField<MatInputField>;

/**
 * Configuration for a forge Material slider field.
 */
interface DbxForgeNumberSliderFieldConfig extends DbxForgeFieldFunctionDef<MatSliderField> {
    /**
     * Whether or not to show the thumb label while sliding.
     *
     * Defaults to true.
     */
    readonly thumbLabel?: boolean;
    /**
     * Tick interval. If not provided defaults to the step value, if provided.
     * If false, the ticks are disabled.
     */
    readonly tickInterval?: false | number;
}
/**
 * Material slider wrapped in a form-field container. Supports thumb label, tick interval, and step-derived tick spacing.
 *
 * The wrapper provides the Material outlined form-field appearance (notched outline with
 * floating label, hint/error subscript). The inner slider uses the ng-forge built-in
 * `slider` type.
 *
 * @param config - Slider field configuration including max (required), thumb label, and tick interval
 * @returns A {@link DbxForgeFormFieldWrapperDef} wrapping a slider field
 *
 * @dbxFormField
 * @dbxFormSlug number-slider
 * @dbxFormTier field-factory
 * @dbxFormProduces number
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType slider
 * @dbxFormWrapperPattern material-form-field-wrapped
 * @dbxFormConfigInterface DbxForgeNumberSliderFieldConfig
 * @example
 * ```typescript
 * dbxForgeNumberSliderField({ key: 'rating', label: 'Rating', min: 0, max: 10, step: 1 })
 * ```
 */
declare const dbxForgeNumberSliderField: _dereekb_dbx_form.DbxForgeFieldFunction<DbxForgeNumberSliderFieldConfig, MatSliderField>;

/**
 * Where the field's primary label is rendered when wrapped by the form-field wrapper.
 */
type DbxForgeBooleanShowLabelAt = 'wrapper' | 'content' | 'both';
/**
 * Configuration for a forge Material toggle (slide toggle) field.
 */
interface DbxForgeToggleFieldConfig extends DbxForgeFieldFunctionDef<MatToggleField> {
    /**
     * Whether to render the toggle inside the shared Material-style form-field wrapper
     * so it picks up the outlined chrome and properly styled error/hint subscript.
     *
     * Defaults to `true`.
     */
    readonly styledBox?: boolean;
    /**
     * Where to render the field's primary label. Defaults to `'content'`.
     *
     * Ignored if `styledBox` is false.
     */
    readonly showLabelAt?: DbxForgeBooleanShowLabelAt;
    /**
     * Optional secondary label rendered inside the wrapper's content area, regardless
     * of {@link showLabelAt}. Useful for adding helper text inside the box.
     */
    readonly contentLabel?: DynamicText;
}
/**
 * Material slide toggle. Renders inside the shared form-field wrapper by default so
 * it visually matches surrounding outlined form fields and uses the standard error
 * subscript chrome; pass `styledBox: false` to opt out.
 *
 * @param config - Toggle field configuration
 * @returns A validated {@link MatToggleField} with type `'toggle'`
 *
 * @dbxFormField
 * @dbxFormSlug toggle
 * @dbxFormTier field-factory
 * @dbxFormProduces boolean
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType toggle
 * @dbxFormWrapperPattern material-form-field-wrapped
 * @dbxFormConfigInterface DbxForgeToggleFieldConfig
 * @example
 * ```typescript
 * dbxForgeToggleField({ key: 'active', label: 'Active', value: true })
 * ```
 */
declare const dbxForgeToggleField: _dereekb_dbx_form.DbxForgeFieldFunction<DbxForgeToggleFieldConfig, MatToggleField>;
/**
 * Configuration for a forge Material checkbox field.
 */
interface DbxForgeCheckboxFieldConfig extends DbxForgeFieldFunctionDef<MatCheckboxField> {
    /**
     * Whether to render the checkbox inside the shared Material-style form-field wrapper
     * so it picks up the outlined chrome and properly styled error/hint subscript.
     *
     * Defaults to `true`.
     */
    readonly styledBox?: boolean;
    /**
     * Where to render the field's primary label. Defaults to `'content'`.
     *
     * Ignored if `styledBox` is false.
     */
    readonly showLabelAt?: DbxForgeBooleanShowLabelAt;
    /**
     * Optional secondary label rendered inside the wrapper's content area, regardless
     * of {@link showLabelAt}. Useful for adding helper text inside the box.
     */
    readonly contentLabel?: DynamicText;
}
/**
 * Material checkbox. Shares the form-field-wrapper opt-out with toggle.
 *
 * @param config - Checkbox field configuration
 * @returns A validated {@link MatCheckboxField} with type `'checkbox'`
 *
 * @dbxFormField
 * @dbxFormSlug checkbox
 * @dbxFormTier field-factory
 * @dbxFormProduces boolean
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType checkbox
 * @dbxFormWrapperPattern material-form-field-wrapped
 * @dbxFormConfigInterface DbxForgeCheckboxFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeCheckboxField({ key: 'agree', label: 'I agree to the terms' })
 * ```
 */
declare const dbxForgeCheckboxField: _dereekb_dbx_form.DbxForgeFieldFunction<DbxForgeCheckboxFieldConfig, MatCheckboxField>;

declare enum DbxDateTimeFieldTimeMode {
    /**
     * Time is required.
     */
    REQUIRED = "required",
    /**
     * Time is optional.
     */
    OPTIONAL = "optional",
    /**
     * Time is permenantly off.
     */
    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';
/**
 * Error code used when the selected date is not in the schedule.
 */
declare const DBX_DATE_TIME_FIELD_DATE_NOT_IN_SCHEDULE_ERROR = "dateTimeFieldDateNotInSchedule";
/**
 * Error code used when the selected time/time input is not in the limited range.
 */
declare const DBX_DATE_TIME_FIELD_TIME_NOT_IN_RANGE_ERROR = "dateTimeFieldTimeNotInRange";

/**
 * A pair of either a logical date or a time string.
 */
interface DateTimePresetValue {
    /**
     * Logical date to provide.
     */
    logicalDate?: Maybe<LogicalDate>;
    /**
     * Time string value. Ignored if logical date is provided.
     */
    timeString?: Maybe<ReadableTimeString>;
}
/**
 * Configuration for a DateTimePreset
 */
interface DateTimePresetConfiguration {
    /**
     * Label
     */
    label: GetterOrValue<string>;
    /**
     * Whether or not the value should be retrieved each time or can be cached.
     *
     * Only relevant if a getter is used.
     */
    dynamic?: boolean;
    /**
     * Logical time to provide.
     */
    logicalDate?: Maybe<GetterOrValue<LogicalDate>>;
    /**
     * Time string to return. Ignored if logicalDate is provided.
     */
    timeString?: Maybe<GetterOrValue<ReadableTimeString>>;
}
/**
 * A label and value getter.
 */
interface DateTimePreset {
    /**
     * Getter for the label
     */
    label: Getter<string>;
    /**
     * Getter for the value
     */
    value: Getter<DateTimePresetValue>;
}
/**
 * Creates a DateTimePreset from a DateTimePresetConfiguration.
 *
 * @param config - The preset configuration with label and value getter.
 * @returns A DateTimePreset with a lazy value getter.
 */
declare function dateTimePreset(config: DateTimePresetConfiguration): DateTimePreset;

/**
 * Input for computing a combined datetime from date/time field state.
 */
interface DateTimeCalcInput {
    readonly dateValue: Maybe<Date>;
    readonly timeString: Maybe<ReadableTimeString>;
    readonly isFullDay: boolean;
    readonly fullDayInUTC: boolean;
    readonly isTimeOnly: boolean;
    readonly timeMode: DbxDateTimeFieldTimeMode;
    readonly timeDate: Maybe<Date>;
    readonly isCleared: boolean;
}
/**
 * Result of keyboard step computation.
 */
interface KeyboardStepResult {
    readonly direction: number;
    readonly offset: number;
}
/**
 * Interface wrapping all datetime field calculation functions.
 */
interface DateTimeFieldCalc {
    /**
     * Combines date + time inputs into a single Date value.
     *
     * This is the core logic that merges the separate date and time controls
     * into one unified datetime, handling fullDay, timeOnly, cleared states, and timeDate fallbacks.
     */
    buildCombinedDateTime(input: DateTimeCalcInput): Maybe<Date>;
    /**
     * Applies a keyboard offset (in steps) to a date, clamping to the given picker config limits.
     *
     * Each step is multiplied by minuteStep to get the actual minutes delta.
     * The result is clamped via DateTimeMinuteInstance.
     *
     * @param input - The time offset input containing date, step offset, minute step, and optional config
     */
    applyTimeOffset(input: ApplyTimeOffsetInput): Date;
    /**
     * Merges picker config limits with min/max values from synced fields.
     *
     * Sync "before" values contribute a minimum date (this field must be after that value).
     * Sync "after" values contribute a maximum date (this field must be before that value).
     */
    mergePickerConfig(config: Maybe<DbxDateTimePickerConfiguration>, syncBeforeValue: Maybe<Date>, syncAfterValue: Maybe<Date>): Maybe<DbxDateTimePickerConfiguration>;
    /**
     * Filters presets based on selected date, fullDay/timeOnly state, and config limits.
     *
     * - Returns empty array when fullDay is active.
     * - Returns all presets unfiltered when timeOnly (no date-based filtering).
     * - Otherwise evaluates each preset against the selected date and config limits.
     *
     * @param input - The filter presets input containing presets, selected date, mode flags, and optional config
     */
    filterPresets(input: FilterPresetsInput): DateTimePreset[];
    /**
     * Computes a human-readable error message from a form field's error record.
     */
    computeErrorMessage(errors: Maybe<Record<string, unknown>>, isRequired: boolean): string | undefined;
}
/**
 * Creates a {@link DateTimeFieldCalc} instance with all datetime calculation functions.
 *
 * @returns A DateTimeFieldCalc instance bundling all pure datetime calculation functions.
 */
declare function dateTimeFieldCalc(): DateTimeFieldCalc;
/**
 * Combines date and time inputs into a single Date.
 *
 * Handles fullDay, timeOnly, cleared states, and timeDate fallbacks to produce
 * a unified datetime value from the separate date and time form controls.
 *
 * @param input - The datetime calculation input containing date, time, and mode information.
 * @returns The combined Date value, or undefined if the input is cleared or incomplete.
 *
 * @__NO_SIDE_EFFECTS__
 */
declare function buildCombinedDateTime(input: DateTimeCalcInput): Maybe<Date>;
/**
 * Input for {@link applyTimeOffset}.
 */
interface ApplyTimeOffsetInput {
    readonly date: Date;
    readonly stepsOffset: number;
    readonly minuteStep: number;
    readonly config?: Maybe<DbxDateTimePickerConfiguration>;
}
/**
 * Applies a keyboard time offset (in step increments) and clamps to picker config limits.
 *
 * @param input - The time offset input containing date, step offset, minute step, and optional config.
 * @returns The offset date, clamped to the picker config limits.
 */
declare function applyTimeOffset(input: ApplyTimeOffsetInput): Date;
/**
 * Merges picker config with sync constraint values (before/after from synced fields).
 *
 * Sync "before" values contribute a minimum date (this field must be after that value).
 * Sync "after" values contribute a maximum date (this field must be before that value).
 *
 * @param config - The base picker configuration to merge into.
 * @param syncBeforeValue - Minimum date constraint from a synced "before" field, or null.
 * @param syncAfterValue - Maximum date constraint from a synced "after" field, or null.
 * @returns The merged picker configuration with updated limits, or the original config if no sync values.
 */
declare function mergePickerConfig(config: Maybe<DbxDateTimePickerConfiguration>, syncBeforeValue: Maybe<Date>, syncAfterValue: Maybe<Date>): Maybe<DbxDateTimePickerConfiguration>;
/**
 * Input for {@link filterPresets}.
 */
interface FilterPresetsInput {
    readonly presets: DateTimePreset[];
    readonly selectedDate: Maybe<Date>;
    readonly isFullDay: boolean;
    readonly isTimeOnly: boolean;
    readonly config?: Maybe<DbxDateTimePickerConfiguration>;
}
/**
 * Filters presets based on the current field state and config limits.
 *
 * Returns an empty array when fullDay is active (no time presets apply).
 * Returns all presets unfiltered when timeOnly (no date-based filtering needed).
 * Otherwise evaluates each preset against the selected date and config limits.
 *
 * @param input - The filter presets input containing presets, selected date, mode flags, and optional config.
 * @returns The filtered array of applicable presets.
 */
declare function filterPresets(input: FilterPresetsInput): DateTimePreset[];
/**
 * Computes a human-readable error message from a field's error record.
 *
 * Checks for required, schedule, time range, and pattern errors in priority order.
 *
 * @param errors - The validation error record from the form field, or null/undefined.
 * @param isRequired - Whether the field is required (affects the "required" error message)
 * @returns A human-readable error message string, or undefined if no errors exist.
 */
declare function computeErrorMessage(errors: Maybe<Record<string, unknown>>, isRequired: boolean): string | undefined;
/**
 * Computes the date keyboard navigation step from a KeyboardEvent.
 *
 * - ArrowUp/Down: ±1 day
 * - Ctrl: ±30 days
 * - Shift: ±7 days
 * - Ctrl+Shift: ±365 days
 *
 * Returns null if the event is not a recognized arrow key.
 *
 * @param event - The keyboard event to evaluate.
 * @returns A KeyboardStepResult with direction and offset, or null if the key is not an arrow key.
 */
declare function computeDateKeyboardStep(event: KeyboardEvent): Maybe<KeyboardStepResult>;
/**
 * Computes the time keyboard navigation step from a KeyboardEvent.
 *
 * - ArrowUp/Down: ±1 step
 * - Alt: ±60 steps (typically minutes)
 * - Shift: ±5 steps
 * - Alt+Shift: ±300 steps
 *
 * Returns null if the event is not a recognized arrow key.
 *
 * @param event - The keyboard event to evaluate.
 * @returns A KeyboardStepResult with direction and offset, or null if the key is not an arrow key.
 */
declare function computeTimeKeyboardStep(event: KeyboardEvent): Maybe<KeyboardStepResult>;
/**
 * Navigates to a new date by applying a keyboard step, validating against the schedule, and clamping to limits.
 *
 * @param currentDate - The current date to navigate from.
 * @param step - The keyboard step result (direction + offset in days)
 * @param config - Optional picker config for schedule/limit validation.
 * @returns The new date, or null if no valid date is available in the requested direction.
 */
declare function navigateDate(currentDate: Date, step: KeyboardStepResult, config: Maybe<DbxDateTimePickerConfiguration>): Maybe<Date>;

/**
 * Configuration for a forge date picker field.
 */
interface DbxForgeDateFieldConfig extends DbxForgeFieldFunctionDef<MatDatepickerField> {
}
/**
 * Material datepicker (date-only, no time). For time-of-day picking use the `date-time` field; for ranges use `date-range-row` or `date-time-range-row`.
 *
 * Uses the native ng-forge MatDatepickerField.
 *
 * @param config - Date field configuration including key, label, and date constraints
 * @returns A validated {@link MatDatepickerField}
 *
 * @dbxFormField
 * @dbxFormSlug date
 * @dbxFormTier field-factory
 * @dbxFormProduces Date
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType datepicker
 * @dbxFormWrapperPattern unwrapped
 * @dbxFormConfigInterface DbxForgeDateFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeDateField({ key: 'startDate', label: 'Start Date', required: true })
 * ```
 */
declare const dbxForgeDateField: _dereekb_dbx_form.DbxForgeFieldFunction<DbxForgeDateFieldConfig, MatDatepickerField>;

declare enum DbxDateTimeValueMode {
    /**
     * Value is returned/parsed as a Date.
     */
    DATE = 0,
    /**
     * Value is returned/parsed as an ISO8601DateString
     */
    DATE_STRING = 1,
    /**
     * Value is returned/parsed as an ISO8601DayString, relative to the current timezone.
     */
    DAY_STRING = 2,
    /**
     * Value is returned/parsed as a Unix timestamp, relative to the current timezone.
     */
    UNIX_TIMESTAMP = 3,
    /**
     * Value is returned/parsed as a minute of the day, relative to the current timezone.
     */
    MINUTE_OF_DAY = 4,
    /**
     * Value is returned/parsed as a minute of the day, relative to the system timezone.
     */
    SYSTEM_MINUTE_OF_DAY = 5
}
/**
 * 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 Parses input values to Date objects.
 *
 * @example
 * ```typescript
 * const parser = dbxDateTimeInputValueParseFactory(DbxDateTimeValueMode.DATE_STRING, timezoneInstance);
 * const date = parser('2024-01-15T10:00:00Z');
 * ```
 *
 * @__NO_SIDE_EFFECTS__
 */
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 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'
 * ```
 *
 * @__NO_SIDE_EFFECTS__
 */
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;

/**
 * Custom props for the forge date-time field.
 *
 * Full parity with formly `DbxDateTimeFieldProps`.
 */
interface DbxForgeDateTimeFieldComponentProps {
    readonly timeOnly?: boolean;
    readonly timeMode?: DbxDateTimeFieldTimeMode;
    readonly valueMode?: DbxDateTimeValueMode;
    readonly dateLabel?: string;
    readonly timeLabel?: string;
    readonly allDayLabel?: string;
    readonly atTimeLabel?: string;
    readonly minDate?: Date | string;
    readonly maxDate?: Date | string;
    readonly timezone?: Maybe<ObservableOrValueGetter<Maybe<TimezoneString>>>;
    readonly showTimezone?: Maybe<boolean>;
    readonly pickerConfig?: ObservableOrValueGetter<DbxDateTimePickerConfiguration>;
    readonly hideDateHint?: boolean;
    readonly hideDatePicker?: boolean;
    readonly alwaysShowDateInput?: boolean;
    readonly showClearButton?: Maybe<boolean>;
    readonly autofillDateWhenTimeIsPicked?: boolean;
    readonly presets?: ObservableOrValueGetter<DateTimePresetConfiguration[]>;
    readonly timeDate?: Maybe<ObservableOrValueGetter<Maybe<DateOrDayString>>>;
    readonly fullDayFieldName?: string;
    readonly fullDayInUTC?: boolean;
    readonly minuteStep?: Maybe<number>;
    readonly inputOutputDebounceTime?: Milliseconds;
    readonly appearance?: 'fill' | 'outline';
    readonly hint?: DynamicText;
    readonly getSyncFieldsObs?: () => Observable<ArrayOrValue<DbxForgeDateTimeSyncField>>;
    /**
     * Behavior when the date input is clicked.
     *
     * - `'picker'` — opens the datepicker overlay (default)
     * - `'input'` — normal text-selection / cursor-placement behavior
     */
    readonly openOnInputClick?: 'picker' | 'input';
}
/**
 * Forge date-time field component.
 *
 * Hybrid signal + observable architecture: uses signals for primary/derived state and template
 * bindings, with observable pipelines for timing-sensitive operations (throttling, debouncing,
 * display refresh). Reuses the same value parsing/output utilities as the formly implementation.
 *
 * Registered as custom field type 'datetime' via `forge.providers.ts`.
 */
declare class DbxForgeDateTimeFieldComponent {
    private readonly materialConfig;
    private readonly destroyRef;
    private readonly elementRef;
    private readonly presetsService;
    private readonly fieldSignalContext;
    readonly field: InputSignal<FieldTree<unknown>>;
    readonly key: InputSignal<string>;
    readonly label: InputSignal<DynamicText | undefined>;
    readonly placeholder: InputSignal<DynamicText | undefined>;
    readonly className: InputSignal<string>;
    readonly tabIndex: InputSignal<number | undefined>;
    readonly props: InputSignal<DbxForgeDateTimeFieldComponentProps | undefined>;
    readonly meta: InputSignal<FieldMeta | undefined>;
    readonly validationMessages: InputSignal<ValidationMessages | undefined>;
    readonly defaultValidationMessages: InputSignal<ValidationMessages | undefined>;
    readonly dateCtrl: FormControl<Maybe<Date>>;
    readonly timeCtrl: FormControl<Maybe<string>>;
    private readonly _fullDay;
    private readonly _timezone;
    private readonly _pickerConfig;
    private readonly _timeDate;
    private readonly _presetConfigs;
    private readonly _isCleared;
    private readonly _isTimeInputFocused;
    private readonly _sub;
    private readonly _valueSub;
    private readonly _autoFillDateSync;
    private readonly _resyncTimeInputSub;
    private _timezoneSub?;
    private _pickerConfigSub?;
    private _timeDateSub?;
    private _presetsSub?;
    private readonly _offset;
    private readonly _updateTime;
    private readonly _resyncTimeInput;
    private readonly _syncConfigObs;
    readonly timeErrorStateMatcher: ErrorStateMatcher;
    readonly fieldLabelSignal: Signal<string | undefined>;
    readonly isRequiredSignal: Signal<boolean>;
    readonly isDateRequiredSignal: Signal<boolean>;
    readonly isTimeRequiredSignal: Signal<boolean>;
    readonly descriptionSignal: Signal<string | undefined>;
    readonly appearanceSignal: Signal<_angular_material_form_field.MatFormFieldAppearance>;
    readonly valueModeSignal: Signal<DbxDateTimeValueMode>;
    readonly timeModeSignal: Signal<DbxDateTimeFieldTimeMode>;
    readonly isTimeOnlySignal: Signal<boolean>;
    readonly isDateOnlySignal: Signal<boolean>;
    readonly isFullDaySignal: Signal<boolean>;
    readonly showDateInputSignal: Signal<boolean>;
    readonly showTimeInputSignal: Signal<boolean>;
    readonly showAddTimeButtonSignal: Signal<boolean>;
    readonly dateLabelSignal: Signal<string>;
    readonly timeLabelSignal: Signal<string>;
    readonly allDayLabelSignal: Signal<string>;
    readonly atTimeLabelSignal: Signal<string>;
    readonly hideDateHintSignal: Signal<boolean>;
    readonly hideDatePickerSignal: Signal<boolean>;
    readonly showTimezoneSignal: Signal<boolean>;
    readonly showClearButtonSignal: Signal<boolean>;
    readonly minuteStepSignal: Signal<number>;
    readonly alwaysShowDateInputSignal: Signal<boolean>;
    readonly autofillDateWhenTimeIsPickedSignal: Signal<boolean>;
    readonly openOnInputClickSignal: Signal<"input" | "picker">;
    readonly resolvedTimezoneSignal: Signal<string | undefined>;
    readonly timezoneInstanceSignal: Signal<Maybe<DateTimezoneUtcNormalInstance>>;
    readonly fieldValueSignal: Signal<unknown>;
    readonly isDisabled: Signal<boolean>;
    readonly fieldValue$: Observable<unknown>;
    readonly timezoneInstance$: Observable<Maybe<DateTimezoneUtcNormalInstance>>;
    readonly valueInSystemTimezone$: Observable<Maybe<Date>>;
    readonly refreshInterval$: Observable<number>;
    readonly displayValue$: Observable<Maybe<Date>>;
    readonly timeString$: Observable<ReadableTimeString>;
    readonly currentDate$: Observable<Maybe<Date>>;
    readonly date$: Observable<Date>;
    readonly dateValue$: Observable<Maybe<Date>>;
    readonly timeInput$: Observable<ReadableTimeString>;
    readonly resyncTimeInput$: Observable<void>;
    readonly tzAbbreviation$: Observable<string>;
    private readonly _isCleared$;
    private readonly _timeDate$;
    readonly isTimeCleared$: Observable<boolean>;
    readonly syncConfigObs$: Observable<Maybe<DbxForgeDateTimeSyncField | DbxForgeDateTimeSyncField[]>>;
    readonly parsedSyncConfigs$: Observable<{
        syncType: DbxDateTimeFieldSyncType;
        fieldState: any;
    }[]>;
    private _syncConfigValueObs;
    readonly syncConfigBeforeValue$: Observable<Maybe<Date>>;
    readonly syncConfigAfterValue$: Observable<Maybe<Date>>;
    readonly pickerConfig$: Observable<Maybe<DbxDateTimePickerConfiguration>>;
    readonly dateTimePickerConfig$: Observable<Maybe<DbxDateTimePickerConfiguration>>;
    readonly dateInputMin$: Observable<Maybe<Date>>;
    readonly dateInputMax$: Observable<Maybe<Date>>;
    readonly dateMinAndMaxIsSameDay$: Observable<boolean>;
    readonly pickerFilter$: Observable<(d: Maybe<Date>) => boolean>;
    readonly showDateInput$: Observable<boolean>;
    private readonly _rawDateTimeDate$;
    readonly rawDateTime$: Observable<Maybe<Date>>;
    readonly timeOutput$: Observable<Maybe<Date>>;
    readonly dateTimePickerInstance$: Observable<DateTimeMinuteInstance>;
    readonly allPresets$: Observable<DateTimePreset[]>;
    readonly presets$: Observable<DateTimePreset[]>;
    readonly hasEmptyDisplayValue$: Observable<boolean>;
    readonly currentErrorMessage$: Observable<string | undefined>;
    readonly hasError$: Observable<boolean>;
    readonly showClearButton$: Observable<boolean>;
    /**
     * Template signal for the date input `[value]` binding.
     *
     * Reads directly from the Signal Forms field value so it updates on both
     * inbound sync (form source) and user picks. Returns null when cleared.
     */
    readonly dateValueSignal: Signal<Date | null>;
    readonly displayValueSignal: Signal<Maybe<Date>>;
    readonly pickerFilterSignal: Signal<((d: Maybe<Date>) => boolean) | (() => boolean)>;
    readonly dateInputMinSignal: Signal<Maybe<Date>>;
    readonly dateInputMaxSignal: Signal<Maybe<Date>>;
    readonly resolvedShowDateInputSignal: Signal<boolean | undefined>;
    readonly fullDaySignal: Signal<boolean>;
    readonly tzAbbreviationSignal: Signal<string | undefined>;
    readonly hasValueSignal: Signal<boolean | undefined>;
    readonly currentErrorMessageSignal: Signal<string | undefined>;
    readonly hasErrorSignal: Signal<boolean | undefined>;
    readonly resolvedShowClearButtonSignal: Signal<boolean | undefined>;
    readonly presetsSignal: Signal<DateTimePreset[] | undefined>;
    readonly isDisabledSignal: Signal<boolean>;
    readonly isTimeMenuDisabledSignal: Signal<boolean>;
    protected readonly hintIdSignal: Signal<string>;
    protected readonly errorIdSignal: Signal<string>;
    protected readonly ariaInvalidSignal: Signal<"true" | null>;
    protected readonly ariaRequiredSignal: Signal<"true" | null>;
    protected readonly ariaDescribedBySignal: Signal<string | null>;
    constructor();
    onDateInputClick(picker: {
        open(): void;
    }): void;
    onDatePicked(event: MatDatepickerInputEvent<Date | undefined>): void;
    onDateKeydown(event: KeyboardEvent): void;
    onTimeKeydown(event: KeyboardEvent): void;
    onTimeFocus(): void;
    onTimeBlur(): void;
    clearValue(): void;
    addTime(): void;
    removeTime(): void;
    selectPreset(preset: DateTimePreset): void;
    setTime(time: ReadableTimeString): void;
    private _setFieldValue;
    private _syncFullDayToSibling;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeDateTimeFieldComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeDateTimeFieldComponent, "dbx-forge-datetime-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; "defaultValidationMessages": { "alias": "defaultValidationMessages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
/**
 * Custom mapper for the datetime field type.
 * Called by ng-forge's DynamicForm to create the inputs for the component.
 *
 * @param fieldDef - Field definition configuration.
 * @param fieldDef.key - Form model key for the field.
 * @returns Signal containing a Record of input names to values for ngComponentOutlet.
 */
declare function dateTimeFieldMapper(fieldDef: {
    key: string;
}): Signal<Record<string, unknown>>;

/**
 * Sync field configuration for forge datetime fields.
 *
 * Same as formly's {@link DbxDateTimeFieldSyncField} but re-exported here so forge consumers
 * don't need to import from the formly module.
 */
interface DbxForgeDateTimeSyncField {
    /**
     * Sibling field key/path to sync with.
     */
    readonly syncWith: string;
    /**
     * How to sync against the other field.
     *
     * - `'before'`: The synced field's value acts as a minimum for this field.
     * - `'after'`: The synced field's value acts as a maximum for this field.
     */
    readonly syncType: DbxDateTimeFieldSyncType;
}
/**
 * The custom forge field type name for the date-time field.
 */
declare const FORGE_DATETIME_FIELD_TYPE: "datetime";
/**
 * Field definition type for a forge date-time field.
 */
type DbxForgeDateTimeFieldDef = BaseValueField<DbxForgeDateTimeFieldComponentProps, unknown> & {
    readonly type: typeof FORGE_DATETIME_FIELD_TYPE;
};
/**
 * Configuration for a forge date-time picker field combining date and time selection.
 *
 * Full parity with the formly `DateTimeFieldConfig` — supports timezone, valueMode, timeMode,
 * pickerConfig, presets, field sync, and all other formly datetime features via `props`.
 */
interface DbxForgeDateTimeFieldConfig extends DbxForgeFieldFunctionDef<DbxForgeDateTimeFieldDef> {
}
/**
 * Combined date-time picker with timezone, value mode (DATE_STRING / TIMESTAMP / Date), and time mode (REQUIRED / OPTIONAL / NONE). Powers `date-range-row` and `date-time-range-row`.
 *
 * Full parity with formly `dateTimeField()` — supports timezone, valueMode, timeMode,
 * pickerConfig, presets, and all other features via the `props` slot.
 *
 * @param config - Date-time field configuration
 * @returns A {@link DbxForgeDateTimeFieldDef}
 *
 * @dbxFormField
 * @dbxFormSlug date-time
 * @dbxFormTier field-factory
 * @dbxFormProduces DateTimeValue
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType datetime
 * @dbxFormWrapperPattern unwrapped
 * @dbxFormConfigInterface DbxForgeDateTimeFieldConfig
 * @dbxFormPropsInterface DbxForgeDateTimeFieldComponentProps
 *
 * @example
 * ```typescript
 * dbxForgeDateTimeField({ key: 'when', label: 'When', timezone: 'America/New_York' })
 * ```
 */
declare const dbxForgeDateTimeField: _dereekb_dbx_form.DbxForgeFieldFunction<DbxForgeDateTimeFieldConfig, DbxForgeDateTimeFieldDef>;

/**
 * Per-field overrides for a forge date range start/end picker.
 *
 * Mirrors formly's `DateDateRangeFieldDateConfig`. Runtime component props go under `props`;
 * `dateLabel`, `timeOnly`, `timeMode`, and `getSyncFieldsObs` are managed by the row builder
 * and excluded from the override surface.
 */
interface DbxForgeDateRangeFieldDateConfig extends Omit<DbxForgeDateTimeFieldConfig, 'props'> {
    readonly props?: Omit<DbxForgeDateTimeFieldComponentProps, 'dateLabel' | 'timeOnly' | 'timeMode' | 'getSyncFieldsObs'>;
}
type DbxForgeDateRangeRowSharedProps = Pick<DbxForgeDateTimeFieldComponentProps, 'timeDate' | 'timezone' | 'showTimezone' | 'presets' | 'valueMode' | 'minuteStep'>;
/**
 * Configuration for a forge date range row with separate start and end date pickers.
 *
 * Mirrors formly's `DateDateRangeFieldConfig`. Shared runtime props (timezone, presets,
 * valueMode, etc.) go under `props`; per-field overrides go under `start` / `end`.
 */
interface DbxForgeDateRangeRowConfig {
    readonly required?: boolean;
    readonly props?: DbxForgeDateRangeRowSharedProps;
    readonly start?: Partial<DbxForgeDateRangeFieldDateConfig>;
    readonly end?: Partial<DbxForgeDateRangeFieldDateConfig>;
}
/**
 * Two-column row of start/end date-time fields configured for date-only picking. Use when you need a paired start/end date range laid out horizontally.
 *
 * Composite builder that creates a pair of date pickers for selecting a date range (start and end dates)
 * arranged in a flex row. The pickers are synchronized so the start date stays before the end date.
 *
 * This is the forge equivalent of formly's `formlyDateRangeField()`.
 *
 * @param config - Date range configuration with optional shared props and start/end overrides.
 * @returns A {@link RowField} containing the start and end date field pair.
 *
 * @dbxFormField
 * @dbxFormSlug date-range-row
 * @dbxFormTier composite-builder
 * @dbxFormSuffix Row
 * @dbxFormProduces RowField
 * @dbxFormArrayOutput no
 * @dbxFormConfigInterface DbxForgeDateRangeRowConfig
 * @dbxFormComposesFrom date-time, row
 *
 * @example
 * ```typescript
 * dbxForgeDateRangeRow({ required: true, start: { key: 'from', label: 'From' }, end: { key: 'to', label: 'To' } })
 * ```
 */
declare function dbxForgeDateRangeRow(config?: DbxForgeDateRangeRowConfig): RowField;

/**
 * Per-field overrides for a forge date-time range start/end time picker.
 *
 * Mirrors formly's `DateTimeRangeFieldTimeConfig`. All-day related props are excluded
 * from the override surface.
 */
interface DbxForgeDateTimeRangeFieldTimeConfig extends Omit<DbxForgeDateRangeFieldDateConfig, 'props'> {
    readonly props?: Omit<DbxForgeDateTimeFieldComponentProps, 'dateLabel' | 'timeMode' | 'timeOnly' | 'hideDateHint' | 'allDayLabel' | 'fullDayFieldName' | 'fullDayInUTC' | 'getSyncFieldsObs'>;
}
type DbxForgeDateTimeRangeRowSharedProps = Pick<DbxForgeDateTimeFieldComponentProps, 'timeDate' | 'timezone' | 'showTimezone' | 'presets' | 'valueMode' | 'minuteStep'>;
/**
 * Configuration for a forge date-time range row with separate start and end time pickers.
 *
 * Mirrors formly's `DateDateTimeRangeFieldConfig`.
 */
interface DbxForgeDateTimeRangeRowConfig {
    readonly required?: boolean;
    readonly props?: DbxForgeDateTimeRangeRowSharedProps;
    readonly start?: Partial<DbxForgeDateTimeRangeFieldTimeConfig>;
    readonly end?: Partial<DbxForgeDateTimeRangeFieldTimeConfig>;
}
/**
 * Two-column row of time-only pickers for selecting a time range within a single day.
 *
 * This is the forge equivalent of formly's `formlyDateTimeRangeField()`.
 *
 * @param inputConfig - Time range configuration with optional shared props and start/end overrides.
 * @returns A {@link RowField} containing the start and end time field pair.
 *
 * @dbxFormField
 * @dbxFormSlug date-time-range-row
 * @dbxFormTier composite-builder
 * @dbxFormSuffix Row
 * @dbxFormProduces RowField
 * @dbxFormArrayOutput no
 * @dbxFormConfigInterface DbxForgeDateTimeRangeRowConfig
 * @dbxFormComposesFrom date-time, row
 *
 * @example
 * ```typescript
 * dbxForgeDateTimeRangeRow({ start: { label: 'From' }, end: { label: 'Until' } })
 * ```
 */
declare function dbxForgeDateTimeRangeRow(inputConfig?: DbxForgeDateTimeRangeRowConfig): RowField;

/**
 * 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';
/**
 * 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.
     */
    readonly lastPickType?: Maybe<FixedDateRangeScanType>;
    /**
     * The latest date passed, if applicable.
     */
    readonly lastDateRange?: Maybe<Partial<DateRange>>;
    /**
     * The generated boundary range.
     */
    readonly boundary?: DateRange;
    /**
     * New Date Range
     */
    readonly range?: DateRange;
}

type SelectedDateEventType = 'calendar' | 'input';
/**
 * Value shape for the fixed date range field.
 *
 * Uses the same `DateRange` shape as `@dereekb/date` — an object with `start` and `end` dates.
 * The actual stored value format depends on the configured `valueMode`.
 */
interface DbxForgeFixedDateRangeValue {
    readonly start?: Maybe<Date>;
    readonly end?: Maybe<Date>;
}
/**
 * Custom props for the forge fixed date range field.
 *
 * Full parity with formly `DbxFixedDateRangeFieldProps`.
 */
interface DbxForgeFixedDateRangeFieldComponentProps {
    /**
     * Date range input to build the date range from a single picked date.
     * Required for 'single' mode and boundary-based selection modes.
     */
    readonly dateRangeInput?: ObservableOrValueGetter<DbxFixedDateRangeDateRangeInput>;
    /**
     * Selection mode to use when picking dates on the calendar.
     *
     * - `'single'` — Picks one date, range computed from dateRangeInput 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.
     *
     * Defaults to `'single'`.
     */
    readonly selectionMode?: Maybe<ObservableOrValueGetter<DbxFixedDateRangeSelectionMode>>;
    /**
     * Value mode for the dates in the output DateRange.
     * Defaults to DATE.
     */
    readonly valueMode?: DbxDateTimeValueMode;
    /**
     * Whether to pass the date value as a UTC date, or a date in the current timezone.
     */
    readonly fullDayInUTC?: boolean;
    /**
     * Custom picker configuration (limits, schedule).
     */
    readonly pickerConfig?: ObservableOrValueGetter<DbxFixedDateRangePickerConfiguration>;
    /**
     * The input timezone to default to. Ignored if fullDayInUTC is true.
     */
    readonly timezone?: Maybe<ObservableOrValueGetter<Maybe<TimezoneString>>>;
    /**
     * Whether to display the timezone. Defaults to true.
     */
    readonly showTimezone?: Maybe<boolean>;
    /**
     * Custom presets.
     */
    readonly presets?: ObservableOrValueGetter<DateTimePresetConfiguration[]>;
    /**
     * Whether to show the range input text fields. Defaults to true.
     */
    readonly showRangeInput?: boolean;
    /**
     * Material form field appearance.
     */
    readonly appearance?: 'fill' | 'outline';
    /**
     * Hint text displayed below the field.
     */
    readonly hint?: DynamicText;
}
/**
 * Forge custom field component for selecting a fixed date range using an inline calendar.
 *
 * Full parity with formly `DbxFixedDateRangeFieldComponent`: supports multiple selection modes
 * (single, normal, arbitrary, arbitrary_quick), timezone conversion, date range input configuration,
 * picker config (limits, schedule), and optional text inputs for start/end dates.
 *
 * Uses a custom `MatDateRangeSelectionStrategy` for preview highlighting on the calendar.
 *
 * Registered as ng-forge type 'fixeddaterange'.
 */
declare class DbxForgeFixedDateRangeFieldComponent {
    private readonly destroyRef;
    private readonly elementRef;
    readonly field: InputSignal<FieldTree<unknown>>;
    readonly key: InputSignal<string>;
    readonly label: InputSignal<DynamicText | undefined>;
    readonly placeholder: InputSignal<DynamicText | undefined>;
    readonly className: InputSignal<string>;
    readonly tabIndex: InputSignal<number | undefined>;
    readonly props: InputSignal<DbxForgeFixedDateRangeFieldComponentProps | undefined>;
    readonly meta: InputSignal<FieldMeta | undefined>;
    readonly validationMessages: InputSignal<ValidationMessages | undefined>;
    readonly defaultValidationMessages: InputSignal<ValidationMessages | undefined>;
    readonly calendar: Signal<MatCalendar<Date>>;
    readonly startDateInputElement: Signal<ElementRef<any> | undefined>;
    readonly endDateInputElement: Signal<ElementRef<any> | undefined>;
    readonly currentDateRangeInputSignal: _angular_core.WritableSignal<Maybe<DbxFixedDateRangeDateRangeInput>>;
    readonly currentSelectionModeSignal: _angular_core.WritableSignal<DbxFixedDateRangeSelectionMode>;
    private readonly _sub;
    private readonly _inputRangeFormSub;
    private readonly _inputRangeFormValueSub;
    private readonly _dateRangeInputSub;
    private readonly _currentSelectionModeSub;
    private readonly _disableEndSub;
    private readonly _activeDateSub;
    private readonly _config;
    private readonly _selectionMode;
    private readonly _dateRangeInput;
    private readonly _timezone;
    private readonly _selectionEvent;
    readonly selectedDateRange$: Observable<Maybe<Partial<DateRange>>>;
    readonly inputRangeForm: FormGroup<{
        start: FormControl<Maybe<Date>>;
        end: FormControl<Maybe<Date>>;
    }>;
    readonly isRequiredSignal: Signal<boolean>;
    readonly isDisabled: Signal<boolean>;
    readonly valueModeSignal: Signal<DbxDateTimeValueMode>;
    readonly showRangeInputSignal: Signal<boolean>;
    readonly showTimezoneSignal: Signal<boolean>;
    readonly resolvedErrors: Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    readonly showErrors: Signal<boolean>;
    readonly errorsToDisplaySignal: Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    protected readonly hintIdSignal: Signal<string>;
    protected readonly errorIdSignal: Signal<string>;
    protected readonly ariaInvalidSignal: Signal<"true" | null>;
    protected readonly ariaRequiredSignal: Signal<"true" | null>;
    protected readonly ariaDescribedBySignal: Signal<string | null>;
    readonly hasRequiredErrorSignal: Signal<boolean>;
    readonly fieldValueSignal: Signal<unknown>;
    readonly fieldValue$: Observable<unknown>;
    readonly config$: Observable<DbxFixedDateRangePickerConfiguration>;
    readonly limitDateTimeInstance$: Observable<_dereekb_date.LimitDateTimeInstance>;
    readonly selectionMode$: Observable<DbxFixedDateRangeSelectionMode>;
    readonly dateRangeInput$: Observable<Maybe<DbxFixedDateRangeDateRangeInput>>;
    readonly timezone$: Observable<Maybe<TimezoneString>>;
    readonly timezoneInstance$: Observable<Maybe<DateTimezoneUtcNormalInstance>>;
    readonly valueInSystemTimezone$: Observable<Maybe<DateRange>>;
    readonly minMaxRange$: Observable<Maybe<Partial<DateRange>>>;
    readonly min$: Observable<Date | null>;
    readonly max$: Observable<Date | null>;
    readonly pickerFilter$: Observable<DecisionFunction<Maybe<Date>>>;
    readonly defaultPickerFilter: DecisionFunction<Maybe<Date>>;
    dateRangeSelectionForMode(mode: DbxFixedDateRangeSelectionMode): Observable<Maybe<DateRange>>;
    readonly fullBoundary$: Observable<Maybe<DateRange>>;
    readonly latestBoundary$: Observable<Maybe<DateRange>>;
    readonly calendarFocusDate$: Observable<Date>;
    readonly dateRangeSelection$: Observable<Maybe<DateRange>>;
    readonly calendarSelection$: Observable<Maybe<DateRange$1<Date>>>;
    readonly endDisabled$: Observable<boolean>;
    readonly minDateSignal: Signal<Date | null>;
    readonly maxDateSignal: Signal<Date | null>;
    readonly endDisabledSignal: Signal<boolean | undefined>;
    readonly latestBoundarySignal: Signal<Maybe<DateRange>>;
    readonly calendarSelectionSignal: Signal<Maybe<DateRange$1<Date>>>;
    readonly pickerFilterSignal: Signal<DecisionFunction<Maybe<Date>>>;
    constructor();
    selectedChange(date: Maybe<Date>): void;
    setDateRange(range: Maybe<Partial<DateRange>>, type: SelectedDateEventType): void;
    _createDateRange(date: Maybe<Date>): Maybe<DateRange>;
    private _setFieldValue;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeFixedDateRangeFieldComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeFixedDateRangeFieldComponent, "dbx-forge-fixeddaterange-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; "defaultValidationMessages": { "alias": "defaultValidationMessages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
/**
 * Custom Material date range selection strategy for the forge fixed date range field.
 *
 * Provides preview highlighting on the calendar based on the current selection mode
 * and boundary constraints.
 */
declare class DbxForgeFixedDateRangeFieldSelectionStrategy<D> implements MatDateRangeSelectionStrategy<D> {
    private readonly _dateAdapter;
    readonly component: DbxForgeFixedDateRangeFieldComponent;
    selectionFinished(date: Maybe<D>, currentRange: DateRange$1<D>, _event: Event): DateRange$1<D>;
    createPreview(activeDate: Maybe<D>, _currentRange: DateRange$1<D>, _event: Event): DateRange$1<D>;
    private _createDateRangeWithDate;
    private _createDateRange;
    dateFromAdapterDate(input: D): Date;
    adapterDateFromDate(date: Date): D;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeFixedDateRangeFieldSelectionStrategy<any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DbxForgeFixedDateRangeFieldSelectionStrategy<any>>;
}
/**
 * Custom mapper for the fixeddaterange field type.
 *
 * Uses the standard valueFieldMapper pattern from ng-forge/integration.
 *
 * @param fieldDef - Field definition configuration.
 * @param fieldDef.key - Form model key for the field.
 * @returns Signal containing a Record of input names to values for ngComponentOutlet.
 */
declare function fixedDateRangeFieldMapper(fieldDef: {
    key: string;
}): Signal<Record<string, unknown>>;

/**
 * The custom forge field type name for the fixed date range field.
 */
declare const FORGE_FIXEDDATERANGE_FIELD_TYPE: "fixeddaterange";
/**
 * Field definition type for a forge fixed date range field.
 */
type DbxForgeFixedDateRangeFieldDef = BaseValueField<DbxForgeFixedDateRangeFieldComponentProps, DbxForgeFixedDateRangeValue> & {
    readonly type: typeof FORGE_FIXEDDATERANGE_FIELD_TYPE;
};
/**
 * Configuration for a forge fixed date range field using an inline calendar-style range picker.
 *
 * Full parity with the formly `FixedDateRangeFieldConfig`.
 */
interface DbxForgeFixedDateRangeFieldConfig extends DbxForgeFieldFunctionDef<DbxForgeFixedDateRangeFieldDef> {
}
/**
 * Inline calendar-style date-range picker with fixed range length (e.g. "7 days from start"). Wrapped in a Material form-field container with a custom selection strategy.
 *
 * Uses an inline `<mat-calendar>` with a custom selection strategy, matching the formly
 * `fixedDateRangeField()` behavior. Supports multiple selection modes, timezone conversion,
 * date range input configuration, and optional text inputs.
 *
 * @param config - Fixed date range field configuration
 * @returns A {@link DbxForgeFixedDateRangeFieldDef}
 *
 * @dbxFormField
 * @dbxFormSlug fixed-date-range
 * @dbxFormTier field-factory
 * @dbxFormProduces DbxForgeFixedDateRangeValue
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType fixeddaterange
 * @dbxFormWrapperPattern material-form-field-wrapped
 * @dbxFormConfigInterface DbxForgeFixedDateRangeFieldConfig
 * @dbxFormPropsInterface DbxForgeFixedDateRangeFieldComponentProps
 *
 * @example
 * ```typescript
 * dbxForgeFixedDateRangeField({ key: 'range', label: 'Date Range' })
 * ```
 */
declare const dbxForgeFixedDateRangeField: _dereekb_dbx_form.DbxForgeFieldFunction<DbxForgeFixedDateRangeFieldConfig, DbxForgeFixedDateRangeFieldDef>;

/**
 * The custom forge field type name for the date range field.
 */
declare const FORGE_DATERANGE_FIELD_TYPE: "daterange";
/**
 * Value shape for the date range field.
 */
interface DbxForgeDateRangeValue {
    readonly start?: Maybe<Date>;
    readonly end?: Maybe<Date>;
}
/**
 * Custom props for the forge date range field.
 */
interface DbxForgeDateRangeFieldComponentProps {
    /**
     * Custom label for the start date input.
     */
    readonly startLabel?: string;
    /**
     * Custom label for the end date input.
     */
    readonly endLabel?: string;
    /**
     * Whether to include time inputs alongside the date pickers.
     *
     * Defaults to false.
     */
    readonly showTime?: boolean;
    /**
     * Material form field appearance.
     */
    readonly appearance?: 'fill' | 'outline';
    /**
     * Hint text displayed below the field.
     */
    readonly hint?: DynamicText;
    /**
     * Minimum selectable date.
     */
    readonly minDate?: Date | string;
    /**
     * Maximum selectable date.
     */
    readonly maxDate?: Date | string;
}
/**
 * Field definition type for a forge date range field.
 */
type DbxForgeDateRangeFieldDef = BaseValueField<DbxForgeDateRangeFieldComponentProps, DbxForgeDateRangeValue> & {
    readonly type: typeof FORGE_DATERANGE_FIELD_TYPE;
};
/**
 * Custom ng-forge field component for date range selection.
 *
 * This component provides two date pickers (start and end) and bridges their
 * values with ng-forge Signal Forms. The value is stored as a `{ start, end }` object.
 *
 * Registered as ng-forge type 'daterange'.
 */
declare class DbxForgeDateRangeFieldComponent {
    private readonly materialConfig;
    private readonly destroyRef;
    private readonly elementRef;
    readonly field: InputSignal<FieldTree<unknown>>;
    readonly key: InputSignal<string>;
    readonly label: InputSignal<DynamicText | undefined>;
    readonly placeholder: InputSignal<DynamicText | undefined>;
    readonly className: InputSignal<string>;
    readonly tabIndex: InputSignal<number | undefined>;
    readonly props: InputSignal<DbxForgeDateRangeFieldComponentProps | undefined>;
    readonly meta: InputSignal<FieldMeta | undefined>;
    readonly validationMessages: InputSignal<ValidationMessages | undefined>;
    readonly defaultValidationMessages: InputSignal<ValidationMessages | undefined>;
    /**
     * Internal FormControls for start and end dates and times.
     */
    readonly startDateCtrl: FormControl<Maybe<Date>>;
    readonly startTimeCtrl: FormControl<string | null>;
    readonly endDateCtrl: FormControl<Maybe<Date>>;
    readonly endTimeCtrl: FormControl<string | null>;
    readonly startLabelSignal: Signal<string>;
    readonly endLabelSignal: Signal<string>;
    readonly showTimeSignal: Signal<boolean>;
    readonly effectiveAppearanceSignal: Signal<_angular_material_form_field.MatFormFieldAppearance>;
    readonly minDateSignal: Signal<Maybe<Date>>;
    readonly maxDateSignal: Signal<Maybe<Date>>;
    readonly resolvedErrors: Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    readonly showErrors: Signal<boolean>;
    readonly errorsToDisplaySignal: Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    protected readonly hintIdSignal: Signal<string>;
    protected readonly errorIdSignal: Signal<string>;
    protected readonly ariaInvalidSignal: Signal<"true" | null>;
    protected readonly ariaRequiredSignal: Signal<"true" | null>;
    protected readonly ariaDescribedBySignal: Signal<string | null>;
    /**
     * Flag to prevent feedback loops during sync.
     */
    private _syncing;
    constructor();
    /**
     * Sets the date and time FormControls from a source Date value without emitting events.
     *
     * @param dateCtrl - The date FormControl to update.
     * @param timeCtrl - The time string FormControl to update.
     * @param value - The source Date value to extract date and time from.
     */
    private _setDateCtrlFromValue;
    /**
     * Combines the date and time controls into a date range value
     * and writes it to the Signal Forms field tree.
     */
    private _syncOutbound;
    /**
     * Combines a date and optional time string into a single Date.
     *
     * @param dateValue - The base date value.
     * @param timeValue - Optional time string in "HH:mm" format to apply to the date.
     * @returns A new Date with the combined date and time, or undefined if no date is provided.
     */
    private _combineDateAndTime;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeDateRangeFieldComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeDateRangeFieldComponent, "dbx-forge-daterange-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; "defaultValidationMessages": { "alias": "defaultValidationMessages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
/**
 * Custom mapper for the daterange field type.
 *
 * Uses the standard valueFieldMapper pattern from ng-forge/integration to resolve
 * the field tree and build the standard inputs for the component.
 *
 * @param fieldDef - The date range field definition.
 * @param fieldDef.key - Form model key for the field.
 * @returns Signal containing Record of input names to values for ngComponentOutlet.
 */
declare function dateRangeFieldMapper(fieldDef: {
    key: string;
}): Signal<Record<string, unknown>>;

/**
 * Determines the shape of the output value from a time duration field.
 *
 * - `'number'` — output is a single number in the configured output unit
 * - `'hours_and_minutes'` — output is an HoursAndMinutes object
 * - `'duration_data'` — output is a TimeDurationData object
 */
type TimeDurationFieldValueMode = 'number' | 'hours_and_minutes' | 'duration_data';

/**
 * Custom props for the forge time duration field.
 */
interface DbxForgeTimeDurationFieldComponentProps {
    /**
     * The unit of the output value.
     *
     * Defaults to `'ms'`.
     */
    readonly outputUnit?: TimeUnit;
    /**
     * Output value mode.
     *
     * Defaults to `'number'`.
     */
    readonly valueMode?: TimeDurationFieldValueMode;
    /**
     * The time units available for the field.
     * Controls which units the parser recognizes and default popover columns.
     *
     * Defaults to all time units.
     */
    readonly allowedUnits?: TimeUnit[];
    /**
     * Which units to show in the popover picker.
     *
     * Defaults to allowedUnits filtered to exclude 'ms'.
     */
    readonly pickerUnits?: TimeUnit[];
    /**
     * Minimum output value (in the output unit).
     */
    readonly min?: number;
    /**
     * Maximum output value (in the output unit).
     */
    readonly max?: number;
    /**
     * Whether the popover picker carries over values to the next larger unit.
     */
    readonly carryOver?: boolean;
    /**
     * Material form field appearance.
     */
    readonly appearance?: 'fill' | 'outline';
    /**
     * Hint text displayed below the field.
     */
    readonly hint?: DynamicText;
}
/**
 * Custom ng-forge field component for time duration input with text parsing and a popover picker.
 *
 * The text input accepts duration strings like "3d10h5m8s", "2 hours 30 minutes", etc.
 * A picker button opens a popover with +/- columns for each time unit.
 *
 * This component bridges a FormControl-based duration input with ng-forge Signal Forms.
 *
 * Registered as ng-forge type 'timeduration'.
 */
declare class DbxForgeTimeDurationFieldComponent {
    private readonly materialConfig;
    private readonly popoverService;
    private readonly elementRef;
    readonly field: InputSignal<FieldTree<unknown>>;
    readonly key: InputSignal<string>;
    readonly label: InputSignal<DynamicText | undefined>;
    readonly placeholder: InputSignal<DynamicText | undefined>;
    readonly className: InputSignal<string>;
    readonly tabIndex: InputSignal<number | undefined>;
    readonly props: InputSignal<DbxForgeTimeDurationFieldComponentProps | undefined>;
    readonly meta: InputSignal<FieldMeta | undefined>;
    readonly validationMessages: InputSignal<ValidationMessages | undefined>;
    readonly defaultValidationMessages: InputSignal<ValidationMessages | undefined>;
    /**
     * Internal FormControl for the text input.
     */
    readonly textCtrl: FormControl<string | null>;
    readonly pickerButtonElement: Signal<ElementRef<any> | undefined>;
    /**
     * Tracks the last parsed duration data for the picker popover.
     */
    private _currentDurationData;
    readonly effectiveAppearanceSignal: Signal<_angular_material_form_field.MatFormFieldAppearance>;
    readonly outputUnitSignal: Signal<TimeUnit>;
    readonly valueModeSignal: Signal<TimeDurationFieldValueMode>;
    readonly allowedUnitsSignal: Signal<TimeUnit[]>;
    readonly pickerUnitsSignal: Signal<TimeUnit[]>;
    /**
     * Units used for decomposing/displaying duration text.
     */
    readonly displayUnitsSignal: Signal<TimeUnit[]>;
    readonly isDisabled: Signal<boolean>;
    readonly resolvedErrors: Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    readonly showErrors: Signal<boolean>;
    readonly errorsToDisplaySignal: Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    protected readonly hintIdSignal: Signal<string>;
    protected readonly errorIdSignal: Signal<string>;
    protected readonly ariaInvalidSignal: Signal<"true" | null>;
    protected readonly ariaRequiredSignal: Signal<"true" | null>;
    protected readonly ariaDescribedBySignal: Signal<string | null>;
    /**
     * Flag to prevent feedback loops during sync.
     */
    private _syncing;
    constructor();
    /**
     * Called when the text input loses focus. Parses the text and updates the output.
     */
    onTextBlur(): void;
    /**
     * Called when Enter is pressed in the text input.
     *
     * @param event - The keyboard event triggered by pressing Enter.
     */
    onTextEnter(event: Event): void;
    /**
     * Opens the duration picker popover.
     */
    openPicker(): void;
    /**
     * Parses the current text input and syncs the output value.
     */
    private _parseAndSync;
    /**
     * Converts duration data to the output value and sets it on the field.
     *
     * @param data - The parsed duration data containing time unit values.
     */
    private _syncOutputFromDurationData;
    /**
     * Writes a value to the Signal Forms field tree.
     *
     * @param value - The value to set on the field, or undefined to clear it.
     */
    private _setFieldValue;
    /**
     * Converts an output value (number, HoursAndMinutes, or TimeDurationData) to milliseconds.
     *
     * @param value - The output value to convert (number, HoursAndMinutes, or TimeDurationData depending on valueMode)
     * @param outputUnit - The time unit of the numeric output value (used when valueMode is 'number')
     * @param valueMode - The current value mode determining how to interpret the value.
     * @returns The equivalent duration in milliseconds.
     */
    private _outputValueToMilliseconds;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeTimeDurationFieldComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeTimeDurationFieldComponent, "dbx-forge-timeduration-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; "defaultValidationMessages": { "alias": "defaultValidationMessages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
/**
 * Custom mapper for the timeduration field type.
 *
 * Uses the standard valueFieldMapper pattern from ng-forge/integration to resolve
 * the field tree and build the standard inputs for the component.
 *
 * @param fieldDef - The time duration field definition.
 * @param fieldDef.key - Form model key for the field.
 * @returns Signal containing Record of input names to values for ngComponentOutlet.
 */
declare function timeDurationFieldMapper(fieldDef: {
    key: string;
}): Signal<Record<string, unknown>>;

/**
 * The custom forge field type name for the time duration field.
 */
declare const FORGE_TIMEDURATION_FIELD_TYPE: "timeduration";
/**
 * Field definition type for a forge time duration field.
 */
type DbxForgeTimeDurationFieldDef = BaseValueField<DbxForgeTimeDurationFieldComponentProps, unknown> & {
    readonly type: typeof FORGE_TIMEDURATION_FIELD_TYPE;
};
/**
 * Configuration for a forge time duration input field.
 */
interface DbxForgeTimeDurationFieldConfig extends DbxForgeFieldFunctionDef<DbxForgeTimeDurationFieldDef> {
    /**
     * The unit of the output value.
     *
     * Defaults to `'ms'` (milliseconds).
     */
    readonly outputUnit?: TimeUnit;
    /**
     * The output value mode.
     *
     * Defaults to `'number'`.
     */
    readonly valueMode?: TimeDurationFieldValueMode;
    /**
     * The time units available for the field.
     */
    readonly allowedUnits?: TimeUnit[];
    /**
     * Which units to show in the popover picker.
     *
     * Defaults to allowedUnits filtered to exclude 'ms'.
     */
    readonly pickerUnits?: TimeUnit[];
    /**
     * Whether the popover picker should carry over values to the next larger unit.
     */
    readonly carryOver?: boolean;
}
/**
 * Duration input with popover picker. Output shape varies by `valueMode` — number (ms/s/…), string, or structured object.
 *
 * Uses a custom ng-forge ValueFieldComponent that provides a text input
 * accepting duration strings (e.g. "2h30m") and a popover picker.
 *
 * @param config - Time duration field configuration
 * @returns A {@link DbxForgeTimeDurationFieldDef}
 *
 * @dbxFormField
 * @dbxFormSlug time-duration
 * @dbxFormTier field-factory
 * @dbxFormProduces TimeDurationValue
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType timeduration
 * @dbxFormWrapperPattern unwrapped
 * @dbxFormConfigInterface DbxForgeTimeDurationFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeTimeDurationField({ key: 'duration', label: 'Duration', outputUnit: 'm' })
 * ```
 */
declare const dbxForgeTimeDurationField: _dereekb_dbx_form.DbxForgeFieldFunction<DbxForgeTimeDurationFieldConfig, DbxForgeTimeDurationFieldDef>;

/**
 * Custom props for the forge phone field.
 */
interface DbxForgePhoneFieldProps {
    /**
     * ISO country codes for countries shown first in the dropdown.
     */
    readonly preferredCountries?: string[];
    /**
     * ISO country codes to restrict the dropdown to.
     */
    readonly onlyCountries?: string[];
    /**
     * Whether or not to enable the search feature. True by default.
     */
    readonly enableSearch?: boolean;
    /**
     * Whether or not to allow adding an extension. False by default.
     */
    readonly allowExtension?: boolean;
    /**
     * Material form field appearance.
     */
    readonly appearance?: 'fill' | 'outline';
    /**
     * Hint text displayed below the field.
     */
    readonly hint?: DynamicText;
    /**
     * Autocomplete value for the phone input. The underlying `ngx-mat-input-tel`
     * component supports `'off'` and `'tel'`.
     */
    readonly autocomplete?: 'off' | 'tel';
}
/**
 * Custom ng-forge field component that wraps the ngx-mat-input-tel phone input.
 *
 * Since ngx-mat-input-tel uses ControlValueAccessor (reactive forms) and does not support
 * Signal Forms' [formField] directive, this component bridges the two systems by manually
 * syncing the FieldTree signal state with a FormControl.
 *
 * Registered as ng-forge type 'phone'.
 */
declare class DbxForgePhoneFieldComponent {
    private readonly materialConfig;
    private readonly destroyRef;
    private readonly elementRef;
    readonly field: InputSignal<FieldTree<string>>;
    readonly key: InputSignal<string>;
    readonly label: InputSignal<DynamicText | undefined>;
    readonly placeholder: InputSignal<DynamicText | undefined>;
    readonly className: InputSignal<string>;
    readonly tabIndex: InputSignal<number | undefined>;
    readonly props: InputSignal<DbxForgePhoneFieldProps | undefined>;
    readonly meta: InputSignal<FieldMeta | undefined>;
    readonly validationMessages: InputSignal<ValidationMessages | undefined>;
    readonly defaultValidationMessages: InputSignal<ValidationMessages | undefined>;
    /**
     * Internal FormControl used to bridge ngx-mat-input-tel (reactive forms)
     * with the ng-forge Signal Forms field tree.
     */
    readonly phoneCtrl: FormControl<string | null>;
    readonly extensionCtrl: FormControl<string | null>;
    readonly preferredCountriesSignal: Signal<string[]>;
    readonly onlyCountriesSignal: Signal<string[]>;
    readonly enableSearchSignal: Signal<boolean>;
    readonly allowExtensionSignal: Signal<boolean>;
    readonly effectiveAppearanceSignal: Signal<_angular_material_form_field.MatFormFieldAppearance>;
    readonly effectiveAutocompleteSignal: Signal<"tel" | "off">;
    readonly isDisabled: Signal<boolean>;
    readonly resolvedErrors: Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    readonly showErrors: Signal<boolean>;
    readonly errorsToDisplaySignal: Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    protected readonly hintIdSignal: Signal<string>;
    protected readonly errorIdSignal: Signal<string>;
    protected readonly ariaInvalidSignal: Signal<"true" | null>;
    protected readonly ariaRequiredSignal: Signal<"true" | null>;
    protected readonly ariaDescribedBySignal: Signal<string | null>;
    /**
     * Flag to prevent feedback loops during sync.
     */
    private _syncing;
    constructor();
    private _syncOutbound;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgePhoneFieldComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgePhoneFieldComponent, "dbx-forge-phone-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; "defaultValidationMessages": { "alias": "defaultValidationMessages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
/**
 * Custom mapper for the phone field type.
 *
 * Uses the standard valueFieldMapper pattern from ng-forge/integration to resolve
 * the field tree and build the standard inputs for the component.
 *
 * @param fieldDef - The phone field definition with a key property.
 * @param fieldDef.key - The field key used to resolve the FieldTree from the form context.
 * @returns Signal containing Record of input names to values for ngComponentOutlet.
 */
declare function phoneFieldMapper(fieldDef: {
    key: string;
}): Signal<Record<string, unknown>>;

/**
 * The custom forge field type name for the phone field.
 */
declare const FORGE_PHONE_FIELD_TYPE: "phone";
/**
 * Field definition type for a forge phone field.
 */
type DbxForgePhoneFieldDef = BaseValueField<DbxForgePhoneFieldProps, string> & {
    readonly type: typeof FORGE_PHONE_FIELD_TYPE;
};
/**
 * Configuration for a forge international phone number input field.
 */
/**
 * Autocomplete values supported by the phone field.
 *
 * The underlying `ngx-mat-input-tel` component only supports `'off'` and `'tel'`.
 * Pass `false` to disable autocomplete (equivalent to `'off'`).
 */
type DbxForgePhoneFieldAutocomplete = 'off' | 'tel' | false;
interface DbxForgePhoneFieldConfig extends DbxForgeFieldFunctionDef<DbxForgePhoneFieldDef> {
    /**
     * Preferred countries to show at the top of the country selector.
     */
    readonly preferredCountries?: string[];
    /**
     * ISO country codes to restrict the dropdown to.
     */
    readonly onlyCountries?: string[];
    /**
     * Whether or not to enable the search feature. True by default.
     */
    readonly enableSearch?: boolean;
    /**
     * Whether or not to allow adding an extension. False by default.
     */
    readonly allowExtension?: boolean;
    /**
     * Sets the autocomplete attribute on the phone input.
     *
     * Pass `'tel'` to enable phone autofill, or `false`/`'off'` to disable.
     */
    readonly autocomplete?: DbxForgePhoneFieldAutocomplete;
}
/**
 * International phone number input backed by ngx-mat-input-tel. Supports preferred-country lists, search, and optional extension input.
 *
 * Uses the custom 'phone' field type which renders the ngx-mat-input-tel component
 * bridged to Signal Forms.
 *
 * @param config - Phone field configuration
 * @returns A forge field definition for the phone input
 *
 * @dbxFormField
 * @dbxFormSlug phone
 * @dbxFormTier field-factory
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType phone
 * @dbxFormWrapperPattern unwrapped
 * @dbxFormConfigInterface DbxForgePhoneFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgePhoneField({ key: 'phone', label: 'Phone', preferredCountries: ['US', 'CA'] })
 * ```
 */
declare const dbxForgePhoneField: _dereekb_dbx_form.DbxForgeFieldFunction<DbxForgePhoneFieldConfig, DbxForgePhoneFieldDef>;

declare const DBX_FORGE_ARRAY_FIELD_WRAPPER_NAME: "dbx-forge-array-field-wrapper";
interface DbxForgeArrayFieldWrapperProps extends DbxForgeFieldHintValueRef<DynamicText> {
    /**
     * The template used when adding new items to the array.
     *
     * ng-forge requires an explicit template for every dynamic add operation —
     * there is no automatic fallback. This is typically the container field
     * definition (with element wrappers) built by {@link dbxForgeArrayField}.
     */
    readonly itemTemplate: ArrayItemDefinitionTemplate;
    /**
     * Minimum number of items required in the array.
     *
     * Flowed from the array FieldDef by `dbxForgeArrayField` when not set
     * explicitly on the wrapper props.
     */
    readonly minLength?: number;
    /**
     * Maximum number of items allowed in the array.
     *
     * When set, the add button is disabled once the array reaches this length.
     * Flowed from the array FieldDef by `dbxForgeArrayField` when not set
     * explicitly on the wrapper props.
     */
    readonly maxLength?: number;
    /**
     * The label for the array field itself.
     */
    readonly label?: DynamicText;
    /**
     * Text for the add button. Defaults to 'Add'.
     */
    readonly addText?: DynamicText;
    /**
     * Text for the remove button. Defaults to 'Remove'.
     */
    readonly removeText?: DynamicText;
    /**
     * Whether the add button is shown. Defaults to true.
     */
    readonly allowAdd?: boolean;
    /**
     * Whether items can be removed. Defaults to true.
     */
    readonly allowRemove?: boolean;
    /**
     * Whether drag/drop reordering is disabled. Defaults to false.
     */
    readonly disableRearrange?: boolean;
    /**
     * Style configuration for the add button. Defaults to raised primary.
     */
    readonly addButtonStyle?: DbxButtonStyle;
    /**
     * Style configuration for the remove button. Defaults to stroked warn.
     */
    readonly removeButtonStyle?: DbxButtonStyle;
}
interface DbxForgeArrayFieldWrapperDef {
    readonly type: typeof DBX_FORGE_ARRAY_FIELD_WRAPPER_NAME;
    readonly props: DbxForgeArrayFieldWrapperProps;
}

/**
 * Predicate/factory that receives an {@link EvaluationContext} for the current array item.
 *
 * - `fieldValue` / `formValue` are scoped to the item.
 * - `arrayIndex` / `arrayPath` identify the item within its array.
 */
type DbxForgeArrayItemEvaluationFn<TResult, TItem = unknown> = (ctx: EvaluationContext<TItem>) => TResult;
/**
 * Props for the dbx-forge-array-field-element wrapper.
 *
 * Controls per-item rendering: drag handle, item label, and remove button
 * for each array entry.
 */
interface DbxForgeArrayFieldElementWrapperProps<T = unknown> {
    /**
     * Label for each array item. Can be a static value or a function that receives
     * an {@link EvaluationContext} scoped to the current item.
     */
    readonly labelForEntry?: DynamicText | DbxForgeArrayItemEvaluationFn<DynamicText, T>;
    /**
     * Whether to show the index chip. Defaults to true.
     */
    readonly showIndexChip?: boolean;
    /**
     * Customizes the display of the index chip.
     *
     * By default, is small with a grey color.
     */
    readonly indexChipDisplay?: DbxForgeArrayItemEvaluationFn<DbxChipDisplay, T>;
    /**
     * Text for the remove button. Defaults to 'Remove'.
     */
    readonly removeText?: DynamicText;
    /**
     * Whether items can be removed. Can be a boolean or a function that receives an
     * {@link EvaluationContext} scoped to the current item. Defaults to `true`.
     */
    readonly allowRemove?: boolean | DbxForgeArrayItemEvaluationFn<boolean, T>;
    /**
     * Controls whether items can be duplicated. Defaults to `false`.
     *
     * - `true` — show the duplicate button; the duplicate is inserted immediately after the source item.
     * - `false` — no duplicate button.
     * - Function returning `boolean` — evaluated per-item; `true` shows the button with default placement.
     * - Function returning {@link IndexNumber} — shows the button; the returned index is
     *   the position at which the duplicate will be inserted.
     */
    readonly allowDuplicate?: boolean | DbxForgeArrayItemEvaluationFn<boolean | IndexNumber, T>;
    /**
     * Display and style for the duplicate button.
     *
     * Defaults to stroked primary with the text 'Duplicate'.
     */
    readonly duplicateButton?: DbxButtonDisplayStylePair | DbxForgeArrayItemEvaluationFn<DbxButtonDisplayStylePair, T>;
    /**
     * Whether drag/drop reordering is disabled. Defaults to false.
     */
    readonly disableRearrange?: boolean;
    /**
     * Style configuration for the remove button. Defaults to stroked warn.
     */
    readonly removeButtonStyle?: DbxButtonStyle;
}
declare const DBX_FORGE_ARRAY_FIELD_ELEMENT_WRAPPER_NAME: "dbx-forge-array-field-element-wrapper";
interface DbxForgeArrayFieldElementWrapperDef<T = unknown> {
    readonly type: typeof DBX_FORGE_ARRAY_FIELD_ELEMENT_WRAPPER_NAME;
    readonly props?: DbxForgeArrayFieldElementWrapperProps<T>;
}

/**
 * Configuration for creating a forge array field.
 *
 * The outer array wrapper provides label/hint header chrome.
 * Each template item is wrapped in a ContainerField with the element wrapper
 * to provide per-item drag handle, label, and remove button.
 */
interface DbxForgeArrayFieldConfig extends DbxForgeFieldFunctionDef<Omit<ArrayField, 'props' | 'label' | 'fields'>> {
    /**
     * Template defining the fields for each array item.
     * Each item is wrapped in a ContainerField with the element wrapper
     * for per-item drag handle, label, and remove button.
     *
     * The array starts empty — items are added via the add button.
     */
    readonly template: ContainerField['fields'];
    readonly props?: Omit<DbxForgeArrayFieldWrapperProps, 'itemTemplate'>;
    readonly elementProps?: DbxForgeArrayFieldElementWrapperProps;
}
type DbxForgeArrayFieldFunction = (config: DbxForgeArrayFieldConfig) => DbxForgeField<ArrayField>;
/**
 * Repeatable array wrapper with add/remove/drag-to-reorder controls. Template fields are cloned per item. Internally built with `dbxForgeFieldFunction` but categorized as a primitive because composites wrap it.
 *
 * Wraps the array with {@link DbxForgeArrayFieldWrapperComponent} for label/hint,
 * and wraps each template item in a ContainerField with
 * {@link DbxForgeArrayFieldElementWrapperComponent} for per-item drag handle,
 * label, and remove button.
 *
 * @param config - Array field configuration
 * @returns A {@link DbxForgeField}
 *
 * @dbxFormField
 * @dbxFormSlug array-field
 * @dbxFormTier primitive
 * @dbxFormProduces ArrayField
 * @dbxFormReturns ArrayField
 * @dbxFormArrayOutput yes
 * @dbxFormConfigInterface DbxForgeArrayFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeArrayField({ key: 'tags', template: [dbxForgeTextField({ key: 'value' })] })
 * ```
 */
declare const dbxForgeArrayField: DbxForgeArrayFieldFunction;

/**
 * A selectable option with a value, label, and optional disabled state.
 */
interface ValueSelectionOptionWithValue<T> extends Readonly<LabeledValue<T>> {
    readonly disabled?: boolean;
}
/**
 * A special "clear" option that resets the selection when chosen.
 */
interface ValueSelectionOptionClear {
    readonly label?: string;
    readonly clear: true;
}
/**
 * A selectable option: either a value option or a clear option.
 */
type ValueSelectionOption<T> = ValueSelectionOptionWithValue<T> | ValueSelectionOptionClear;

/**
 * A fully resolved selection option with label and value, ready for rendering in a `<mat-option>`.
 *
 * Produced by resolving {@link ValueSelectionOption} items: value options pass through,
 * while clear options are mapped to `{ label, value: null }`.
 */
interface DbxForgeResolvedSelectionOption<T> {
    readonly label: string;
    readonly value: Maybe<T>;
    readonly disabled?: boolean;
}
/**
 * Props interface for the forge value selection field component.
 *
 * Passed via the `props` property on the forge field definition.
 */
interface DbxForgeValueSelectionFieldProps<T = unknown> extends MatSelectProps {
    /**
     * Options to select from.
     *
     * Accepts a static array or an Observable that emits option arrays.
     * Options may include {@link ValueSelectionOptionClear} entries with `clear: true`.
     */
    readonly options: ObservableOrValue<ValueSelectionOption<T>[]>;
    /**
     * When true or a string, adds a clear/reset option at the top of the options list.
     * If a string is provided, it is used as the clear option label.
     *
     * If the options already contain a clear option, no additional one is added.
     */
    readonly addClearOption?: boolean | string;
}
/**
 * The custom forge field type name for the value selection field.
 */
declare const FORGE_VALUE_SELECTION_FIELD_TYPE: "dbx-value-selection";
/**
 * Forge field definition interface for the value selection field.
 */
interface DbxForgeValueSelectionFieldDef<T = unknown> extends BaseValueField<DbxForgeValueSelectionFieldProps<T>, T> {
    readonly type: typeof FORGE_VALUE_SELECTION_FIELD_TYPE;
}
/**
 * Resolves {@link ValueSelectionOption} items into flat {@link DbxForgeResolvedSelectionOption} items
 * suitable for rendering in `<mat-option>`.
 *
 * Maps `ValueSelectionOptionClear` (`{ clear: true }`) to `{ label, value: null }`.
 * Optionally prepends a clear option if `addClearOption` is configured and no clear option exists.
 *
 * @param options - Source selection options.
 * @param addClearOption - Whether to prepend a clear option.
 * @returns Resolved options ready for rendering.
 */
declare function resolveForgeSelectionOptions<T>(options: ValueSelectionOption<T>[], addClearOption: boolean | string): DbxForgeResolvedSelectionOption<T>[];

/**
 * Configuration for a forge select (dropdown) field.
 *
 * Equivalent to formly's `ValueSelectionFieldConfig` — supports static and Observable options,
 * clear options, and multiple selection.
 */
interface DbxForgeValueSelectionFieldConfig<T = unknown> extends Omit<DbxForgeFieldFunctionDef<DbxForgeValueSelectionFieldDef<T>>, 'props'> {
    readonly props: DbxForgeValueSelectionFieldProps<T>;
}
/**
 * Generic function type for dbxForgeValueSelectionField to preserve caller generics.
 */
type DbxForgeValueSelectionFieldFunction = <T = unknown>(config: DbxForgeValueSelectionFieldConfig<T>) => DbxForgeField<DbxForgeValueSelectionFieldDef<T>>;
/**
 * Single-select dropdown over a static or async value list. Simpler than `source-select` when metadata lookup is unnecessary.
 *
 * The component uses `<mat-form-field>` with `[formField]` for native ng-forge value binding,
 * proper Material rendering, and built-in logic (hidden/disabled/readonly) support.
 *
 * Supports static arrays, Observable option sources, and `ValueSelectionOptionClear` entries.
 *
 * @param config - Selection field configuration
 * @returns A forge field definition for the value selection component
 *
 * @dbxFormField
 * @dbxFormSlug value-selection
 * @dbxFormTier field-factory
 * @dbxFormProduces T
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType dbx-value-selection
 * @dbxFormWrapperPattern material-form-field-wrapped
 * @dbxFormConfigInterface DbxForgeValueSelectionFieldConfig<T>
 * @dbxFormGeneric <T = unknown>
 *
 * @example
 * ```typescript
 * dbxForgeValueSelectionField<string>({ key: 'status', props: { options: [{ value: 'active', label: 'Active' }] } })
 * ```
 */
declare const dbxForgeValueSelectionField: DbxForgeValueSelectionFieldFunction;

/**
 * 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.
     */
    readonly value: T;
    /**
     * Optional metadata on the field.
     */
    readonly meta?: Maybe<M>;
}
/**
 * Displayed value.
 */
interface SelectionDisplayValue<T, M = unknown> extends SelectionValue<T, M>, LabelRef {
    readonly sublabel?: string;
    readonly icon?: string;
    /**
     * Whether or not the value is known.
     */
    readonly isUnknown?: Maybe<boolean>;
}
/**
 * Used to hash the value from the input pickable value.
 */
type SelectionValueHashFunction<T, H extends PrimativeKey = PrimativeKey> = MapFunction<T, H>;

/**
 * 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.
     */
    readonly anchor?: ClickableAnchor;
}
/**
 * Displayed value.
 */
interface SearchableValueFieldDisplayValue<T, M = unknown> extends SelectionDisplayValue<T, M>, SearchableValueFieldValue<T, M> {
    /**
     * Display override configuration
     */
    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;
}
/**
 * SearchableValueField function for searching values.
 */
type SearchableValueFieldStringSearchFn<T, M = unknown> = MapFunction<string, Observable<SearchableValueFieldValue<T, M>[]>>;
/**
 * SearchableValueField function that allows the values a chance to go through another observable for unknown changes.
 *
 * An example usage is passing an email address, then getting back metadata that can be used to show the values.
 *
 * The value itself should not change. All other fields on the value may change, however.
 */
type SearchableValueFieldDisplayFn<T, M = unknown> = MapFunction<SearchableValueFieldValue<T, M>[], Observable<SearchableValueFieldDisplayValue<T, M>[]>>;
/**
 * SearchableValueField function for setting anchor values on a field value.
 */
type SearchableValueFieldAnchorFn<T, M = unknown> = MapFunction<SearchableValueFieldValue<T, M>, ClickableAnchor>;
/**
 * Hash function for searchable field values, used to identify and deduplicate selections.
 */
type SearchableValueFieldHashFn<T, H extends PrimativeKey = PrimativeKey> = SelectionValueHashFunction<T, H>;

/**
 * The custom forge field type name for the searchable text field.
 */
declare const DBX_FORGE_SEARCHABLE_TEXT_FIELD_TYPE_NAME: "dbx-searchable-text";
/**
 * Props interface for the forge searchable text field.
 *
 * Passed via the `props` property on the forge field definition.
 */
interface DbxForgeSearchableTextFieldProps<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> {
    readonly search: SearchableValueFieldStringSearchFn<T, M>;
    readonly displayForValue: SearchableValueFieldDisplayFn<T, M>;
    readonly hashForValue?: SearchableValueFieldHashFn<T, H>;
    readonly allowStringValues?: boolean;
    readonly convertStringValue?: (text: string) => T;
    readonly showSelectedValue?: boolean;
    readonly searchOnEmptyText?: boolean;
    readonly display?: Partial<DbxInjectionComponentConfig>;
    readonly useAnchor?: boolean;
    readonly anchorForValue?: SearchableValueFieldAnchorFn<T, M>;
    readonly showClearValue?: boolean;
    readonly searchLabel?: string;
    readonly refreshDisplayValues$?: Observable<unknown>;
    readonly hint?: string;
    readonly textInputValidator?: ValidatorFn | ValidatorFn[];
}
/**
 * Forge field definition interface for the searchable text field.
 */
interface DbxForgeSearchableTextFieldDef<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends BaseValueField<DbxForgeSearchableTextFieldProps<T, M, H>, T> {
    readonly type: typeof DBX_FORGE_SEARCHABLE_TEXT_FIELD_TYPE_NAME;
}
/**
 * Configuration for a forge searchable text field (single-value autocomplete).
 */
interface DbxForgeSearchableTextFieldConfig<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends DbxForgeFieldFunctionDef<DbxForgeSearchableTextFieldDef<T, M, H>> {
}
type DbxForgeSearchableTextFieldFunction = <T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey>(config: DbxForgeSearchableTextFieldConfig<T, M, H>) => DbxForgeField<DbxForgeSearchableTextFieldDef<T, M, H>>;
/**
 * Single-value autocomplete field with search-as-you-type. Optionally allows free-form typed strings as values.
 *
 * @param config - Searchable text field configuration
 * @returns A {@link DbxForgeFormFieldWrapperFieldDef} wrapping a searchable text field
 *
 * @dbxFormField
 * @dbxFormSlug searchable-text
 * @dbxFormTier field-factory
 * @dbxFormProduces T
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType dbx-searchable-text
 * @dbxFormWrapperPattern material-form-field-wrapped
 * @dbxFormConfigInterface DbxForgeSearchableTextFieldConfig<T, M, H>
 * @dbxFormGeneric <T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey>
 *
 * @example
 * ```typescript
 * dbxForgeSearchableTextField<User>({ key: 'user', props: { search, displayForValue } })
 * ```
 */
declare const dbxForgeSearchableTextField: DbxForgeSearchableTextFieldFunction;

/**
 * Abstract base directive for forge searchable fields that manages display caching,
 * search result loading, and common signals.
 *
 * Subclasses provide the specific value model (single-value text or multi-value chip).
 */
declare abstract class AbstractForgeSearchableFieldDirective<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey, P extends DbxForgeSearchableTextFieldProps<T, M, H> = DbxForgeSearchableTextFieldProps<T, M, H>> implements OnInit, OnDestroy {
    readonly key: _angular_core.InputSignal<string>;
    readonly label: _angular_core.InputSignal<DynamicText | undefined>;
    readonly placeholder: _angular_core.InputSignal<DynamicText | undefined>;
    readonly className: _angular_core.InputSignal<string>;
    readonly tabIndex: _angular_core.InputSignal<number | undefined>;
    readonly props: _angular_core.InputSignal<P | undefined>;
    readonly meta: _angular_core.InputSignal<FieldMeta | undefined>;
    readonly validationMessages: _angular_core.InputSignal<ValidationMessages | undefined>;
    readonly defaultValidationMessages: _angular_core.InputSignal<ValidationMessages | undefined>;
    readonly inputCtrl: FormControl<string | null>;
    protected readonly _clearDisplayHashMapSub: _dereekb_rxjs.SubscriptionObject<rxjs.Unsubscribable>;
    protected readonly _displayHashMap: BehaviorSubject<Map<H, ConfiguredSearchableValueFieldDisplayValue<T, M>>>;
    readonly inputValue$: Observable<string>;
    readonly inputValueString$: Observable<string>;
    readonly labelSignal: _angular_core.Signal<string | undefined>;
    readonly hintSignal: _angular_core.Signal<string | undefined>;
    protected readonly hintIdSignal: _angular_core.Signal<string>;
    protected readonly errorIdSignal: _angular_core.Signal<string>;
    readonly searchInputPlaceholderSignal: _angular_core.Signal<string>;
    readonly searchResultsState$: Observable<LoadingState<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>>;
    readonly searchResults$: Observable<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>;
    readonly searchResultsSignal: _angular_core.Signal<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    /**
     * Subclass lifecycle hook called at the end of ngOnInit.
     */
    protected abstract _onInit(): void;
    /**
     * Subclass lifecycle hook called at the end of ngOnDestroy.
     */
    protected abstract _onDestroy(): void;
    protected _hashForValue(): SearchableValueFieldHashFn<T, H>;
    protected _displayForValue(): SearchableValueFieldDisplayFn<T, M>;
    protected _loadDisplayValuesForValues(values: T[]): Observable<LoadingState<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>>;
    protected _loadDisplayValuesForFieldValues(values: SearchableValueFieldValue<T, M>[]): Observable<LoadingState<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>>;
    protected _getDisplayValuesForFieldValues(values: SearchableValueFieldValue<T, M>[]): Observable<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractForgeSearchableFieldDirective<any, any, any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractForgeSearchableFieldDirective<any, any, any, any>, never, never, { "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; "defaultValidationMessages": { "alias": "defaultValidationMessages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * The custom forge field type name for the searchable chip field.
 */
declare const DBX_FORGE_SEARCHABLE_CHIP_FIELD_TYPE_NAME: "dbx-searchable-chip";
/**
 * Props interface for the forge searchable chip field.
 */
interface DbxForgeSearchableChipFieldProps<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends DbxForgeSearchableTextFieldProps<T, M, H> {
    readonly multiSelect?: boolean;
    readonly asArrayValue?: boolean;
}
/**
 * Forge field definition interface for the searchable chip field.
 */
interface DbxForgeSearchableChipFieldDef<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends BaseValueField<DbxForgeSearchableChipFieldProps<T, M, H>, T | T[]> {
    readonly type: typeof DBX_FORGE_SEARCHABLE_CHIP_FIELD_TYPE_NAME;
}
/**
 * Configuration for a forge searchable chip field (multi-value autocomplete with chips).
 */
interface DbxForgeSearchableChipFieldConfig<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends DbxForgeFieldFunctionDef<DbxForgeSearchableChipFieldDef<T, M, H>> {
}
type DbxForgeSearchableChipFieldFunction = <T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey>(config: DbxForgeSearchableChipFieldConfig<T, M, H>) => DbxForgeField<DbxForgeSearchableChipFieldDef<T, M, H>>;
/**
 * Multi-value autocomplete with chips. Defaults to multi-select; supports free-form text entry when `allowStringValues` is set.
 *
 * @param config - Searchable chip field configuration
 * @returns A {@link DbxForgeFormFieldWrapperFieldDef} wrapping a searchable chip field
 *
 * @dbxFormField
 * @dbxFormSlug searchable-chip
 * @dbxFormTier field-factory
 * @dbxFormProduces T | T[]
 * @dbxFormArrayOutput optional
 * @dbxFormNgFormType dbx-searchable-chip
 * @dbxFormWrapperPattern material-form-field-wrapped
 * @dbxFormConfigInterface DbxForgeSearchableChipFieldConfig<T, M, H>
 * @dbxFormGeneric <T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey>
 *
 * @example
 * ```typescript
 * dbxForgeSearchableChipField<Tag>({ key: 'tags', props: { search, displayForValue } })
 * ```
 */
declare const dbxForgeSearchableChipField: DbxForgeSearchableChipFieldFunction;
/**
 * Configuration for a forge searchable string chip field, pre-configured for string values.
 *
 * `allowStringValues` is omitted from the config — it is always forced to `true`
 * so users can type a value and press Enter to add it as a chip.
 */
type DbxForgeSearchableStringChipFieldConfig<M = unknown> = Omit<DbxForgeSearchableChipFieldConfig<string, M>, 'props'> & {
    readonly props?: Omit<DbxForgeSearchableChipFieldProps<string, M>, 'allowStringValues'>;
};
/**
 * String-value specialization of `searchable-chip`. `allowStringValues` is forced true — use for free-form tag entry.
 *
 * Always sets `allowStringValues: true` on the inner field props so pressing Enter
 * (or typing a separator key) commits the typed value as a chip.
 *
 * @param config - String-specific searchable chip field configuration (omits allowStringValues)
 * @returns A {@link DbxForgeFormFieldWrapperFieldDef} wrapping a searchable chip field.
 *
 * @dbxFormField
 * @dbxFormSlug searchable-string-chip
 * @dbxFormTier field-factory
 * @dbxFormProduces string | string[]
 * @dbxFormArrayOutput optional
 * @dbxFormNgFormType dbx-searchable-chip
 * @dbxFormWrapperPattern material-form-field-wrapped
 * @dbxFormConfigInterface DbxForgeSearchableStringChipFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeSearchableStringChipField({ key: 'tags', props: { search, displayForValue } })
 * ```
 */
declare function dbxForgeSearchableStringChipField<M = unknown>(config: DbxForgeSearchableStringChipFieldConfig<M>): DbxForgeField<DbxForgeSearchableChipFieldDef<string, M, PrimativeKey>>;

/**
 * Forge ValueFieldComponent for searchable text selection (single value).
 *
 * Wraps the existing searchable text autocomplete pattern from formly as a standalone
 * ng-forge dynamic forms component. Receives field config via signal inputs from the mapper.
 */
declare class DbxForgeSearchableTextFieldComponent<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends AbstractForgeSearchableFieldDirective<T, M, H, DbxForgeSearchableTextFieldProps<T, M, H>> {
    private readonly elementRef;
    readonly field: _angular_core.InputSignal<FieldTree<T>>;
    readonly textInputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
    private readonly _singleValueSyncSub;
    private readonly _valuesSubject;
    readonly isDisabled: _angular_core.Signal<boolean>;
    readonly resolvedErrors: _angular_core.Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    readonly showErrors: _angular_core.Signal<boolean>;
    readonly errorsToDisplaySignal: _angular_core.Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    protected readonly ariaInvalidSignal: _angular_core.Signal<"true" | null>;
    protected readonly ariaDescribedBySignal: _angular_core.Signal<string | null>;
    readonly showClearValueSignal: _angular_core.Signal<boolean>;
    readonly searchLabelSignal: _angular_core.Signal<string>;
    readonly fieldValueSignal: _angular_core.Signal<Maybe<T>>;
    readonly displayValues$: Observable<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>;
    readonly selectedDisplayValue$: Observable<ConfiguredSearchableValueFieldDisplayValue<T, M>>;
    readonly selectedDisplayValueSignal: _angular_core.Signal<ConfiguredSearchableValueFieldDisplayValue<T, M> | undefined>;
    readonly hasValueSignal: _angular_core.Signal<boolean>;
    readonly showSelectedDisplayValueSignal: _angular_core.Signal<boolean>;
    private readonly _disabledEffect;
    private readonly _syncFieldValueEffect;
    constructor();
    protected _onInit(): void;
    protected _onDestroy(): void;
    focusInput(): void;
    selected(event: MatAutocompleteSelectedEvent): void;
    private _setFieldValue;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeSearchableTextFieldComponent<any, any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeSearchableTextFieldComponent<any, any, any>, "dbx-forge-searchable-text-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Forge ValueFieldComponent for searchable chip selection (multi-value).
 *
 * Wraps the existing searchable chip pattern from formly as a standalone
 * ng-forge dynamic forms component. Supports adding/removing chips with autocomplete search.
 */
declare class DbxForgeSearchableChipFieldComponent<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends AbstractForgeSearchableFieldDirective<T, M, H, DbxForgeSearchableChipFieldProps<T, M, H>> {
    private readonly elementRef;
    readonly field: _angular_core.InputSignal<FieldTree<T | T[]>>;
    readonly separatorKeysCodes: number[];
    readonly isDisabled: _angular_core.Signal<boolean>;
    readonly resolvedErrors: _angular_core.Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    readonly showErrors: _angular_core.Signal<boolean>;
    readonly errorsToDisplaySignal: _angular_core.Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    protected readonly ariaInvalidSignal: _angular_core.Signal<"true" | null>;
    protected readonly ariaDescribedBySignal: _angular_core.Signal<string | null>;
    private readonly _blur;
    private readonly _blurSub;
    private readonly _valuesSubject;
    readonly values$: Observable<T[]>;
    readonly displayValues$: Observable<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>;
    readonly displayValuesSignal: _angular_core.Signal<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>;
    private readonly _disabledEffect;
    private readonly _syncFieldValueEffect;
    constructor();
    get inputErrorMessage(): Maybe<string>;
    protected _onInit(): void;
    protected _onDestroy(): void;
    selectedChip(event: MatAutocompleteSelectedEvent): void;
    removeWithDisplayValue(displayValue: SearchableValueFieldDisplayValue<T>): void;
    addChip(event: MatChipInputEvent): void;
    tabPressedOnInput(event: KeyboardEvent): boolean;
    onBlur(): void;
    private get _multiSelect();
    private get _asArrayValue();
    private get _pickOnlyOne();
    private get _allowStringValues();
    private _tryAddCurrentInputValue;
    private _addWithTextValue;
    private _addValue;
    private _removeValue;
    private _setValues;
    private _setFieldValue;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeSearchableChipFieldComponent<any, any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeSearchableChipFieldComponent<any, any, any>, "dbx-forge-searchable-chip-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * 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.
 */
type PickableValueFieldLoadValuesFunction<T, M = unknown> = () => Observable<PickableValueFieldValue<T, M>[]>;
/**
 * PickableValueField function that allows the values a chance to go through another observable for any changes.
 *
 * Values may not have metadata on them in some cases, where the value may infact be an unknown value.
 * The returned value should be marked as unknown, or if it has no meta but is known, isUnknown should be marked false.
 *
 * The value itself should not change. All other fields on the value may change, however.
 */
type PickableValueFieldDisplayFunction<T, M = unknown> = (values: PickableValueFieldValue<T, M>[]) => Observable<PickableValueFieldDisplayValue<T, M>[]>;
/**
 * Used for filtering the values that should be displayed.
 */
type PickableValueFieldFilterFunction<T, M = unknown> = (flterText: Maybe<string>, values: PickableValueFieldDisplayValue<T, M>[]) => Observable<T[]>;
/**
 * Input for a PickableValueFieldFilterSelectedValuesFunction.
 */
interface PickableValueFieldFilterSelectedValuesInput<T> {
    /**
     * Values selected before this selection change.
     */
    readonly beforeValues: T[];
    /**
     * Proposed values after the selection change (already de-duplicated).
     */
    readonly afterValues: T[];
}
/**
 * Filters/modifies the selected values whenever the user changes the selection
 * (chip/list pick, remove, select-all). Returns the final values to set.
 * Lets a field enforce rules like group exclusivity internally instead of
 * round-tripping conflicting values through external sync.
 */
type PickableValueFieldFilterSelectedValuesFunction<T> = (input: PickableValueFieldFilterSelectedValuesInput<T>) => T[];
/**
 * Used to hash the value from the input pickable value.
 */
type PickableValueFieldHashFunction<T, H extends PrimativeKey = PrimativeKey> = SelectionValueHashFunction<T, H>;

/**
 * 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>[];

/**
 * The custom forge field type name for the pickable chip field.
 */
declare const FORGE_PICKABLE_CHIP_FIELD_TYPE: "dbx-pickable-chip";
/**
 * The custom forge field type name for the pickable list field.
 */
declare const FORGE_PICKABLE_LIST_FIELD_TYPE: "dbx-pickable-list";
/**
 * Props interface for forge pickable fields (both chip and list variants).
 *
 * Passed via the `props` property on the forge field definition.
 */
interface DbxForgePickableFieldProps<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> {
    readonly loadValues: PickableValueFieldLoadValuesFunction<T, M>;
    readonly displayForValue: PickableValueFieldDisplayFunction<T, M>;
    readonly hashForValue?: PickableValueFieldHashFunction<T, H>;
    readonly filterValues?: PickableValueFieldFilterFunction<T, M>;
    /**
     * Filters/modifies the selected values at selection time (user pick, remove, select-all).
     *
     * Lets the field enforce rules like group exclusivity internally instead of round-tripping conflicting values through external sync.
     */
    readonly filterSelectedValues?: PickableValueFieldFilterSelectedValuesFunction<T>;
    readonly sortItems?: PickableItemFieldItemSortFn<T, M>;
    readonly multiSelect?: boolean;
    readonly asArrayValue?: boolean;
    readonly showTextFilter?: boolean;
    readonly skipFilterFnOnEmpty?: boolean;
    readonly filterLabel?: string;
    readonly maxPicks?: number;
    readonly showSelectAllButton?: boolean;
    readonly changeSelectionModeToViewOnDisabled?: boolean;
    readonly footerConfig?: DbxInjectionComponentConfig;
    readonly refreshDisplayValues$?: Observable<unknown>;
    readonly hint?: string;
}
/**
 * Forge field definition interface for the pickable chip field.
 */
interface DbxForgePickableChipFieldDef<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends BaseValueField<DbxForgePickableFieldProps<T, M, H>, T | T[]> {
    readonly type: typeof FORGE_PICKABLE_CHIP_FIELD_TYPE;
}
/**
 * Forge field definition interface for the pickable list field.
 */
interface DbxForgePickableListFieldDef<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends BaseValueField<DbxForgePickableFieldProps<T, M, H>, T | T[]> {
    readonly type: typeof FORGE_PICKABLE_LIST_FIELD_TYPE;
}

/**
 * Display value augmented with its computed hash for deduplication.
 */
interface PickableDisplayValueWithHash<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends PickableValueFieldDisplayValue<T, M> {
    _hash: H;
}
/**
 * Abstract base directive for forge pickable item fields that manages value loading,
 * display caching, text filtering, and selection state.
 *
 * Subclasses provide the specific UI presentation (chips, lists, etc.).
 * This mirrors the formly {@link AbstractDbxPickableItemFieldDirective} pattern.
 */
declare abstract class AbstractForgePickableItemFieldDirective<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> implements OnInit {
    readonly field: InputSignal<FieldTree<T | T[]>>;
    readonly key: InputSignal<string>;
    readonly label: InputSignal<DynamicText | undefined>;
    readonly placeholder: InputSignal<DynamicText | undefined>;
    readonly className: InputSignal<string>;
    readonly tabIndex: InputSignal<number | undefined>;
    readonly props: InputSignal<DbxForgePickableFieldProps<T, M, H> | undefined>;
    readonly meta: InputSignal<FieldMeta | undefined>;
    readonly validationMessages: InputSignal<ValidationMessages | undefined>;
    readonly defaultValidationMessages: InputSignal<ValidationMessages | undefined>;
    readonly inputCtrl: FormControl<string | null>;
    private readonly _clearDisplayHashMapSub;
    private readonly _displayHashMap;
    private readonly _valuesSubject;
    readonly labelSignal: _angular_core.Signal<string | undefined>;
    readonly hintSignal: _angular_core.Signal<string | undefined>;
    readonly multiSelectSignal: _angular_core.Signal<boolean>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    readonly readonlySignal: _angular_core.Signal<any>;
    readonly isDisabledOrReadonlySignal: _angular_core.Signal<any>;
    readonly showSelectAllButtonSignal: _angular_core.Signal<boolean>;
    readonly showTextFilterSignal: _angular_core.Signal<boolean>;
    readonly filterLabelSignal: _angular_core.Signal<string | undefined>;
    readonly footerConfigSignal: _angular_core.Signal<_dereekb_dbx_core.DbxInjectionComponentConfig<unknown> | undefined>;
    readonly resolvedErrors: _angular_core.Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    readonly showErrors: _angular_core.Signal<boolean>;
    readonly errorsToDisplaySignal: _angular_core.Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    protected readonly hintIdSignal: _angular_core.Signal<string>;
    protected readonly errorIdSignal: _angular_core.Signal<string>;
    protected readonly ariaInvalidSignal: _angular_core.Signal<"true" | null>;
    protected readonly ariaRequiredSignal: _angular_core.Signal<"true" | null>;
    protected readonly ariaDescribedBySignal: _angular_core.Signal<string | null>;
    private get _pickOnlyOne();
    private _hashForValue;
    readonly filterInputValueString$: Observable<Maybe<string>>;
    readonly loadResultsDisplayValues$: Observable<PickableDisplayValueWithHash<T, M, H>[]>;
    readonly displayValuesState$: Observable<LoadingState<PickableDisplayValueWithHash<T, M, H>[]>>;
    readonly filteredSearchResults$: Observable<PickableDisplayValueWithHash<T, M, H>[]>;
    readonly items$: Observable<PickableItemFieldItem<T, M>[]>;
    readonly itemsSignal: _angular_core.Signal<PickableItemFieldItem<T, M>[]>;
    readonly noItemsAvailable$: Observable<boolean>;
    readonly noItemsAvailableSignal: _angular_core.Signal<boolean>;
    readonly allSelectedSignal: _angular_core.Signal<boolean>;
    private readonly _syncFieldValueEffect;
    ngOnInit(): void;
    itemClicked(item: PickableItemFieldItem<T, M>): void;
    protected _addValue(value: T): void;
    protected _removeValue(value: T): void;
    protected _setValues(values: T[]): void;
    private _setFieldValue;
    private _filterValues;
    private _loadDisplayValuesForFieldValues;
    private _loadDisplayValuesForFieldValuesState;
    private _getDisplayValuesForFieldValues;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractForgePickableItemFieldDirective<any, any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractForgePickableItemFieldDirective<any, any, any>, never, never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; "defaultValidationMessages": { "alias": "defaultValidationMessages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Configuration for a forge pickable chip field.
 */
interface DbxForgePickableChipFieldConfig<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends DbxForgeFieldFunctionDef<DbxForgePickableChipFieldDef<T, M, H>> {
}
type DbxForgePickableChipFieldFunction = <T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey>(config: DbxForgePickableChipFieldConfig<T, M, H>) => DbxForgeField<DbxForgePickableChipFieldDef<T, M, H>>;
/**
 * Selection field rendering selected values as Material chips. Defaults to multi-select; flip to single-select via the underlying props.
 *
 * @param config - Pickable chip field configuration
 * @returns A {@link DbxForgeFormFieldWrapperFieldDef} wrapping a pickable chip field
 *
 * @dbxFormField
 * @dbxFormSlug pickable-chip
 * @dbxFormTier field-factory
 * @dbxFormProduces T | T[]
 * @dbxFormArrayOutput optional
 * @dbxFormNgFormType dbx-pickable-chip
 * @dbxFormWrapperPattern material-form-field-wrapped
 * @dbxFormConfigInterface DbxForgePickableChipFieldConfig<T, M, H>
 * @dbxFormPropsInterface DbxForgePickableFieldProps
 * @dbxFormGeneric <T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey>
 *
 * @example
 * ```typescript
 * dbxForgePickableChipField<Tag>({ key: 'tags', label: 'Tags', props: { loadValues: () => loadTags$, displayForValue: displayTag } })
 * ```
 */
declare const dbxForgePickableChipField: DbxForgePickableChipFieldFunction;

/**
 * Configuration for a forge pickable list field.
 */
interface DbxForgePickableListFieldConfig<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends DbxForgeFieldFunctionDef<DbxForgePickableListFieldDef<T, M, H>> {
}
type DbxForgePickableListFieldFunction = <T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey>(config: DbxForgePickableListFieldConfig<T, M, H>) => DbxForgeField<DbxForgePickableListFieldDef<T, M, H>>;
/**
 * Scrollable-list variant of `pickable-chip` — same API, different presentation. Prefer this when the option set is large.
 *
 * @param config - Pickable list field configuration
 * @returns A {@link DbxForgeFormFieldWrapperFieldDef} wrapping a pickable list field
 *
 * @dbxFormField
 * @dbxFormSlug pickable-list
 * @dbxFormTier field-factory
 * @dbxFormProduces T | T[]
 * @dbxFormArrayOutput optional
 * @dbxFormNgFormType dbx-pickable-list
 * @dbxFormWrapperPattern material-form-field-wrapped
 * @dbxFormConfigInterface DbxForgePickableListFieldConfig<T, M, H>
 * @dbxFormPropsInterface DbxForgePickableFieldProps
 * @dbxFormGeneric <T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey>
 *
 * @example
 * ```typescript
 * dbxForgePickableListField<Item>({ key: 'items', props: { loadValues, displayForValue } })
 * ```
 */
declare const dbxForgePickableListField: DbxForgePickableListFieldFunction;

/**
 * Forge ValueFieldComponent for pickable chip selection.
 *
 * Renders available values as Material chips with optional text filtering, select-all toggle,
 * and custom display/hash functions. Bridges the FieldTree signal form model with the
 * pickable value loading and caching pipeline.
 */
declare class DbxForgePickableChipFieldComponent<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends AbstractForgePickableItemFieldDirective<T, M, H> {
    private readonly elementRef;
    constructor();
    toggleAll(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgePickableChipFieldComponent<any, any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgePickableChipFieldComponent<any, any, any>, "dbx-forge-pickable-chip-field", never, {}, {}, never, never, true, never>;
}

/**
 * Forge ValueFieldComponent for pickable list selection.
 *
 * Renders available values as a `mat-selection-list` with checkbox-based selection.
 * Supports text filtering, select-all toggle, and custom display/hash functions.
 * Uses `mat-list-option` items with icon, label, and sublabel content projection.
 */
declare class DbxForgePickableListFieldComponent<T = unknown, M = unknown, H extends PrimativeKey = PrimativeKey> extends AbstractForgePickableItemFieldDirective<T, M, H> {
    private readonly elementRef;
    constructor();
    onSelectionChange(event: MatSelectionListChange): void;
    toggleAll(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgePickableListFieldComponent<any, any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgePickableListFieldComponent<any, any, any>, "dbx-forge-pickable-list-field", never, {}, {}, never, never, true, never>;
}

/**
 * A source-select value with its associated metadata.
 */
interface SourceSelectValue<T extends PrimativeKey = PrimativeKey, M = unknown> {
    value: T;
    meta: M;
}
/**
 * Group of SourceSelectValues with a label.
 */
interface SourceSelectValueGroup<T extends PrimativeKey = PrimativeKey, M = unknown> {
    /**
     * Label for this source.
     */
    readonly label: string;
    /**
     * Values
     */
    readonly values: SourceSelectValue<T, M>[];
}
/**
 * Display value configuration for a SourceSelectValue.
 */
type SourceSelectDisplayValue<T extends PrimativeKey = PrimativeKey, M = unknown> = Omit<SelectionDisplayValue<T, M>, 'meta'> & Pick<SourceSelectValue<T, M>, 'meta'>;
/**
 * Display value configuration for a SourceSelectValue.
 */
interface SourceSelectDisplayValueGroup<T extends PrimativeKey = PrimativeKey, M = unknown> {
    /**
     * Label for this source.
     */
    readonly label: string;
    /**
     * Values
     */
    readonly values: SourceSelectDisplayValue<T, M>[];
}
/**
 * Options for a SourceSelect input.
 */
interface SourceSelectOptions<T extends PrimativeKey = PrimativeKey, M = unknown> {
    readonly nonGroupedValues: SourceSelectDisplayValue<T, M>[];
    readonly groupedValues: SourceSelectDisplayValueGroup<T, M>[];
}
/**
 * Returns an observable that loads all the display info for the input values.
 */
type SourceSelectDisplayFunction<T extends PrimativeKey = PrimativeKey, M = unknown> = MapFunction<SourceSelectValue<T, M>[], Observable<SourceSelectDisplayValue<T, M>[]>>;
/**
 * Reads the value from the input meta value. Should always return the same value.
 */
type SourceSelectMetaValueReader<T extends PrimativeKey = PrimativeKey, M = unknown> = MapFunction<M, T>;
/**
 * Returns an observable that loads the metadata of the input values.
 */
type SourceSelectValueMetaLoader<T extends PrimativeKey = PrimativeKey, M = unknown> = FactoryWithRequiredInput<Observable<M[]>, T[]>;
interface SourceSelectOpenFunctionParams {
    /**
     * Origin of the button for the SourceSelect
     */
    readonly origin: ElementRef;
}
/**
 * Returns an observable that returns an array of meta values to be added to the selection.
 */
type SourceSelectOpenFunction<M = unknown> = FactoryWithRequiredInput<Observable<SourceSelectOpenSourceResult<M>>, SourceSelectOpenFunctionParams>;
/**
 * Returns an observable that returns an array of meta values to be added to the selection.
 */
interface SourceSelectOpenSourceResult<M = unknown> {
    /**
     * The values to set entirely, clearing the current selection.
     *
     * If null/undefined, current values will not be replaced.
     */
    readonly set?: Maybe<M[]>;
    /**
     * New values to add to the selection, if applicable.
     *
     * If null/undefined, no values will be added to selection.
     *
     * Is ignored if "set" value is provided.
     */
    readonly select?: Maybe<M[]>;
    /**
     * New options to make available for selection, but are not automatically selected.
     *
     * If null/undefined, no options will be added.
     */
    readonly options?: Maybe<M[]>;
}
/**
 * Function used to return an observable for an array of SourceSelectLoadSource values.
 */
type SourceSelectLoadSourcesFunction<M = unknown> = Factory<Observable<SourceSelectLoadSource<M>[]>>;
/**
 * Source that has a label and an observable of meta values.
 */
interface SourceSelectLoadSource<M = unknown> {
    /**
     * Label for this source.
     */
    readonly label: string;
    /**
     * Metadata loaded from this source.
     */
    readonly meta: Observable<LoadingState<M[]>>;
}
/**
 * Loading state for a source-select data source, including the source's label.
 */
interface SourceSelectLoadSourceLoadingState<M = unknown> extends LoadingState<M[]> {
    /**
     * Label for this source.
     */
    readonly label: string;
}

/**
 * The custom forge field type name for the source select field.
 */
declare const FORGE_SOURCE_SELECT_FIELD_TYPE: "dbx-source-select";
/**
 * Props interface for the forge source select field.
 *
 * Passed via the `props` property on the forge field definition.
 */
interface DbxForgeSourceSelectFieldProps<T extends PrimativeKey = PrimativeKey, M = unknown> {
    readonly openSource?: Maybe<SourceSelectOpenFunction<M>>;
    readonly loadSources?: Maybe<SourceSelectLoadSourcesFunction<M>>;
    readonly valueReader: SourceSelectMetaValueReader<T, M>;
    readonly metaLoader: SourceSelectValueMetaLoader<T, M>;
    readonly displayForValue: SourceSelectDisplayFunction<T, M>;
    readonly selectButtonIcon?: Maybe<string>;
    readonly multiple?: Maybe<boolean>;
    readonly refreshDisplayValues$?: Maybe<Observable<unknown>>;
    readonly filterable?: Maybe<boolean>;
    readonly filterableGroups?: Maybe<boolean>;
    readonly hint?: Maybe<string>;
}
/**
 * Forge field definition interface for the source select field.
 */
interface DbxForgeSourceSelectFieldDef<T extends PrimativeKey = PrimativeKey, M = unknown> extends BaseValueField<DbxForgeSourceSelectFieldProps<T, M>, T | T[]> {
    readonly type: typeof FORGE_SOURCE_SELECT_FIELD_TYPE;
}
/**
 * Configuration for a forge source select field.
 */
interface DbxForgeSourceSelectFieldConfig<T extends PrimativeKey = PrimativeKey, M = unknown> extends DbxForgeFieldFunctionDef<DbxForgeSourceSelectFieldDef<T, M>> {
}
type DbxForgeSourceSelectFieldFunction = <T extends PrimativeKey = PrimativeKey, M = unknown>(config: DbxForgeSourceSelectFieldConfig<T, M>) => DbxForgeSourceSelectFieldDef<T, M>;
/**
 * Selection field that stores just the value key (`T`) but resolves full metadata (`M`) async for display. Use for reference fields where the form should store only the id.
 *
 * The component uses `<mat-form-field>` with `[formField]` for native ng-forge value binding,
 * proper Material rendering, and built-in logic (hidden/disabled/readonly) support.
 *
 * @param config - Source select field configuration
 * @returns A {@link DbxForgeSourceSelectFieldDef}
 *
 * @dbxFormField
 * @dbxFormSlug source-select
 * @dbxFormTier field-factory
 * @dbxFormProduces T | T[]
 * @dbxFormArrayOutput optional
 * @dbxFormNgFormType dbx-source-select
 * @dbxFormWrapperPattern unwrapped
 * @dbxFormConfigInterface DbxForgeSourceSelectFieldConfig<T, M>
 * @dbxFormGeneric <T extends PrimativeKey = PrimativeKey, M = unknown>
 *
 * @example
 * ```typescript
 * dbxForgeSourceSelectField<string, User>({ key: 'userId', props: { valueReader: (u) => u.id, metaLoader, displayForValue } })
 * ```
 */
declare const dbxForgeSourceSelectField: DbxForgeSourceSelectFieldFunction;

/**
 * Forge ValueFieldComponent for source-select fields.
 *
 * Renders a Material select dropdown inside `<mat-form-field>` populated from multiple data sources
 * (open source dialogs, loaded sources, and form control values).
 * Merges values, deduplicates by key, groups options by label,
 * and caches display values and metadata for performance.
 *
 * Uses `[formField]` for native ng-forge value binding, `<mat-form-field>` for proper
 * Material rendering, and `[attr.hidden]` for built-in logic (hidden/disabled) support.
 */
declare class DbxForgeSourceSelectFieldComponent<T extends PrimativeKey = PrimativeKey, M = unknown> implements OnInit, OnDestroy {
    private readonly materialConfig;
    private readonly elementRef;
    readonly field: _angular_core.InputSignal<FieldTree<T | T[]>>;
    readonly key: _angular_core.InputSignal<string>;
    readonly label: _angular_core.InputSignal<DynamicText | undefined>;
    readonly placeholder: _angular_core.InputSignal<DynamicText | undefined>;
    readonly className: _angular_core.InputSignal<string>;
    readonly tabIndex: _angular_core.InputSignal<number | undefined>;
    readonly props: _angular_core.InputSignal<DbxForgeSourceSelectFieldProps<T, M> | undefined>;
    readonly meta: _angular_core.InputSignal<FieldMeta | undefined>;
    readonly validationMessages: _angular_core.InputSignal<ValidationMessages | undefined>;
    readonly defaultValidationMessages: _angular_core.InputSignal<ValidationMessages | undefined>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly _cacheMetaSub;
    private readonly _clearDisplayHashMapSub;
    private readonly _valueMetaHashMap;
    private readonly _displayHashMap;
    private readonly _fromOpenSource;
    private readonly _loadSources;
    private readonly _valuesSubject;
    private readonly _filterText$;
    readonly buttonElement: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
    readonly filterInputElement: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
    readonly hintSignal: _angular_core.Signal<Maybe<string>>;
    readonly effectiveAppearanceSignal: _angular_core.Signal<_angular_material_form_field.MatFormFieldAppearance>;
    readonly effectiveSubscriptSizingSignal: _angular_core.Signal<_angular_material_form_field.SubscriptSizing>;
    readonly resolvedErrors: _angular_core.Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    readonly showErrors: _angular_core.Signal<boolean>;
    readonly errorsToDisplaySignal: _angular_core.Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    protected readonly hintIdSignal: _angular_core.Signal<string>;
    protected readonly errorIdSignal: _angular_core.Signal<string>;
    protected readonly ariaInvalidSignal: _angular_core.Signal<"true" | null>;
    protected readonly ariaRequiredSignal: _angular_core.Signal<"true" | null>;
    protected readonly ariaDescribedBySignal: _angular_core.Signal<string | null>;
    readonly multipleSignal: _angular_core.Signal<boolean>;
    readonly showOpenSourceButtonSignal: _angular_core.Signal<boolean>;
    readonly selectButtonIconSignal: _angular_core.Signal<string>;
    readonly filterableSignal: _angular_core.Signal<boolean>;
    readonly filterableGroupsSignal: _angular_core.Signal<boolean>;
    readonly selectPanelClassSignal: _angular_core.Signal<"" | "dbx-source-select-filterable-panel">;
    readonly values$: Observable<T[]>;
    readonly allValuesEverSelected$: Observable<T[]>;
    readonly sourceSelectValuesFromValuesState$: Observable<LoadingState<SourceSelectValue<T, M>[]>>;
    readonly loadSources$: Observable<LoadingState<SourceSelectValueGroup<T, M>[]>>;
    readonly fromOpenSource$: Observable<SourceSelectValueGroup<T, M>>;
    readonly valueGroupsFromSourcesState$: Observable<LoadingStateWithDefinedValue<SourceSelectValueGroup<T, M>[]>>;
    readonly allValueGroupsState$: Observable<LoadingState<SourceSelectValueGroup<T, M>[]>>;
    readonly allOptionGroupsState$: Observable<LoadingState<SourceSelectDisplayValueGroup<T, M>[]>>;
    readonly allOptionGroups$: Observable<SourceSelectDisplayValueGroup<T, M>[]>;
    readonly options$: Observable<SourceSelectOptions<T, M>>;
    readonly filteredOptions$: Observable<SourceSelectOptions<T, M>>;
    readonly filteredNonGroupedValuesSignal: _angular_core.Signal<SourceSelectDisplayValue<T, M>[] | undefined>;
    readonly filteredGroupedOptionsSignal: _angular_core.Signal<SourceSelectDisplayValueGroup<T, M>[] | undefined>;
    readonly context: _dereekb_rxjs.MutableLoadingStateContext<unknown, LoadingState<SourceSelectDisplayValueGroup<T, M>[]>, _dereekb_rxjs.LoadingContextEvent & LoadingState<SourceSelectDisplayValueGroup<T, M>[]>>;
    private readonly _syncFieldValueEffect;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    onSelectOpenedChange(opened: boolean): void;
    onFilterInput(event: Event): void;
    onFilterKeydown(event: KeyboardEvent): void;
    readonly handleSelectOptions: WorkUsingContext<unknown>;
    private _addToOpenSourceMap;
    private _addToCurrentValue;
    private _setCurrentValue;
    private _setFieldValue;
    private _loadSourceSelectValueForValues;
    private _getSourceSelectValueForValues;
    private _getDisplayValuesForSelectValues;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeSourceSelectFieldComponent<any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeSourceSelectFieldComponent<any, any>, "dbx-forge-source-select-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; "defaultValidationMessages": { "alias": "defaultValidationMessages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * The custom forge field type name for the list selection field.
 */
declare const FORGE_LIST_SELECTION_FIELD_TYPE: "dbx-list-selection";
/**
 * Max-height value for the rendered list. Either a CSS length passthrough
 * (`'60vh'`, `'400px'`, …), a number interpreted as pixels, or `'none'` to
 * remove the cap entirely.
 */
type DbxForgeListSelectionFieldMaxHeight = string | number;
/**
 * Props interface for the forge list selection field.
 *
 * Passed via the `props` property on the forge field definition.
 */
interface DbxForgeListSelectionFieldProps<T = unknown, C extends AbstractDbxSelectionListWrapperDirective<T> = AbstractDbxSelectionListWrapperDirective<T>, K extends PrimativeKey = PrimativeKey> {
    /**
     * List component class to render items from. Can be provided as an Observable for lazy loading.
     */
    readonly listComponentClass: Observable<Type<C>>;
    /**
     * Read key function to extract the identifier from each item.
     */
    readonly readKey: ReadKeyFunction<T, K>;
    /**
     * Observable that provides the items to select.
     */
    readonly state$: Observable<ListLoadingState<T>>;
    /**
     * Function that signals to load more items.
     */
    readonly loadMore?: () => void;
    /**
     * Hint text shown below the field.
     */
    readonly hint?: string;
    /**
     * When `false`, render the list bare without the surrounding Material
     * form-field wrapper (no notched outline, no notch label, no hint chrome
     * below). The label/hint inputs become inert in that mode. Defaults to `true`.
     */
    readonly wrapped?: boolean;
    /**
     * Override the default 300px max-height cap on the rendered list.
     *
     * - `undefined` (default) — leave the existing CSS variable alone.
     * - `'none'` — remove the cap entirely (the list grows to fit its content).
     * - `number` — interpreted as pixels (`{value}px`).
     * - `string` — passthrough (e.g. `'60vh'`, `'clamp(200px, 50vh, 600px)'`).
     */
    readonly maxHeight?: DbxForgeListSelectionFieldMaxHeight;
}
/**
 * Forge field definition interface for the list selection field.
 */
interface DbxForgeListSelectionFieldDef<T = unknown, C extends AbstractDbxSelectionListWrapperDirective<T> = AbstractDbxSelectionListWrapperDirective<T>, K extends PrimativeKey = PrimativeKey> extends BaseValueField<DbxForgeListSelectionFieldProps<T, C, K>, K[]> {
    readonly type: typeof FORGE_LIST_SELECTION_FIELD_TYPE;
}
/**
 * Configuration for a forge list selection field.
 */
interface DbxForgeListSelectionFieldConfig<T = unknown, C extends AbstractDbxSelectionListWrapperDirective<T> = AbstractDbxSelectionListWrapperDirective<T>, K extends PrimativeKey = PrimativeKey> extends DbxForgeFieldFunctionDef<DbxForgeListSelectionFieldDef<T, C, K>> {
}
type DbxForgeListSelectionFieldFunction = <T = unknown, C extends AbstractDbxSelectionListWrapperDirective<T> = AbstractDbxSelectionListWrapperDirective<T>, K extends PrimativeKey = PrimativeKey>(config: DbxForgeListSelectionFieldConfig<T, C, K>) => DbxForgeField<DbxForgeListSelectionFieldDef<T, C, K>>;
/**
 * Multi-select backed by a lazy-loadable custom list component. Use when you need complete control over item layout and pagination.
 *
 * @param config - List selection field configuration
 * @returns A {@link DbxForgeFormFieldWrapperFieldDef} wrapping a list selection field
 *
 * @dbxFormField
 * @dbxFormSlug list-selection
 * @dbxFormTier field-factory
 * @dbxFormProduces K[]
 * @dbxFormArrayOutput yes
 * @dbxFormNgFormType dbx-list-selection
 * @dbxFormWrapperPattern material-form-field-wrapped
 * @dbxFormConfigInterface DbxForgeListSelectionFieldConfig<T, C, K>
 * @dbxFormGeneric <T = unknown, C extends AbstractDbxSelectionListWrapperDirective<T> = AbstractDbxSelectionListWrapperDirective<T>, K extends PrimativeKey = PrimativeKey>
 *
 * @example
 * ```typescript
 * dbxForgeListSelectionField<Item, MyListComponent, string>({ key: 'items', props: { listComponentClass, readKey: (i) => i.id, state$ } })
 * ```
 */
declare const dbxForgeListSelectionField: DbxForgeListSelectionFieldFunction;

/**
 * Forge ValueFieldComponent for list-based selection.
 *
 * Renders items via a custom {@link AbstractDbxSelectionListWrapperDirective} component
 * and tracks selected items by key. Bridges the FieldTree signal form model
 * with the dbx-web list selection infrastructure.
 */
declare class DbxForgeListSelectionFieldComponent<T = unknown, C extends AbstractDbxSelectionListWrapperDirective<T> = AbstractDbxSelectionListWrapperDirective<T>, K extends PrimativeKey = PrimativeKey> implements OnInit {
    private readonly elementRef;
    readonly field: _angular_core.InputSignal<FieldTree<K[]>>;
    readonly key: _angular_core.InputSignal<string>;
    readonly label: _angular_core.InputSignal<DynamicText | undefined>;
    readonly placeholder: _angular_core.InputSignal<DynamicText | undefined>;
    readonly className: _angular_core.InputSignal<string>;
    readonly tabIndex: _angular_core.InputSignal<number | undefined>;
    readonly props: _angular_core.InputSignal<DbxForgeListSelectionFieldProps<T, C, K> | undefined>;
    readonly meta: _angular_core.InputSignal<FieldMeta | undefined>;
    readonly validationMessages: _angular_core.InputSignal<ValidationMessages | undefined>;
    readonly defaultValidationMessages: _angular_core.InputSignal<ValidationMessages | undefined>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    readonly isDisabled$: Observable<boolean>;
    private readonly _selectionEventSub;
    private readonly _loadMoreSub;
    private readonly _listComponentClassObs;
    private readonly _valuesSubject;
    readonly labelSignal: _angular_core.Signal<string | undefined>;
    readonly hintSignal: _angular_core.Signal<string | undefined>;
    /**
     * Resolves the configured `maxHeight` prop into a CSS length string for the
     * `--dbx-forge-list-item-field-height` custom property. Returns `null` when
     * the prop is absent so the existing 300px default in `_list.scss` wins.
     */
    readonly maxHeightCssVarSignal: _angular_core.Signal<Maybe<string>>;
    readonly resolvedErrors: _angular_core.Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    readonly showErrors: _angular_core.Signal<boolean>;
    readonly errorsToDisplaySignal: _angular_core.Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    protected readonly hintIdSignal: _angular_core.Signal<string>;
    protected readonly errorIdSignal: _angular_core.Signal<string>;
    protected readonly ariaInvalidSignal: _angular_core.Signal<"true" | null>;
    protected readonly ariaDescribedBySignal: _angular_core.Signal<string | null>;
    readonly listComponentClass$: Observable<Type<C>>;
    readonly config$: Observable<DbxInjectionComponentConfig<C>>;
    readonly values$: Observable<K[]>;
    readonly isSelectedModifierFunction$: Observable<DbxValueListItemDecisionFunction<T>>;
    readonly configSignal: _angular_core.Signal<DbxInjectionComponentConfig<C> | undefined>;
    readonly isSelectedModifierFunctionSignal: _angular_core.Signal<DbxValueListItemDecisionFunction<T> | undefined>;
    constructor();
    ngOnInit(): void;
    private _updateForSelection;
    private _setValues;
    private _setFieldValue;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeListSelectionFieldComponent<any, any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeListSelectionFieldComponent<any, any, any>, "dbx-forge-list-selection-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; "defaultValidationMessages": { "alias": "defaultValidationMessages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Configuration for a forge multi-checkbox (checklist) field.
 */
interface DbxForgeChecklistFieldConfig<T = unknown> extends DbxForgeFieldFunctionDef<MatMultiCheckboxField<T>> {
}
/**
 * Generic function type for dbxForgeChecklistField to preserve caller generics.
 */
type DbxForgeChecklistFieldFunction = <T = unknown>(config: DbxForgeChecklistFieldConfig<T>) => DbxForgeField<MatMultiCheckboxField<T>>;
/**
 * Multi-checkbox group. Use for small static option sets where every option is visible at once.
 *
 * @param config - Checklist field configuration
 * @returns A validated {@link MatMultiCheckboxField} with type `'multi-checkbox'`
 *
 * @dbxFormField
 * @dbxFormSlug checklist
 * @dbxFormTier field-factory
 * @dbxFormProduces T[]
 * @dbxFormArrayOutput yes
 * @dbxFormNgFormType multi-checkbox
 * @dbxFormWrapperPattern unwrapped
 * @dbxFormConfigInterface DbxForgeChecklistFieldConfig<T>
 * @dbxFormGeneric <T = unknown>
 *
 * @example
 * ```typescript
 * dbxForgeChecklistField<string>({ key: 'flags', props: { options: [{ value: 'a', label: 'A' }, { value: 'b', label: 'B' }] } })
 * ```
 */
declare const dbxForgeChecklistField: DbxForgeChecklistFieldFunction;

/**
 * The custom forge field type name for the component field.
 */
declare const FORGE_COMPONENT_FIELD_TYPE: "dbx-component";
/**
 * Props interface for the forge component field.
 *
 * Passed via the `props` property on the forge field definition.
 * Contains the {@link DbxInjectionComponentConfig} for rendering an arbitrary Angular component.
 */
interface DbxForgeComponentFieldProps<T = unknown> {
    /**
     * The injection component configuration that describes which component to render.
     */
    readonly componentField: DbxInjectionComponentConfig<T>;
    /**
     * Whether to visually indicate the disabled state on this component.
     *
     * Defaults to `true`. Set to `false` for display-only components that should
     * remain visually unchanged when the form is disabled.
     */
    readonly allowDisabledEffects?: boolean;
}
/**
 * Forge field definition interface for the component field.
 */
interface DbxForgeComponentFieldDef<T = unknown> extends BaseValueField<DbxForgeComponentFieldProps<T>, unknown> {
    readonly type: typeof FORGE_COMPONENT_FIELD_TYPE;
}
/**
 * Forge ValueFieldComponent that renders a custom Angular component via dynamic injection.
 *
 * Uses {@link DbxInjectionComponent} to instantiate the component class specified in the
 * field's `props.componentField` configuration. This is the forge equivalent of
 * the formly `DbxFormComponentFieldComponent`.
 */
declare class DbxForgeComponentFieldComponent<T = unknown> {
    private readonly elementRef;
    readonly field: _angular_core.InputSignal<FieldTree<unknown>>;
    readonly key: _angular_core.InputSignal<string>;
    readonly label: _angular_core.InputSignal<DynamicText | undefined>;
    readonly placeholder: _angular_core.InputSignal<DynamicText | undefined>;
    readonly className: _angular_core.InputSignal<string>;
    readonly tabIndex: _angular_core.InputSignal<number | undefined>;
    readonly props: _angular_core.InputSignal<DbxForgeComponentFieldProps<T> | undefined>;
    readonly meta: _angular_core.InputSignal<FieldMeta | undefined>;
    readonly validationMessages: _angular_core.InputSignal<ValidationMessages | undefined>;
    readonly defaultValidationMessages: _angular_core.InputSignal<ValidationMessages | undefined>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    readonly showDisabledStateSignal: _angular_core.Signal<boolean>;
    constructor();
    readonly configSignal: _angular_core.Signal<Maybe<DbxInjectionComponentConfig<T>>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeComponentFieldComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeComponentFieldComponent<any>, "dbx-forge-component-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; "defaultValidationMessages": { "alias": "defaultValidationMessages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Internal config with required key for the factory.
 */
type _DbxForgeComponentFieldConfig<T = unknown> = Omit<DbxForgeFieldFunctionDef<DbxForgeComponentFieldDef<T>>, 'props'> & {
    readonly props: DbxForgeComponentFieldProps<T>;
};
/**
 * Configuration for a forge field that renders a custom Angular component.
 */
type DbxForgeComponentFieldConfig<T = unknown> = Omit<_DbxForgeComponentFieldConfig<T>, 'key'> & {
    /**
     * Key for the field. Optional for display-only components.
     */
    readonly key?: string;
};
/**
 * Generic function type for dbxForgeComponentField to preserve caller generics.
 */
type DbxForgeComponentFieldFunction = <T = unknown>(config: DbxForgeComponentFieldConfig<T>) => DbxForgeField<DbxForgeComponentFieldDef<T>>;
/**
 * Escape hatch — injects any Angular component as the field renderer via DbxInjection. Use when no existing form field fits.
 *
 * Uses {@link DbxInjectionComponent} to dynamically inject any Angular component
 * into the form. Generates a unique key when none is provided so that ng-forge's
 * field reconciliation treats each config change as a new field instance.
 *
 * @param config - Component field configuration.
 * @returns A validated {@link DbxForgeComponentFieldDef}
 *
 * @dbxFormField
 * @dbxFormSlug component-field
 * @dbxFormTier field-factory
 * @dbxFormProduces T
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType component
 * @dbxFormWrapperPattern unwrapped
 * @dbxFormConfigInterface DbxForgeComponentFieldConfig<T>
 * @dbxFormGeneric <T = unknown>
 *
 * @example
 * ```typescript
 * dbxForgeComponentField<MyValue>({ key: 'custom', props: { component: MyCustomComp } })
 * ```
 */
declare const dbxForgeComponentField: DbxForgeComponentFieldFunction;

/**
 * Props interface for the forge text editor field.
 *
 * Passed via the `props` property on the forge field definition.
 */
interface DbxForgeTextEditorFieldProps {
    /**
     * Minimum text length.
     */
    readonly minLength?: number;
    /**
     * Maximum text length.
     */
    readonly maxLength?: number;
    /**
     * Hint text shown below the editor.
     */
    readonly hint?: string;
}
/**
 * The custom forge field type name for the text editor field.
 */
declare const FORGE_TEXT_EDITOR_FIELD_TYPE: "dbx-texteditor";
/**
 * Forge field definition interface for the text editor field.
 */
interface DbxForgeTextEditorFieldDef extends BaseValueField<DbxForgeTextEditorFieldProps, string> {
    readonly type: typeof FORGE_TEXT_EDITOR_FIELD_TYPE;
}
/**
 * Forge ValueFieldComponent for rich text editing powered by ngx-editor.
 *
 * Wraps the existing ngx-editor integration from the formly text editor component
 * as a standalone ng-forge dynamic forms component. Outputs HTML format.
 * Supports compact mode via {@link CompactContextStore}.
 */
declare class DbxForgeTextEditorFieldComponent implements OnInit, OnDestroy {
    private readonly _compactContextStore;
    private readonly elementRef;
    readonly field: _angular_core.InputSignal<FieldTree<string>>;
    readonly key: _angular_core.InputSignal<string>;
    readonly label: _angular_core.InputSignal<DynamicText | undefined>;
    readonly placeholder: _angular_core.InputSignal<DynamicText | undefined>;
    readonly className: _angular_core.InputSignal<string>;
    readonly tabIndex: _angular_core.InputSignal<number | undefined>;
    readonly props: _angular_core.InputSignal<DbxForgeTextEditorFieldProps | undefined>;
    readonly meta: _angular_core.InputSignal<FieldMeta | undefined>;
    readonly validationMessages: _angular_core.InputSignal<ValidationMessages | undefined>;
    readonly defaultValidationMessages: _angular_core.InputSignal<ValidationMessages | undefined>;
    private _editor;
    private readonly _editorValueSub;
    private readonly _syncFromFieldSub;
    readonly editorFormControl: FormControl<string>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    readonly compactClass$: rxjs.Observable<string>;
    readonly compactClassSignal: _angular_core.Signal<string>;
    readonly labelSignal: _angular_core.Signal<string | undefined>;
    readonly placeholderSignal: _angular_core.Signal<string>;
    readonly descriptionSignal: _angular_core.Signal<string | undefined>;
    readonly resolvedErrors: _angular_core.Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    readonly showErrors: _angular_core.Signal<boolean>;
    readonly errorsToDisplaySignal: _angular_core.Signal<_ng_forge_dynamic_forms_internal.ResolvedError[]>;
    protected readonly hintIdSignal: _angular_core.Signal<string>;
    protected readonly errorIdSignal: _angular_core.Signal<string>;
    protected readonly ariaInvalidSignal: _angular_core.Signal<"true" | null>;
    protected readonly ariaDescribedBySignal: _angular_core.Signal<string | null>;
    constructor();
    get editor(): Editor;
    private readonly _disabledEffect;
    private readonly _syncFieldToEditor;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private _setFieldValue;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeTextEditorFieldComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeTextEditorFieldComponent, "dbx-forge-texteditor-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "validationMessages": { "alias": "validationMessages"; "required": false; "isSignal": true; }; "defaultValidationMessages": { "alias": "defaultValidationMessages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Configuration for a forge rich text editor field.
 */
interface DbxForgeTextEditorFieldConfig extends DbxForgeFieldFunctionDef<DbxForgeTextEditorFieldDef> {
}
/**
 * Rich HTML text editor (ngx-editor). Output is the serialized HTML string.
 *
 * Uses ngx-editor under the hood, outputting HTML format.
 * The field defaults to an empty string.
 *
 * @param config - Text editor field configuration
 * @returns A validated {@link DbxForgeTextEditorFieldDef}
 *
 * @dbxFormField
 * @dbxFormSlug text-editor
 * @dbxFormTier field-factory
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormNgFormType texteditor
 * @dbxFormWrapperPattern unwrapped
 * @dbxFormConfigInterface DbxForgeTextEditorFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeTextEditorField({ key: 'content', label: 'Body', maxLength: 10000 })
 * ```
 */
declare const dbxForgeTextEditorField: _dereekb_dbx_form.DbxForgeFieldFunction<DbxForgeTextEditorFieldConfig, DbxForgeTextEditorFieldDef>;

declare const FORGE_EXPAND_FIELD_TYPE_NAME: "dbx-forge-expand";
/**
 * Visual style for the expand trigger.
 */
type DbxForgeExpandButtonType = 'button' | 'text';
/**
 * Props interface for the forge expand field.
 */
interface DbxForgeExpandFieldProps {
    /**
     * Visual style for the expand trigger. Defaults to `'text'`.
     */
    readonly buttonType: DbxForgeExpandButtonType;
    /**
     * Label displayed on the expand trigger.
     */
    readonly expandLabel: string;
}
/**
 * Forge field definition for the expand control.
 *
 * This is a boolean value field that renders as a clickable button or text link.
 * When toggled, it writes `true`/`false` to its FieldTree value, which
 * is used by a sibling group's `logic` to show/hide content.
 */
interface DbxForgeExpandFieldDef extends BaseValueField<DbxForgeExpandFieldProps, boolean> {
    readonly type: typeof FORGE_EXPAND_FIELD_TYPE_NAME;
}

/**
 * Logic configuration for container fields (group, row, array).
 *
 * Containers only support `'hidden'` since they are layout containers,
 * not form controls. This mirrors ng-forge's internal `ContainerLogicConfig`.
 */
interface DbxForgeContainerLogicConfig {
    readonly type: 'hidden';
    readonly condition: ConditionalExpression | boolean;
}
/**
 * Configuration for a forge row layout that arranges fields horizontally.
 *
 * Extends {@link RowField} with `key` made optional (auto-generated if omitted)
 * and `type` omitted (always `'row'`).
 */
interface DbxForgeRowConfig extends Omit<RowField, 'type' | 'key'> {
    /**
     * Optional key for the row. Defaults to a unique auto-generated key.
     *
     * Must be unique within the form config to avoid ng-forge duplicate key errors.
     */
    readonly key?: string;
}
/**
 * Flex row that lays child fields out in columns. Child fields typically carry a `col` property (1–12) for grid placement.
 *
 * Uses the `@ng-forge/dynamic-forms` `RowField` type with a 12-column grid system.
 * Each child field can specify a `col` value (1-12) for responsive sizing.
 *
 * @param config - Row layout configuration with fields and optional className.
 * @returns A {@link RowField} with type `'row'`
 *
 * @dbxFormField
 * @dbxFormSlug row
 * @dbxFormTier primitive
 * @dbxFormProduces RowField
 * @dbxFormReturns RowField
 * @dbxFormArrayOutput no
 * @dbxFormConfigInterface DbxForgeRowConfig
 *
 * @example
 * ```typescript
 * dbxForgeRow({ fields: [ { ...dbxForgeTextField({ key: 'first' }), col: 6 }, { ...dbxForgeTextField({ key: 'last' }), col: 6 } ] })
 * ```
 */
declare function dbxForgeRow(config: DbxForgeRowConfig): RowField;
/**
 * Configuration for a forge group layout.
 *
 * Extends {@link GroupField} with `type` omitted (always `'group'`). The `key`
 * is required because a `group` field creates a nested object in the form value
 * under that key — it is part of the value shape, not a display-only identifier.
 */
interface DbxForgeGroupConfig extends Omit<GroupField, 'type'> {
}
/**
 * Creates a plain ng-forge `group` field. A group produces a nested object in
 * the form value under its `key`, so the key is semantically significant and
 * must be chosen deliberately.
 *
 * For visual-only grouping (conditional visibility, layout wrappers, shared
 * CSS class) that should NOT introduce a nested object in the form value, use
 * {@link dbxForgeContainer} instead — that is what ng-forge's `container`
 * field type is for.
 *
 * For sections with headers, use the section wrapper type instead.
 *
 * @param config - Group configuration with fields and required key.
 * @returns A {@link GroupField} with type `'group'`
 *
 * @dbxFormField
 * @dbxFormSlug group
 * @dbxFormTier primitive
 * @dbxFormProduces GroupField
 * @dbxFormReturns GroupField
 * @dbxFormArrayOutput no
 * @dbxFormConfigInterface DbxForgeGroupConfig
 *
 * @example
 * ```typescript
 * // Groups the address sub-fields under an `address` property in the form value.
 * const group = dbxForgeGroup({
 *   key: 'address',
 *   fields: [
 *     dbxForgeTextField({ key: 'city', label: 'City' }),
 *     dbxForgeTextField({ key: 'state', label: 'State' })
 *   ]
 * });
 *
 * // Resulting form value shape:
 * // { address: { city: '...', state: '...' } }
 * ```
 * @example
 * ```typescript
 * // Wrong: if the intent is purely visual (e.g. conditional visibility) and
 * // the fields should remain at the parent level in the form value, do NOT
 * // use a group — use dbxForgeContainer instead. Otherwise you end up with a
 * // spurious nested object:
 * //   { _group_0: { city: '...', state: '...' } }   // ← unwanted wrapper
 * ```
 */
declare function dbxForgeGroup(config: DbxForgeGroupConfig): GroupField;
/**
 * Configuration for a forge container layout.
 *
 * Extends {@link ContainerField} with `type` omitted (always `'container'`),
 * `key` made optional (auto-generated if omitted), and `wrappers` made optional
 * (defaults to an empty array).
 */
interface DbxForgeContainerConfig extends Omit<ContainerField, 'type' | 'key' | 'wrappers'> {
    /**
     * Optional key for the container. Defaults to a unique auto-generated key.
     *
     * Containers do not introduce a nested object in the form value — the key is
     * only an identifier and is not part of the value shape. Must still be unique
     * within the form config to avoid ng-forge duplicate key errors.
     */
    readonly key?: string;
    /**
     * Optional wrapper configs to chain around the children. Defaults to `[]`.
     */
    readonly wrappers?: readonly WrapperConfig[];
}
/**
 * Creates an ng-forge `container` field. Containers group child fields for
 * layout, conditional visibility, or wrapper application WITHOUT introducing
 * a nested object in the form value — child values remain at the same level
 * as the container itself.
 *
 * Use this (not {@link dbxForgeGroup}) whenever the grouping is purely visual
 * or structural. Use {@link dbxForgeGroup} when the intent is to nest the
 * child values under a named key in the form value.
 *
 * @param config - Container configuration with fields and optional key/wrappers.
 * @returns A {@link ContainerField} with type `'container'`
 *
 * @example
 * ```typescript
 * // Visual-only grouping (e.g. to apply a CSS class or a wrapper). Children
 * // remain at the parent level in the form value — the container itself
 * // does not add a property.
 * const container = dbxForgeContainer({
 *   className: 'dbx-highlight-group',
 *   fields: [
 *     dbxForgeTextField({ key: 'city', label: 'City' }),
 *     dbxForgeTextField({ key: 'state', label: 'State' })
 *   ]
 * });
 *
 * // Resulting form value shape (flat):
 * // { city: '...', state: '...' }
 * ```
 * @example
 * ```typescript
 * // Conditional visibility without altering the value shape — a common use
 * // case that should NOT use dbxForgeGroup.
 * const container = dbxForgeContainer({
 *   fields: [dbxForgeTextField({ key: 'jwks_uri', label: 'JWKS URI' })],
 *   logic: [{
 *     type: 'hidden',
 *     condition: { type: 'fieldValue', fieldPath: 'authMethod', operator: 'notEquals', value: 'private_key_jwt' }
 *   }]
 * });
 *
 * // Resulting form value shape (jwks_uri stays flat, not nested):
 * // { authMethod: '...', jwks_uri: '...' }
 * ```
 */
declare function dbxForgeContainer(config: DbxForgeContainerConfig): ContainerField;
/**
 * Configuration for a forge toggle wrapper that shows/hides content via a slide toggle.
 */
interface DbxForgeToggleWrapperConfig {
    /**
     * Fields to show/hide based on the toggle state.
     */
    readonly fields: FieldDef<unknown>[];
    /**
     * Label for the toggle control.
     */
    readonly label?: string;
    /**
     * Key for the toggle boolean field. Defaults to auto-generated `_toggle_N`.
     */
    readonly key?: string;
    /**
     * Optional CSS class name applied to the outer row container.
     */
    readonly className?: string;
    /**
     * Whether the toggle starts in the open state. Defaults to false.
     */
    readonly defaultOpen?: boolean;
    /**
     * Optional key for the content container. Auto-generated if omitted.
     *
     * The container does not add a property to the form value; this is only a
     * stable identifier for the container field.
     */
    readonly contentKey?: string;
}
/**
 * Wraps content fields in a Material slide toggle — the toggle state controls conditional visibility of the inner fields.
 *
 * Uses ng-forge's built-in `toggle` field type (MatSlideToggle) and
 * `FieldValueCondition` for conditional visibility. The toggle boolean value
 * IS part of the form model. The hidden content is wrapped in a `container`
 * (not a `group`), so the wrapped fields sit at the same level as the toggle
 * in the form value — they are NOT nested under an extra object.
 *
 * Structure produced:
 * ```
 * Container (outer, with flex wrapper)
 *   ├── toggle field (type: 'toggle', boolean value)
 *   └── Container (content, hidden when toggle === false)
 * ```
 *
 * This is the forge equivalent of the formly `formlyToggleWrapper`.
 *
 * @param config - Toggle wrapper configuration.
 * @returns A {@link ContainerField} containing the toggle and content container.
 *
 * @dbxFormField
 * @dbxFormSlug toggle-wrapper
 * @dbxFormTier composite-builder
 * @dbxFormSuffix Wrapper
 * @dbxFormProduces ContainerField
 * @dbxFormArrayOutput no
 * @dbxFormConfigInterface DbxForgeToggleWrapperConfig
 * @dbxFormComposesFrom toggle, group
 *
 * @example
 * ```typescript
 * const toggle = dbxForgeToggleWrapper({
 *   key: 'showAdvanced',
 *   label: 'Show advanced options',
 *   fields: [
 *     dbxForgeTextField({ key: 'advanced1', label: 'Option 1' }),
 *     dbxForgeTextField({ key: 'advanced2', label: 'Option 2' })
 *   ]
 * });
 *
 * // Resulting form value (flat — no nesting under the container):
 * // { showAdvanced: true, advanced1: '...', advanced2: '...' }
 * ```
 */
declare function dbxForgeToggleWrapper(config: DbxForgeToggleWrapperConfig): ContainerField;
/**
 * Configuration for a forge expand wrapper that shows/hides content via a button or text link.
 */
interface DbxForgeExpandWrapperConfig {
    /**
     * Fields to show/hide when the expand control is toggled.
     */
    readonly fields: FieldDef<unknown>[];
    /**
     * Label for the expand trigger.
     */
    readonly label?: string;
    /**
     * Visual style for the expand trigger. Defaults to `'text'`.
     */
    readonly buttonType?: DbxForgeExpandButtonType;
    /**
     * Key for the expand boolean field. Defaults to auto-generated `_expand_N`.
     */
    readonly key?: string;
    /**
     * Optional CSS class name applied to the outer row container.
     */
    readonly className?: string;
    /**
     * Whether the expand starts in the open state. Defaults to false.
     */
    readonly defaultOpen?: boolean;
    /**
     * Optional key for the content container. Auto-generated if omitted.
     *
     * The container does not add a property to the form value; this is only a
     * stable identifier for the container field.
     */
    readonly contentKey?: string;
}
/**
 * Wraps content fields behind a button or text "expand" control. Use for optional sections like "Show advanced options".
 *
 * Uses a custom `dbx-forge-expand` field type for the expand trigger and
 * `FieldValueCondition` for conditional visibility on the content. The
 * expand boolean value IS part of the form model. The hidden content is
 * wrapped in a `container` (not a `group`), so the wrapped fields sit at the
 * same level as the expand control in the form value — they are NOT nested
 * under an extra object.
 *
 * Structure produced:
 * ```
 * Container (outer, with flex wrapper)
 *   ├── expand field (type: 'dbx-forge-expand', boolean value)
 *   └── Container (content, hidden when expand field === false)
 * ```
 *
 * This is the forge equivalent of the formly `formlyExpandWrapper`.
 *
 * @param config - Expand wrapper configuration.
 * @returns A {@link ContainerField} containing the expand control and content container.
 *
 * @dbxFormField
 * @dbxFormSlug expand-wrapper
 * @dbxFormTier composite-builder
 * @dbxFormSuffix Wrapper
 * @dbxFormProduces ContainerField
 * @dbxFormArrayOutput no
 * @dbxFormConfigInterface DbxForgeExpandWrapperConfig
 * @dbxFormComposesFrom group
 *
 * @example
 * ```typescript
 * const expand = dbxForgeExpandWrapper({
 *   key: 'showMore',
 *   label: 'Show more options',
 *   buttonType: 'button',
 *   fields: [
 *     dbxForgeTextField({ key: 'extra1', label: 'Extra 1' }),
 *     dbxForgeTextField({ key: 'extra2', label: 'Extra 2' })
 *   ]
 * });
 *
 * // Resulting form value (flat — no nesting under the container):
 * // { showMore: true, extra1: '...', extra2: '...' }
 * ```
 */
declare function dbxForgeExpandWrapper(config: DbxForgeExpandWrapperConfig): ContainerField;

/**
 * Forge wrapper component that wraps an ng-forge `array` field with
 * a section header (label + hint), a cdkDropList for drag-and-drop reordering,
 * and the array field content.
 *
 * Provides {@link DbxForgeArrayFieldState} so element wrappers can inject it
 * for coordinated add/remove/reorder operations.
 */
declare class DbxForgeArrayFieldWrapperComponent implements FieldWrapper {
    readonly fieldComponent: _angular_core.Signal<ViewContainerRef>;
    readonly fieldInputs: _angular_core.InputSignal<WrapperFieldInputs | undefined>;
    private readonly dispatcher;
    private readonly _formContextService;
    /**
     * Wrapper config props passed via addWrappers({ type, props }).
     * ng-forge delivers wrapper config properties (with `type` stripped) as individual inputs.
     */
    readonly props: _angular_core.InputSignal<DbxForgeArrayFieldWrapperProps | undefined>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    readonly labelSignal: _angular_core.Signal<_ng_forge_dynamic_forms.DynamicText>;
    readonly hintSignal: _angular_core.Signal<_ng_forge_dynamic_forms.DynamicText>;
    readonly disableRearrangeSignal: _angular_core.Signal<boolean>;
    readonly allowAddSignal: _angular_core.Signal<boolean>;
    readonly addTextSignal: _angular_core.Signal<string>;
    readonly addButtonStyleSignal: _angular_core.Signal<DbxButtonStyle>;
    /**
     * Current item count read reactively from the form value.
     */
    readonly itemCountSignal: _angular_core.Signal<number>;
    /**
     * Whether the array has reached its configured `maxLength`. When true, the
     * add button is disabled. Returns false when `maxLength` is not set.
     */
    readonly atMaxLengthSignal: _angular_core.Signal<boolean>;
    /**
     * Add button disabled state — combines the standard disabled flag with the
     * `maxLength` cap so clicking past the limit is prevented.
     */
    readonly addButtonDisabledSignal: _angular_core.Signal<boolean>;
    drop(event: CdkDragDrop<unknown>): void;
    /**
     * Returns the array field key from the wrapper's field inputs.
     *
     * @returns The array field key, or an empty string if not available.
     */
    private _arrayKey;
    /**
     * Returns the item template from the wrapper props.
     *
     * ng-forge requires an explicit template for every dynamic add operation.
     * The template is the container field definition (with element wrappers)
     * built by {@link dbxForgeArrayField} and passed via wrapper props.
     *
     * @returns The array item definition template, or undefined if not configured.
     */
    private _itemTemplate;
    /**
     * Returns the current items for this array field.
     *
     * Reads the parent form value from {@link DbxForgeFormContextService} (which
     * mirrors `DynamicForm.formValue()`) and indexes by the array's key. The
     * wrapper's `fieldInputs.field.value()` is unreliable here — it reports
     * undefined in some render phases — so we source the value from the
     * DynamicForm signal instead.
     *
     * @returns The current array items, or an empty array if unavailable.
     */
    private _readArrayValue;
    /**
     * Moves an array item from one index to another.
     *
     * Strategy:
     * 1. Insert a new item at toIndex (ng-forge creates a new resolved item)
     * 2. Remove the original item at fromIndex (adjusted for the insertion shift)
     * 3. Patch the form value so the moved item's data ends up at the correct position
     *
     * @param fromIndex - The source index of the item to move.
     * @param toIndex - The destination index for the item.
     */
    move(fromIndex: number, toIndex: number): void;
    /**
     * Appends a new item to the end of the array using the item template.
     *
     * No-ops when the array has reached its configured `maxLength`.
     */
    addItem(): void;
    /**
     * Removes an item at the given index.
     *
     * @param index - The index of the item to remove.
     */
    removeItem(index: number): void;
    /**
     * Duplicates the item at `fromIndex`, inserting a copy at `toIndex`.
     *
     * ng-forge's array slots are managed through `arrayEvent` dispatches — writing
     * a bigger value into the form doesn't create a new slot. We read the source
     * item from the form value, stamp its fields onto the template via
     * {@link dbxForgeArrayFieldTemplateWithItemValues}, and dispatch `insertAt`
     * so the slot is registered AND initialized with the duplicated values in a
     * single event (back-to-back dispatches don't settle reliably).
     *
     * @param fromIndex - The index of the item to duplicate.
     * @param toIndex - The index at which to insert the duplicated item.
     */
    duplicateItem(fromIndex: IndexNumber, toIndex: IndexNumber): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeArrayFieldWrapperComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeArrayFieldWrapperComponent, "dbx-forge-array-field-wrapper", never, { "fieldInputs": { "alias": "fieldInputs"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Forge wrapper component that wraps a single array item with
 * a drag handle, item label, and remove button.
 */
declare class DbxForgeArrayFieldElementWrapperComponent implements FieldWrapper {
    readonly fieldComponent: _angular_core.Signal<ViewContainerRef>;
    private readonly parent;
    private readonly formContextService;
    readonly arrayContext: _ng_forge_dynamic_forms_internal.ArrayContext;
    readonly isDisabled: _angular_core.Signal<boolean>;
    readonly fieldInputs: _angular_core.InputSignal<WrapperFieldInputs | undefined>;
    readonly props: _angular_core.InputSignal<DbxForgeArrayFieldElementWrapperProps<unknown> | undefined>;
    readonly disableRearrangeSignal: _angular_core.Signal<boolean>;
    readonly showIndexChipSignal: _angular_core.Signal<boolean>;
    readonly indexChipDisplaySignal: _angular_core.Signal<DbxChipDisplay>;
    readonly allowRemoveSignal: _angular_core.Signal<boolean>;
    readonly removeTextSignal: _angular_core.Signal<string>;
    readonly removeButtonStyleSignal: _angular_core.Signal<DbxButtonStyle>;
    /**
     * Resolves {@link DbxForgeArrayFieldElementWrapperProps.allowDuplicate} to either
     * `false` (hide the button) or a target {@link IndexNumber}. `true` maps to the
     * default insert position — immediately after the source item.
     */
    readonly duplicateTargetIndexSignal: _angular_core.Signal<number | false>;
    readonly allowDuplicateSignal: _angular_core.Signal<boolean>;
    readonly duplicateButtonSignal: _angular_core.Signal<DbxButtonDisplayStylePair>;
    readonly labelSignal: _angular_core.Signal<string>;
    removeItem(): void;
    duplicateItem(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeArrayFieldElementWrapperComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeArrayFieldElementWrapperComponent, "dbx-forge-array-field-element-wrapper", never, { "fieldInputs": { "alias": "fieldInputs"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Registered wrapper type name for the flex layout wrapper.
 */
declare const DBX_FORGE_FLEX_WRAPPER_TYPE_NAME: "dbx-forge-flex";
/**
 * Wrapper config for the flex layout wrapper.
 *
 * Provides responsive flex layout behavior via the `dbxFlexGroup` directive.
 */
interface DbxForgeFlexWrapper {
    readonly type: typeof DBX_FORGE_FLEX_WRAPPER_TYPE_NAME;
    /**
     * Breakpoint based on the screen width below which fields stack.
     */
    readonly breakpoint?: ScreenMediaWidthType;
    /**
     * Whether to use relative sizing (removes max-width constraints).
     */
    readonly relative?: boolean;
    /**
     * Whether to break to a column layout when the breakpoint is reached.
     */
    readonly breakToColumn?: boolean;
}
/**
 * Configuration for a single field within a flex layout,
 * pairing a field definition with an optional flex size.
 */
interface DbxForgeFlexLayoutFieldConfig {
    readonly field: FieldDef<unknown>;
    /**
     * Flex space sizing for the field (1-6). Defaults to the layout-level default size.
     */
    readonly size?: DbxFlexSize;
}
/**
 * Default configuration for a flex layout, combining flex wrapper settings
 * with a default size for fields that don't specify their own.
 */
interface DbxForgeFlexLayoutConfig extends Omit<DbxForgeFlexWrapper, 'type'> {
    /**
     * Fields to include in the layout. Each entry may be a plain {@link FieldDef}
     * or a {@link DbxForgeFlexLayoutFieldConfig} with a per-field size override.
     */
    readonly fields?: readonly (FieldDef<unknown> | DbxForgeFlexLayoutFieldConfig)[];
    /**
     * Default flex size for fields that don't specify their own.
     *
     * @defaultValue 2
     */
    readonly size?: DbxFlexSize;
}
/**
 * Preferred overload: configure the flex layout with a single {@link DbxForgeFlexLayoutConfig} object.
 *
 * @param config - Layout configuration carrying `fields` and breakpoint/sizing defaults.
 * @returns A {@link ContainerField} with the flex wrapper applied and per-child sizing classes.
 */
declare function dbxForgeFlexLayout(config: DbxForgeFlexLayoutConfig): ContainerField;

/**
 * Registered wrapper type name for the Material-style form-field wrapper.
 *
 * Used in {@link WrapperConfig.type} to identify this wrapper when building
 * wrapper chains via {@link dbxForgeMaterialFormFieldWrappedFieldFunction}.
 */
declare const DBX_FORGE_FORM_FIELD_WRAPPER_NAME: "dbx-forge-form-field-wrapper";
/**
 * Where the form-field wrapper should render the field's primary label.
 *
 * - `'wrapper'` — render the label in the notched outline only (default).
 * - `'content'` — suppress the notch label so the inner field can render its own
 *   label (used by checkbox/toggle, whose Material elements render their label inline).
 * - `'both'` — render the label in the notch AND let the inner field render its own.
 * - `'none'` — render no label in the notch and rely solely on `contentLabel`.
 */
type DbxForgeFormFieldWrapperShowLabelAt = 'wrapper' | 'content' | 'both' | 'none';
/**
 * Props for the form-field wrapper. Passed via `addWrappers({ type, props })`
 * and exposed to the wrapper component as a single `props` input.
 */
interface DbxForgeFormFieldWrapperProps {
    /**
     * Optional label override for the notch.
     *
     * When set, this replaces the field's primary label inside the notched outline.
     * Has no effect when {@link showLabelAt} is `'content'` or `'none'`.
     */
    readonly label?: DynamicText;
}
/**
 * Marker interface for a wrapper config that targets the form-field wrapper.
 */
interface DbxForgeFormFieldWrapperDef {
    readonly type: typeof DBX_FORGE_FORM_FIELD_WRAPPER_NAME;
    readonly props?: DbxForgeFormFieldWrapperProps;
}
/**
 * Adds the Material-style form-field wrapper ({@link DBX_FORGE_FORM_FIELD_WRAPPER_NAME}) to
 * the builder instance's wrapper chain so the rendered field is surrounded by the shared
 * label / hint / error chrome.
 *
 * @param instance - The field builder instance to mutate.
 */
declare function configureDbxForgeFormFieldWrapper<C extends DbxForgeFieldFunctionDef<any>>(instance: DbxForgeFieldFunctionFieldDefBuilderFunctionInstance<C>): void;
/**
 * Returns a configurator that adds the form-field wrapper with the given props.
 *
 * Use this from a field factory's `buildFieldDef` step to attach the wrapper and
 * pass props (such as `showLabelAt` / `contentLabel`) through to the wrapper component.
 *
 * Undefined entries in `props` are dropped, and `props` is omitted from the wrapper
 * config entirely when no values remain — keeps the wrapper bare in the common case
 * (e.g. a checkbox/toggle with no label override).
 *
 * @param inputProps - Wrapper props applied to the inserted wrapper config; undefined entries are stripped and the `props` block is omitted entirely when no values remain.
 * @returns A configurator that mutates the builder instance to add the form-field wrapper with the resolved props.
 */
declare function configureDbxForgeFormFieldWrapperWith(inputProps?: Maybe<DbxForgeFormFieldWrapperProps>): <C extends DbxForgeFieldFunctionDef<any>>(instance: DbxForgeFieldFunctionFieldDefBuilderFunctionInstance<C>) => void;

/**
 * Forge wrapper field component that renders child fields inside a Material-style
 * outlined container with a notched outline, floating label, and hint/error subscript.
 *
 * Reads wrapper config (label, hint, className) from component inputs
 * and the parent {@link FieldSignalContext} to observe form validation state.
 */
declare class DbxForgeFormFieldWrapperComponent implements FieldWrapper {
    readonly fieldComponent: _angular_core.Signal<ViewContainerRef>;
    readonly fieldInputs: _angular_core.InputSignal<WrapperFieldInputs | undefined>;
    /**
     * Wrapper config props passed via `addWrappers({ type, props })`.
     * ng-forge delivers wrapper config properties (with `type` stripped) as individual inputs.
     */
    readonly props: _angular_core.InputSignal<DbxForgeFormFieldWrapperProps | undefined>;
    private readonly formStateSignal;
    readonly isDisabledSignal: _angular_core.Signal<boolean | undefined>;
    /**
     * Resolved notch label. Prefers a wrapper-level `props.label` override and
     * falls back to the wrapped field's own label.
     */
    readonly labelSignal: _angular_core.Signal<_ng_forge_dynamic_forms.DynamicText | undefined>;
    readonly hintSignal: _angular_core.Signal<any>;
    readonly classNameSignal: _angular_core.Signal<string>;
    private readonly keySignal;
    private readonly childErrorsSignal;
    /**
     * Whether errors should be displayed.
     *
     * Shows when the field is invalid and has errors. Does not gate on touched/dirty
     * because this wrapper targets non-standard fields (sliders, custom components)
     * where standard blur-based touch behavior may not apply.
     */
    readonly showErrorsSignal: _angular_core.Signal<boolean>;
    readonly hasError: _angular_core.Signal<boolean>;
    /**
     * Resolves the first error message using the same priority as ng-forge's
     * `resolveErrorMessage`: field-level `validationMessages` -> form-level
     * `defaultValidationMessages` -> `error.message` -> error kind.
     *
     * Uses `interpolateParams` for `{{param}}` placeholder substitution.
     */
    readonly firstErrorMessageSignal: _angular_core.Signal<string>;
    /**
     * Whether any child field has `required` state, used to show the asterisk in the label.
     */
    readonly isRequiredSignal: _angular_core.Signal<boolean | undefined>;
    protected readonly labelIdSignal: _angular_core.Signal<string>;
    protected readonly errorIdSignal: _angular_core.Signal<string>;
    protected readonly hintIdSignal: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeFormFieldWrapperComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeFormFieldWrapperComponent, "dbx-forge-form-field-wrapper", never, { "fieldInputs": { "alias": "fieldInputs"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Registered wrapper type name for the section wrapper.
 *
 * Used in {@link WrapperConfig.type} to identify this wrapper when building
 * wrapper chains.
 */
declare const DBX_FORGE_SECTION_WRAPPER_TYPE_NAME: "dbx-forge-section";
/**
 * Configuration for the section wrapper type.
 *
 * Wraps child fields inside a `<dbx-section>` or `<dbx-subsection>` component
 * with proper semantic structure, header, and content area styling.
 *
 * @example
 * ```typescript
 * const wrapper: DbxForgeSectionWrapper = {
 *   type: 'dbx-forge-section',
 *   headerConfig: { header: 'Contact Info', h: 3 },
 *   elevate: true,
 * };
 * ```
 */
interface DbxForgeSectionWrapper {
    readonly type: typeof DBX_FORGE_SECTION_WRAPPER_TYPE_NAME;
    /**
     * Section header configuration.
     */
    readonly headerConfig: DbxSectionHeaderConfig;
    /**
     * Whether to apply elevated card styling to the section.
     */
    readonly elevate?: boolean;
    /**
     * Whether to render as a `<dbx-subsection>` instead of `<dbx-section>`.
     */
    readonly subsection?: boolean;
}
/**
 * Section wrapper config — attach via a field's `wrappers: []` array for a semantic section with header and optional card elevation.
 *
 * @param config - The section wrapper configuration without the `type` property.
 * @returns A complete {@link DbxForgeSectionWrapper} config with the type set.
 *
 * @dbxFormField
 * @dbxFormSlug section-wrapper
 * @dbxFormTier primitive
 * @dbxFormProduces WrapperConfig
 * @dbxFormReturns WrapperConfig
 * @dbxFormArrayOutput no
 * @dbxFormConfigInterface DbxForgeSectionWrapper
 *
 * @example
 * ```typescript
 * dbxForgeSectionWrapper({ headerConfig: { text: 'Contact Details' } })
 * ```
 */
declare function dbxForgeSectionWrapper(config: Omit<DbxForgeSectionWrapper, 'type'>): DbxForgeSectionWrapper;
/**
 * Subsection variant of `section-wrapper` — defaults to heading level 4 and `subsection: true`.
 *
 * @param config - The subsection wrapper configuration without the `type` and `subsection` properties.
 * @returns A complete {@link DbxForgeSectionWrapper} config with `type` and `subsection: true` set.
 *
 * @dbxFormField
 * @dbxFormSlug subsection-wrapper
 * @dbxFormTier primitive
 * @dbxFormProduces WrapperConfig
 * @dbxFormReturns WrapperConfig
 * @dbxFormArrayOutput no
 * @dbxFormConfigInterface DbxForgeSectionWrapper
 *
 * @example
 * ```typescript
 * dbxForgeSubsectionWrapper({ headerConfig: { text: 'Options' } })
 * ```
 */
declare function dbxForgeSubsectionWrapper(config: Omit<DbxForgeSectionWrapper, 'type' | 'subsection'>): DbxForgeSectionWrapper;

declare const FORGE_INFO_BUTTON_FIELD_TYPE_NAME: "dbx-forge-info-button";
/**
 * Props interface for the forge info button field.
 */
interface DbxForgeInfoButtonFieldProps {
    /**
     * Callback invoked when the info button is clicked.
     */
    readonly onInfoClick: () => void;
    /**
     * Accessible label for the info button.
     */
    readonly ariaLabel?: string;
}
/**
 * Forge field definition for an info button.
 */
interface DbxForgeInfoButtonFieldDef extends BaseValueField<DbxForgeInfoButtonFieldProps, unknown> {
    readonly type: typeof FORGE_INFO_BUTTON_FIELD_TYPE_NAME;
}

/**
 * Registered wrapper type name for the info wrapper.
 *
 * Used in {@link WrapperConfig.type} to identify this wrapper when building
 * wrapper chains.
 */
declare const DBX_FORGE_INFO_WRAPPER_TYPE_NAME: "dbx-forge-info";
/**
 * Configuration for the info wrapper type.
 *
 * Renders an info icon button beside the wrapped content inside a flex layout.
 *
 * @example
 * ```typescript
 * const wrapper: DbxForgeInfoWrapper = {
 *   type: 'dbx-forge-info',
 *   onInfoClick: () => openHelpDialog(),
 *   ariaLabel: 'Show help for this field',
 * };
 * ```
 */
interface DbxForgeInfoWrapper {
    readonly type: typeof DBX_FORGE_INFO_WRAPPER_TYPE_NAME;
    /**
     * Callback invoked when the info button is clicked.
     */
    readonly onInfoClick: () => void;
    /**
     * Accessible label for the info button.
     */
    readonly ariaLabel?: string;
}
/**
 * Creates an info wrapper config for use in a field's `wrappers` array.
 *
 * @param config - The info wrapper configuration without the `type` property.
 * @returns A complete {@link DbxForgeInfoWrapper} config with the type set.
 *
 * @example
 * ```typescript
 * dbxForgeNameField({
 *   wrappers: [dbxForgeInfoWrapper({ onInfoClick: () => openHelp() })]
 * })
 * ```
 */
declare function dbxForgeInfoWrapper(config: Omit<DbxForgeInfoWrapper, 'type'>): DbxForgeInfoWrapper;

/**
 * Registered wrapper type name for the style wrapper.
 *
 * Used in {@link WrapperConfig.type} to identify this wrapper when building
 * wrapper chains.
 */
declare const DBX_FORGE_STYLE_WRAPPER_TYPE_NAME: "dbx-forge-style";
/**
 * A map of CSS style properties to their values, used with `[ngStyle]`.
 */
type DbxForgeStyleObject = {
    [styleProperty: string]: unknown;
};
/**
 * Configuration for the style wrapper type.
 *
 * Applies dynamic CSS classes and inline styles around wrapped content.
 * Supports both static values and reactive observables via `ObservableOrValue`.
 *
 * @example
 * ```typescript
 * const wrapper: DbxForgeStyleWrapper = {
 *   type: 'dbx-forge-style',
 *   classGetter: 'highlight-section',
 *   styleGetter: { background: 'rgba(255,0,0,0.3)' },
 * };
 * ```
 */
interface DbxForgeStyleWrapper {
    readonly type: typeof DBX_FORGE_STYLE_WRAPPER_TYPE_NAME;
    /**
     * Observable or static value providing CSS class names via `[ngClass]`.
     */
    readonly classGetter?: MaybeObservableOrValue<string>;
    /**
     * Observable or static value providing inline styles via `[ngStyle]`.
     */
    readonly styleGetter?: MaybeObservableOrValue<DbxForgeStyleObject>;
}
/**
 * Style wrapper config — applies dynamic CSS classes (`ngClass`) and/or inline styles (`ngStyle`) to any field via its `wrappers: []`.
 *
 * @param config - The style wrapper configuration without the `type` property.
 * @returns A complete {@link DbxForgeStyleWrapper} config with the type set.
 *
 * @dbxFormField
 * @dbxFormSlug style-wrapper
 * @dbxFormTier primitive
 * @dbxFormProduces WrapperConfig
 * @dbxFormReturns WrapperConfig
 * @dbxFormArrayOutput no
 * @dbxFormConfigInterface DbxForgeStyleWrapper
 *
 * @example
 * ```typescript
 * dbxForgeStyleWrapper({ classGetter: 'highlighted' })
 * ```
 */
declare function dbxForgeStyleWrapper(config: Omit<DbxForgeStyleWrapper, 'type'>): DbxForgeStyleWrapper;

/**
 * Forge wrapper component that renders child fields with a loading
 * indicator shown during async validation.
 *
 * Implements {@link FieldWrapper} and monitors the field tree's
 * pending signal to detect when async validators are running.
 */
declare class DbxForgeWorkingWrapperComponent implements FieldWrapper {
    readonly fieldComponent: _angular_core.Signal<ViewContainerRef>;
    private readonly fieldSignalContext;
    readonly showLoadingSignal: _angular_core.Signal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeWorkingWrapperComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeWorkingWrapperComponent, "dbx-forge-working-wrapper", never, {}, {}, never, never, true, never>;
}

/**
 * Registered wrapper type name for the working wrapper.
 *
 * Used in {@link WrapperConfig.type} to identify this wrapper when building
 * wrapper chains.
 */
declare const DBX_FORGE_WORKING_WRAPPER_TYPE_NAME: "dbx-forge-working-wrapper";
/**
 * Configuration for the working wrapper type.
 *
 * Shows an indeterminate progress bar when any child field has pending
 * async validation. No additional configuration is needed — the wrapper
 * monitors the form tree's pending state automatically.
 *
 * @example
 * ```typescript
 * const wrapper: DbxForgeWorkingWrapper = {
 *   type: 'dbx-forge-working-wrapper',
 * };
 * ```
 */
interface DbxForgeWorkingWrapper {
    readonly type: typeof DBX_FORGE_WORKING_WRAPPER_TYPE_NAME;
}

/**
 * Abstract injectable that exposes the active {@link DynamicForm} instance as a signal.
 *
 * Implemented by {@link DbxForgeFormComponent} and provided via
 * `{ provide: DbxForgeDynamicFormSignalRef, useExisting: DbxForgeFormComponent }`.
 *
 * Services provided at the forge-component level cannot inject ng-forge's
 * `RootFormRegistryService` (which is provided BY `DynamicForm`, a child of
 * {@link DbxForgeFormComponent}). This abstract ref lets higher-level services
 * ({@link DbxForgeFormContextService}) reactively read from DynamicForm without
 * relying on its injector.
 */
declare abstract class DbxForgeDynamicFormSignalRef {
    abstract readonly dynamicForm: Signal<DynamicForm<any, any> | undefined>;
}
/**
 * Input for {@link DbxForgeFormContextService.createArrayItemEvaluationContext}.
 */
interface DbxForgeArrayItemEvaluationContextInput {
    /**
     * The array context for the current array item, retrieved via `inject(ARRAY_CONTEXT)`
     * inside an array element wrapper.
     */
    readonly arrayContext: ArrayContext;
    /**
     * When true, reads from the form value / array index signals create reactive
     * dependencies so a consuming `computed()` re-evaluates on change.
     *
     * When false (default), reads are wrapped in `untracked()` to prevent cycles
     * in validators and similar non-reactive callers.
     */
    readonly reactive?: boolean;
}
/**
 * Provides {@link EvaluationContext} objects for dbx-forge wrapper and field components.
 *
 * Mirrors the subset of ng-forge's internal `FieldContextRegistryService` that we can
 * build from the public API. Provided at the {@link DbxForgeFormComponent} level so
 * every descendant wrapper/field can inject it without repeating providers.
 *
 * Reads form state via {@link DbxForgeDynamicFormSignalRef} — ng-forge's
 * `RootFormRegistryService` is provided below the forge component and is not
 * reachable from this injector level.
 *
 * Currently supports array-item-scoped contexts. Field-level and display-only
 * contexts may be added later as needs arise.
 */
declare class DbxForgeFormContextService {
    private readonly _signalRef;
    private readonly _logger;
    /**
     * The active {@link DynamicForm} instance (undefined until the view-child resolves).
     */
    readonly dynamicForm: Signal<DynamicForm<any, any> | undefined>;
    /**
     * Current form value as a plain record. Empty object when the DynamicForm hasn't
     * mounted yet.
     */
    readonly formValue: Signal<Record<string, unknown>>;
    /**
     * The active Signal Form tree, or undefined until the DynamicForm mounts.
     */
    readonly rootForm: Signal<FieldTree<Record<string, unknown>> | undefined>;
    /**
     * Builds an {@link EvaluationContext} scoped to the current array item.
     *
     * - `fieldValue` is the current item.
     * - `formValue` is the current item (item-scoped, matching ng-forge's buildArrayScopedContext).
     * - `rootFormValue` is the full form.
     * - `arrayIndex` / `arrayPath` come from the provided {@link ArrayContext}.
     * - `fieldPath` is `"${arrayKey}.${index}"`.
     *
     * Falls back to the root form value as `formValue` when the array item lookup fails
     * (bad index, missing array, or non-object item).
     *
     * @param input - Configuration specifying the array context and reactivity mode.
     * @returns An evaluation context scoped to the array item at the current index.
     */
    createArrayItemEvaluationContext(input: DbxForgeArrayItemEvaluationContextInput): EvaluationContext;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeFormContextService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DbxForgeFormContextService>;
}

/**
 * Wraps ng-forge's DynamicForm and bridges it to the DbxForm system.
 *
 * Uses ng-forge's signal-based form value and derives DbxFormEvent state
 * from signal reads rather than complex Observable chains.
 */
declare class DbxForgeFormComponent<T extends object = object> implements DbxForgeDynamicFormSignalRef, OnInit {
    private readonly _context;
    private readonly _setValueSub;
    private readonly _resetSub;
    private readonly _disabledSub;
    readonly dynamicForm: _angular_core.Signal<DynamicForm<_ng_forge_dynamic_forms.RegisteredFieldTypes[], Record<string, unknown>> | undefined>;
    readonly formValue: _angular_core.WritableSignal<T>;
    readonly configSignal: _angular_core.Signal<_ng_forge_dynamic_forms.FormConfig<_ng_forge_dynamic_forms.RegisteredFieldTypes[], {
        [x: string]: unknown[];
    } & {
        [x: string]: unknown[];
    } & {
        [x: string]: unknown[];
    } & {
        [x: string]: unknown[];
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | number | boolean | (string | number | boolean)[];
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string | undefined;
    } & {
        [x: string]: string[] | number[] | number[] | number[] | number[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | (string | number | boolean | (string | number | boolean)[])[] | number[] | string[] | string[] | boolean[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | string[] | number[] | boolean[] | string[] | string[] | string[] | ({
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | number | boolean | (string | number | boolean)[];
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: string | undefined;
        } & {
            [x: string]: unknown[];
        } & {
            [x: string]: unknown[];
        } & {
            [x: string]: unknown[];
        } & {
            [x: string]: unknown[];
        } & {
            [x: string]: Record<string, unknown>;
        } & {
            [x: string]: string | undefined;
        })[];
    } & {
        [x: string]: Record<string, unknown>;
    } & {
        [x: string]: unknown[];
    } & {
        [x: string]: string | undefined;
    }, Record<string, unknown>, unknown> | undefined>;
    private readonly _changesCount;
    private readonly _lastResetAt;
    private readonly _isReset;
    private readonly _disabled;
    /**
     * True once ng-forge has finished its synchronous initialization: the config
     * has arrived, the DynamicForm view child is populated, and ng-forge has
     * performed its initial field-default writebacks via the two-way [(value)]
     * binding. A setValue that arrives before this point would be clobbered by
     * those writebacks, so we queue it until ready.
     *
     * The form is kept in RESET state while not ready so that
     * {@link DbxFormSourceDirective} 'reset' mode still forwards an
     * asynchronously-resolving value once it arrives.
     */
    private readonly _formReady;
    /**
     * A setValue payload received while {@link _formReady} was false. Applied
     * once ready; only the most recent pending value is retained.
     *
     * Wrapped in a single-element object so we can distinguish "no pending
     * value" (undefined) from "pending value of undefined/null" (object present
     * with a null/undefined inner value).
     */
    private _pendingValue;
    readonly isDisabledSignal: _angular_core.Signal<boolean>;
    readonly formOptionsSignal: _angular_core.Signal<FormOptions | undefined>;
    /**
     * Computed validity combining the ng-forge DynamicForm's valid signal with
     * validity from all registered wrapper nested forms.
     *
     * Wrapper fields (forgeFormFieldWrapper, section wrapper, etc.) create
     * isolated DynamicForm instances whose validity is not visible to the parent
     * DynamicForm.valid(). They register their nested validity via
     * {@link DbxForgeFormContext.registerWrapperValidity}, and this computed combines both sources.
     */
    readonly formValidSignal: _angular_core.Signal<boolean>;
    /**
     * Track form value changes and update the context value + changes count.
     *
     * Only `formValue()` is tracked — all other signal reads use `untracked()`
     * to avoid infinite re-triggering from writing back to signals in this effect.
     *
     * While the form is not yet ready (see {@link _formReady}), any formValue
     * change that arrives through ng-forge's two-way [(value)] binding is
     * treated as an initialization artifact: the context value is still synced,
     * but the form is held in RESET state (changesCount clamped at 1) so that
     * {@link DbxFormSourceDirective} in 'reset' mode can still forward an
     * async source value once it arrives.
     */
    protected readonly _formValueEffect: _angular_core.EffectRef;
    /**
     * Marks the form as ready once the ng-forge DynamicForm view child is
     * populated. The viewChild signal updates after ng-forge has completed its
     * synchronous initialization (including any field-default writebacks), so
     * setting ready here is safe — the writebacks have already happened and
     * been absorbed by the not-ready branch of {@link _formValueEffect}.
     *
     * Applies any queued setValue payload immediately upon becoming ready so
     * that the user-intended value wins over ng-forge's defaults.
     */
    protected readonly _formReadyEffect: _angular_core.EffectRef;
    /**
     * Expose the parent DynamicForm's field tree to the context so wrapper components
     * can write to sibling hidden fields in the parent form.
     */
    protected readonly _parentFormTreeEffect: _angular_core.EffectRef;
    /**
     * Track validity changes from the DynamicForm and update the context.
     *
     * Separated from the value effect so that validity changes (e.g. async validators resolving)
     * update isComplete and status without incrementing changesCount.
     */
    protected readonly _validityEffect: _angular_core.EffectRef;
    protected _emitFormState(): void;
    /**
     * The last value passed to setValue, used as the reset target.
     * Mirrors formly's behavior where resetForm() restores the initial value
     * rather than clearing to `{}`. This prevents ng-forge's two-way [(value)]
     * binding from writing back empty field defaults that overwrite a
     * subsequent dbxFormSource re-apply.
     */
    private _initialValue;
    ngOnInit(): void;
    private _resetState;
    private _applySetValueNow;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeFormComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeFormComponent<any>, "dbx-forge", never, {}, {}, never, never, true, never>;
}
/**
 * Deep-equality comparator for the {@link DbxForgeFormComponent.formValue} signal.
 *
 * ng-forge's outward sync effect writes entity values back through the
 * `[(value)]` two-way binding. Each write creates a new object reference even
 * when the content is identical. Without this guard the `_formValueEffect`
 * re-fires on every write-back, which triggers `updateValue` (stripping
 * internal/empty keys) and `_emitFormState`, creating an infinite effect cycle
 * that leads to OOM.
 *
 * The filter used depends on the context's configuration:
 * - Custom {@link DbxForgeFormContext.formValuePojoFilter} if set
 * - Default filter that strips `_`-prefixed keys and null/undefined values
 *   when {@link DbxForgeFormContext.stripInternalKeys} is true (default)
 * - Null/undefined-only filter when `stripInternalKeys` is false
 *
 * @param a - The previous form value.
 * @param b - The next form value.
 * @param context - The forge form context providing filter configuration.
 * @returns True if the two values are considered equal after filtering.
 */
declare function _forgeFormValueEqual<T>(a: T, b: T, context: DbxForgeFormContext<T>): boolean;
/**
 * Default filter: strips `_`-prefixed keys (ng-forge internal/layout keys),
 * null/undefined values, and NaN values before deep equality comparison.
 *
 * The `_`-prefixed keys can reference complex, self-referencing ng-forge
 * objects (field trees, form instances) that cause stack overflows during
 * recursive comparison. They are layout artifacts and irrelevant for
 * value equality. NaN values are stripped because `NaN === NaN` is false,
 * which would otherwise cause `_forgeFormValueEqual` to treat two structurally
 * identical values as unequal and trigger an infinite effect cycle.
 *
 * @param input - The form value object to filter.
 * @returns A filtered copy with internal keys and null/undefined/NaN values removed.
 */
declare function _filterForgeFormValueStripInternal<T>(input: T): T;
/**
 * Filter used when `stripInternalKeys` is false: retains `_`-prefixed keys
 * but still strips null/undefined and NaN values.
 *
 * @param input - The form value object to filter.
 * @returns A filtered copy with null/undefined/NaN values removed but internal keys retained.
 */
declare function _filterForgeFormValueKeepInternal<T>(input: T): T;

/**
 * Default template for a view that extends AbstractSyncForgeFormDirective or AbstractConfigAsyncForgeFormDirective.
 */
declare const DBX_FORGE_FORM_COMPONENT_TEMPLATE: "<dbx-forge></dbx-forge>";

/**
 * Default imports module for a view that extends AbstractSyncForgeFormDirective or AbstractConfigAsyncForgeFormDirective.
 */
declare class DbxForgeFormComponentImportsModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeFormComponentImportsModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<DbxForgeFormComponentImportsModule, never, [typeof DbxForgeFormComponent], [typeof DbxForgeFormComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<DbxForgeFormComponentImportsModule>;
}

/**
 * Base directive for forge form components. Injects the DbxForgeFormContext and
 * provides utility methods for form interaction.
 */
declare abstract class AbstractForgeFormDirective<T = unknown> {
    readonly context: DbxForgeFormContext<T>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    protected readonly _disabledEffect: _angular_core.EffectRef;
    getValue(): Observable<T>;
    setValue(value: Maybe<Partial<T>>): void;
    resetForm(): void;
    clearValue(): void;
    setDisabled(key?: DbxFormDisabledKey, disabled?: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractForgeFormDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractForgeFormDirective<any>, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
/**
 * Base directive for forge forms with static (synchronous) FormConfig.
 */
declare abstract class AbstractSyncForgeFormDirective<T = unknown> extends AbstractForgeFormDirective<T> implements OnInit {
    abstract readonly formConfig: FormConfig;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractSyncForgeFormDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractSyncForgeFormDirective<any>, never, never, {}, {}, never, never, true, never>;
}
/**
 * Base directive for forge forms with dynamic (Observable) FormConfig.
 */
declare abstract class AbstractAsyncForgeFormDirective<T = unknown> extends AbstractForgeFormDirective<T> implements OnInit {
    abstract readonly formConfig$: Observable<Maybe<FormConfig>>;
    private readonly _configSub;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractAsyncForgeFormDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractAsyncForgeFormDirective<any>, never, never, {}, {}, never, never, true, never>;
}
/**
 * Base directive for forge forms driven by an external config input that gets
 * transformed into a FormConfig Observable.
 *
 * Uses toObservable to convert the signal-based input into an Observable stream,
 * then pipes through maybeValueFromObservableOrValue to unwrap nested observables.
 */
declare abstract class AbstractConfigAsyncForgeFormDirective<T = unknown, C = unknown> extends AbstractAsyncForgeFormDirective<T> {
    /**
     * The forge form config input.
     */
    readonly config: _angular_core.ModelSignal<MaybeObservableOrValue<C>>;
    readonly currentConfig$: Observable<Maybe<C>>;
    /**
     * Subclasses must implement this to map C → FormConfig.
     * For simple cases where C is FormConfig, just pipe through directly.
     */
    abstract readonly formConfig$: Observable<Maybe<FormConfig>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractConfigAsyncForgeFormDirective<any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractConfigAsyncForgeFormDirective<any, any>, never, never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "config": "configChange"; }, never, never, true, never>;
}

/**
 * A basic forge form that takes in the config and passes it off as form-config.
 *
 * Useful for tests.
 */
declare class DbxForgeAsyncConfigFormComponent<O = unknown, C extends FormConfig = FormConfig> extends AbstractConfigAsyncForgeFormDirective<O, C> {
    readonly formConfig$: Observable<Maybe<FormConfig>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeAsyncConfigFormComponent<any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgeAsyncConfigFormComponent<any, any>, "dbx-forge-form", never, {}, {}, never, never, true, never>;
}

/**
 * Root-provided service that holds the {@link DbxForgeGlobalFormConfigDefaults} applied
 * as the lowest-priority layer during {@link dbxForgeFinalizeFormConfig} merging.
 *
 * Seeded with {@link dbxForgeDefaultValidationMessages} so apps receive the standard
 * dbx-form validation messages without any explicit configuration.
 */
declare class DbxForgeGlobalDefaultConfigService {
    private _defaults;
    /**
     * Returns the current global defaults applied to every finalized forge form config.
     *
     * @returns The active {@link DbxForgeGlobalFormConfigDefaults} object.
     *
     * @example
     * ```ts
     * const defaults = service.getGlobalDefaults();
     * ```
     */
    getGlobalDefaults(): DbxForgeGlobalFormConfigDefaults;
    /**
     * Replaces the entire global defaults object.
     *
     * @param value - The new {@link DbxForgeGlobalFormConfigDefaults} to apply.
     *
     * @example
     * ```ts
     * service.setGlobalDefaults({ defaultValidationMessages: { required: 'Required' } });
     * ```
     */
    setGlobalDefaults(value: DbxForgeGlobalFormConfigDefaults): void;
    /**
     * Replaces only the default validation messages on the global defaults, preserving
     * any other fields in the current defaults object.
     *
     * @param messages - The {@link ValidationMessages} to apply, or `undefined` to clear.
     *
     * @example
     * ```ts
     * service.setDefaultValidationMessages({ required: 'This field is required.' });
     * ```
     */
    setDefaultValidationMessages(messages: Maybe<ValidationMessages>): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgeGlobalDefaultConfigService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DbxForgeGlobalDefaultConfigService>;
}

/**
 * All custom dbx-form forge field type definitions.
 */
declare const DBX_FORGE_FIELD_TYPES: FieldTypeDefinition[];
/**
 * All custom dbx-form forge wrapper type definitions.
 */
declare const DBX_FORGE_FIELD_WRAPPER_TYPES: WrapperTypeDefinition[];
/**
 * Registers ng-forge dynamic form field declarations with Material Design field types
 * and custom dbx field types (phone, datetime, fixeddaterange, timeduration,
 * searchable text, searchable chip, text editor, component).
 *
 * Pass additional field types from extension packages (e.g. `DBX_FORGE_CALENDAR_FIELD_TYPES`,
 * `DBX_FORGE_MAPBOX_FIELD_TYPES`) to register them in the same `provideDynamicForm()` call.
 * Only one `provideDynamicForm()` call should exist per app — multiple calls overwrite
 * rather than merge.
 *
 * Add this to your app's providers alongside provideDbxFormConfiguration().
 *
 * @param additionalFieldTypes - Extra field type definitions from extension packages to register alongside the built-in types.
 * @returns The providers that register all forge field types with ng-forge's dynamic form system.
 *
 * @example
 * ```typescript
 * provideDbxForgeFormFieldDeclarations(
 *   ...DBX_FORGE_CALENDAR_FIELD_TYPES,
 *   ...DBX_FORGE_MAPBOX_FIELD_TYPES
 * )
 * ```
 */
declare function provideDbxForgeFormFieldDeclarations(...additionalFieldTypes: FieldTypeDefinition[]): _angular_core.EnvironmentProviders & {
    __fieldDefs?: undefined;
    __formValue?: unknown;
};

/**
 * Module augmentation that registers all custom dbx-form forge field types
 * with ng-forge's DynamicFormFieldRegistry.
 *
 * This enables TypeScript to recognize custom field types in FormConfig.fields
 * without requiring `as unknown` casts.
 *
 * @see https://www.ng-forge.com/dynamic-forms/custom/building-an-adapter
 */
type DbxForgeFieldRegistryAugmentation = void;

declare module '@ng-forge/dynamic-forms' {
    interface FieldRegistryLeaves {
        [FORGE_PHONE_FIELD_TYPE]: DbxForgePhoneFieldDef;
        [FORGE_DATETIME_FIELD_TYPE]: DbxForgeDateTimeFieldDef;
        [FORGE_FIXEDDATERANGE_FIELD_TYPE]: DbxForgeFixedDateRangeFieldDef;
        [FORGE_TIMEDURATION_FIELD_TYPE]: DbxForgeTimeDurationFieldDef;
        [DBX_FORGE_SEARCHABLE_TEXT_FIELD_TYPE_NAME]: DbxForgeSearchableTextFieldDef<any, any, any>;
        [DBX_FORGE_SEARCHABLE_CHIP_FIELD_TYPE_NAME]: DbxForgeSearchableChipFieldDef<any, any, any>;
        [FORGE_PICKABLE_CHIP_FIELD_TYPE]: DbxForgePickableChipFieldDef<any, any, any>;
        [FORGE_PICKABLE_LIST_FIELD_TYPE]: DbxForgePickableListFieldDef<any, any, any>;
        [FORGE_LIST_SELECTION_FIELD_TYPE]: DbxForgeListSelectionFieldDef<any, any, any>;
        [FORGE_VALUE_SELECTION_FIELD_TYPE]: DbxForgeValueSelectionFieldDef<any>;
        [FORGE_SOURCE_SELECT_FIELD_TYPE]: DbxForgeSourceSelectFieldDef<any, any>;
        [FORGE_TEXT_EDITOR_FIELD_TYPE]: DbxForgeTextEditorFieldDef;
        [FORGE_COMPONENT_FIELD_TYPE]: DbxForgeComponentFieldDef<any>;
    }
    interface FieldRegistryWrappers {
        [DBX_FORGE_ARRAY_FIELD_WRAPPER_NAME]: DbxForgeArrayFieldWrapperDef;
        [DBX_FORGE_ARRAY_FIELD_ELEMENT_WRAPPER_NAME]: DbxForgeArrayFieldElementWrapperDef;
        [DBX_FORGE_FORM_FIELD_WRAPPER_NAME]: DbxForgeFormFieldWrapperDef;
        [DBX_FORGE_SECTION_WRAPPER_TYPE_NAME]: DbxForgeSectionWrapper;
        [DBX_FORGE_STYLE_WRAPPER_TYPE_NAME]: DbxForgeStyleWrapper;
        [DBX_FORGE_INFO_WRAPPER_TYPE_NAME]: DbxForgeInfoWrapper;
        [DBX_FORGE_WORKING_WRAPPER_TYPE_NAME]: DbxForgeWorkingWrapper;
        [DBX_FORGE_FLEX_WRAPPER_TYPE_NAME]: DbxForgeFlexWrapper;
    }
}

interface DbxForgePresetSearchFormFieldsValue {
    readonly search: string;
}
interface DbxForgePresetSearchFormFieldsConfig {
    readonly key?: string;
    readonly label?: string;
    readonly placeholder?: string;
    /**
     * Escape hatch for Material form field styling (appearance, floatLabel, hideRequiredMarker, subscriptSizing, etc.).
     * Forwarded to the underlying forge text field's `props`. `type` is fixed to `'text'`.
     */
    readonly props?: Partial<Omit<MatInputProps, 'type'>>;
}
/**
 * Creates a forge field array for a simple search form with a single text input.
 *
 * @param config - Optional search field configuration with label and placeholder.
 * @returns The forge field defs for the search form.
 */
declare function dbxForgePresetSearchFormFields(config: Maybe<DbxForgePresetSearchFormFieldsConfig>): DbxForgeField<MatInputField>[];

declare class DbxForgePresetSearchFormComponent extends AbstractConfigAsyncForgeFormDirective<DbxForgePresetSearchFormFieldsValue, DbxForgePresetSearchFormFieldsConfig> {
    readonly search: _angular_core.OutputEmitterRef<string>;
    readonly formConfig$: Observable<Maybe<FormConfig>>;
    searchChanged(value: Maybe<DbxForgePresetSearchFormFieldsValue>): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxForgePresetSearchFormComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxForgePresetSearchFormComponent, "dbx-form-search-form", never, {}, { "search": "search"; }, never, never, true, never>;
}

/**
 * Validation kind used on the verify password field to indicate the passwords do not match.
 */
declare const DBX_FORGE_PASSWORDS_MATCH_VALIDATION_KIND = "passwordsMatch";
/**
 * Default validation message used when the passwords do not match.
 */
declare const DEFAULT_DBX_FORGE_PASSWORDS_MATCH_VALIDATION_MESSAGE = "The passwords do not match.";
/**
 * Default autocomplete value for password fields.
 */
declare const DEFAULT_DBX_FORGE_TEXT_PASSWORD_AUTOCOMPLETE = "current-password";
/**
 * Default autocomplete value for verify password fields.
 */
declare const DEFAULT_DBX_FORGE_TEXT_VERIFY_PASSWORD_AUTOCOMPLETE = "new-password";
/**
 * Configuration for a forge password field.
 */
interface DbxForgeTextPasswordFieldConfig extends Omit<DbxForgeTextFieldConfig, 'inputType' | 'key'>, Partial<Pick<DbxForgeTextFieldConfig, 'key'>> {
}
/**
 * Convenience type for the password parameters (length/pattern constraints) of a forge password field.
 */
type DbxForgeTextPasswordFieldPasswordParameters = Partial<Pick<DbxForgeTextFieldConfig, 'maxLength' | 'minLength' | 'pattern'>>;
/**
 * Password input (HTML `type="password"`) with secure autocomplete defaults.
 *
 * Defaults to the key `'password'` and label `'Password'` unless overridden.
 *
 * @param config - Optional configuration for the password field.
 * @returns A {@link MatInputField} with password input type.
 *
 * @dbxFormSlug password-field
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormFieldDerivative text
 * @dbxFormConfigInterface DbxForgeTextPasswordFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeTextPasswordField({ key: 'password', required: true })
 * ```
 */
declare function dbxForgeTextPasswordField(config?: DbxForgeTextPasswordFieldConfig): DbxForgeField<MatInputField>;
/**
 * Companion to `password-field` for sign-up flows. Defaults `autocomplete` to `new-password`. Pair with `password-with-verify-fields` for cross-field equality validation.
 *
 * Defaults to the key `'verifyPassword'` and label `'Verify Password'` unless overridden.
 *
 * @param config - Optional configuration for the verify password field.
 * @returns A {@link MatInputField} with password input type.
 *
 * @dbxFormSlug verify-password-field
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormFieldDerivative password-field
 * @dbxFormConfigInterface DbxForgeTextPasswordFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeTextVerifyPasswordField({ key: 'verifyPassword' })
 * ```
 */
declare function dbxForgeTextVerifyPasswordField(config?: DbxForgeTextPasswordFieldConfig): DbxForgeField<MatInputField>;
/**
 * Configuration for a forge password field group that includes a verification (confirm) password field.
 */
interface DbxForgeTextPasswordWithVerifyFieldConfig {
    /**
     * Optional configuration for the primary password field.
     */
    readonly password?: DbxForgeTextPasswordFieldConfig;
    /**
     * Optional configuration for the verify/confirm password field.
     */
    readonly verifyPassword?: DbxForgeTextPasswordFieldConfig;
}
/**
 * Password + verify-password pair with cross-field equality validation wired up. Drop-in for sign-up flows.
 *
 * The verify password field uses an expression-based custom validator that compares the
 * verify field value against the primary password field's value via `formValue`.
 *
 * @param config - Configuration for the password and verify password fields.
 * @returns A tuple of `[passwordField, verifyPasswordField]`
 *
 * @dbxFormSlug password-with-verify-fields
 * @dbxFormProduces FieldDef[]
 * @dbxFormArrayOutput no
 * @dbxFormFieldTemplate password-field, verify-password-field
 * @dbxFormConfigInterface DbxForgeTextPasswordWithVerifyFieldConfig
 *
 * @example
 * ```typescript
 * dbxForgeTextPasswordWithVerifyField({ password: { required: true } })
 * ```
 */
declare function dbxForgeTextPasswordWithVerifyField(config?: DbxForgeTextPasswordWithVerifyFieldConfig): readonly [DbxForgeField<MatInputField>, DbxForgeField<MatInputField>];
/**
 * Value type exported by dbxForgeUsernameLoginField().
 */
interface DbxForgeDefaultUsernameLoginFieldValue {
    readonly username: string;
}
/**
 * Value type exported by dbxForgeUsernamePasswordLoginFields().
 */
interface DbxForgeDefaultUsernameLoginFieldsValue extends DbxForgeDefaultUsernameLoginFieldValue {
    readonly password: string;
    readonly verifyPassword?: string;
}
/**
 * Configuration for the username field in a forge login form.
 */
interface DbxForgeUsernameLoginFieldUsernameConfig {
    /**
     * Configuration for an email-based username field.
     */
    readonly email?: Omit<DbxForgeEmailFieldConfig, 'key'>;
    /**
     * Configuration for a plain text username field.
     */
    readonly username?: Omit<DbxForgeTextFieldConfig, 'key'>;
}
/**
 * Input type for the username field configuration.
 *
 * Can be the string `'email'` or `'username'` for quick defaults,
 * or a full {@link DbxForgeUsernameLoginFieldUsernameConfig} object for custom configuration.
 */
type DbxForgeUsernameLoginFieldUsernameConfigInput = 'email' | 'username' | DbxForgeUsernameLoginFieldUsernameConfig;
/**
 * Configuration for forge username/password login fields.
 */
interface DbxForgeUsernameLoginFieldsConfig {
    /**
     * Username field configuration. Use `'email'` or `'username'` for defaults,
     * or provide a custom config.
     */
    readonly username: DbxForgeUsernameLoginFieldUsernameConfigInput;
    /**
     * Optional configuration for the password field.
     */
    readonly password?: DbxForgeTextPasswordFieldConfig;
    /**
     * 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 | DbxForgeTextPasswordFieldConfig>;
}
/**
 * Complete login/signup field set: username, password, and optional verify-password. Drop into the top-level `fields: []`.
 *
 * When `verifyPassword` is provided, a second password field is added with a custom
 * validator that ensures both password values match.
 *
 * @param config - Login fields configuration.
 * @returns The forge field definitions for the login form.
 *
 * @dbxFormSlug username-password-login-fields
 * @dbxFormProduces FieldDef[]
 * @dbxFormArrayOutput no
 * @dbxFormFieldTemplate username-login-field, password-field, verify-password-field
 * @dbxFormConfigInterface DbxForgeUsernameLoginFieldsConfig
 *
 * @example
 * ```typescript
 * dbxForgeUsernamePasswordLoginFields({ username: 'email', verifyPassword: true })
 * ```
 */
declare function dbxForgeUsernamePasswordLoginFields(config: DbxForgeUsernameLoginFieldsConfig): DbxForgeField<MatInputField>[];
/**
 * Username field for login forms. Accepts `"email"` or `"username"` as shorthand presets, or a full config object.
 *
 * Supports email or plain text input based on the provided configuration.
 *
 * @param username - Either `'email'`, `'username'`, or a full config object.
 * @returns A forge field definition for the username input.
 *
 * @dbxFormSlug username-login-field
 * @dbxFormProduces string
 * @dbxFormArrayOutput no
 * @dbxFormFieldDerivative text
 * @dbxFormConfigInterface DbxForgeUsernameLoginFieldUsernameConfigInput
 *
 * @example
 * ```typescript
 * dbxForgeUsernameLoginField({ username: 'email' })
 * ```
 */
declare function dbxForgeUsernameLoginField(username: DbxForgeUsernameLoginFieldUsernameConfigInput): DbxForgeField<MatInputField>;

/**
 * Configuration for a forge timezone string field.
 *
 * Omits search-related properties that are internally configured.
 */
interface DbxForgeTimezoneStringFieldConfig extends Omit<DbxForgeSearchableTextFieldConfig<TimezoneString, TimezoneInfo>, 'key' | 'search' | 'displayForValue' | 'searchOnEmptyText' | 'allowStringValues' | 'showClearValue'>, Partial<Pick<DbxForgeSearchableTextFieldConfig<TimezoneString, TimezoneInfo>, 'key'>> {
}
/**
 * Creates a forge searchable field for selecting a timezone.
 *
 * 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 forge searchable text field definition for timezone selection.
 *
 * @example
 * ```typescript
 * const field = dbxForgeTimezoneStringField();
 * const fieldWithKey = dbxForgeTimezoneStringField({ key: 'tz', label: 'Select Timezone' });
 * ```
 */
declare function dbxForgeTimezoneStringField(config?: DbxForgeTimezoneStringFieldConfig): _dereekb_dbx_form.DbxForgeField<_dereekb_dbx_form.DbxForgeSearchableTextFieldDef<string, TimezoneInfo, _dereekb_util.PrimativeKey>>;

declare const IS_NOT_WEBSITE_URL_VALIDATION_KEY = "isNotWebsiteUrl";
declare const IS_NOT_WEBSITE_URL_WITH_PREFIX_VALIDATION_KEY = "isNotWebsiteUrlWithPrefix";
declare const IS_NOT_WEBSITE_URL_WITH_EXPECTED_DOMAIN_VALIDATION_KEY = "isNotWebsiteUrlWithExpectedDomain";
interface IsNotWebsiteUrlErrorData {
    readonly value: string;
    readonly isPrefixRequired: boolean;
    readonly message: string;
}
interface IsWebsiteUrlValidatorConfig {
    /**
     * Whether or not to require an http/https prefix.
     *
     * Defaults to true.
     */
    readonly requirePrefix?: Maybe<boolean>;
    /**
     * 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.
     *
     * Defaults to undefined.
     */
    readonly validDomains?: Maybe<ArrayOrValue<WebsiteDomain>>;
}
/**
 * Angular form validator that checks whether the control value is a valid website URL,
 * optionally requiring an http/https prefix, allowing port numbers, and restricting to specific domains.
 *
 * @param config - Optional validation configuration for prefix, port, and domain requirements.
 * @returns A ValidatorFn that validates website URLs.
 */
declare function isWebsiteUrlValidator(config?: IsWebsiteUrlValidatorConfig): ValidatorFn;

/**
 * Configuration for {@link dbxForgeWebsiteUrlValidator}. Extends
 * {@link IsWebsiteUrlValidatorConfig} with per-error message overrides.
 */
interface DbxForgeWebsiteUrlValidatorConfig extends IsWebsiteUrlValidatorConfig {
    /**
     * Optional override for the "is not a valid website url" error message.
     */
    readonly notWebsiteUrlMessage?: DynamicText;
    /**
     * Optional override for the "is not a valid website url with an http/https prefix" error message.
     */
    readonly notWebsiteUrlWithPrefixMessage?: DynamicText;
    /**
     * Optional override for the "is not a valid website url with an expected domain" error message.
     */
    readonly notWebsiteUrlWithExpectedDomainMessage?: DynamicText;
}

/**
 * Configuration for a forge website URL text field.
 */
interface DbxForgeWebsiteUrlFieldConfig extends Omit<DbxForgeTextFieldConfig, 'inputType' | 'key'>, Partial<Pick<DbxForgeTextFieldConfig, 'key'>>, DbxForgeWebsiteUrlValidatorConfig {
}
/**
 * Creates a forge text field configured for website URL input, with website URL validation.
 *
 * 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 {@link MatInputField} for website URL input.
 *
 * @example
 * ```typescript
 * const field = dbxForgeWebsiteUrlField();
 * ```
 */
declare function dbxForgeWebsiteUrlField(config?: DbxForgeWebsiteUrlFieldConfig): _dereekb_dbx_form.DbxForgeField<_ng_forge_dynamic_forms_material.MatInputField>;

/**
 * The default validator name used in the field's validators array and the customFnConfig registration.
 */
declare const FORGE_FIELD_VALUE_IS_AVAILABLE_VALIDATOR_NAME = "fieldValueIsAvailable";
/**
 * Function that checks whether a value is available.
 *
 * @returns An observable that emits `true` if the value is available, `false` otherwise.
 */
type DbxForgeFieldValueIsAvailableCheckFn<T> = (value: T) => Observable<boolean>;
/**
 * Configuration for the forge field-value-is-available async validator.
 */
interface DbxForgeFieldValueIsAvailableValidatorConfig<T> {
    /**
     * Function that checks whether the entered value is available.
     */
    readonly checkValueIsAvailable: DbxForgeFieldValueIsAvailableCheckFn<T>;
    /**
     * Custom error message displayed when the value is not available.
     *
     * Defaults to 'This value is not available.'.
     */
    readonly isNotAvailableErrorMessage?: string;
    /**
     * Optional custom validator name. Defaults to {@link FORGE_FIELD_VALUE_IS_AVAILABLE_VALIDATOR_NAME}.
     *
     * Useful when multiple availability fields exist in the same form to avoid name collisions.
     */
    readonly validatorName?: string;
    /**
     * Optional throttle delay in milliseconds between availability checks.
     */
    readonly throttle?: number;
}
/**
 * Configuration for a forge text field that includes an async availability check.
 */
interface DbxForgeTextAvailableFieldConfig extends DbxForgeTextFieldConfig, Omit<DbxForgeFieldValueIsAvailableValidatorConfig<string>, 'checkValueIsAvailable'> {
    /**
     * Function that checks whether the entered value is available.
     */
    readonly checkValueIsAvailable: DbxForgeFieldValueIsAvailableCheckFn<string>;
}
/**
 * Creates a forge text field with an async availability validator.
 *
 * The validator function and validation messages are auto-registered into the field's `_formConfig`,
 * so callers using {@link dbxForgeFinalizeFormConfig} get everything wired automatically.
 *
 * @param config - Configuration for the text field and availability validation.
 * @returns A {@link DbxForgeField} text field with the validator and messages registered in `_formConfig`.
 *
 * @example
 * ```typescript
 * const field = dbxForgeTextIsAvailableField({
 *   key: 'username',
 *   label: 'Username',
 *   checkValueIsAvailable: (value) => userService.isAvailable(value),
 *   isNotAvailableErrorMessage: 'Username is already taken'
 * });
 *
 * const formConfig = dbxForgeFinalizeFormConfig({
 *   fields: [field, ...otherFields]
 * }).config;
 * ```
 */
declare function dbxForgeTextIsAvailableField(config: DbxForgeTextAvailableFieldConfig): DbxForgeField<MatInputField>;

/**
 * Default validation messages for all built-in Angular validators.
 *
 * Uses ng-forge's `{{param}}` interpolation for dynamic values.
 *
 * Can be used as `FormConfig.defaultValidationMessages` to apply form-wide,
 * or spread into individual field `validationMessages`.
 *
 * @returns A ValidationMessages object with messages for required, email, minLength, maxLength, min, max, and pattern validators.
 *
 * @example
 * ```typescript
 * const config: FormConfig = {
 *   fields: [...],
 *   defaultValidationMessages: forgeDefaultValidationMessages()
 * };
 * ```
 */
declare function dbxForgeDefaultValidationMessages(): ValidationMessages;

declare const DEFAULT_DATE_TIME_FIELD_MENU_PRESETS_PRESETS: DateTimePresetConfiguration[];

/**
 * 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[]>;
    get configurations(): DateTimePresetConfiguration[];
    set configurations(configurations: DateTimePresetConfiguration[]);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxDateTimeFieldMenuPresetsService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DbxDateTimeFieldMenuPresetsService>;
}

/**
 * Default popover key for the duration picker.
 */
declare const DEFAULT_DURATION_PICKER_POPOVER_KEY = "durationpicker";
/**
 * Callback invoked on every +/- click in the duration picker.
 */
type DbxDurationPickerChangeCallback = (data: TimeDurationData) => void;
/**
 * Data passed to the duration picker popover.
 */
interface DbxDurationPickerPopoverData {
    /**
     * The current duration values.
     */
    readonly current: TimeDurationData;
    /**
     * Which time unit columns to show.
     */
    readonly units: TimeUnit[];
    /**
     * Optional callback invoked on every +/- change for live updates.
     */
    readonly onChange?: DbxDurationPickerChangeCallback;
    /**
     * Minimum total value in milliseconds. Used to disable decrement buttons.
     */
    readonly minMs?: Milliseconds;
    /**
     * Maximum total value in milliseconds. Used to disable increment buttons.
     */
    readonly maxMs?: Milliseconds;
    /**
     * Whether values should carry over to the next larger unit when they overflow
     * (e.g., 60 seconds → 1 minute). Only carries into units present in `units`.
     *
     * Defaults to false.
     */
    readonly carryOver?: boolean;
}
/**
 * Popover component that displays a horizontal duration picker with +/- buttons for each time unit.
 *
 * Each column shows the unit label, an increment button, the current value, and a decrement button.
 * Buttons are disabled when incrementing/decrementing would exceed min/max constraints.
 * Changes are applied immediately via the onChange callback and returned when the popover closes.
 *
 * @example
 * ```typescript
 * DbxDurationPickerPopoverComponent.openPopover(popoverService, {
 *   origin: elementRef,
 *   data: { current: { hours: 1, minutes: 30 }, units: ['h', 'min', 's'] }
 * });
 * ```
 */
declare class DbxDurationPickerPopoverComponent extends AbstractPopoverDirective<TimeDurationData, DbxDurationPickerPopoverData> {
    readonly durationData: _angular_core.WritableSignal<TimeDurationData>;
    readonly units: TimeUnit[];
    private readonly _onChange;
    private readonly _minMs;
    private readonly _maxMs;
    private readonly _carryOver;
    constructor();
    /**
     * Opens the duration picker popover.
     *
     * @param popoverService - The popover service to use.
     * @param config - Configuration with origin element and picker data.
     * @param config.origin - The element to anchor the popover to.
     * @param config.data - The picker data including current values and which units to show.
     * @returns A reference to the opened popover.
     */
    static openPopover(popoverService: DbxPopoverService, config: {
        origin: ElementRef;
        data: DbxDurationPickerPopoverData;
    }): NgPopoverRef;
    /**
     * Gets the short label for a time unit.
     *
     * @param unit - The time unit.
     * @returns The short label string.
     */
    unitLabel(unit: TimeUnit): string;
    /**
     * Gets the current value for a specific time unit.
     *
     * @param unit - The time unit to read.
     * @returns The current value for that unit.
     */
    getValue(unit: TimeUnit): number;
    /**
     * Returns true if incrementing the given unit by 1 would not exceed the maximum.
     *
     * @param unit - The time unit to check.
     * @returns Whether incrementing is allowed.
     */
    canIncrement(unit: TimeUnit): boolean;
    /**
     * Returns true if decrementing the given unit by 1 would not go below the minimum (or below 0).
     *
     * @param unit - The time unit to check.
     * @returns Whether decrementing is allowed.
     */
    canDecrement(unit: TimeUnit): boolean;
    /**
     * Increments the value for a specific time unit.
     * Holding shift doubles the step.
     *
     * @param unit - The time unit to increment.
     * @param step - The amount to increment by (defaults to 1)
     */
    increment(unit: TimeUnit, step?: number): void;
    /**
     * Decrements the value for a specific time unit.
     * Holding shift doubles the step.
     *
     * @param unit - The time unit to decrement.
     * @param step - The amount to decrement by (defaults to 1)
     */
    decrement(unit: TimeUnit, step?: number): void;
    /**
     * Returns the step size — 2 if shift is held, 1 otherwise.
     *
     * @param event - The mouse or keyboard event.
     * @returns The step multiplier.
     */
    stepFromEvent(event?: Event): number;
    /**
     * When carryOver is enabled, normalizes the data by converting to total milliseconds
     * and decomposing back into the picker's units (e.g., 60s becomes 1m, 7d becomes 1w).
     *
     * @param data - The duration data to normalize.
     * @returns Normalized or original data.
     */
    private _normalizeIfCarryOver;
    private _holdInterval;
    private _holdTimeout;
    private _holdActive;
    private _shiftHeld;
    /**
     * Fires one action immediately and starts hold-to-repeat.
     * Used by both mousedown and keydown.
     *
     * @param action - The action to perform.
     * @param unit - The time unit.
     * @param event - The triggering event (for shift detection)
     */
    onHoldStart(action: 'increment' | 'decrement', unit: TimeUnit, event: Event): void;
    /**
     * Returns the current step based on whether shift is held.
     *
     * @returns Two when shift is held for larger increments, one otherwise.
     */
    private get _currentStep();
    /**
     * Stops the hold-to-repeat interval.
     */
    /**
     * Handles keyup events. Only stops the hold when an arrow key is released.
     * Releasing modifier keys (shift, ctrl, etc.) does not stop the hold.
     *
     * @param event - The keyboard event.
     */
    onKeyUp(event: KeyboardEvent): void;
    stopHold(): void;
    /**
     * Executes an increment or decrement action if allowed.
     *
     * @param action - Whether to increment or decrement the value.
     * @param unit - The time unit to adjust (e.g. 'h', 'm', 's')
     * @param step - The step multiplier for the action.
     * @returns True if the action was performed.
     */
    private _doAction;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxDurationPickerPopoverComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxDurationPickerPopoverComponent, "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: _angular_core.InputSignal<ConfiguredSearchableValueFieldDisplayValue<T, unknown>>;
    readonly configSignal: _angular_core.Signal<DbxInjectionComponentConfig<unknown>>;
    readonly anchorSignal: _angular_core.Signal<_dereekb_dbx_core.ClickableAnchor | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxSearchableFieldAutocompleteItemComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<AbstractDbxSearchableFieldDisplayDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<DbxDefaultSearchableFieldDisplayComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxDefaultSearchableFieldDisplayComponent<any>, "dbx-default-searchable-field-display", never, {}, {}, never, never, true, never>;
}

/**
 * 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[]>;
/**
 * Subset of pickable field props derived from a static set of labeled values.
 */
interface PickableValueFieldValuesConfigForStaticLabeledValues<T, M extends LabeledValue<T>> {
    readonly loadValues: PickableValueFieldLoadValuesFunction<T, M>;
    readonly displayForValue: PickableValueFieldDisplayFunction<T, M>;
    readonly filterValues: PickableValueFieldFilterFunction<T, M>;
}
/**
 * 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>;

/**
 * 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: _angular_core.ɵɵFactoryDeclaration<DbxFormSpacerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DbxFormSpacerDirective, "dbx-form-spacer,[dbxFormSpacer],.dbx-form-spacer", never, {}, {}, never, never, true, never>;
}

/**
 * Angular form validator that requires the control value to be truthy.
 *
 * @returns A ValidatorFn that fails when the value is falsy.
 */
declare function isTruthy(): ValidatorFn;

/**
 * Angular form validator that checks whether the control value matches a website domain name pattern.
 *
 * @returns A ValidatorFn that validates against the domain name regex.
 */
declare function isDomain(): ValidatorFn;

declare const FIELD_VALUES_ARE_EQUAL_VALIDATION_KEY = "fieldValuesAreEqual";
interface FieldValuesAreEqualValidatorConfig<T extends object = object> {
    /**
     * Keys of the value to match on.
     *
     * If none are defined, then all fields from the control are matched.
     */
    readonly keysFilter?: (keyof T)[];
    /**
     * Full filter to use, if defined.
     */
    readonly valuesFilter?: KeyValueTupleFilter<T>;
    /**
     * Optional equivalence comparator.
     */
    readonly isEqual?: EqualityComparatorFunction<T>;
    /**
     * Custom message for this validator.
     */
    readonly message?: string;
}
/**
 * Validator for validating all values within an object.
 *
 * This is useful for validating a control group where two or more values are expected to be the same, such as a password and a password verification field.
 *
 * @param config
 * @returns
 */
declare function fieldValuesAreEqualValidator<T extends object = object>(config?: FieldValuesAreEqualValidatorConfig<T>): ValidatorFn;

/**
 * Merges the use of the min and max validator.
 *
 * @param min
 * @param max
 * @returns
 */
declare function isInRange(min?: number, max?: number): ValidatorFn;
declare const IS_DIVISIBLE_BY_VALIDATION_KEY = "isDivisibleBy";
interface IsDivisibleByError {
    value: number;
    nearest: number;
    divisor: number;
    message: string;
}
/**
 * Angular Form ValidationFn for checking isDivisibleBy the input divisor.
 *
 * @param divisor - The non-zero divisor every input value must be divisible by.
 * @returns A `ValidatorFn` that emits an `isDivisibleBy` error when the control value is not divisible by `divisor`.
 * @throws {Error} When `divisor` is zero.
 */
declare function isDivisibleBy(divisor: number): ValidatorFn;

declare const FIELD_VALUE_IS_AVAILABLE_VALIDATION_KEY = "fieldValueIsAvailable";
declare const FIELD_VALUE_IS_AVAILABLE_ERROR_VALIDATION_KEY = "fieldValueIsAvailableError";
type FieldValueIsAvailableValidatorFunction<T> = (value: T) => Observable<boolean>;
interface FieldValueIsAvailableValidatorConfig<T> {
    /**
     * How long to wait in between value changes.
     */
    readonly throttle?: number;
    /**
     * Returns an observable that checks whether or not the value is currently available.
     *
     * @param value
     */
    readonly checkValueIsAvailable: FieldValueIsAvailableValidatorFunction<T>;
    /**
     * Custom message for this validator.
     */
    readonly message?: string;
}
/**
 * Validator for validating all values within an object.
 *
 * This is useful for validating a control group where two or more values are expected to be the same, such as a password and a password verification field.
 *
 * @param config
 * @returns
 */
declare function fieldValueIsAvailableValidator<T>(config: FieldValueIsAvailableValidatorConfig<T>): AsyncValidatorFn;

/**
 * Validation message shown when a value is not a valid phone number.
 */
declare const INVALID_PHONE_NUMBER_MESSAGE: {
    name: string;
    message: string;
};
/**
 * Validation message shown when a value is not a valid phone number extension.
 */
declare const INVALID_PHONE_NUMBER_EXTENSION_MESSAGE: {
    name: string;
    message: string;
};
/**
 * Angular form validator that checks whether the control value is a valid E.164 phone number.
 *
 * @param allowExtension - Whether to allow phone number extensions in the value.
 * @returns A ValidatorFn that validates E.164 phone numbers.
 */
declare function isE164PhoneNumber(allowExtension: boolean): ValidatorFn;
/**
 * Angular Form ValidationFn for checking the input is a valid phone extension. Empty values return true.
 *
 * @returns A ValidatorFn that validates phone extension numbers.
 */
declare function isPhoneExtension(): ValidatorFn;
/**
 * Angular form validator that checks the value is a valid E.164 phone number with a valid extension (if present).
 *
 * @returns A ValidatorFn that validates E.164 phone numbers with optional extensions.
 */
declare function isE164PhoneNumberWithValidExtension(): ValidatorFn;

interface ProvideDbxFormConfigurationConfig {
    readonly provideDateAdapter?: boolean;
    readonly defaultDateTimePresets?: Maybe<DateTimePresetConfiguration[]>;
}
/**
 * Provides the core dbx-form configuration including Material form field defaults,
 * date adapter, and optional date-time presets.
 *
 * @param config - Optional configuration for the date adapter and default date-time presets.
 * @returns Environment providers for dbx-form.
 */
declare function provideDbxFormConfiguration(config?: ProvideDbxFormConfigurationConfig): EnvironmentProviders;

export { APP_ACTION_FORM_DISABLED_KEY, AbstractAsyncForgeFormDirective, AbstractConfigAsyncForgeFormDirective, AbstractDbxSearchableFieldDisplayDirective, AbstractForgeFormDirective, AbstractForgePickableItemFieldDirective, AbstractForgeSearchableFieldDirective, AbstractSyncForgeFormDirective, DBX_DATE_TIME_FIELD_DATE_NOT_IN_SCHEDULE_ERROR, DBX_DATE_TIME_FIELD_MENU_PRESETS_TOKEN, DBX_DATE_TIME_FIELD_TIME_NOT_IN_RANGE_ERROR, DBX_FORGE_ARRAY_FIELD_ELEMENT_WRAPPER_NAME, DBX_FORGE_ARRAY_FIELD_WRAPPER_NAME, DBX_FORGE_FIELD_TYPES, DBX_FORGE_FIELD_WRAPPER_TYPES, DBX_FORGE_FLEX_WRAPPER_TYPE_NAME, DBX_FORGE_FORM_COMPONENT_TEMPLATE, DBX_FORGE_FORM_FIELD_WRAPPER_NAME, DBX_FORGE_INFO_WRAPPER_TYPE_NAME, DBX_FORGE_PASSWORDS_MATCH_VALIDATION_KIND, DBX_FORGE_SEARCHABLE_CHIP_FIELD_TYPE_NAME, DBX_FORGE_SEARCHABLE_TEXT_FIELD_TYPE_NAME, DBX_FORGE_SECTION_WRAPPER_TYPE_NAME, DBX_FORGE_STYLE_WRAPPER_TYPE_NAME, DBX_FORGE_WORKING_WRAPPER_TYPE_NAME, DBX_SEARCHABLE_FIELD_COMPONENT_DATA_TOKEN, DEFAULT_DATE_TIME_FIELD_MENU_PRESETS_PRESETS, DEFAULT_DBX_FORGE_PASSWORDS_MATCH_VALIDATION_MESSAGE, DEFAULT_DBX_FORGE_TEXT_PASSWORD_AUTOCOMPLETE, DEFAULT_DBX_FORGE_TEXT_VERIFY_PASSWORD_AUTOCOMPLETE, DEFAULT_DURATION_PICKER_POPOVER_KEY, DEFAULT_FORGE_LAT_LNG_TEXT_FIELD_PATTERN_MESSAGE, DEFAULT_FORGE_LAT_LNG_TEXT_FIELD_PLACEHOLDER, DEFAULT_FORM_DISABLED_KEY, DEFAULT_TRANSFORM_DEBOUNCE_TIME, DbxActionFormDirective, DbxActionFormSafetyDirective, DbxDateTimeFieldMenuPresetsService, DbxDateTimeFieldTimeMode, DbxDateTimeValueMode, DbxDefaultSearchableFieldDisplayComponent, DbxDurationPickerPopoverComponent, DbxForgeActionDialogComponent, DbxForgeArrayFieldElementWrapperComponent, DbxForgeArrayFieldWrapperComponent, DbxForgeAsyncConfigFormComponent, DbxForgeComponentFieldComponent, DbxForgeDateRangeFieldComponent, DbxForgeDateTimeFieldComponent, DbxForgeDynamicFormSignalRef, DbxForgeFixedDateRangeFieldComponent, DbxForgeFixedDateRangeFieldSelectionStrategy, DbxForgeFormComponent, DbxForgeFormComponentImportsModule, DbxForgeFormContext, DbxForgeFormContextService, DbxForgeFormFieldWrapperComponent, DbxForgeGlobalDefaultConfigService, DbxForgeListSelectionFieldComponent, DbxForgePhoneFieldComponent, DbxForgePickableChipFieldComponent, DbxForgePickableListFieldComponent, DbxForgePresetSearchFormComponent, DbxForgeSearchableChipFieldComponent, DbxForgeSearchableTextFieldComponent, DbxForgeSourceSelectFieldComponent, DbxForgeTextEditorFieldComponent, DbxForgeTimeDurationFieldComponent, DbxForgeWorkingWrapperComponent, DbxForm, DbxFormLoadingSourceDirective, DbxFormLoggerDirective, DbxFormSourceDirective, DbxFormSpacerDirective, DbxFormState, DbxFormValueChangeDirective, DbxMutableForm, DbxSearchableFieldAutocompleteItemComponent, FIELD_VALUES_ARE_EQUAL_VALIDATION_KEY, FIELD_VALUE_IS_AVAILABLE_ERROR_VALIDATION_KEY, FIELD_VALUE_IS_AVAILABLE_VALIDATION_KEY, FORGE_COMPONENT_FIELD_TYPE, FORGE_DATERANGE_FIELD_TYPE, FORGE_DATETIME_FIELD_TYPE, FORGE_EXPAND_FIELD_TYPE_NAME, FORGE_FIELD_VALUE_IS_AVAILABLE_VALIDATOR_NAME, FORGE_FIXEDDATERANGE_FIELD_TYPE, FORGE_INFO_BUTTON_FIELD_TYPE_NAME, FORGE_IS_DIVISIBLE_BY_VALIDATION_KEY, FORGE_LIST_SELECTION_FIELD_TYPE, FORGE_PHONE_FIELD_TYPE, FORGE_PICKABLE_CHIP_FIELD_TYPE, FORGE_PICKABLE_LIST_FIELD_TYPE, FORGE_SOURCE_SELECT_FIELD_TYPE, FORGE_TEXT_EDITOR_FIELD_TYPE, FORGE_TIMEDURATION_FIELD_TYPE, FORGE_VALUE_SELECTION_FIELD_TYPE, INVALID_PHONE_NUMBER_EXTENSION_MESSAGE, INVALID_PHONE_NUMBER_MESSAGE, IS_DIVISIBLE_BY_VALIDATION_KEY, IS_NOT_WEBSITE_URL_VALIDATION_KEY, IS_NOT_WEBSITE_URL_WITH_EXPECTED_DOMAIN_VALIDATION_KEY, IS_NOT_WEBSITE_URL_WITH_PREFIX_VALIDATION_KEY, SELF_DEPENDENCY_TOKEN, _filterForgeFormValueKeepInternal, _filterForgeFormValueStripInternal, _forgeFormValueEqual, applyTimeOffset, buildCombinedDateTime, computeDateKeyboardStep, computeErrorMessage, computeTimeKeyboardStep, configureDbxForgeFormFieldWrapper, configureDbxForgeFormFieldWrapperWith, configureForgeAutocompleteFieldMeta, copyFormConfigCustomFnConfig, dateRangeFieldMapper, dateTimeFieldCalc, dateTimeFieldMapper, dateTimePreset, dbxDateRangeIsSameDateRangeFieldValue, dbxDateTimeInputValueParseFactory, dbxDateTimeIsSameDateTimeFieldValue, dbxDateTimeOutputValueFactory, dbxForgeAddressFields, dbxForgeAddressGroup, dbxForgeAddressLineField, dbxForgeAddressListField, dbxForgeArrayField, dbxForgeBuildFieldDef, dbxForgeCheckboxField, dbxForgeChecklistField, dbxForgeCityField, dbxForgeComponentField, dbxForgeContainer, dbxForgeCountryField, dbxForgeDateField, dbxForgeDateRangeRow, dbxForgeDateTimeField, dbxForgeDateTimeRangeRow, dbxForgeDefaultValidationMessages, dbxForgeDollarAmountField, dbxForgeEmailField, dbxForgeExpandWrapper, dbxForgeFieldDisabled, dbxForgeFieldFunction, dbxForgeFieldFunctionConfigPropsWithHintBuilder, dbxForgeFieldFunctionConfigure, dbxForgeFinalizeFormConfig, dbxForgeFixedDateRangeField, dbxForgeFlexLayout, provideDbxForgeFormContext as dbxForgeFormComponentProviders, dbxForgeGroup, dbxForgeInfoWrapper, dbxForgeLatLngTextField, dbxForgeListSelectionField, dbxForgeNameField, dbxForgeNumberField, dbxForgeNumberSliderField, dbxForgePhoneField, dbxForgePickableChipField, dbxForgePickableListField, dbxForgePresetSearchFormFields, dbxForgeRow, dbxForgeSearchableChipField, dbxForgeSearchableStringChipField, dbxForgeSearchableTextField, dbxForgeSectionWrapper, dbxForgeSourceSelectField, dbxForgeStateField, dbxForgeStyleWrapper, dbxForgeSubsectionWrapper, dbxForgeTextAreaField, dbxForgeTextEditorField, dbxForgeTextField, dbxForgeTextIsAvailableField, dbxForgeTextPasswordField, dbxForgeTextPasswordWithVerifyField, dbxForgeTextVerifyPasswordField, dbxForgeTimeDurationField, dbxForgeTimezoneStringField, dbxForgeToggleField, dbxForgeToggleWrapper, dbxForgeUsernameLoginField, dbxForgeUsernamePasswordLoginFields, dbxForgeValueSelectionField, dbxForgeWebsiteUrlField, dbxForgeZipCodeField, dbxFormSourceObservable, dbxFormSourceObservableFromStream, disableAutofillAttributes, fieldAutocompleteAttributeValue, fieldValueIsAvailableValidator, fieldValuesAreEqualValidator, filterPickableItemFieldValuesByLabel, filterPickableItemFieldValuesByLabelFilterFunction, filterPresets, fixedDateRangeFieldMapper, isDivisibleBy, isDomain, isE164PhoneNumber, isE164PhoneNumberWithValidExtension, isInRange, isPhoneExtension, isTruthy, isWebsiteUrlValidator, mergeDbxForgeFieldFormConfig, mergePickerConfig, navigateDate, phoneFieldMapper, pickableValueFieldValuesConfigForStaticLabeledValues, provideDbxForgeFormContext, provideDbxForgeFormFieldDeclarations, provideDbxForm, provideDbxFormConfiguration, provideDbxMutableForm, resolveForgeSelectionOptions, streamValueFromControl, stripEmptyForgeValues, stripForgeInternalKeys, timeDurationFieldMapper, toggleDisableFormControl };
export type { ApplyTimeOffsetInput, ConfiguredSearchableValueFieldDisplayValue, DateTimeCalcInput, DateTimeFieldCalc, DateTimePreset, DateTimePresetConfiguration, DateTimePresetValue, DbxActionFormMapValueFunction, DbxDateTimeFieldSyncType, DbxDateTimePickerConfiguration, DbxDurationPickerChangeCallback, DbxDurationPickerPopoverData, DbxFixedDateRangeDateRangeInput, DbxFixedDateRangePickerConfiguration, DbxFixedDateRangePicking, DbxFixedDateRangeSelectionMode, DbxForgeActionDialogComponentButtonConfig, DbxForgeActionDialogComponentConfig, DbxForgeAddressFieldsConfig, DbxForgeAddressGroupConfig, DbxForgeAddressLineFieldConfig, DbxForgeAddressListFieldConfig, DbxForgeArrayFieldConfig, DbxForgeArrayFieldElementWrapperDef, DbxForgeArrayFieldElementWrapperProps, DbxForgeArrayFieldFunction, DbxForgeArrayFieldWrapperDef, DbxForgeArrayFieldWrapperProps, DbxForgeArrayItemEvaluationContextInput, DbxForgeArrayItemEvaluationFn, DbxForgeBooleanShowLabelAt, DbxForgeBuildFieldDefConfig, DbxForgeBuildFieldDefFunction, DbxForgeCheckboxFieldConfig, DbxForgeChecklistFieldConfig, DbxForgeChecklistFieldFunction, DbxForgeCityFieldConfig, DbxForgeComponentFieldConfig, DbxForgeComponentFieldDef, DbxForgeComponentFieldFunction, DbxForgeComponentFieldProps, DbxForgeContainerConfig, DbxForgeContainerLogicConfig, DbxForgeCountryFieldConfig, DbxForgeDateFieldConfig, DbxForgeDateRangeFieldComponentProps, DbxForgeDateRangeFieldDateConfig, DbxForgeDateRangeFieldDef, DbxForgeDateRangeRowConfig, DbxForgeDateRangeValue, DbxForgeDateTimeFieldComponentProps, DbxForgeDateTimeFieldConfig, DbxForgeDateTimeFieldDef, DbxForgeDateTimeRangeFieldTimeConfig, DbxForgeDateTimeRangeRowConfig, DbxForgeDateTimeSyncField, DbxForgeDefaultUsernameLoginFieldValue, DbxForgeDefaultUsernameLoginFieldsValue, DbxForgeDollarAmountFieldConfig, DbxForgeEmailFieldConfig, DbxForgeExpandButtonType, DbxForgeExpandFieldDef, DbxForgeExpandFieldProps, DbxForgeExpandWrapperConfig, DbxForgeField, DbxForgeFieldAsyncTransformFunction, DbxForgeFieldAsyncTransformLogic, DbxForgeFieldAsyncTransformLogicWhenAlways, DbxForgeFieldAsyncTransformLogicWhenDefined, DbxForgeFieldAsyncValidatorWithFn, DbxForgeFieldCustomValidatorWithFn, DbxForgeFieldDebouncedTransformLogic, DbxForgeFieldDebouncedTransformLogicWhenAlways, DbxForgeFieldDebouncedTransformLogicWhenDefined, DbxForgeFieldFormConfig, DbxForgeFieldFunction, DbxForgeFieldFunctionConfig, DbxForgeFieldFunctionConfigPropsBuilder, DbxForgeFieldFunctionDef, DbxForgeFieldFunctionDefLogicValue, DbxForgeFieldFunctionFieldDefBuilder, DbxForgeFieldFunctionFieldDefBuilderFunctionInstance, DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceAddValidationInput, DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceFormConfigBuilder, DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceLogicBuilder, DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceLogicBuilderLogic, DbxForgeFieldFunctionFieldDefBuilderFunctionInstanceWrappersBuilder, DbxForgeFieldFunctionResult, DbxForgeFieldHiddenFieldsRef, DbxForgeFieldHintValueRef, DbxForgeFieldIdempotentTransformLogic, DbxForgeFieldIdempotentTransformLogicWhenAlways, DbxForgeFieldIdempotentTransformLogicWhenDefined, DbxForgeFieldLogicAsyncFn, DbxForgeFieldLogicExternalData, DbxForgeFieldLogicFn, DbxForgeFieldLogicValueRef, DbxForgeFieldRegistryAugmentation, DbxForgeFieldTransformFunction, DbxForgeFieldTransformLogic, DbxForgeFieldTransformType, DbxForgeFieldTransformWhen, DbxForgeFieldValidation, DbxForgeFieldValidatorInput, DbxForgeFieldValueIsAvailableCheckFn, DbxForgeFieldValueIsAvailableValidatorConfig, DbxForgeFinalizeFormConfigResult, DbxForgeFixedDateRangeFieldComponentProps, DbxForgeFixedDateRangeFieldConfig, DbxForgeFixedDateRangeFieldDef, DbxForgeFixedDateRangeValue, DbxForgeFlexLayoutConfig, DbxForgeFlexLayoutFieldConfig, DbxForgeFlexWrapper, DbxForgeFormFieldWrapperDef, DbxForgeFormFieldWrapperProps, DbxForgeFormFieldWrapperShowLabelAt, DbxForgeGlobalFormConfigDefaults, DbxForgeGroupConfig, DbxForgeInfoButtonFieldDef, DbxForgeInfoButtonFieldProps, DbxForgeInfoWrapper, DbxForgeLatLngTextFieldConfig, DbxForgeListSelectionFieldConfig, DbxForgeListSelectionFieldDef, DbxForgeListSelectionFieldFunction, DbxForgeListSelectionFieldMaxHeight, DbxForgeListSelectionFieldProps, DbxForgeNameFieldConfig, DbxForgeNumberFieldConfig, DbxForgeNumberFieldNumberConfig, DbxForgeNumberSliderFieldConfig, DbxForgePhoneFieldAutocomplete, DbxForgePhoneFieldConfig, DbxForgePhoneFieldDef, DbxForgePhoneFieldProps, DbxForgePickableChipFieldConfig, DbxForgePickableChipFieldDef, DbxForgePickableChipFieldFunction, DbxForgePickableFieldProps, DbxForgePickableListFieldConfig, DbxForgePickableListFieldDef, DbxForgePickableListFieldFunction, DbxForgePresetSearchFormFieldsConfig, DbxForgePresetSearchFormFieldsValue, DbxForgeResolvedSelectionOption, DbxForgeRowConfig, DbxForgeSearchableChipFieldConfig, DbxForgeSearchableChipFieldDef, DbxForgeSearchableChipFieldFunction, DbxForgeSearchableChipFieldProps, DbxForgeSearchableStringChipFieldConfig, DbxForgeSearchableTextFieldConfig, DbxForgeSearchableTextFieldDef, DbxForgeSearchableTextFieldFunction, DbxForgeSearchableTextFieldProps, DbxForgeSectionWrapper, DbxForgeSourceSelectFieldConfig, DbxForgeSourceSelectFieldDef, DbxForgeSourceSelectFieldFunction, DbxForgeSourceSelectFieldProps, DbxForgeStateFieldConfig, DbxForgeStyleObject, DbxForgeStyleWrapper, DbxForgeTextAreaFieldConfig, DbxForgeTextAvailableFieldConfig, DbxForgeTextEditorFieldConfig, DbxForgeTextEditorFieldDef, DbxForgeTextEditorFieldProps, DbxForgeTextFieldConfig, DbxForgeTextFieldInputType, DbxForgeTextFieldLengthConfig, DbxForgeTextFieldPatternConfig, DbxForgeTextPasswordFieldConfig, DbxForgeTextPasswordFieldPasswordParameters, DbxForgeTextPasswordWithVerifyFieldConfig, DbxForgeTimeDurationFieldComponentProps, DbxForgeTimeDurationFieldConfig, DbxForgeTimeDurationFieldDef, DbxForgeTimezoneStringFieldConfig, DbxForgeToggleFieldConfig, DbxForgeToggleWrapperConfig, DbxForgeUsernameLoginFieldUsernameConfig, DbxForgeUsernameLoginFieldUsernameConfigInput, DbxForgeUsernameLoginFieldsConfig, DbxForgeValueSelectionFieldConfig, DbxForgeValueSelectionFieldDef, DbxForgeValueSelectionFieldFunction, DbxForgeValueSelectionFieldProps, DbxForgeWebsiteUrlFieldConfig, DbxForgeWorkingWrapper, DbxForgeZipCodeFieldConfig, DbxFormDisabledKey, DbxFormEvent, DbxFormSourceDirectiveMode, DbxFormStateRef, DisableAutocompleteForField, ExtractDbxForgeFieldDef, FieldAutocompleteAttributeOption, FieldAutocompleteAttributeOptionRef, FieldAutocompleteAttributeValue, FieldAutocompleteAttributes, FieldValueIsAvailableValidatorConfig, FieldValueIsAvailableValidatorFunction, FieldValuesAreEqualValidatorConfig, FilterPresetsInput, FixedDateRangeScan, FixedDateRangeScanType, FormControlPath, IsDivisibleByError, IsNotWebsiteUrlErrorData, IsWebsiteUrlValidatorConfig, KeyboardStepResult, PickableItemFieldItem, PickableItemFieldItemSortFn, PickableValueFieldDisplayFunction, PickableValueFieldDisplayValue, PickableValueFieldFilterFunction, PickableValueFieldFilterSelectedValuesFunction, PickableValueFieldFilterSelectedValuesInput, PickableValueFieldHashFunction, PickableValueFieldLoadValuesFunction, PickableValueFieldValue, PickableValueFieldValuesConfigForStaticLabeledValues, PickableValueFieldValuesConfigForStaticLabeledValuesConfig, ProvideDbxFormConfigurationConfig, SearchableValueFieldAnchorFn, SearchableValueFieldDisplayFn, SearchableValueFieldDisplayValue, SearchableValueFieldHashFn, SearchableValueFieldStringSearchFn, SearchableValueFieldValue, SelectionDisplayValue, SelectionValue, SelectionValueHashFunction, SourceSelectDisplayFunction, SourceSelectDisplayValue, SourceSelectDisplayValueGroup, SourceSelectLoadSource, SourceSelectLoadSourceLoadingState, SourceSelectLoadSourcesFunction, SourceSelectMetaValueReader, SourceSelectOpenFunction, SourceSelectOpenFunctionParams, SourceSelectOpenSourceResult, SourceSelectOptions, SourceSelectValue, SourceSelectValueGroup, SourceSelectValueMetaLoader, TimeDurationFieldValueMode, ValueSelectionOption, ValueSelectionOptionClear, ValueSelectionOptionWithValue };