@decaf-ts/for-angular 0.0.25 → 0.0.27

package/engine/NgxFormService.d.ts

@@ -1,601 +0,0 @@
-import { FieldProperties, UIModelMetadata } from '@decaf-ts/ui-decorators';
-import { FieldUpdateMode, FormParent } from './types';
-import { IComponentConfig, IComponentInput } from './interfaces';
-import { AbstractControl, FormArray, FormControl, FormGroup } from '@angular/forms';
-import { OperationKeys } from '@decaf-ts/db-decorators';
-/**
- * @description Service for managing Angular forms and form controls.
- * @summary The NgxFormService provides utility methods for creating, managing, and validating Angular forms and form controls. It includes functionality for registering forms, adding controls, validating fields, and handling form data.
- *
- * @class
- * @param {WeakMap<AbstractControl, FieldProperties>} controls - A WeakMap to store control properties.
- * @param {Map<string, FormGroup>} formRegistry - A Map to store registered forms.
- *
- * @example
- * // Creating a form from components
- * const components = [
- *   { inputs: { name: 'username', type: 'text', required: true } },
- *   { inputs: { name: 'password', type: 'password', minLength: 8 } }
- * ];
- * const form = NgxFormService.createFormFromComponents('loginForm', components, true);
- *
- * // Validating fields
- * NgxFormService.validateFields(form);
- *
- * // Getting form data
- * const formData = NgxFormService.getFormData(form);
- *
- * @mermaid
- * sequenceDiagram
- *   participant C as Component
- *   participant NFS as NgxFormService
- *   participant AF as Angular Forms
- *   C->>NFS: createFormFromComponents()
- *   NFS->>AF: new FormGroup()
- *   NFS->>NFS: addFormControl()
- *   NFS->>AF: addControl()
- *   NFS-->>C: Return FormGroup
- *   C->>NFS: validateFields()
- *   NFS->>AF: markAsTouched(), markAsDirty(), updateValueAndValidity()
- *   C->>NFS: getFormData()
- *   NFS->>AF: Get control values
- *   NFS-->>C: Return form data
- */
-export declare class NgxFormService {
-    /**
-     * @description WeakMap that stores control properties for form controls.
-     * @summary A WeakMap that associates AbstractControl instances with their corresponding FieldProperties.
-     * This allows the service to track metadata for form controls without creating memory leaks.
-     *
-     * @type {WeakMap<AbstractControl, FieldProperties>}
-     * @private
-     * @static
-     * @memberOf NgxFormService
-     */
-    private static controls;
-    /**
-     * @description Registry of form groups indexed by their unique identifiers.
-     * @summary A Map that stores FormGroup instances with their unique string identifiers.
-     * This allows global access to registered forms throughout the application.
-     *
-     * @type {Map<string, FormGroup>}
-     * @private
-     * @static
-     * @memberOf NgxFormService
-     */
-    private static formRegistry;
-    private static pageMapper;
-    /**
-     * @description Creates a new form group or form array with the specified identifier.
-     * @summary Generates a FormGroup or FormArray based on the provided properties. If pages are specified
-     * and greater than 1, creates a FormArray; otherwise creates a FormGroup. The form can optionally
-     * be registered in the global form registry for later access throughout the application.
-     *
-     * @param {string} id - Unique identifier for the form
-     * @param {Partial<IComponentInput>} [props={}] - Configuration properties for the form
-     * @param {boolean} [registry=true] - Whether to register the form in the global registry
-     * @return {FormGroup | FormArray} The created form instance
-     *
-     * @mermaid
-     * sequenceDiagram
-     *   participant C as Component
-     *   participant NFS as NgxFormService
-     *   participant FR as Form Registry
-     *   participant AF as Angular Forms
-     *
-     *   C->>NFS: createForm(id, props, registry)
-     *   NFS->>FR: Check if form exists
-     *   alt Form doesn't exist
-     *     alt props.pages > 1
-     *       NFS->>AF: new FormArray([])
-     *     else
-     *       NFS->>AF: new FormGroup({})
-     *     end
-     *     alt registry is true
-     *       NFS->>FR: addRegistry(id, form)
-     *     end
-     *   end
-     *   NFS-->>C: Return FormGroup | FormArray
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static createForm(id: string, props?: Partial<IComponentInput>, registry?: boolean): FormGroup | FormArray;
-    /**
-     * @description Adds a form to the registry.
-     * @summary Registers a FormGroup or FormArray with a unique identifier for global access throughout
-     * the application. This allows forms to be retrieved and managed centrally. Throws an error if
-     * the identifier is already in use to prevent conflicts.
-     *
-     * @param {string} formId - The unique identifier for the form
-     * @param {FormParent} formGroup - The FormGroup or FormArray to be registered
-     * @return {void}
-     * @throws {Error} If a FormGroup with the given id is already registered
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static addRegistry(formId: string, formGroup: FormParent): void;
-    /**
-     * @description Removes a form from the registry.
-     * @summary Deletes a FormGroup or FormArray from the registry using its unique identifier.
-     * This cleans up the registry and allows the identifier to be reused. The form itself
-     * is not destroyed, only removed from the central registry.
-     *
-     * @param {string} formId - The unique identifier of the form to be removed
-     * @return {void}
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static removeRegistry(formId: string): void;
-    /**
-     * @description Resolves the parent group and control name from a path.
-     * @summary Traverses the form group structure to find the parent group and control name for a given path.
-     * Handles complex nested structures including arrays and sub-groups. Creates missing intermediate
-     * groups as needed and properly configures FormArray controls for multiple value scenarios.
-     *
-     * @param {FormGroup} formGroup - The root FormGroup to traverse
-     * @param {string} path - The dot-separated path to the control (e.g., 'user.address.street')
-     * @param {IComponentInput} componentProps - Properties defining the component configuration
-     * @param {KeyValue} parentProps - Properties from the parent component for context
-     * @return {FormParentGroup} A tuple containing the parent FormGroup and the control name
-     *
-     * @private
-     * @mermaid
-     * sequenceDiagram
-     *   participant NFS as NgxFormService
-     *   participant FG as FormGroup
-     *   participant FA as FormArray
-     *
-     *   NFS->>NFS: Split path into parts
-     *   loop For each path part
-     *     alt Control doesn't exist
-     *       alt isMultiple and part is childOf
-     *         NFS->>FA: new FormArray([new FormGroup({})])
-     *       else
-     *         NFS->>FG: new FormGroup({})
-     *       end
-     *       NFS->>FG: addControl(part, newControl)
-     *     end
-     *     NFS->>NFS: Navigate to next level
-     *   end
-     *   NFS-->>NFS: Return [parentGroup, controlName]
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    private static resolveParentGroup;
-    /**
-     * @description Retrieves component properties from a FormGroup or FormArray.
-     * @summary Extracts component properties stored in the form group metadata. If a FormGroup is provided
-     * and groupArrayName is specified, it will look for the FormArray within the form structure.
-     *
-     * @param {FormGroup | FormArray} formGroup - The form group or form array to extract properties from
-     * @param {string} [key] - Optional key to retrieve a specific property
-     * @param {string} [groupArrayName] - Optional name of the group array if formGroup is not a FormArray
-     * @return {Partial<FieldProperties>} The component properties or a specific property if key is provided
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static getComponentPropsFromGroupArray(formGroup: FormGroup | FormArray, key?: string, groupArrayName?: string | undefined): Partial<FieldProperties>;
-    /**
-     * @description Adds a new group to a parent FormArray.
-     * @summary Creates and adds a new FormGroup to the specified parent FormArray based on the
-     * component properties stored in the parent's metadata. This is used for dynamic form arrays
-     * where new groups need to be added at runtime.
-     *
-     * @param {FormGroup} formGroup - The root form group containing the parent FormArray
-     * @param {string} parentName - The name of the parent FormArray to add the group to
-     * @param {number} [index=1] - The index position where the new group should be added
-     * @return {FormGroup} The newly created and added FormGroup
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static addGroupToParent(formGroup: FormGroup, parentName: string, index?: number): FormGroup;
-    /**
-     * @description Retrieves a FormGroup from a parent FormArray at the specified index.
-     * @summary Gets a FormGroup from the specified parent FormArray. If the group doesn't exist
-     * at the given index, it will create a new one using addGroupToParent.
-     *
-     * @param {FormGroup} formGroup - The root form group containing the parent FormArray
-     * @param {string} parentName - The name of the parent FormArray to retrieve the group from
-     * @param {number} [index=1] - The index of the group to retrieve
-     * @return {FormGroup} The FormGroup at the specified index
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static getGroupFromParent(formGroup: FormGroup, parentName: string, index?: number): FormGroup;
-    /**
-     * @description Checks if a value is unique within a FormArray group.
-     * @summary Validates that the primary key value in a FormGroup is unique among all groups
-     * in the parent FormArray. The uniqueness check behavior differs based on the operation type.
-     *
-     * @param {FormGroup} formGroup - The FormGroup to check for uniqueness
-     * @param {number} index - The index of the current group within the FormArray
-     * @param {OperationKeys} [operation=OperationKeys.CREATE] - The type of operation being performed
-     * @return {boolean} True if the value is unique, false otherwise
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static isUniqueOnGroup(formGroup: FormGroup, index: number, operation?: OperationKeys): boolean;
-    /**
-     * @description Enables all controls within a FormGroup or FormArray.
-     * @summary Recursively enables all form controls within the provided FormGroup or FormArray.
-     * This is useful for making all controls interactive after they have been disabled.
-     *
-     * @param {FormArray | FormGroup} formGroup - The FormGroup or FormArray to enable all controls for
-     * @return {void}
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static enableAllGroupControls(formGroup: FormArray | FormGroup): void;
-    /**
-     * @description Adds a form control to a form group based on component properties.
-     * @summary Creates and configures a FormControl within the specified FormGroup using the provided
-     * component properties. Handles nested paths, multiple controls (FormArrays), and control registration.
-     * This method supports complex form structures with nested groups and arrays.
-     *
-     * @param {FormGroup} formGroup - The form group to add the control to
-     * @param {IComponentInput} componentProps - The component properties defining the control configuration
-     * @param {KeyValue} [parentProps={}] - Properties from the parent component for context
-     * @param {number} [index=0] - The index for multiple controls in FormArrays
-     * @return {void}
-     *
-     * @private
-     * @static
-     * @memberOf NgxFormService
-     */
-    private static addFormControl;
-    /**
-     * @description Retrieves a control from a registered form.
-     * @summary Finds and returns an AbstractControl from a registered form using the form id and optional path.
-     * This method provides centralized access to form controls across the application by leveraging
-     * the form registry system.
-     *
-     * @param {string} formId - The unique identifier of the form in the registry
-     * @param {string} [path] - The optional dot-separated path to a specific control within the form
-     * @return {AbstractControl} The requested AbstractControl (FormGroup, FormArray, or FormControl)
-     * @throws {Error} If the form is not found in the registry or the control is not found in the form
-     *
-     * @mermaid
-     * sequenceDiagram
-     *   participant C as Component
-     *   participant NFS as NgxFormService
-     *   participant FR as Form Registry
-     *
-     *   C->>NFS: getControlFromForm(formId, path?)
-     *   NFS->>FR: Get form by formId
-     *   alt Form not found
-     *     FR-->>NFS: null
-     *     NFS-->>C: Throw Error
-     *   else Form found
-     *     FR-->>NFS: Return form
-     *     alt path provided
-     *       NFS->>NFS: form.get(path)
-     *       alt Control not found
-     *         NFS-->>C: Throw Error
-     *       else
-     *         NFS-->>C: Return control
-     *       end
-     *     else
-     *       NFS-->>C: Return form
-     *     end
-     *   end
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static getControlFromForm(formId: string, path?: string): AbstractControl;
-    /**
-     * @description Creates a form from UI model metadata children.
-     * @summary Generates a FormGroup from an array of UIModelMetadata objects, extracting component
-     * properties and creating appropriate form controls. This method is specifically designed to work
-     * with the UI decorator system and provides automatic form generation from metadata.
-     *
-     * @param {string} id - Unique identifier for the form
-     * @param {boolean} [registry=false] - Whether to register the created form in the global registry
-     * @param {UIModelMetadata[]} [children] - Array of UI model metadata objects to create controls from
-     * @return {FormGroup} The created FormGroup with controls for each child metadata
-     *
-     * @mermaid
-     * sequenceDiagram
-     *   participant C as Component
-     *   participant NFS as NgxFormService
-     *   participant AF as Angular Forms
-     *
-     *   C->>NFS: createFormFromChildren(id, registry, children)
-     *   NFS->>AF: new FormGroup({})
-     *   loop For each child metadata
-     *     NFS->>NFS: addFormControl(form, child.props)
-     *     NFS->>AF: Create and add FormControl
-     *   end
-     *   alt registry is true
-     *     NFS->>NFS: addRegistry(id, form)
-     *   end
-     *   NFS-->>C: Return FormGroup
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static createFormFromChildren(id: string, registry?: boolean, children?: UIModelMetadata[]): FormGroup;
-    /**
-     * @description Creates a form from component configurations.
-     * @summary Generates a FormGroup based on an array of component configurations and optionally registers it.
-     * This method processes component input configurations to create appropriate form controls with
-     * validation and initial values.
-     *
-     * @param {string} id - The unique identifier for the form
-     * @param {IComponentConfig[]} components - An array of component configurations defining the form structure
-     * @param {boolean} [registry=false] - Whether to register the created form in the global registry
-     * @return {FormGroup} The created FormGroup with controls for each component configuration
-     *
-     * @mermaid
-     * sequenceDiagram
-     *   participant C as Component
-     *   participant NFS as NgxFormService
-     *   participant AF as Angular Forms
-     *
-     *   C->>NFS: createFormFromComponents(id, components, registry)
-     *   NFS->>AF: new FormGroup({})
-     *   loop For each component config
-     *     NFS->>NFS: addFormControl(form, component.inputs)
-     *     NFS->>AF: Create and add FormControl
-     *   end
-     *   alt registry is true
-     *     NFS->>NFS: addRegistry(id, form)
-     *   end
-     *   NFS-->>C: Return FormGroup
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static createFormFromComponents(id: string, components: IComponentConfig[], registry?: boolean): FormGroup;
-    /**
-     * @description Adds a control to a form based on component properties.
-     * @summary Creates and adds a form control to a form (existing or new) based on the provided component properties.
-     * Handles multi-page forms by managing FormArray structures and proper indexing. This method supports
-     * complex form scenarios including nested controls and page-based form organization.
-     *
-     * @param {string} id - The unique identifier of the form
-     * @param {FieldProperties} componentProperties - The properties of the component to create the control from
-     * @param {FieldProperties} [parentProps] - Optional parent properties for context and configuration
-     * @return {AbstractControl} The form or created control
-     *
-     * @mermaid
-     * sequenceDiagram
-     *   participant C as Component
-     *   participant NFS as NgxFormService
-     *   participant F as Form
-     *
-     *   C->>NFS: addControlFromProps(id, componentProps, parentProps?)
-     *   NFS->>NFS: createForm(id, parentProps, true)
-     *   alt Multi-page form (parentProps.pages > 1)
-     *     NFS->>NFS: Calculate page index
-     *     NFS->>F: Get or create FormGroup at index
-     *     NFS->>NFS: Set form to page FormGroup
-     *   end
-     *   alt componentProperties has path
-     *     NFS->>NFS: addFormControl(form, componentProperties, parentProps)
-     *   end
-     *   NFS-->>C: Return form/control
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static addControlFromProps(id: string, componentProperties: FieldProperties, parentProps?: FieldProperties): AbstractControl;
-    /**
-     * @description Retrieves form data from a FormGroup.
-     * @summary Extracts and processes the data from a FormGroup, handling different input types and nested form groups.
-     * Performs type conversion for various HTML5 input types, validates nested controls, and manages
-     * multiple control scenarios. Automatically enables all group controls after data extraction.
-     *
-     * @param {FormGroup} formGroup - The FormGroup to extract data from
-     * @return {Record<string, unknown>} An object containing the processed form data with proper type conversions
-     *
-     * @mermaid
-     * sequenceDiagram
-     *   participant C as Component
-     *   participant NFS as NgxFormService
-     *   participant FG as FormGroup
-     *   participant FC as FormControl
-     *
-     *   C->>NFS: getFormData(formGroup)
-     *   loop For each control in formGroup
-     *     alt Control is not FormControl
-     *       NFS->>NFS: Recursive getFormData(control)
-     *       alt parentProps.multiple and !isValid
-     *         NFS->>NFS: reset(control)
-     *       end
-     *     else Control is FormControl
-     *       NFS->>FC: Get control value
-     *       NFS->>NFS: Apply type conversion based on props.type
-     *       alt HTML5CheckTypes
-     *         NFS->>NFS: Keep boolean value
-     *       else NUMBER type
-     *         NFS->>NFS: parseToNumber(value)
-     *       else DATE/DATETIME types
-     *         NFS->>NFS: new Date(value)
-     *       else Other types
-     *         NFS->>NFS: escapeHtml(value)
-     *       end
-     *     end
-     *   end
-     *   NFS->>NFS: enableAllGroupControls(formGroup)
-     *   NFS-->>C: Return processed data object
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static getFormData(formGroup: FormGroup): Record<string, unknown>;
-    /**
-     * @description Validates fields in a form control or form group.
-     * @summary Recursively validates all fields in a form control or form group, marking them as touched and dirty.
-     * Performs comprehensive validation including uniqueness checks for primary keys in FormArray scenarios.
-     * This method ensures all validation rules are applied and form state is properly updated.
-     *
-     * @param {AbstractControl} control - The control or form group to validate
-     * @param {string} [pk] - Optional primary key field name for uniqueness validation
-     * @param {string} [path] - The path to the control within the form for error reporting
-     * @return {boolean} True if all fields are valid, false otherwise
-     * @throws {Error} If no control is found at the specified path or if the control type is unknown
-     *
-     * @mermaid
-     * sequenceDiagram
-     *   participant C as Component
-     *   participant NFS as NgxFormService
-     *   participant FC as FormControl
-     *   participant FG as FormGroup
-     *   participant FA as FormArray
-     *
-     *   C->>NFS: validateFields(control, pk?, path?)
-     *   alt Control is FormControl
-     *     NFS->>FC: markAsTouched()
-     *     NFS->>FC: markAsDirty()
-     *     NFS->>FC: updateValueAndValidity()
-     *     alt Is in FormArray group
-     *       NFS->>NFS: Check uniqueness in group
-     *       alt Not unique
-     *         NFS->>FC: setErrors({notUnique: true})
-     *       end
-     *     end
-     *     NFS-->>C: Return control.valid
-     *   else Control is FormGroup
-     *     loop For each child control
-     *       NFS->>NFS: Recursive validateFields(child)
-     *     end
-     *     NFS-->>C: Return allValid
-     *   else Control is FormArray
-     *     loop For each array control
-     *       NFS->>NFS: Recursive validateFields(child)
-     *     end
-     *     NFS-->>C: Return allValid
-     *   else Unknown control type
-     *     NFS-->>C: Throw Error
-     *   end
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static validateFields(control: AbstractControl, pk?: string, path?: string): boolean;
-    /**
-     * @description Generates validators from component properties.
-     * @summary Creates an array of ValidatorFn based on the supported validation keys in the component properties.
-     * @param {FieldProperties} props - The component properties.
-     * @return {ValidatorFn[]} An array of validator functions.
-     */
-    private static validatorsFromProps;
-    /**
-     * @description Creates a FormControl from component properties.
-     * @summary Generates a FormControl with validators and initial configuration based on the provided
-     * component properties. Handles different input types, sets initial values, and configures
-     * validation rules and update modes.
-     *
-     * @param {FieldProperties} props - The component properties defining the control configuration
-     * @param {FieldUpdateMode} [updateMode='change'] - The update mode for the control ('change', 'blur', 'submit')
-     * @return {FormControl} The created FormControl with proper configuration and validators
-     *
-     * @mermaid
-     * sequenceDiagram
-     *   participant C as Component
-     *   participant NFS as NgxFormService
-     *   participant VF as ValidatorFactory
-     *   participant AF as Angular Forms
-     *
-     *   C->>NFS: fromProps(props, updateMode?)
-     *   NFS->>NFS: validatorsFromProps(props)
-     *   NFS->>VF: Create validators from props
-     *   VF-->>NFS: Return validator array
-     *   NFS->>NFS: Compose validators
-     *   alt props.value exists and not checkbox
-     *     alt props.type is DATE
-     *       NFS->>NFS: Validate date format
-     *     end
-     *     NFS->>NFS: Set initial value
-     *   end
-     *   NFS->>AF: new FormControl(config)
-     *   AF-->>NFS: Return FormControl
-     *   NFS-->>C: Return configured FormControl
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static fromProps(props: FieldProperties, updateMode?: FieldUpdateMode): FormControl;
-    /**
-     * @description Retrieves properties from a FormControl, FormArray, or FormGroup.
-     * @summary Gets the FieldProperties associated with a form control from the internal WeakMap.
-     * This method provides access to the original component properties that were used to create
-     * the control, enabling validation, rendering, and behavior configuration.
-     *
-     * @param {FormControl | FormArray | FormGroup} control - The form control to get properties for
-     * @return {FieldProperties} The properties associated with the control, or empty object if not found
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static getPropsFromControl(control: FormControl | FormArray | FormGroup): FieldProperties;
-    /**
-     * @description Finds a parent element with a specific tag in the DOM tree.
-     * @summary Traverses up the DOM tree to find the nearest parent element with the specified tag name.
-     * This is useful for finding container elements or specific parent components in the DOM hierarchy.
-     * The search is case-insensitive for tag name matching.
-     *
-     * @param {HTMLElement} el - The starting element to traverse from
-     * @param {string} tag - The tag name to search for (case-insensitive)
-     * @return {HTMLElement} The found parent element with the specified tag
-     * @throws {Error} If no parent with the specified tag is found in the DOM tree
-     *
-     * @mermaid
-     * sequenceDiagram
-     *   participant C as Component
-     *   participant NFS as NgxFormService
-     *   participant DOM as DOM Tree
-     *
-     *   C->>NFS: getParentEl(element, tagName)
-     *   loop Traverse up DOM tree
-     *     NFS->>DOM: Get parentElement
-     *     DOM-->>NFS: Return parent or null
-     *     alt Parent exists and tag matches
-     *       NFS-->>C: Return parent element
-     *     else Parent is null
-     *       NFS-->>C: Throw Error
-     *     end
-     *   end
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static getParentEl(el: HTMLElement, tag: string): HTMLElement;
-    /**
-     * @description Registers a control with its properties in the internal WeakMap.
-     * @summary Associates a form control with its component properties for later retrieval.
-     * This enables the service to maintain metadata about controls without creating memory leaks,
-     * as WeakMap automatically cleans up references when controls are garbage collected.
-     *
-     * @param {AbstractControl} control - The control to register (FormControl, FormGroup, or FormArray)
-     * @param {FieldProperties} props - The properties to associate with the control
-     * @return {void}
-     *
-     * @static
-     * @memberOf NgxFormService
-     */
-    static register(control: AbstractControl, props: FieldProperties): void;
-    /**
-     * @description Unregisters a control.
-     * @summary Removes a control and its associated properties from the internal WeakMap.
-     * @param {AbstractControl} control - The control to unregister.
-     * @return {boolean} True if the control was successfully unregistered, false otherwise.
-     */
-    static unregister(control: AbstractControl): boolean;
-    /**
-     * @description Resets a form group.
-     * @summary Recursively resets all controls in a form group, clearing values, errors, and marking them as pristine and untouched.
-     * @param {FormGroup} formGroup - The form group to reset.
-     */
-    static reset(formGroup: FormGroup | FormControl): void;
-}