@tstdl/base 0.91.40 → 0.91.42

package/form/form-array.js

@@ -1,188 +0,0 @@
-import { computed, signal, untracked } from '../signals/api.js';
-import { switchAll } from '../signals/index.js';
-import { createArray } from '../utils/array/array.js';
-import { fromEntries } from '../utils/object/object.js';
-import { deferThrow } from '../utils/throw.js';
-import { isDefined, isNotNull } from '../utils/type-guards.js';
-import { ignoreFormValue } from './abstract-control.js';
-import { FormContainer } from './form-container.js';
-import { bindReactiveOption } from './utils.js';
-export class FormArray extends FormContainer {
-    #children = signal([]);
-    #selfTouched = signal(false);
-    #selfDirty = signal(false);
-    #displayType = signal('tabs');
-    #allowRemove = signal(true);
-    #allowRemoveAll = signal(true);
-    #removedChildren = signal(new Set());
-    internalValidators = null;
-    children = this.#children.asReadonly();
-    enabledChildren = computed(() => this.#children().filter((child) => child.enabled()));
-    size = computed(() => this.children().length);
-    displayType = this.#displayType.asReadonly();
-    allowRemove = this.#allowRemove.asReadonly();
-    allowRemoveAll = this.#allowRemoveAll.asReadonly();
-    removedChildren = computed(() => [...this.#removedChildren()]);
-    removeHandler;
-    builder;
-    /** Raw values of all children whether disabled or not */
-    rawValue = computed(() => this.#children().map((child) => child.rawValue()));
-    /** Values of all enabled children */
-    value = computed(() => this.enabledChildren().map((child) => child.value()));
-    dirty = computed(() => this.#selfDirty() || this.children().some((child) => child.dirty()));
-    touched = computed(() => this.#selfTouched() || this.children().some((child) => child.touched()));
-    localErrors = switchAll(() => {
-        const validations = this.validators().map((validator) => validator(this));
-        return computed(() => validations.map((validation) => validation()).filter(isNotNull));
-    });
-    childrenErrors = computed(() => this.children().flatMap((child) => child.errors()));
-    errors = computed(() => [
-        ...this.localErrors(),
-        ...this.childrenErrors()
-    ]);
-    errorDebug = computed(() => this.valid()
-        ? null
-        : ({
-            _self: this.localErrors(),
-            ...fromEntries(this.children().map((child, index) => [index, child.errorDebug()]).filter(([, errorDebug]) => isNotNull(errorDebug)))
-        }));
-    constructor(options = {}) {
-        super(options);
-        this.builder = options.builder ?? deferThrow(() => new Error('Builder required to add children by value'));
-        this.removeHandler = options.removeHandler ?? (() => true);
-        if (isDefined(options.children)) {
-            this.add(...options.children);
-        }
-        bindReactiveOption(options.displayType, this.#displayType);
-        bindReactiveOption(options.allowRemove, this.#allowRemove);
-        bindReactiveOption(options.allowRemoveAll, this.#allowRemoveAll);
-    }
-    get(index) {
-        return this.children()[index];
-    }
-    getValue(index) {
-        return this.get(index)?.value();
-    }
-    getRawValue(index) {
-        return this.get(index)?.rawValue();
-    }
-    reset() {
-        for (const child of untracked(this.#children)) {
-            child.reset();
-        }
-        this.#removedChildren.set(new Set());
-    }
-    indexOf(child) {
-        const index = untracked(this.children).indexOf(child);
-        return (index == -1) ? null : index;
-    }
-    add(...children) {
-        this.#children.set([...untracked(this.children), ...children]);
-        for (const child of children) {
-            child.setParent(this);
-        }
-    }
-    addValue(...values) {
-        const children = values.map((value) => this.builder(value));
-        this.add(...children);
-    }
-    removeAll() {
-        const newlyRemovedChildren = [];
-        for (const child of untracked(this.children)) {
-            if (untracked(child.parent) == this) {
-                child.setParent(null);
-            }
-            newlyRemovedChildren.push(child);
-        }
-        this.#removedChildren.update((removedChildren) => new Set([...removedChildren, ...newlyRemovedChildren]));
-        this.#children.set([]);
-    }
-    remove(child) {
-        const index = this.indexOf(child);
-        if (isNotNull(index)) {
-            this.removeAt(index);
-        }
-    }
-    removeAt(index, count = 1) {
-        const children = untracked(this.children);
-        const newlyRemovedChildren = [];
-        const end = Math.min(index + count, children.length);
-        if (end <= index) {
-            return;
-        }
-        for (let i = index; i < end; i++) {
-            const child = children[i];
-            child.setParent(null);
-            newlyRemovedChildren.push(child);
-        }
-        const spliced = children.toSpliced(index, 1);
-        this.#removedChildren.update((removedChildren) => new Set([...removedChildren, ...newlyRemovedChildren]));
-        this.#children.set(spliced);
-    }
-    setValue(values) {
-        if (values == ignoreFormValue) {
-            return;
-        }
-        let children = untracked(this.#children);
-        const newlyRemovedChildren = [];
-        if (values.length < children.length) {
-            for (let i = values.length; i < children.length - 1; i++) {
-                const child = children[i];
-                child.setParent(null);
-                newlyRemovedChildren.push(child);
-            }
-            children = children.slice(0, values.length);
-        }
-        else if (values.length > children.length) {
-            const newChildren = createArray(values.length - children.length, (index) => this.builder(values[children.length + index]));
-            children = [...children, ...newChildren];
-        }
-        for (let i = 0; i < values.length; i++) {
-            children[i].setValue(values[i]);
-        }
-        this.#removedChildren.update((removedChildren) => new Set([...removedChildren, ...newlyRemovedChildren]));
-        this.#children.set(children);
-    }
-    markAsDirty({ onlySelf = false } = {}) {
-        this.#selfDirty.set(true);
-        if (onlySelf) {
-            return;
-        }
-        for (const child of untracked(this.children)) {
-            child.markAsDirty();
-        }
-    }
-    markAsTouched({ onlySelf = false } = {}) {
-        this.#selfTouched.set(true);
-        if (onlySelf) {
-            return;
-        }
-        for (const child of untracked(this.children)) {
-            child.markAsTouched();
-        }
-    }
-    setParent(parent, force) {
-        super.setParent(parent, force);
-        this.updateParents(true);
-    }
-    *[Symbol.iterator]() {
-        yield* untracked(this.children);
-    }
-    getChildPath(child) {
-        return computed(() => {
-            const key = this.#children().indexOf(child);
-            return this.path().add((key >= 0) ? key : 'CHILD_NOT_FOUND');
-        });
-    }
-    updateParents(force) {
-        for (const child of untracked(this.#children)) {
-            child.setParent(this, force);
-        }
-    }
-}
-export function formArray(options) {
-    return new FormArray(options); // eslint-disable-line @typescript-eslint/no-unsafe-return
-}
-export function isFormArray(value) {
-    return (value instanceof FormArray);
-}

package/form/form-button.d.ts

@@ -1,41 +0,0 @@
-import type { PartialProperty, ReactiveValue, TypedOmit } from '../types.js';
-import type { FormDialog } from './form-dialog.js';
-import { FormHeaderFooterElement, type FormHeaderFooterElementOptions } from './form-header-footer-element.js';
-import type { DynamicTextOption } from './types.js';
-export type FormButtonSize = 'normal' | 'small';
-export type FormButtonColor = 'transparent' | 'white' | 'accent' | 'neutral' | 'stone' | 'red' | 'orange' | 'amber' | 'yellow' | 'lime' | 'green' | 'emerald' | 'teal' | 'cyan' | 'sky' | 'blue' | 'indigo' | 'violet' | 'purple' | 'fuchsia' | 'pink' | 'rose';
-export type FormButtonType = 'button' | 'submit' | 'reset';
-export type FormButtonDesign = 'flat' | 'outline' | 'icon' | 'icon-outline' | 'none';
-export type IconLocation = 'before' | 'after';
-export type IconSize = 'small' | 'normal';
-export type FormButtonHandler = () => any;
-export type FormButtonOptions = FormHeaderFooterElementOptions & {
-    handler: FormButtonHandler;
-    label?: ReactiveValue<DynamicTextOption>;
-    type?: ReactiveValue<FormButtonType | null>;
-    disabled?: ReactiveValue<boolean | null>;
-    design?: ReactiveValue<FormButtonDesign | null>;
-    color?: ReactiveValue<FormButtonColor | null>;
-    icon?: ReactiveValue<string | null>;
-    iconLocation?: ReactiveValue<IconLocation | null>;
-    iconSize?: ReactiveValue<IconSize | null>;
-};
-export declare class FormButton extends FormHeaderFooterElement {
-    #private;
-    readonly handler: FormButtonHandler;
-    readonly label: import("../signals/api.js").Signal<DynamicTextOption>;
-    readonly type: import("../signals/api.js").Signal<FormButtonType>;
-    readonly disabled: import("../signals/api.js").Signal<boolean>;
-    readonly style: import("../signals/api.js").Signal<FormButtonDesign>;
-    readonly color: import("../signals/api.js").Signal<FormButtonColor>;
-    readonly icon: import("../signals/api.js").Signal<string | null>;
-    readonly iconLocation: import("../signals/api.js").Signal<IconLocation>;
-    readonly iconSize: import("../signals/api.js").Signal<IconSize>;
-    constructor(options: FormButtonOptions);
-}
-export declare function formButton(options: FormButtonOptions): FormButton;
-export declare function dialogFormButton(options: {
-    dialog: FormDialog;
-    showErrors?: boolean;
-} & TypedOmit<PartialProperty<FormButtonOptions, 'handler'>, 'icon' | 'color'>): FormButton;
-export declare function isFormButton(value: any): value is FormButton;

package/form/form-button.js

@@ -1,49 +0,0 @@
-import { computed, signal } from '../signals/api.js';
-import { FormHeaderFooterElement } from './form-header-footer-element.js';
-import { bindReactiveOption } from './utils.js';
-export class FormButton extends FormHeaderFooterElement {
-    #label = signal(null);
-    #type = signal('button');
-    #disabled = signal(false);
-    #design = signal('flat');
-    #color = signal('accent');
-    #icon = signal(null);
-    #iconLocation = signal('before');
-    #iconSize = signal('normal');
-    handler;
-    label = this.#label.asReadonly();
-    type = this.#type.asReadonly();
-    disabled = this.#disabled.asReadonly();
-    style = this.#design.asReadonly();
-    color = this.#color.asReadonly();
-    icon = this.#icon.asReadonly();
-    iconLocation = this.#iconLocation.asReadonly();
-    iconSize = this.#iconSize.asReadonly();
-    constructor(options) {
-        super(options);
-        this.handler = options.handler;
-        bindReactiveOption(options.label, this.#label, { defaultValue: null });
-        bindReactiveOption(options.type, this.#type, { defaultValue: 'button' });
-        bindReactiveOption(options.disabled, this.#disabled, { defaultValue: false });
-        bindReactiveOption(options.design, this.#design, { defaultValue: 'flat' });
-        bindReactiveOption(options.color, this.#color, { defaultValue: 'accent' });
-        bindReactiveOption(options.icon, this.#icon, { defaultValue: null });
-        bindReactiveOption(options.iconLocation, this.#iconLocation, { defaultValue: 'before' });
-        bindReactiveOption(options.iconSize, this.#iconSize, { defaultValue: 'normal' });
-    }
-}
-export function formButton(options) {
-    return new FormButton(options);
-}
-export function dialogFormButton(options) {
-    const showError = computed(() => ((options.showErrors ?? true) ? options.dialog.touched() ? options.dialog.invalid() : false : false));
-    return formButton({
-        handler: () => options.dialog.openDialog(),
-        ...options,
-        icon: computed(() => (showError() ? 'warning' : null)),
-        color: computed(() => (showError() ? 'red' : null))
-    });
-}
-export function isFormButton(value) {
-    return (value instanceof FormButton);
-}

package/form/form-container.d.ts

@@ -1,24 +0,0 @@
-import type { OneOrMany, ReactiveValue } from '../types.js';
-import { AbstractControl, type AbstractControlOptions } from './abstract-control.js';
-import type { FormHeaderFooterElement } from './form-header-footer-element.js';
-import type { ClassesOption, ClassesOptions } from './types.js';
-export type FormContainerOptions<T> = AbstractControlOptions<T> & ClassesOptions & {
-    displayLabel?: ReactiveValue<boolean>;
-    displayLine?: ReactiveValue<boolean>;
-    headerContainerClasses?: ReactiveValue<ClassesOption>;
-    footerContainerClasses?: ReactiveValue<ClassesOption>;
-    headerElements?: ReactiveValue<OneOrMany<FormHeaderFooterElement>>;
-    footerElements?: ReactiveValue<OneOrMany<FormHeaderFooterElement>>;
-};
-export declare abstract class FormContainer<T, TRaw> extends AbstractControl<T, TRaw> {
-    #private;
-    readonly displayLabel: import("../signals/api.js").Signal<boolean>;
-    readonly displayLine: import("../signals/api.js").Signal<boolean>;
-    readonly headerElements: import("../signals/api.js").Signal<readonly FormHeaderFooterElement[]>;
-    readonly footerElements: import("../signals/api.js").Signal<readonly FormHeaderFooterElement[]>;
-    readonly headerContainerClasses: import("../signals/api.js").Signal<readonly string[]>;
-    readonly footerContainerClasses: import("../signals/api.js").Signal<readonly string[]>;
-    readonly classes: import("../signals/api.js").Signal<readonly string[]>;
-    constructor(options: FormContainerOptions<T>);
-}
-export declare function isFormContainer(value: any): value is FormContainer<any, any>;

package/form/form-container.js

@@ -1,33 +0,0 @@
-import { signal } from '../signals/api.js';
-import { toArray } from '../utils/array/array.js';
-import { AbstractControl } from './abstract-control.js';
-import { bindReactiveOption, normalizeClassesOption } from './utils.js';
-export class FormContainer extends AbstractControl {
-    #displayLabel = signal(true);
-    #displayLine = signal(false);
-    #headerElements = signal([]);
-    #footerElements = signal([]);
-    #headerContainerClasses = signal([]);
-    #footerContainerClasses = signal([]);
-    #classes = signal([]);
-    displayLabel = this.#displayLabel.asReadonly();
-    displayLine = this.#displayLine.asReadonly();
-    headerElements = this.#headerElements.asReadonly();
-    footerElements = this.#footerElements.asReadonly();
-    headerContainerClasses = this.#headerContainerClasses.asReadonly();
-    footerContainerClasses = this.#footerContainerClasses.asReadonly();
-    classes = this.#classes.asReadonly();
-    constructor(options) {
-        super(options);
-        bindReactiveOption(options.displayLabel, this.#displayLabel, { defaultValue: true });
-        bindReactiveOption(options.displayLine, this.#displayLine, { defaultValue: false });
-        bindReactiveOption(options.headerElements, (elements) => this.#headerElements.set(toArray(elements)), { defaultValue: [] });
-        bindReactiveOption(options.footerElements, (elements) => this.#footerElements.set(toArray(elements)), { defaultValue: [] });
-        bindReactiveOption(options.headerContainerClasses, (classes) => this.#headerContainerClasses.set(normalizeClassesOption(classes)));
-        bindReactiveOption(options.footerContainerClasses, (classes) => this.#footerContainerClasses.set(normalizeClassesOption(classes)));
-        bindReactiveOption(options.classes, (classes) => this.#classes.set(normalizeClassesOption(classes)));
-    }
-}
-export function isFormContainer(value) {
-    return (value instanceof FormContainer);
-}

package/form/form-control.d.ts

@@ -1,45 +0,0 @@
-import { type Signal } from '../signals/api.js';
-import type { ReactiveValue } from '../types.js';
-import { AbstractControl, type AbstractControlOptions } from './abstract-control.js';
-import type { ClassesOptions, DynamicTextOption } from './types.js';
-import { type FormValidatorError } from './validators/index.js';
-export type InitialValue<T> = T | null;
-export type InitialValueOption<T> = {
-    initialValue: T;
-};
-export type FormControlOptions<T = any> = AbstractControlOptions<T> & ClassesOptions & {
-    initialValue?: ReactiveValue<T>;
-    required?: ReactiveValue<boolean | null>;
-    suffix?: ReactiveValue<DynamicTextOption>;
-    hint?: ReactiveValue<DynamicTextOption>;
-};
-export type FormControlValueType<T extends FormControl<any>> = T extends FormControl<infer U> ? U : never;
-export declare abstract class FormControl<T, U = any> extends AbstractControl<T, T> {
-    #private;
-    readonly initialValue: Signal<T>;
-    readonly rawValue: Signal<T>;
-    /** Value for rendering including formatting etc. */
-    readonly inputValue: Signal<U | null>;
-    /** Same as {@link rawValue} for simple controls */
-    readonly value: Signal<T>;
-    readonly dirty: Signal<boolean>;
-    readonly touched: Signal<boolean>;
-    readonly required: Signal<boolean>;
-    readonly suffix: Signal<DynamicTextOption>;
-    readonly hint: Signal<DynamicTextOption>;
-    readonly classes: Signal<string[]>;
-    readonly errors: Signal<FormValidatorError[]>;
-    readonly errorDebug: Signal<FormValidatorError[] | null>;
-    constructor(initialValue: T, options: FormControlOptions<T>);
-    setInitialValue(value: T): void;
-    setInputValue(value: U | null): void;
-    setValue(value: T | null): void;
-    reset(): void;
-    markAsDirty(): void;
-    markAsTouched(): void;
-    formatInputValue(): void;
-    parseRawValue?(value: T | null): T | null;
-    abstract parseInputValue(value: U | null): T | null;
-    abstract formatRawValue(value: T | null): U;
-}
-export declare function isFormControl(value: any): value is FormControl<any>;

package/form/form-control.js

@@ -1,92 +0,0 @@
-import { computed, signal, untracked } from '../signals/api.js';
-import { switchAll } from '../signals/index.js';
-import { isDefined, isNotNull } from '../utils/type-guards.js';
-import { AbstractControl, computedInternalValidators, ignoreFormValue } from './abstract-control.js';
-import { bindReactiveOption, normalizeClassesOption } from './utils.js';
-import { requiredValidator } from './validators/index.js';
-export class FormControl extends AbstractControl {
-    #initialValue = signal(null);
-    #rawValue = signal(null);
-    #inputValue = signal(null);
-    #dirty = signal(false);
-    #touched = signal(false);
-    #required = signal(false);
-    #suffix = signal(null);
-    #hint = signal(null);
-    #classes = signal([]);
-    initialValue = this.#initialValue.asReadonly();
-    rawValue = computed(() => this.#rawValue() ?? this.initialValue());
-    /** Value for rendering including formatting etc. */
-    inputValue = this.#inputValue.asReadonly();
-    /** Same as {@link rawValue} for simple controls */
-    value = this.rawValue;
-    dirty = this.#dirty.asReadonly();
-    touched = this.#touched.asReadonly();
-    required = this.#required.asReadonly();
-    suffix = this.#suffix.asReadonly();
-    hint = this.#hint.asReadonly();
-    classes = this.#classes.asReadonly();
-    errors = switchAll(() => {
-        const validations = this.validators().map((validator) => validator(this));
-        return computed(() => validations.map((validation) => validation()).filter(isNotNull));
-    });
-    errorDebug = computed(() => this.valid() ? null : this.errors());
-    constructor(initialValue, options) {
-        super(options);
-        this.#initialValue.set(initialValue);
-        this.setValue(initialValue);
-        bindReactiveOption(options.initialValue ?? initialValue, (value) => this.setInitialValue(value));
-        bindReactiveOption(options.required, this.#required, { defaultValue: false });
-        bindReactiveOption(options.suffix, this.#suffix, { defaultValue: null });
-        bindReactiveOption(options.hint, this.#hint, { defaultValue: null });
-        bindReactiveOption(options.classes, (value) => this.#classes.set(normalizeClassesOption(value)));
-        this.registerValidators(computedInternalValidators(() => [
-            this.required() ? requiredValidator() : null
-        ]));
-    }
-    setInitialValue(value) {
-        const updateInputValue = untracked(this.value) == untracked(this.initialValue);
-        this.#initialValue.set(value);
-        if (updateInputValue) {
-            this.#inputValue.set(this.formatRawValue(value));
-        }
-    }
-    setInputValue(value) {
-        if (value == untracked(this.#inputValue)) {
-            return;
-        }
-        const parsed = this.parseInputValue(value);
-        this.#inputValue.set(value);
-        this.#rawValue.set(parsed);
-    }
-    setValue(value) {
-        if (value == ignoreFormValue) {
-            return;
-        }
-        const newRawValue = (value == this.initialValue()) ? null : value;
-        if (newRawValue === untracked(this.#rawValue)) {
-            return;
-        }
-        const parsed = isDefined(this.parseRawValue) ? this.parseRawValue(newRawValue) : newRawValue; // eslint-disable-line @typescript-eslint/unbound-method
-        this.#rawValue.set(parsed);
-        this.formatInputValue();
-    }
-    reset() {
-        this.setValue(null);
-        this.#dirty.set(false);
-        this.#touched.set(false);
-    }
-    markAsDirty() {
-        this.#dirty.set(true);
-    }
-    markAsTouched() {
-        this.#touched.set(true);
-    }
-    formatInputValue() {
-        const formatted = this.formatRawValue(untracked(this.value));
-        this.#inputValue.set(formatted);
-    }
-}
-export function isFormControl(value) {
-    return (value instanceof FormControl);
-}

package/form/form-dialog.d.ts

@@ -1,22 +0,0 @@
-import type { Signal } from '../signals/api.js';
-import type { ReactiveValue } from '../types.js';
-import type { AbstractControl, AbstractControlRawValueType, AbstractControlValueType } from './abstract-control.js';
-import { FormWrapper, type FormWrapperOptions } from './form-wrapper.js';
-import type { DynamicTextOption } from './types.js';
-export type FormDialogOptions<T, C extends AbstractControl<T>> = FormWrapperOptions<T, C> & {
-    header?: ReactiveValue<DynamicTextOption>;
-    displayType?: ReactiveValue<FormDialogDisplayType>;
-};
-export type FormDialogDisplayType = 'none' | 'button';
-export type FormDialogByControl<C extends AbstractControl> = FormDialog<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-export declare class FormDialog<T = any, TRaw = any, C extends AbstractControl<T, TRaw> = AbstractControl<T, TRaw>, DialogHandle = any> extends FormWrapper<T, TRaw, C> {
-    #private;
-    readonly displayType: Signal<FormDialogDisplayType>;
-    readonly header: Signal<DynamicTextOption>;
-    readonly openDialog$: import("rxjs").Observable<void>;
-    dialogHandle: DialogHandle | null;
-    constructor(options: FormDialogOptions<T, C>);
-    openDialog(): void;
-}
-export declare function formDialog<C extends AbstractControl>(options: FormDialogOptions<AbstractControlRawValueType<C>, C>): FormDialog<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-export declare function isFormDialog(value: any): value is FormDialog;

package/form/form-dialog.js

@@ -1,24 +0,0 @@
-import { Subject } from 'rxjs';
-import { FormWrapper } from './form-wrapper.js';
-import { reactiveOptionToSignal } from './utils.js';
-export class FormDialog extends FormWrapper {
-    #openDialogSubject = new Subject();
-    displayType;
-    header;
-    openDialog$ = this.#openDialogSubject.asObservable();
-    dialogHandle = null;
-    constructor(options) {
-        super(options);
-        this.displayType = reactiveOptionToSignal(options.displayType ?? 'none', { initialValue: 'none' });
-        this.header = reactiveOptionToSignal(options.header ?? null, { initialValue: null });
-    }
-    openDialog() {
-        this.#openDialogSubject.next();
-    }
-}
-export function formDialog(options) {
-    return new FormDialog(options);
-}
-export function isFormDialog(value) {
-    return (value instanceof FormDialog);
-}

package/form/form-element.d.ts

@@ -1,7 +0,0 @@
-export type FormElementOptions = {
-    id?: string;
-};
-export declare abstract class FormElement {
-    readonly id: string;
-    constructor(options?: FormElementOptions);
-}

package/form/form-element.js

@@ -1,6 +0,0 @@
-export class FormElement {
-    id;
-    constructor(options) {
-        this.id = options?.id ?? crypto.randomUUID();
-    }
-}

package/form/form-group.d.ts

@@ -1,70 +0,0 @@
-import type { JsonPath } from '../json-path/json-path.js';
-import { type Signal } from '../signals/index.js';
-import type { ReactiveValue, Record } 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 { FormValue, RawFormValue } from './types.js';
-import type { FormValidatorError } from './validators/form.validator.js';
-type FormGroupDisplayType = 'simple' | 'block' | 'stepper' | 'tabs';
-type FormGroupStepperOrientiation = 'horizontal' | 'vertical';
-export type FromGroupControls<T extends Record> = {
-    [P in keyof T]: AbstractControl<T[P]>;
-};
-export type FormGroupOptions<T extends Record = Record, C extends FromGroupControls<T> = FromGroupControls<T>> = FormContainerOptions<Partial<T>> & {
-    displayType?: ReactiveValue<FormGroupDisplayType>;
-    stepperOrientation?: ReactiveValue<FormGroupStepperOrientiation>;
-    children: C;
-};
-export type FormGroupChildren<T extends FormGroup> = T extends FormGroup<any, infer C> ? C : never;
-export type FormGroupChild<T extends FormGroup, K extends keyof FormGroupChildren<T>> = FormGroupChildren<T>[K];
-export type FormGroupChildValue<T extends FormGroup, K extends keyof AbstractControlRawValueType<T>> = AbstractControlValueType<T>[K];
-export type FormGroupChildRawValue<T extends FormGroup, K extends keyof AbstractControlRawValueType<T>> = AbstractControlRawValueType<T>[K];
-export type FormGroupRawValueType<C extends FromGroupControls<Record>> = {
-    [P in keyof C]: AbstractControlRawValueType<C[P]>;
-};
-export type FormGroupByControls<C extends FromGroupControls<Record> = FromGroupControls<Record>> = FormGroup<FormGroupRawValueType<C>, C>;
-export declare class FormGroup<T extends Record = Record, C extends FromGroupControls<T> = FromGroupControls<T>> extends FormContainer<Partial<T>, T> implements Iterable<[keyof C, C[keyof C]]> {
-    #private;
-    protected readonly internalValidators: null;
-    readonly displayType: Signal<FormGroupDisplayType>;
-    readonly stepperOrientation: Signal<FormGroupStepperOrientiation>;
-    readonly children: Signal<Readonly<C>>;
-    readonly childrenEntries: Signal<[keyof C, Readonly<C>[keyof C]][]>;
-    readonly childrenValues: Signal<Readonly<C>[keyof C][]>;
-    readonly enabledChildrenEntries: Signal<[keyof C, Readonly<C>[keyof C]][]>;
-    readonly enabledChildrenValues: Signal<Readonly<C>[keyof C][]>;
-    /**
-     * Raw values of all children whether disabled or not
-     */
-    readonly rawValue: Signal<T>;
-    /**
-     * If enabled: values of all enabled children
-     * if disabled: values of all children whether disabled or not (same as {@link rawValue})
-     */
-    readonly value: Signal<Partial<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[];
-    } & { [K in import("../types.js").Cast<keyof C, PropertyKey>]: import("../types.js").Fallback<Extract<readonly [keyof C, any], readonly [K, any]>[1], any>; }) | null>;
-    constructor(options: FormGroupOptions<T, C>);
-    setParent(parent: AbstractControlParent, force?: boolean): void;
-    setParent(parent: null): void;
-    getChildPath(child: AbstractControl): Signal<JsonPath>;
-    reset(): void;
-    get<K extends keyof C>(key: K): C[K];
-    getValue<K extends keyof C>(key: K): FormValue<C[K]>;
-    getRawValue<K extends keyof C>(key: K): RawFormValue<C[K]>;
-    patchValue(values: Partial<T>): void;
-    setValue(values: Partial<T>): void;
-    markAsDirty({ onlySelf }?: MarkOptions): void;
-    markAsTouched({ onlySelf }?: MarkOptions): void;
-    [Symbol.iterator](): Iterator<[keyof C, C[keyof C]]>;
-    private updateParents;
-}
-export declare function formGroup<C extends FromGroupControls<Record> = FromGroupControls<Record>>(options: FormGroupOptions<FormGroupRawValueType<C>, C>): FormGroup<FormGroupRawValueType<C>, C>;
-export declare function isFormGroup(value: any): value is FormGroup;
-export {};