@tstdl/base 0.91.40 → 0.91.42

package/form/controls/number.control.d.ts

@@ -1,33 +0,0 @@
-import type { Signal } from '../../signals/api.js';
-import type { ReactiveValue } from '../../types.js';
-import type { InputAutocomplete } from '../../web-types.js';
-import { FormControl, type FormControlOptions, type InitialValue, type InitialValueOption } from '../form-control.js';
-import type { DynamicTextOption } from '../types.js';
-export type NumberFormControlOptions<I extends InitialValue<number> = InitialValue<number>> = FormControlOptions<number | I> & {
-    autocomplete?: InputAutocomplete;
-    placeholder?: ReactiveValue<DynamicTextOption>;
-    integer?: ReactiveValue<boolean>;
-    format?: ReactiveValue<Intl.NumberFormatOptions>;
-    minimum?: ReactiveValue<number | null>;
-    maximum?: ReactiveValue<number | null>;
-    step?: ReactiveValue<number>;
-};
-export declare class NumberFormControl<I extends InitialValue<number> = number | null> extends FormControl<number | I, string> {
-    protected readonly internalValidators: Signal<readonly import("../index.js").FormValidator<any>[]>;
-    readonly autocomplete: Signal<InputAutocomplete>;
-    readonly placeholder: Signal<DynamicTextOption>;
-    readonly integer: Signal<boolean>;
-    readonly format: Signal<Intl.NumberFormatOptions>;
-    readonly minimum: Signal<number | null>;
-    readonly maximum: Signal<number | null>;
-    readonly step: Signal<number | null>;
-    constructor(initialValue: I, options?: NumberFormControlOptions<I>);
-    parseRawValue(value: number | I): number | I;
-    parseInputValue(value: string | null): number | I | null;
-    formatRawValue(value: number | I): string;
-}
-export declare function numberFormControl<I extends InitialValue<number>>(options: NumberFormControlOptions<I> & InitialValueOption<I>): NumberFormControl<I>;
-export declare function numberFormControl<I extends InitialValue<number>>(options?: NumberFormControlOptions<I>): NumberFormControl;
-export declare function integerNumberControl(options: NumberFormControlOptions): NumberFormControl;
-export declare function yearNumberControl(options: NumberFormControlOptions): NumberFormControl;
-export declare function isNumberFormControl(value: any): value is NumberFormControl<any>;

package/form/controls/number.control.js

@@ -1,73 +0,0 @@
-import { decimalFormat, formatNumber, integerFormat, yearFormat } from '../../formats.js';
-import { getNumberParser } from '../../intl/number-parser.js';
-import { isDefined, isNull, isNumber } from '../../utils/type-guards.js';
-import { computedInternalValidators } from '../abstract-control.js';
-import { FormControl } from '../form-control.js';
-import { reactiveOptionToSignal } from '../utils.js';
-import { numberValidator } from '../validators/number.validator.js';
-const numberParser = getNumberParser('de');
-export class NumberFormControl extends FormControl {
-    internalValidators = computedInternalValidators(() => {
-        const minimum = this.minimum();
-        const maximum = this.maximum();
-        return [(isDefined(minimum) || isDefined(maximum)) ? numberValidator(minimum, maximum) : undefined];
-    });
-    autocomplete;
-    placeholder;
-    integer;
-    format;
-    minimum;
-    maximum;
-    step;
-    constructor(initialValue, options = {}) {
-        super(initialValue, options);
-        this.autocomplete = reactiveOptionToSignal(options.autocomplete ?? 'off', { initialValue: 'off' });
-        this.placeholder = reactiveOptionToSignal(options.placeholder ?? null, { initialValue: null });
-        this.integer = reactiveOptionToSignal(options.integer ?? false, { initialValue: false });
-        this.format = reactiveOptionToSignal(options.format ?? decimalFormat, { initialValue: decimalFormat });
-        this.minimum = reactiveOptionToSignal(options.minimum ?? null, { initialValue: null });
-        this.maximum = reactiveOptionToSignal(options.maximum ?? null, { initialValue: null });
-        this.step = reactiveOptionToSignal(options.step ?? null, { initialValue: null });
-    }
-    parseRawValue(value) {
-        if (isNumber(value) && this.integer()) {
-            return Math.floor(value);
-        }
-        return value;
-    }
-    parseInputValue(value) {
-        if (isNull(value) || (value.trim().length == 0)) {
-            return null;
-        }
-        const parsed = numberParser.parse(value, true);
-        return this.integer() ? Math.floor(parsed) : parsed;
-    }
-    formatRawValue(value) {
-        if (isNull(value)) {
-            return '';
-        }
-        const valueToFormat = this.integer() ? Math.floor(value) : value;
-        return formatNumber(valueToFormat, this.format());
-    }
-}
-export function numberFormControl(options) {
-    return new NumberFormControl(null, options);
-}
-export function integerNumberControl(options) {
-    return numberFormControl({
-        integer: true,
-        format: integerFormat,
-        ...options
-    });
-}
-export function yearNumberControl(options) {
-    return integerNumberControl({
-        format: yearFormat,
-        minimum: 1600,
-        maximum: 2200,
-        ...options,
-    });
-}
-export function isNumberFormControl(value) {
-    return (value instanceof NumberFormControl);
-}

package/form/controls/radio-group.control.d.ts

@@ -1,22 +0,0 @@
-import type { Signal } from '../../signals/api.js';
-import type { EnumerationObject, FilledReadonlyArray, TypedOmit } from '../../types.js';
-import type { InitialValue, InitialValueOption } from '../form-control.js';
-import { ItemsFormControl, type ItemsFormControlOptions } from './items.control.js';
-export type RadioGroupFormControlDirection = 'row' | 'column';
-export type RadioGroupFormControlOptions<T, I extends InitialValue<T>> = ItemsFormControlOptions<T, I> & {
-    direction?: RadioGroupFormControlDirection;
-};
-export declare class RadioGroupFormControl<T, I extends InitialValue<T> = T | null> extends ItemsFormControl<T, I> {
-    readonly direction: Signal<RadioGroupFormControlDirection>;
-    constructor(initialValue: I, options: RadioGroupFormControlOptions<T, I>);
-}
-export declare function radioGroupFormControl<T, I extends InitialValue<T>>(options: RadioGroupFormControlOptions<T, I> & InitialValueOption<I>): RadioGroupFormControl<T, I>;
-export declare function radioGroupFormControl<T, I extends InitialValue<T>>(options: RadioGroupFormControlOptions<T, I>): RadioGroupFormControl<T, T | null>;
-export declare function booleanRadioGroupFormControl<I extends InitialValue<boolean>>(options: TypedOmit<RadioGroupFormControlOptions<boolean, I>, 'items'> & InitialValueOption<I>): RadioGroupFormControl<boolean, I>;
-export declare function booleanRadioGroupFormControl<I extends InitialValue<boolean>>(options?: TypedOmit<RadioGroupFormControlOptions<boolean, I>, 'items'>): RadioGroupFormControl<boolean>;
-export type EnumRadioGroupFormControlOptions<T extends EnumerationObject, I extends InitialValue<T[keyof T]>> = TypedOmit<RadioGroupFormControlOptions<T[keyof T], I>, 'items'> & {
-    allowedValues?: FilledReadonlyArray<T[keyof T]>;
-};
-export declare function enumRadioGroupFormControl<T extends EnumerationObject, I extends InitialValue<T[keyof T]>>(enumeration: T, options: EnumRadioGroupFormControlOptions<T, I> & InitialValueOption<I>): RadioGroupFormControl<T[keyof T], I>;
-export declare function enumRadioGroupFormControl<T extends EnumerationObject, I extends InitialValue<T[keyof T]>>(enumeration: T, options?: EnumRadioGroupFormControlOptions<T, I>): RadioGroupFormControl<T[keyof T]>;
-export declare function isRadioGroupFormControl(value: any): value is RadioGroupFormControl<any, any>;

package/form/controls/radio-group.control.js

@@ -1,28 +0,0 @@
-import { tstdlCommonLocalizationKeys } from '../../text/common-localization.js';
-import { enumAsItems, reactiveOptionToSignal } from '../utils.js';
-import { ItemsFormControl } from './items.control.js';
-export class RadioGroupFormControl extends ItemsFormControl {
-    direction;
-    constructor(initialValue, options) {
-        super(initialValue, options);
-        this.direction = reactiveOptionToSignal(options.direction ?? 'column', { initialValue: 'column' });
-    }
-}
-export function radioGroupFormControl(options) {
-    return new RadioGroupFormControl(null, options);
-}
-export function booleanRadioGroupFormControl(options = {}) {
-    return radioGroupFormControl({
-        ...options,
-        items: [{ label: tstdlCommonLocalizationKeys.yes, value: true }, { label: tstdlCommonLocalizationKeys.no, value: false }]
-    });
-}
-export function enumRadioGroupFormControl(enumeration, options = {}) {
-    return radioGroupFormControl({
-        ...options,
-        items: enumAsItems(enumeration, options.allowedValues)
-    });
-}
-export function isRadioGroupFormControl(value) {
-    return (value instanceof RadioGroupFormControl);
-}

package/form/controls/select.control.d.ts

@@ -1,17 +0,0 @@
-import type { EnumerationObject, FilledReadonlyArray, TypedOmit } from '../../types.js';
-import type { InitialValue, InitialValueOption } from '../form-control.js';
-import { ItemsFormControl, type ItemsFormControlOptions } from './items.control.js';
-export type SelectFormControlOptions<T, I extends InitialValue<T>> = ItemsFormControlOptions<T, I>;
-export declare class SelectFormControl<T, I extends InitialValue<T> = T | null> extends ItemsFormControl<T, I> {
-    constructor(initialValue: I, options: SelectFormControlOptions<T, I>);
-}
-export declare function selectFormControl<T, I extends InitialValue<T>>(options: SelectFormControlOptions<T, I> & InitialValueOption<I>): SelectFormControl<T, I>;
-export declare function selectFormControl<T, I extends InitialValue<T>>(options: SelectFormControlOptions<T, I>): SelectFormControl<T, T | null>;
-export declare function booleanSelectFormControl<I extends InitialValue<boolean>>(options: TypedOmit<SelectFormControlOptions<boolean, I>, 'items'> & InitialValueOption<I>): SelectFormControl<boolean, I>;
-export declare function booleanSelectFormControl<I extends InitialValue<boolean>>(options?: TypedOmit<SelectFormControlOptions<boolean, I>, 'items'>): SelectFormControl<boolean>;
-export type EnumSelectFormControlOptions<T extends EnumerationObject, I extends InitialValue<T[keyof T]>> = TypedOmit<SelectFormControlOptions<T[keyof T], I>, 'items'> & {
-    allowedValues?: FilledReadonlyArray<T[keyof T]>;
-};
-export declare function enumSelectFormControl<T extends EnumerationObject, I extends InitialValue<T[keyof T]>>(enumeration: T, options: EnumSelectFormControlOptions<T, I> & InitialValueOption<I>): SelectFormControl<T[keyof T], I>;
-export declare function enumSelectFormControl<T extends EnumerationObject, I extends InitialValue<T[keyof T]>>(enumeration: T, options?: EnumSelectFormControlOptions<T, I>): SelectFormControl<T[keyof T]>;
-export declare function isSelectFormControl(value: any): value is SelectFormControl<any, any>;

package/form/controls/select.control.js

@@ -1,26 +0,0 @@
-import { tstdlCommonLocalizationKeys } from '../../text/common-localization.js';
-import { enumAsItems } from '../utils.js';
-import { ItemsFormControl } from './items.control.js';
-export class SelectFormControl extends ItemsFormControl {
-    constructor(initialValue, options) {
-        super(initialValue, options);
-    }
-}
-export function selectFormControl(options) {
-    return new SelectFormControl(null, options);
-}
-export function booleanSelectFormControl(options = {}) {
-    return selectFormControl({
-        ...options,
-        items: [{ label: tstdlCommonLocalizationKeys.yes, value: true }, { label: tstdlCommonLocalizationKeys.no, value: false }]
-    });
-}
-export function enumSelectFormControl(enumeration, options = {}) {
-    return selectFormControl({
-        ...options,
-        items: enumAsItems(enumeration, options.allowedValues)
-    });
-}
-export function isSelectFormControl(value) {
-    return (value instanceof SelectFormControl);
-}

package/form/controls/text.control.d.ts

@@ -1,47 +0,0 @@
-import { type Signal } from '../../signals/index.js';
-import type { ReactiveValue, TypedOmit } from '../../types.js';
-import type { InputAutocomplete } from '../../web-types.js';
-import { FormControl, type FormControlOptions, type InitialValue, type InitialValueOption } from '../form-control.js';
-import type { DynamicTextOption } from '../types.js';
-export type TextFormControlType = 'text' | 'password' | 'email';
-export type AutoFillSuggestionSelectHandler<T = any> = (suggestion: AutoFillSuggestion<T>) => any;
-export type AutoFillSuggestion<T = any> = {
-    display: ReactiveValue<string>;
-    selectValue?: string;
-    data?: T;
-    onSelect?: AutoFillSuggestionSelectHandler<T>;
-};
-export type NormalizedAutoFillSuggestion<T = any> = TypedOmit<AutoFillSuggestion<T>, 'display'> & {
-    display: Signal<string>;
-    searchText: Signal<string>;
-};
-export type TextFormControlOptions<I extends InitialValue<string> = InitialValue<string>> = FormControlOptions<string | I> & {
-    type?: ReactiveValue<TextFormControlType>;
-    autocomplete?: ReactiveValue<InputAutocomplete>;
-    placeholder?: ReactiveValue<DynamicTextOption>;
-    pattern?: ReactiveValue<RegExp | null>;
-    inputPattern?: ReactiveValue<RegExp | null>;
-    trim?: ReactiveValue<boolean>;
-    maxLength?: ReactiveValue<number>;
-    autoFillSuggestions?: ReactiveValue<(string | AutoFillSuggestion)[] | undefined>;
-    filterAutoFillSuggestions?: ReactiveValue<boolean>;
-};
-export declare class TextFormControl<I extends InitialValue<string> = string | null> extends FormControl<string | I, string> {
-    protected readonly internalValidators: Signal<readonly import("../validators/form.validator.js").FormValidator<any>[]>;
-    readonly type: Signal<TextFormControlType>;
-    readonly autocomplete: Signal<InputAutocomplete>;
-    readonly placeholder: Signal<DynamicTextOption>;
-    readonly pattern: Signal<RegExp | null>;
-    readonly inputPattern: Signal<RegExp | null>;
-    readonly trim: Signal<boolean>;
-    readonly maxLength: Signal<number | null>;
-    readonly autoFillSuggestions: Signal<readonly NormalizedAutoFillSuggestion[] | null>;
-    readonly filterAutoFillSuggestions: Signal<boolean>;
-    readonly filteredAutoFillSuggestions: Signal<readonly NormalizedAutoFillSuggestion[] | null>;
-    constructor(initialValue: I, options?: TextFormControlOptions<I>);
-    parseInputValue(value: string | null): string | I | null;
-    formatRawValue(value: string | null): string;
-}
-export declare function textFormControl<I extends InitialValue<string>>(options: TextFormControlOptions<I> & InitialValueOption<I>): TextFormControl<I>;
-export declare function textFormControl<I extends InitialValue<string>>(options?: TextFormControlOptions<I>): TextFormControl;
-export declare function isTextFormControl(value: any): value is TextFormControl<any>;

package/form/controls/text.control.js

@@ -1,94 +0,0 @@
-import { computed, getCurrentSignalsInjector, runInSignalsInjectionContext } from '../../signals/index.js';
-import { normalizeText } from '../../utils/helpers.js';
-import { mailPattern } from '../../utils/patterns.js';
-import { isNotNull, isNull, isNumber, isString } from '../../utils/type-guards.js';
-import { computedInternalValidators } from '../abstract-control.js';
-import { FormControl } from '../form-control.js';
-import { reactiveOptionToSignal } from '../utils.js';
-import { maxLengthValidator, patternValidator } from '../validators/index.js';
-export class TextFormControl extends FormControl {
-    internalValidators = computedInternalValidators(() => {
-        const pattern = this.pattern();
-        const maxLength = this.maxLength();
-        const type = this.type();
-        return [
-            isNumber(maxLength) ? maxLengthValidator(maxLength) : null,
-            (type == 'email') ? patternValidator(mailPattern) : null,
-            isNotNull(pattern) ? patternValidator(pattern) : null
-        ];
-    });
-    type;
-    autocomplete;
-    placeholder;
-    pattern;
-    inputPattern;
-    trim;
-    maxLength;
-    autoFillSuggestions;
-    filterAutoFillSuggestions;
-    filteredAutoFillSuggestions;
-    constructor(initialValue, options = {}) {
-        super(initialValue, options);
-        this.type = reactiveOptionToSignal(options.type ?? 'text', { initialValue: 'text' });
-        this.autocomplete = reactiveOptionToSignal(options.autocomplete ?? 'off', { initialValue: 'off' });
-        this.placeholder = reactiveOptionToSignal(options.placeholder ?? null, { initialValue: null });
-        this.pattern = reactiveOptionToSignal(options.pattern ?? null, { initialValue: null });
-        this.inputPattern = reactiveOptionToSignal(options.inputPattern ?? null, { initialValue: null });
-        this.trim = reactiveOptionToSignal(options.trim ?? true, { initialValue: true });
-        this.maxLength = reactiveOptionToSignal(options.maxLength ?? null, { initialValue: null });
-        const rawAutoFillSuggestions = reactiveOptionToSignal(options.autoFillSuggestions);
-        const signalsInjector = getCurrentSignalsInjector();
-        this.autoFillSuggestions = computed(() => runInSignalsInjectionContext(signalsInjector, () => normalizeAutoFillSuggestions(rawAutoFillSuggestions() ?? null)));
-        this.filterAutoFillSuggestions = reactiveOptionToSignal(options.filterAutoFillSuggestions ?? true, { initialValue: true });
-        this.filteredAutoFillSuggestions = computed(() => {
-            const searchValue = normalizeText(this.value() ?? '');
-            const autoFillSuggestions = this.autoFillSuggestions();
-            if (isNull(autoFillSuggestions)) {
-                return null;
-            }
-            if (!this.filterAutoFillSuggestions() || (searchValue.length == 0)) {
-                return autoFillSuggestions;
-            }
-            return autoFillSuggestions.filter((suggestion) => suggestion.searchText().includes(searchValue));
-        });
-    }
-    parseInputValue(value) {
-        if (isNull(value)) {
-            return null;
-        }
-        const normalized = this.trim() ? value.trim() : value;
-        if (normalized.length == 0) {
-            return null;
-        }
-        return normalized;
-    }
-    formatRawValue(value) {
-        return value ?? '';
-    }
-}
-export function textFormControl(options) {
-    return new TextFormControl(null, options);
-}
-export function isTextFormControl(value) {
-    return (value instanceof TextFormControl);
-}
-function normalizeAutoFillSuggestions(suggestions) {
-    if (isNull(suggestions)) {
-        return null;
-    }
-    return suggestions.map((suggestion) => {
-        if (isString(suggestion)) {
-            return {
-                display: computed(() => suggestion),
-                searchText: computed(() => normalizeText(suggestion)),
-                data: suggestion
-            };
-        }
-        const displaySignal = reactiveOptionToSignal(suggestion.display, { requireSync: true });
-        return {
-            ...suggestion,
-            display: displaySignal,
-            searchText: computed(() => normalizeText(displaySignal()))
-        };
-    });
-}

package/form/controls/time.control.d.ts

@@ -1,24 +0,0 @@
-import type { Signal } from '../../signals/api.js';
-import type { ReactiveValue } from '../../types.js';
-import type { InputAutocomplete } from '../../web-types.js';
-import { FormControl, type FormControlOptions, type InitialValue, type InitialValueOption } from '../form-control.js';
-import type { DynamicTextOption } from '../types.js';
-export type TimeFormControlOptions<I extends InitialValue<number> = InitialValue<number>> = FormControlOptions<number | I> & {
-    autocomplete?: InputAutocomplete;
-    placeholder?: ReactiveValue<DynamicTextOption>;
-    minimum?: ReactiveValue<number | null>;
-    maximum?: ReactiveValue<number | null>;
-};
-export declare class TimeFormControl<I extends InitialValue<number> = number | null> extends FormControl<number | I, string> {
-    protected readonly internalValidators: Signal<readonly import("../index.js").FormValidator<any>[]>;
-    readonly autocomplete: Signal<InputAutocomplete>;
-    readonly placeholder: Signal<DynamicTextOption>;
-    readonly minimum: Signal<number | null>;
-    readonly maximum: Signal<number | null>;
-    constructor(initialValue: I, options?: TimeFormControlOptions<I>);
-    parseInputValue(value: string | null): number | null;
-    formatRawValue(value: number | null): string;
-}
-export declare function timeFormControl<I extends InitialValue<number>>(options: TimeFormControlOptions<I> & InitialValueOption<I>): TimeFormControl<I>;
-export declare function timeFormControl<I extends InitialValue<number>>(options?: TimeFormControlOptions<I>): TimeFormControl;
-export declare function isTimeFormControl(value: any): value is TimeFormControl<any>;

package/form/controls/time.control.js

@@ -1,44 +0,0 @@
-import { Duration } from 'luxon';
-import { isDefined, isNull } from '../../utils/type-guards.js';
-import { millisecondsPerHour, millisecondsPerMinute, millisecondsPerSecond } from '../../utils/units.js';
-import { computedInternalValidators } from '../abstract-control.js';
-import { FormControl } from '../form-control.js';
-import { reactiveOptionToSignal } from '../utils.js';
-import { timeValidator } from '../validators/time.validator.js';
-export class TimeFormControl extends FormControl {
-    internalValidators = computedInternalValidators(() => {
-        const minimum = this.minimum();
-        const maximum = this.maximum();
-        return [(isDefined(minimum) || isDefined(maximum)) ? timeValidator(minimum, maximum) : undefined];
-    });
-    autocomplete;
-    placeholder;
-    minimum;
-    maximum;
-    constructor(initialValue, options = {}) {
-        super(initialValue, options);
-        this.autocomplete = reactiveOptionToSignal(options.autocomplete ?? 'off', { initialValue: 'off' });
-        this.placeholder = reactiveOptionToSignal(options.placeholder ?? null, { initialValue: null });
-        this.minimum = reactiveOptionToSignal(options.minimum ?? null, { initialValue: null });
-        this.maximum = reactiveOptionToSignal(options.maximum ?? null, { initialValue: null });
-    }
-    parseInputValue(value) {
-        if (isNull(value)) {
-            return null;
-        }
-        const [hours, minutes, seconds] = value.split(':').map((part) => Number(part));
-        return ((hours ?? 0) * millisecondsPerHour) + ((minutes ?? 0) * millisecondsPerMinute) + ((seconds ?? 0) * millisecondsPerSecond);
-    }
-    formatRawValue(value) {
-        if (isNull(value) || Number.isNaN(value)) {
-            return '';
-        }
-        return Duration.fromMillis(value).toFormat('hh:mm');
-    }
-}
-export function timeFormControl(options) {
-    return new TimeFormControl(null, options);
-}
-export function isTimeFormControl(value) {
-    return (value instanceof TimeFormControl);
-}

package/form/form-array.d.ts

@@ -1,71 +0,0 @@
-import type { JsonPath } from '../json-path/json-path.js';
-import { type Signal } from '../signals/api.js';
-import type { ReactiveValue } from '../types.js';
-import { type AbstractControl, type AbstractControlParent, type AbstractControlRawValueType, type AbstractControlValueType, type MarkOptions } from './abstract-control.js';
-import { FormContainer, type FormContainerOptions } from './form-container.js';
-import type { FormControlRemoveHandler } from './types.js';
-import type { FormValidatorError } from './validators/form.validator.js';
-export type FormArrayDisplayType = 'simple' | 'tabs';
-export type FormArrayChildBuilder<T = unknown, TRaw = unknown, C extends AbstractControl<T, TRaw> = AbstractControl<T, TRaw>> = (value: T) => C;
-export type FormArrayOptions<T, TRaw, C extends AbstractControl<T, TRaw>> = FormContainerOptions<T[]> & {
-    children?: C[];
-    displayType?: FormArrayDisplayType;
-    allowRemove?: ReactiveValue<boolean>;
-    allowRemoveAll?: ReactiveValue<boolean>;
-    removeHandler?: FormControlRemoveHandler<C & {}>;
-    builder?: FormArrayChildBuilder<T, TRaw, C>;
-};
-export type FormArrayByControl<C extends AbstractControl = AbstractControl> = FormArray<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-export type FormArrayChild<T extends FormArray> = ReturnType<T['children']>[number];
-export declare class FormArray<T = any, TRaw = any, C extends AbstractControl<T, TRaw> = AbstractControl<T, TRaw>> extends FormContainer<T[], TRaw[]> implements Iterable<C> {
-    #private;
-    protected readonly internalValidators: null;
-    readonly children: Signal<readonly C[]>;
-    readonly enabledChildren: Signal<readonly C[]>;
-    readonly size: Signal<number>;
-    readonly displayType: Signal<FormArrayDisplayType>;
-    readonly allowRemove: Signal<boolean>;
-    readonly allowRemoveAll: Signal<boolean>;
-    readonly removedChildren: Signal<C[]>;
-    readonly removeHandler: FormControlRemoveHandler<any>;
-    readonly builder: FormArrayChildBuilder<T, TRaw, C>;
-    /** Raw values of all children whether disabled or not */
-    readonly rawValue: Signal<TRaw[]>;
-    /** Values of all enabled children */
-    readonly value: Signal<T[]>;
-    readonly dirty: Signal<boolean>;
-    readonly touched: Signal<boolean>;
-    readonly localErrors: Signal<readonly FormValidatorError[]>;
-    readonly childrenErrors: Signal<FormValidatorError[]>;
-    readonly errors: Signal<FormValidatorError[]>;
-    readonly errorDebug: Signal<{
-        _self: readonly FormValidatorError[];
-    } | null>;
-    constructor(options?: FormArrayOptions<T, TRaw, C>);
-    get(index: number): C | undefined;
-    getValue(index: number): T | undefined;
-    getRawValue(index: number): TRaw | undefined;
-    reset(): void;
-    indexOf(child: C): number | null;
-    add(...children: C[]): void;
-    addValue(...values: T[]): void;
-    removeAll(): void;
-    remove(child: C): void;
-    removeAt(index: number, count?: number): void;
-    setValue(values: T[]): void;
-    markAsDirty({ onlySelf }?: MarkOptions): void;
-    markAsTouched({ onlySelf }?: MarkOptions): void;
-    setParent(parent: AbstractControlParent, force?: boolean): void;
-    setParent(parent: null): void;
-    [Symbol.iterator](): Iterator<C>;
-    getChildPath(child: C): Signal<JsonPath>;
-    private updateParents;
-}
-export declare function formArray<C extends AbstractControl>(options: FormArrayOptions<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C> & {
-    builder: FormArrayChildBuilder<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-}): FormArray<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-export declare function formArray<C extends AbstractControl>(options: FormArrayOptions<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C> & {
-    children: C[];
-}): FormArray<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-export declare function formArray<T, TRaw, C extends AbstractControl>(options: FormArrayOptions<T, TRaw, C>): FormArray<T, TRaw, C>;
-export declare function isFormArray(value: any): value is FormArray;