@ng-formworks/core 19.6.3 → 20.6.3

package/index.d.ts

@@ -1,5 +1,2774 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, Signal, OnChanges, OnInit, SimpleChanges, ElementRef, ComponentRef, ViewContainerRef, Renderer2 } from '@angular/core';
+import * as i27 from '@angular/forms';
+import { AbstractControl, UntypedFormArray, UntypedFormGroup, ControlValueAccessor, ValidationErrors, ValidatorFn } from '@angular/forms';
+import * as rxjs from 'rxjs';
+import { Subject, Subscription, Observable } from 'rxjs';
+import Ajv2019, { Options, ErrorObject, ValidateFunction } from 'ajv/dist/2019';
+import * as i2 from '@angular/common';
+import * as i28 from 'nxt-sortablejs';
+
+type WidgetContext = {
+    formControl?: AbstractControl;
+    layoutNode?: Signal<any>;
+    layoutIndex?: Signal<number[]>;
+    dataIndex?: Signal<number[]>;
+    options?: any;
+    controlValue?: any;
+    boundControl?: boolean;
+    controlName?: string;
+    controlDisabled?: boolean;
+};
+type AJVRegistryItem = {
+    [name: string]: {
+        name: string;
+        ajvInstance: Ajv2019;
+        ajvValidator: ValidateFunction;
+    };
+};
+interface TitleMapItem {
+    name?: string;
+    value?: any;
+    checked?: boolean;
+    group?: string;
+    items?: TitleMapItem[];
+}
+interface ErrorMessages {
+    [control_name: string]: {
+        message: string | Function | Object;
+        code: string;
+    }[];
+}
+declare class JsonSchemaFormService implements OnDestroy {
+    JsonFormCompatibility: boolean;
+    ReactJsonSchemaFormCompatibility: boolean;
+    AngularSchemaFormCompatibility: boolean;
+    tpldata: any;
+    ajvOptions: Options;
+    ajv: any;
+    validateFormData: any;
+    formValues: any;
+    data: any;
+    schema: any;
+    layout: any[];
+    formGroupTemplate: any;
+    formGroup: any;
+    framework: any;
+    formOptions: any;
+    validData: any;
+    isValid: boolean;
+    ajvErrors: ErrorObject[];
+    validationErrors: any;
+    dataErrors: any;
+    formValueSubscription: any;
+    dataChanges: Subject<any>;
+    isValidChanges: Subject<any>;
+    validationErrorChanges: Subject<any>;
+    arrayMap: Map<string, number>;
+    dataMap: Map<string, any>;
+    dataRecursiveRefMap: Map<string, string>;
+    schemaRecursiveRefMap: Map<string, string>;
+    schemaRefLibrary: any;
+    layoutRefLibrary: any;
+    templateRefLibrary: any;
+    hasRootReference: boolean;
+    language: string;
+    defaultFormOptions: any;
+    fcValueChangesSubs: Subscription;
+    fcStatusChangesSubs: Subscription;
+    private draggableStateSubject;
+    draggableState$: rxjs.Observable<boolean>;
+    setDraggableState(value: boolean): void;
+    private sortableOptionsSubject;
+    sortableOptions$: rxjs.Observable<any>;
+    setSortableOptions(value: any): void;
+    createAjvInstance(ajvOptions: any): Ajv2019;
+    createAndRegisterAjvInstance(ajvOptions: any, name?: string): {
+        name: string;
+        ajvInstance: Ajv2019;
+        ajvValidator: ValidateFunction;
+    };
+    ajvRegistry: AJVRegistryItem;
+    getAjvInstance(name?: string): Ajv2019;
+    getAjvValidator(name?: string): ValidateFunction<unknown>;
+    constructor();
+    ngOnDestroy(): void;
+    setLanguage(language?: string): void;
+    getData(): any;
+    getSchema(): any;
+    getLayout(): any[];
+    resetAllValues(): void;
+    /**
+     * 'buildRemoteError' function
+     *
+     * Example errors:
+     * {
+     *   last_name: [ {
+     *     message: 'Last name must by start with capital letter.',
+     *     code: 'capital_letter'
+     *   } ],
+     *   email: [ {
+     *     message: 'Email must be from example.com domain.',
+     *     code: 'special_domain'
+     *   }, {
+     *     message: 'Email must contain an @ symbol.',
+     *     code: 'at_symbol'
+     *   } ]
+     * }
+     * //{ErrorMessages} errors
+     */
+    buildRemoteError(errors: ErrorMessages): void;
+    validateData(newValue: any, updateSubscriptions?: boolean, ajvInstanceName?: string): void;
+    buildFormGroupTemplate(formValues?: any, setValues?: boolean): void;
+    buildFormGroup(ajvInstanceName?: string): void;
+    buildLayout(widgetLibrary: any): void;
+    setOptions(newOptions: any): void;
+    compileAjvSchema(ajvInstanceName?: string): void;
+    buildSchemaFromData(data?: any, requireAllFields?: boolean): any;
+    buildSchemaFromLayout(layout?: any): any;
+    setTpldata(newTpldata?: any): void;
+    parseText(text?: string, value?: any, values?: any, key?: number | string): string;
+    parseExpression(expression?: string, value?: any, values?: any, key?: number | string, tpldata?: any): any;
+    setArrayItemTitle(parentCtx?: any, childNode?: any, index?: number): string;
+    setItemTitle(ctx: WidgetContext): string;
+    evaluateCondition(layoutNode: any, dataIndex: number[]): boolean;
+    initializeControl(ctx: WidgetContext, bind?: boolean): boolean;
+    formatErrors(errors: any, validationMessages?: any): string;
+    updateValue(ctx: WidgetContext, value: any): void;
+    updateArrayCheckboxList(ctx: WidgetContext, checkboxList: TitleMapItem[]): void;
+    updateArrayMultiSelectList(ctx: WidgetContext, selectList: TitleMapItem[]): void;
+    getFormControl(ctx: WidgetContext): AbstractControl;
+    setFormControl(ctx: WidgetContext, control: AbstractControl): AbstractControl;
+    getFormControlValue(ctx: WidgetContext): AbstractControl;
+    getFormControlGroup(ctx: WidgetContext): UntypedFormArray | UntypedFormGroup;
+    getFormControlName(ctx: WidgetContext): string;
+    getLayoutArray(ctx: WidgetContext): any[];
+    getParentNode(ctx: WidgetContext): any;
+    getDataPointer(ctx: WidgetContext): string;
+    getLayoutPointer(ctx: WidgetContext): string;
+    isControlBound(ctx: WidgetContext): boolean;
+    addItem(ctx: WidgetContext, name?: string): boolean;
+    moveArrayItem(ctx: WidgetContext, oldIndex: number, newIndex: number, moveLayout?: boolean): boolean;
+    removeItem(ctx: WidgetContext): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JsonSchemaFormService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<JsonSchemaFormService>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * @module 'JsonSchemaFormComponent' - Angular JSON Schema Form
+ *
+ * Root module of the Angular JSON Schema Form client-side library,
+ * an Angular library which generates an HTML form from a JSON schema
+ * structured data model and/or a JSON Schema Form layout description.
+ *
+ * This library also validates input data by the user, using both validators on
+ * individual controls to provide real-time feedback while the user is filling
+ * out the form, and then validating the entire input against the schema when
+ * the form is submitted to make sure the returned JSON data object is valid.
+ *
+ * This library is similar to, and mostly API compatible with:
+ *
+ * - JSON Schema Form's Angular Schema Form library for AngularJs
+ *   http://schemaform.io
+ *   http://schemaform.io/examples/bootstrap-example.html (examples)
+ *
+ * - Mozilla's react-jsonschema-form library for React
+ *   https://github.com/mozilla-services/react-jsonschema-form
+ *   https://mozilla-services.github.io/react-jsonschema-form (examples)
+ *
+ * - Joshfire's JSON Form library for jQuery
+ *   https://github.com/joshfire/jsonform
+ *   http://ulion.github.io/jsonform/playground (examples)
+ *
+ * This library depends on:
+ *  - Angular (obviously)                  https://angular.io
+ *  - lodash, JavaScript utility library   https://github.com/lodash/lodash
+ *  - ajv, Another JSON Schema validator   https://github.com/epoberezkin/ajv
+ *
+ * In addition, the Example Playground also depends on:
+ *  - brace, Browserified Ace editor       http://thlorenz.github.io/brace
  */
-/// <amd-module name="@ng-formworks/core" />
-export * from './public_api';
+declare class JsonSchemaFormComponent implements ControlValueAccessor, OnChanges, OnInit, OnDestroy {
+    private changeDetector;
+    private frameworkLibrary;
+    private widgetLibrary;
+    jsf: JsonSchemaFormService;
+    private unsubscribeOnActivateForm$;
+    debugOutput: any;
+    formValueSubscription: any;
+    formInitialized: boolean;
+    objectWrap: boolean;
+    formValuesInput: string;
+    previousInputs: {
+        schema: any;
+        layout: any[];
+        data: any;
+        options: any;
+        framework: any | string;
+        widgets: any;
+        form: any;
+        model: any;
+        JSONSchema: any;
+        UISchema: any;
+        formData: any;
+        loadExternalAssets: boolean;
+        debug: boolean;
+        ajvOptions: any;
+    };
+    readonly schema: _angular_core.InputSignal<any>;
+    readonly layout: _angular_core.InputSignal<any[]>;
+    readonly data: _angular_core.InputSignal<any>;
+    readonly options: _angular_core.InputSignal<any>;
+    readonly framework: _angular_core.InputSignal<any>;
+    readonly widgets: _angular_core.InputSignal<any>;
+    readonly form: _angular_core.InputSignal<any>;
+    readonly model: _angular_core.InputSignal<any>;
+    readonly JSONSchema: _angular_core.InputSignal<any>;
+    readonly UISchema: _angular_core.InputSignal<any>;
+    readonly formData: _angular_core.InputSignal<any>;
+    readonly ngModel: _angular_core.InputSignal<any>;
+    readonly language: _angular_core.InputSignal<string>;
+    readonly loadExternalAssets: _angular_core.InputSignal<boolean>;
+    readonly debug: _angular_core.InputSignal<boolean>;
+    readonly theme: _angular_core.InputSignal<string>;
+    readonly ajvOptions: _angular_core.InputSignal<any>;
+    private ajvInstanceName;
+    get value(): any;
+    set value(value: any);
+    readonly onChanges: _angular_core.OutputEmitterRef<any>;
+    readonly onSubmit: _angular_core.OutputEmitterRef<any>;
+    readonly isValid: _angular_core.OutputEmitterRef<boolean>;
+    readonly validationErrors: _angular_core.OutputEmitterRef<any>;
+    readonly formSchema: _angular_core.OutputEmitterRef<any>;
+    readonly formLayout: _angular_core.OutputEmitterRef<any>;
+    readonly dataChange: _angular_core.OutputEmitterRef<any>;
+    readonly modelChange: _angular_core.OutputEmitterRef<any>;
+    readonly formDataChange: _angular_core.OutputEmitterRef<any>;
+    readonly ngModelChange: _angular_core.OutputEmitterRef<any>;
+    onChange: Function;
+    onTouched: Function;
+    dataChangesSubs: Subscription;
+    statusChangesSubs: Subscription;
+    isValidChangesSubs: Subscription;
+    validationErrorChangesSubs: Subscription;
+    ngOnDestroy(): void;
+    private getInputValue;
+    private resetScriptsAndStyleSheets;
+    private loadScripts;
+    private loadStyleSheets;
+    private loadAssets;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    setDisabledState(isDisabled: boolean): void;
+    updateForm(): void;
+    setFormValues(formValues: any, resetFirst?: boolean): void;
+    submitForm(): void;
+    /**
+     * 'initializeForm' function
+     *
+     * - Update 'schema', 'layout', and 'formValues', from inputs.
+     *
+     * - Create 'schemaRefLibrary' and 'schemaRecursiveRefMap'
+     *   to resolve schema $ref links, including recursive $ref links.
+     *
+     * - Create 'dataRecursiveRefMap' to resolve recursive links in data
+     *   and corectly set output formats for recursively nested values.
+     *
+     * - Create 'layoutRefLibrary' and 'templateRefLibrary' to store
+     *   new layout nodes and formGroup elements to use when dynamically
+     *   adding form components to arrays and recursive $ref points.
+     *
+     * - Create 'dataMap' to map the data to the schema and template.
+     *
+     * - Create the master 'formGroupTemplate' then from it 'formGroup'
+     *   the Angular formGroup used to control the reactive form.
+     */
+    initializeForm(initialData?: any): void;
+    /**
+   * 'initializeAjv' function
+   *
+   * Initialize ajv from 'ajvOptions'
+   */
+    private initializeAjv;
+    /**
+     * 'initializeOptions' function
+     *
+     * Initialize 'options' (global form options) and set framework
+     * Combine available inputs:
+     * 1. options - recommended
+     * 2. form.options - Single input style
+     */
+    private initializeOptions;
+    /**
+     * 'initializeSchema' function
+     *
+     * Initialize 'schema'
+     * Use first available input:
+     * 1. schema - recommended / Angular Schema Form style
+     * 2. form.schema - Single input / JSON Form style
+     * 3. JSONSchema - React JSON Schema Form style
+     * 4. form.JSONSchema - For testing single input React JSON Schema Forms
+     * 5. form - For testing single schema-only inputs
+     *
+     * ... if no schema input found, the 'activateForm' function, below,
+     *     will make two additional attempts to build a schema
+     * 6. If layout input - build schema from layout
+     * 7. If data input - build schema from data
+     */
+    private initializeSchema;
+    /**
+     * 'initializeData' function
+     *
+     * Initialize 'formValues'
+     * defulat or previously submitted values used to populate form
+     * Use first available input:
+     * 1. data - recommended
+     * 2. model - Angular Schema Form style
+     * 3. form.value - JSON Form style
+     * 4. form.data - Single input style
+     * 5. formData - React JSON Schema Form style
+     * 6. form.formData - For easier testing of React JSON Schema Forms
+     * 7. (none) no data - initialize data from schema and layout defaults only
+     */
+    private initializeData;
+    /**
+     * 'initializeLayout' function
+     *
+     * Initialize 'layout'
+     * Use first available array input:
+     * 1. layout - recommended
+     * 2. form - Angular Schema Form style
+     * 3. form.form - JSON Form style
+     * 4. form.layout - Single input style
+     * 5. (none) no layout - set default layout instead
+     *    (full layout will be built later from the schema)
+     *
+     * Also, if alternate layout formats are available,
+     * import from 'UISchema' or 'customFormItems'
+     * used for React JSON Schema Form and JSON Form API compatibility
+     * Use first available input:
+     * 1. UISchema - React JSON Schema Form style
+     * 2. form.UISchema - For testing single input React JSON Schema Forms
+     * 2. form.customFormItems - JSON Form style
+     * 3. (none) no input - don't import
+     */
+    private initializeLayout;
+    /**
+     * 'activateForm' function
+     *
+     * ...continued from 'initializeSchema' function, above
+     * If 'schema' has not been initialized (i.e. no schema input found)
+     * 6. If layout input - build schema from layout input
+     * 7. If data input - build schema from data input
+     *
+     * Create final layout,
+     * build the FormGroup template and the Angular FormGroup,
+     * subscribe to changes,
+     * and activate the form.
+     */
+    private activateForm;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JsonSchemaFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<JsonSchemaFormComponent, "json-schema-form", never, { "schema": { "alias": "schema"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "framework": { "alias": "framework"; "required": false; "isSignal": true; }; "widgets": { "alias": "widgets"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "model": { "alias": "model"; "required": false; "isSignal": true; }; "JSONSchema": { "alias": "JSONSchema"; "required": false; "isSignal": true; }; "UISchema": { "alias": "UISchema"; "required": false; "isSignal": true; }; "formData": { "alias": "formData"; "required": false; "isSignal": true; }; "ngModel": { "alias": "ngModel"; "required": false; "isSignal": true; }; "language": { "alias": "language"; "required": false; "isSignal": true; }; "loadExternalAssets": { "alias": "loadExternalAssets"; "required": false; "isSignal": true; }; "debug": { "alias": "debug"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "ajvOptions": { "alias": "ajvOptions"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; }; }, { "onChanges": "onChanges"; "onSubmit": "onSubmit"; "isValid": "isValid"; "validationErrors": "validationErrors"; "formSchema": "formSchema"; "formLayout": "formLayout"; "dataChange": "dataChange"; "modelChange": "modelChange"; "formDataChange": "formDataChange"; "ngModelChange": "ngModelChange"; }, never, never, false, never>;
+}
+
+declare class AddReferenceComponent implements OnInit {
+    private jsf;
+    options: any;
+    itemCount: number;
+    previousLayoutIndex: number[];
+    previousDataIndex: number[];
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    ngOnInit(): void;
+    get showAddButton(): boolean;
+    addItem(event: any): void;
+    get buttonText(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AddReferenceComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AddReferenceComponent, "add-reference-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class OneOfComponent implements OnInit, OnDestroy {
+    private jsf;
+    formControl: AbstractControl;
+    controlName: string;
+    controlValue: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options: any;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    ngOnInit(): void;
+    findSelectedTab(): number;
+    updateValue(event: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OneOfComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OneOfComponent, "one-of-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class ButtonComponent implements OnInit, OnDestroy {
+    private jsf;
+    formControl: AbstractControl;
+    controlName: string;
+    controlValue: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options: any;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "button-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class CheckboxComponent implements OnInit, OnDestroy {
+    private jsf;
+    formControl: AbstractControl;
+    controlName: string;
+    controlValue: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options: any;
+    trueValue: any;
+    falseValue: any;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    get isChecked(): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "checkbox-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class CheckboxesComponent implements OnInit, OnDestroy {
+    private jsf;
+    formControl: AbstractControl;
+    controlName: string;
+    controlValue: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options: any;
+    layoutOrientation: string;
+    formArray: AbstractControl;
+    checkboxList: TitleMapItem[];
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxesComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxesComponent, "checkboxes-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class FileComponent implements OnInit, OnDestroy {
+    private jsf;
+    formControl: AbstractControl;
+    controlName: string;
+    controlValue: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options: any;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileComponent, "file-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class HiddenComponent implements OnInit, OnDestroy {
+    private jsf;
+    formControl: AbstractControl;
+    controlName: string;
+    controlValue: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HiddenComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HiddenComponent, "hidden-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class InputComponent implements OnInit, OnDestroy {
+    private jsf;
+    formControl: AbstractControl;
+    controlName: string;
+    controlValue: string;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options: any;
+    autoCompleteList: string[];
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    get inputAttributes(): any;
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputComponent, "input-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class MessageComponent implements OnInit {
+    private jsf;
+    options: any;
+    message: string;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageComponent, "message-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class NoneComponent {
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NoneComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NoneComponent, "none-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class NumberComponent implements OnInit, OnDestroy {
+    private jsf;
+    formControl: AbstractControl;
+    controlName: string;
+    controlValue: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options: any;
+    allowNegative: boolean;
+    allowDecimal: boolean;
+    allowExponents: boolean;
+    lastValidNumber: string;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    get inputAttributes(): any;
+    inputControl: ElementRef;
+    div: ElementRef;
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberComponent, "number-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class RadiosComponent implements OnInit, OnDestroy {
+    private jsf;
+    formControl: AbstractControl;
+    controlName: string;
+    controlValue: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options: any;
+    layoutOrientation: string;
+    radiosList: any[];
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadiosComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadiosComponent, "radios-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class RootComponent implements OnInit, OnDestroy {
+    private jsf;
+    options: any;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly layout: _angular_core.InputSignal<any[]>;
+    readonly isOrderable: _angular_core.InputSignal<boolean>;
+    readonly isFlexItem: _angular_core.InputSignal<boolean>;
+    sortableObj: any;
+    sortableConfig: any;
+    private sortableOptionsSubscription;
+    sortableInit(sortable: any): void;
+    isDraggable(node: any): boolean;
+    isFixed(node: any): boolean;
+    getFlexAttribute(node: any, attribute: string): any;
+    showWidget(layoutNode: any): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RootComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RootComponent, "root-widget", never, { "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "isOrderable": { "alias": "isOrderable"; "required": false; "isSignal": true; }; "isFlexItem": { "alias": "isFlexItem"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class SectionComponent implements OnInit {
+    private jsf;
+    options: any;
+    expanded: boolean;
+    containerType: string;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    get sectionTitle(): string;
+    ngOnInit(): void;
+    toggleExpanded(): void;
+    getFlexAttribute(attribute: string): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SectionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SectionComponent, "section-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Validator utility function library:
+ *
+ * Validator and error utilities:
+ *   _executeValidators, _executeAsyncValidators, _mergeObjects, _mergeErrors
+ *
+ * Individual value checking:
+ *   isDefined, hasValue, isEmpty
+ *
+ * Individual type checking:
+ *   isString, isNumber, isInteger, isBoolean, isFunction, isObject, isArray,
+ *   isMap, isSet, isPromise, isObservable
+ *
+ * Multiple type checking and fixing:
+ *   getType, isType, isPrimitive, toJavaScriptType, toSchemaType,
+ *   _toPromise, toObservable
+ *
+ * Utility functions:
+ *   inArray, xor
+ *
+ * Typescript types and interfaces:
+ *   SchemaPrimitiveType, SchemaType, JavaScriptPrimitiveType, JavaScriptType,
+ *   PrimitiveValue, PlainObject, IValidatorFn, AsyncIValidatorFn
+ *
+ * Note: 'IValidatorFn' is short for 'invertable validator function',
+ *   which is a validator functions that accepts an optional second
+ *   argument which, if set to TRUE, causes the validator to perform
+ *   the opposite of its original function.
+ */
+type SchemaPrimitiveType = 'string' | 'number' | 'integer' | 'boolean' | 'null';
+type SchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'null' | 'object' | 'array';
+type JavaScriptPrimitiveType = 'string' | 'number' | 'boolean' | 'null' | 'undefined';
+type JavaScriptType = 'string' | 'number' | 'boolean' | 'null' | 'undefined' | 'object' | 'array' | 'map' | 'set' | 'arguments' | 'date' | 'error' | 'function' | 'json' | 'math' | 'regexp';
+type PrimitiveValue = string | number | boolean | null | undefined;
+interface PlainObject {
+    [k: string]: any;
+}
+type IValidatorFn = (c: AbstractControl, i?: boolean) => PlainObject;
+type AsyncIValidatorFn = (c: AbstractControl, i?: boolean) => any;
+/**
+ * '_executeValidators' utility function
+ *
+ * Validates a control against an array of validators, and returns
+ * an array of the same length containing a combination of error messages
+ * (from invalid validators) and null values (from valid validators)
+ *
+ * //  { AbstractControl } control - control to validate
+ * //  { IValidatorFn[] } validators - array of validators
+ * //  { boolean } invert - invert?
+ * // { PlainObject[] } - array of nulls and error message
+ */
+declare function _executeValidators(control: any, validators: any, invert?: boolean): any;
+/**
+ * '_executeAsyncValidators' utility function
+ *
+ * Validates a control against an array of async validators, and returns
+ * an array of observabe results of the same length containing a combination of
+ * error messages (from invalid validators) and null values (from valid ones)
+ *
+ * //  { AbstractControl } control - control to validate
+ * //  { AsyncIValidatorFn[] } validators - array of async validators
+ * //  { boolean } invert - invert?
+ * //  - array of observable nulls and error message
+ */
+declare function _executeAsyncValidators(control: any, validators: any, invert?: boolean): any;
+/**
+ * '_mergeObjects' utility function
+ *
+ * Recursively Merges one or more objects into a single object with combined keys.
+ * Automatically detects and ignores null and undefined inputs.
+ * Also detects duplicated boolean 'not' keys and XORs their values.
+ *
+ * //  { PlainObject[] } objects - one or more objects to merge
+ * // { PlainObject } - merged object
+ */
+declare function _mergeObjects(...objects: any[]): PlainObject;
+/**
+ * '_mergeErrors' utility function
+ *
+ * Merges an array of objects.
+ * Used for combining the validator errors returned from 'executeValidators'
+ *
+ * //  { PlainObject[] } arrayOfErrors - array of objects
+ * // { PlainObject } - merged object, or null if no usable input objectcs
+ */
+declare function _mergeErrors(arrayOfErrors: any): PlainObject;
+/**
+ * 'isDefined' utility function
+ *
+ * Checks if a variable contains a value of any type.
+ * Returns true even for otherwise 'falsey' values of 0, '', and false.
+ *
+ * //   value - the value to check
+ * // { boolean } - false if undefined or null, otherwise true
+ */
+declare function isDefined(value: any): boolean;
+/**
+ * 'hasValue' utility function
+ *
+ * Checks if a variable contains a value.
+ * Returs false for null, undefined, or a zero-length strng, '',
+ * otherwise returns true.
+ * (Stricter than 'isDefined' because it also returns false for '',
+ * though it stil returns true for otherwise 'falsey' values 0 and false.)
+ *
+ * //   value - the value to check
+ * // { boolean } - false if undefined, null, or '', otherwise true
+ */
+declare function hasValue(value: any): boolean;
+/**
+ * 'isEmpty' utility function
+ *
+ * Similar to !hasValue, but also returns true for empty arrays and objects.
+ *
+ * //   value - the value to check
+ * // { boolean } - false if undefined, null, or '', otherwise true
+ */
+declare function isEmpty(value: any): boolean;
+/**
+ * 'isString' utility function
+ *
+ * Checks if a value is a string.
+ *
+ * //   value - the value to check
+ * // { boolean } - true if string, false if not
+ */
+declare function isString(value: any): value is string;
+/**
+ * 'isNumber' utility function
+ *
+ * Checks if a value is a regular number, numeric string, or JavaScript Date.
+ *
+ * //   value - the value to check
+ * //  { any = false } strict - if truthy, also checks JavaScript tyoe
+ * // { boolean } - true if number, false if not
+ */
+declare function isNumber(value: any, strict?: any): boolean;
+/**
+ * 'isInteger' utility function
+ *
+ * Checks if a value is an integer.
+ *
+ * //   value - the value to check
+ * //  { any = false } strict - if truthy, also checks JavaScript tyoe
+ * // {boolean } - true if number, false if not
+ */
+declare function isInteger(value: any, strict?: any): boolean;
+/**
+ * 'isBoolean' utility function
+ *
+ * Checks if a value is a boolean.
+ *
+ * //   value - the value to check
+ * //  { any = null } option - if 'strict', also checks JavaScript type
+ *                              if TRUE or FALSE, checks only for that value
+ * // { boolean } - true if boolean, false if not
+ */
+declare function isBoolean(value: any, option?: any): boolean;
+declare function isFunction(item: any): boolean;
+declare function isObject(item: any): boolean;
+declare function isArray(item: any): boolean;
+declare function isDate(item: any): boolean;
+declare function isMap(item: any): boolean;
+declare function isSet(item: any): boolean;
+/**
+ * 'getType' function
+ *
+ * Detects the JSON Schema Type of a value.
+ * By default, detects numbers and integers even if formatted as strings.
+ * (So all integers are also numbers, and any number may also be a string.)
+ * However, it only detects true boolean values (to detect boolean values
+ * in non-boolean formats, use isBoolean() instead).
+ *
+ * If passed a second optional parameter of 'strict', it will only detect
+ * numbers and integers if they are formatted as JavaScript numbers.
+ *
+ * Examples:
+ * getType('10.5') = 'number'
+ * getType(10.5) = 'number'
+ * getType('10') = 'integer'
+ * getType(10) = 'integer'
+ * getType('true') = 'string'
+ * getType(true) = 'boolean'
+ * getType(null) = 'null'
+ * getType({ }) = 'object'
+ * getType([]) = 'array'
+ *
+ * getType('10.5', 'strict') = 'string'
+ * getType(10.5, 'strict') = 'number'
+ * getType('10', 'strict') = 'string'
+ * getType(10, 'strict') = 'integer'
+ * getType('true', 'strict') = 'string'
+ * getType(true, 'strict') = 'boolean'
+ *
+ * //   value - value to check
+ * //  { any = false } strict - if truthy, also checks JavaScript tyoe
+ * // { SchemaType }
+ */
+declare function getType(value: any, strict?: any): "string" | "number" | "integer" | "boolean" | "null" | "object" | "array";
+/**
+ * 'isType' function
+ *
+ * Checks wether an input (probably string) value contains data of
+ * a specified JSON Schema type
+ *
+ * //  { PrimitiveValue } value - value to check
+ * //  { SchemaPrimitiveType } type - type to check
+ * // { boolean }
+ */
+declare function isType(value: any, type: any): boolean;
+/**
+ * 'isPrimitive' function
+ *
+ * Checks wether an input value is a JavaScript primitive type:
+ * string, number, boolean, or null.
+ *
+ * //   value - value to check
+ * // { boolean }
+ */
+declare function isPrimitive(value: any): boolean;
+/**
+ * 'toJavaScriptType' function
+ *
+ * Converts an input (probably string) value to a JavaScript primitive type -
+ * 'string', 'number', 'boolean', or 'null' - before storing in a JSON object.
+ *
+ * Does not coerce values (other than null), and only converts the types
+ * of values that would otherwise be valid.
+ *
+ * If the optional third parameter 'strictIntegers' is TRUE, and the
+ * JSON Schema type 'integer' is specified, it also verifies the input value
+ * is an integer and, if it is, returns it as a JaveScript number.
+ * If 'strictIntegers' is FALSE (or not set) the type 'integer' is treated
+ * exactly the same as 'number', and allows decimals.
+ *
+ * Valid Examples:
+ * toJavaScriptType('10',   'number' ) = 10   // '10'   is a number
+ * toJavaScriptType('10',   'integer') = 10   // '10'   is also an integer
+ * toJavaScriptType( 10,    'integer') = 10   //  10    is still an integer
+ * toJavaScriptType( 10,    'string' ) = '10' //  10    can be made into a string
+ * toJavaScriptType('10.5', 'number' ) = 10.5 // '10.5' is a number
+ *
+ * Invalid Examples:
+ * toJavaScriptType('10.5', 'integer') = null // '10.5' is not an integer
+ * toJavaScriptType( 10.5,  'integer') = null //  10.5  is still not an integer
+ *
+ * //  { PrimitiveValue } value - value to convert
+ * //  { SchemaPrimitiveType | SchemaPrimitiveType[] } types - types to convert to
+ * //  { boolean = false } strictIntegers - if FALSE, treat integers as numbers
+ * // { PrimitiveValue }
+ */
+declare function toJavaScriptType(value: any, types: any, strictIntegers?: boolean): any;
+/**
+ * 'toSchemaType' function
+ *
+ * Converts an input (probably string) value to the "best" JavaScript
+ * equivalent available from an allowed list of JSON Schema types, which may
+ * contain 'string', 'number', 'integer', 'boolean', and/or 'null'.
+ * If necssary, it does progressively agressive type coersion.
+ * It will not return null unless null is in the list of allowed types.
+ *
+ * Number conversion examples:
+ * toSchemaType('10', ['number','integer','string']) = 10 // integer
+ * toSchemaType('10', ['number','string']) = 10 // number
+ * toSchemaType('10', ['string']) = '10' // string
+ * toSchemaType('10.5', ['number','integer','string']) = 10.5 // number
+ * toSchemaType('10.5', ['integer','string']) = '10.5' // string
+ * toSchemaType('10.5', ['integer']) = 10 // integer
+ * toSchemaType(10.5, ['null','boolean','string']) = '10.5' // string
+ * toSchemaType(10.5, ['null','boolean']) = true // boolean
+ *
+ * String conversion examples:
+ * toSchemaType('1.5x', ['boolean','number','integer','string']) = '1.5x' // string
+ * toSchemaType('1.5x', ['boolean','number','integer']) = '1.5' // number
+ * toSchemaType('1.5x', ['boolean','integer']) = '1' // integer
+ * toSchemaType('1.5x', ['boolean']) = true // boolean
+ * toSchemaType('xyz', ['number','integer','boolean','null']) = true // boolean
+ * toSchemaType('xyz', ['number','integer','null']) = null // null
+ * toSchemaType('xyz', ['number','integer']) = 0 // number
+ *
+ * Boolean conversion examples:
+ * toSchemaType('1', ['integer','number','string','boolean']) = 1 // integer
+ * toSchemaType('1', ['number','string','boolean']) = 1 // number
+ * toSchemaType('1', ['string','boolean']) = '1' // string
+ * toSchemaType('1', ['boolean']) = true // boolean
+ * toSchemaType('true', ['number','string','boolean']) = 'true' // string
+ * toSchemaType('true', ['boolean']) = true // boolean
+ * toSchemaType('true', ['number']) = 0 // number
+ * toSchemaType(true, ['number','string','boolean']) = true // boolean
+ * toSchemaType(true, ['number','string']) = 'true' // string
+ * toSchemaType(true, ['number']) = 1 // number
+ *
+ * //  { PrimitiveValue } value - value to convert
+ * //  { SchemaPrimitiveType | SchemaPrimitiveType[] } types - allowed types to convert to
+ * // { PrimitiveValue }
+ */
+declare function toSchemaType(value: any, types: any): any;
+/**
+ * 'isPromise' function
+ *
+ * //   object
+ * // { boolean }
+ */
+declare function isPromise(object: any): object is Promise<any>;
+/**
+ * 'isObservable' function
+ *
+ * //   object
+ * // { boolean }
+ */
+declare function isObservable(object: any): object is Observable<any>;
+/**
+ * '_toPromise' function
+ *
+ * //  { object } object
+ * // { Promise<any> }
+ */
+declare function _toPromise(object: any): Promise<any>;
+/**
+ * 'toObservable' function
+ *
+ * //  { object } object
+ * // { Observable<any> }
+ */
+declare function toObservable(object: any): Observable<any>;
+/**
+ * 'inArray' function
+ *
+ * Searches an array for an item, or one of a list of items, and returns true
+ * as soon as a match is found, or false if no match.
+ *
+ * If the optional third parameter allIn is set to TRUE, and the item to find
+ * is an array, then the function returns true only if all elements from item
+ * are found in the array list, and false if any element is not found. If the
+ * item to find is not an array, setting allIn to TRUE has no effect.
+ *
+ * //  { any|any[] } item - the item to search for
+ * //   array - the array to search
+ * //  { boolean = false } allIn - if TRUE, all items must be in array
+ * // { boolean } - true if item(s) in array, false otherwise
+ */
+declare function inArray(item: any, array: any, allIn?: boolean): any;
+/**
+ * 'xor' utility function - exclusive or
+ *
+ * Returns true if exactly one of two values is truthy.
+ *
+ * //   value1 - first value to check
+ * //   value2 - second value to check
+ * // { boolean } - true if exactly one input value is truthy, false if not
+ */
+declare function xor(value1: any, value2: any): boolean;
+
+/**
+ * Utility function library:
+ *
+ * addClasses, copy, forEach, forEachCopy, hasOwn, mergeFilteredObject,
+ * uniqueItems, commonItems, fixTitle, toTitleCase
+*/
+/**
+ * 'addClasses' function
+ *
+ * Merges two space-delimited lists of CSS classes and removes duplicates.
+ *
+ * // {string | string[] | Set<string>} oldClasses
+ * // {string | string[] | Set<string>} newClasses
+ * // {string | string[] | Set<string>} - Combined classes
+ */
+declare function addClasses(oldClasses: string | string[] | Set<string>, newClasses: string | string[] | Set<string>): string | string[] | Set<string>;
+/**
+ * 'copy' function
+ *
+ * Makes a shallow copy of a JavaScript object, array, Map, or Set.
+ * If passed a JavaScript primitive value (string, number, boolean, or null),
+ * it returns the value.
+ *
+ * // {Object|Array|string|number|boolean|null} object - The object to copy
+ * // {boolean = false} errors - Show errors?
+ * // {Object|Array|string|number|boolean|null} - The copied object
+ */
+declare function copy(object: any, errors?: boolean): any;
+/**
+ * 'forEach' function
+ *
+ * Iterates over all items in the first level of an object or array
+ * and calls an iterator funciton on each item.
+ *
+ * The iterator function is called with four values:
+ * 1. The current item's value
+ * 2. The current item's key
+ * 3. The parent object, which contains the current item
+ * 4. The root object
+ *
+ * Setting the optional third parameter to 'top-down' or 'bottom-up' will cause
+ * it to also recursively iterate over items in sub-objects or sub-arrays in the
+ * specified direction.
+ *
+ * // {Object|Array} object - The object or array to iterate over
+ * // {function} fn - the iterator funciton to call on each item
+ * // {boolean = false} errors - Show errors?
+ * // {void}
+ */
+declare function forEach(object: any, fn: (v: any, k?: string | number, c?: any, rc?: any) => any, recurse?: boolean | string, rootObject?: any, errors?: boolean): void;
+/**
+ * 'forEachCopy' function
+ *
+ * Iterates over all items in the first level of an object or array
+ * and calls an iterator function on each item. Returns a new object or array
+ * with the same keys or indexes as the original, and values set to the results
+ * of the iterator function.
+ *
+ * Does NOT recursively iterate over items in sub-objects or sub-arrays.
+ *
+ * // {Object | Array} object - The object or array to iterate over
+ * // {function} fn - The iterator funciton to call on each item
+ * // {boolean = false} errors - Show errors?
+ * // {Object | Array} - The resulting object or array
+ */
+declare function forEachCopy(object: any, fn: (v: any, k?: string | number, o?: any, p?: string) => any, errors?: boolean): any;
+/**
+ * 'hasOwn' utility function
+ *
+ * Checks whether an object or array has a particular property.
+ *
+ * // {any} object - the object to check
+ * // {string} property - the property to look for
+ * // {boolean} - true if object has property, false if not
+ */
+declare function hasOwn(object: any, property: string): boolean;
+/**
+ * 'mergeFilteredObject' utility function
+ *
+ * Shallowly merges two objects, setting key and values from source object
+ * in target object, excluding specified keys.
+ *
+ * Optionally, it can also use functions to transform the key names and/or
+ * the values of the merging object.
+ *
+ * // {PlainObject} targetObject - Target object to add keys and values to
+ * // {PlainObject} sourceObject - Source object to copy keys and values from
+ * // {string[]} excludeKeys - Array of keys to exclude
+ * // {(string: string) => string = (k) => k} keyFn - Function to apply to keys
+ * // {(any: any) => any = (v) => v} valueFn - Function to apply to values
+ * // {PlainObject} - Returns targetObject
+ */
+declare function mergeFilteredObject(targetObject: PlainObject, sourceObject: PlainObject, excludeKeys?: string[], keyFn?: (key: string) => string, valFn?: (val: any) => any): PlainObject;
+/**
+ * 'uniqueItems' function
+ *
+ * Accepts any number of string value inputs,
+ * and returns an array of all input vaues, excluding duplicates.
+ *
+ * // {...string} ...items -
+ * // {string[]} -
+ */
+declare function uniqueItems(...items: any[]): string[];
+/**
+ * 'commonItems' function
+ *
+ * Accepts any number of strings or arrays of string values,
+ * and returns a single array containing only values present in all inputs.
+ *
+ * // {...string|string[]} ...arrays -
+ * // {string[]} -
+ */
+declare function commonItems(...arrays: any[]): string[];
+/**
+ * 'fixTitle' function
+ *
+ *
+ * // {string} input -
+ * // {string} -
+ */
+declare function fixTitle(name: string): string;
+/**
+ * 'toTitleCase' function
+ *
+ * Intelligently converts an input string to Title Case.
+ *
+ * Accepts an optional second parameter with a list of additional
+ * words and abbreviations to force into a particular case.
+ *
+ * This function is built on prior work by John Gruber and David Gouch:
+ * http://daringfireball.net/2008/08/title_case_update
+ * https://github.com/gouch/to-title-case
+ *
+ * // {string} input -
+ * // {string|string[]} forceWords? -
+ * // {string} -
+ */
+declare function toTitleCase(input: string, forceWords?: string | string[]): string;
+/**
+ * Recursively checks if at least one property of the given object (including nested objects)
+ * has a non-null and non-undefined value.
+ *
+ * @param obj - The object to check.
+ * @returns `true` if at least one property has a non-null and non-undefined value, otherwise `false`.
+ *
+ * @example
+ * const testObj = { a: null, b: { b1: null, b2: undefined } };
+ * console.log(hasNonNullValue(testObj));  // Output: false
+ *
+ * const testObj2 = { a: 1, b: { b1: null, b2: undefined } };
+ * console.log(hasNonNullValue(testObj2));  // Output: true
+ */
+declare function hasNonNullValue(obj: Record<string, any>): boolean;
+
+/**
+ * 'JsonPointer' class
+ *
+ * Some utilities for using JSON Pointers with JSON objects
+ * https://tools.ietf.org/html/rfc6901
+ *
+ * get, getCopy, getFirst, set, setCopy, insert, insertCopy, remove, has, dict,
+ * forEachDeep, forEachDeepCopy, escape, unescape, parse, compile, toKey,
+ * isJsonPointer, isSubPointer, toIndexedPointer, toGenericPointer,
+ * toControlPointer, toSchemaPointer, toDataPointer, parseObjectPath
+ *
+ * Some functions based on manuelstofer's json-pointer utilities
+ * https://github.com/manuelstofer/json-pointer
+ */
+type Pointer = string | string[];
+declare class JsonPointer {
+    /**
+     * 'get' function
+     *
+     * Uses a JSON Pointer to retrieve a value from an object.
+     *
+     * //  { object } object - Object to get value from
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * //  { number = 0 } startSlice - Zero-based index of first Pointer key to use
+     * //  { number } endSlice - Zero-based index of last Pointer key to use
+     * //  { boolean = false } getBoolean - Return only true or false?
+     * //  { boolean = false } errors - Show error if not found?
+     * // { object } - Located value (or true or false if getBoolean = true)
+     */
+    static get(object: any, pointer: any, startSlice?: number, endSlice?: number, getBoolean?: boolean, errors?: boolean): any;
+    private static logErrors;
+    /**
+     * Evaluates conditional expression in form of `model.<property>==<value>` or
+     * `model.<property>!=<value>` where the first one means that the value must match to be
+     * shown in a form, while the former shows the property only when the property value is not
+     * set, or does not equal the given value.
+     *
+     * // { subObject } subObject -  an object containing the data values of properties
+     * // { key } key - the key from the for loop in a form of `<property>==<value>`
+     *
+     * Returns the object with two properties. The property passed informs whether
+     * the expression evaluated successfully and the property key returns either the same
+     * key if it is not contained inside the subObject or the key of the property if it is contained.
+     */
+    static evaluateExpression(subObject: Object, key: any): any;
+    /**
+     * Performs the actual evaluation on the given expression with given values and keys.
+     * // { cleanedValue } cleanedValue - the given valued cleaned of quotes if it had any
+     * // { subObject } subObject - the object with properties values
+     * // { keysAndExpression } keysAndExpression - an object holding the expressions with
+     */
+    private static performExpressionOnValue;
+    private static doComparisonByExpressionType;
+    /**
+     * Does the checks when the parsed key is actually no a property inside subObject.
+     * That would mean that the equal comparison makes no sense and thus the negative result
+     * is returned, and the not equal comparison is not necessary because it doesn't equal
+     * obviously. Returns null when the given key is a real property inside the subObject.
+     * // { subObject } subObject - the object with properties values
+     * // { keysAndExpression } keysAndExpression - an object holding the expressions with
+     * the associated keys.
+     */
+    private static doOwnCheckResult;
+    /**
+     * Does the basic checks and tries to parse an expression and a pair
+     * of key and value.
+     * // { key } key - the original for loop created value containing key and value in one string
+     * // { subObject } subObject - the object with properties values
+     */
+    private static parseKeysAndExpression;
+    private static keyOrSubObjEmpty;
+    /**
+     * 'getCopy' function
+     *
+     * Uses a JSON Pointer to deeply clone a value from an object.
+     *
+     * //  { object } object - Object to get value from
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * //  { number = 0 } startSlice - Zero-based index of first Pointer key to use
+     * //  { number } endSlice - Zero-based index of last Pointer key to use
+     * //  { boolean = false } getBoolean - Return only true or false?
+     * //  { boolean = false } errors - Show error if not found?
+     * // { object } - Located value (or true or false if getBoolean = true)
+     */
+    static getCopy(object: any, pointer: any, startSlice?: number, endSlice?: number, getBoolean?: boolean, errors?: boolean): any;
+    /**
+     * 'getFirst' function
+     *
+     * Takes an array of JSON Pointers and objects,
+     * checks each object for a value specified by the pointer,
+     * and returns the first value found.
+     *
+     * //  { [object, pointer][] } items - Array of objects and pointers to check
+     * //  { any = null } defaultValue - Value to return if nothing found
+     * //  { boolean = false } getCopy - Return a copy instead?
+     * //  - First value found
+     */
+    static getFirst(items: any, defaultValue?: any, getCopy?: boolean): any;
+    /**
+     * 'getFirstCopy' function
+     *
+     * Similar to getFirst, but always returns a copy.
+     *
+     * //  { [object, pointer][] } items - Array of objects and pointers to check
+     * //  { any = null } defaultValue - Value to return if nothing found
+     * //  - Copy of first value found
+     */
+    static getFirstCopy(items: any, defaultValue?: any): any;
+    /**
+     * 'set' function
+     *
+     * Uses a JSON Pointer to set a value on an object.
+     * Also creates any missing sub objects or arrays to contain that value.
+     *
+     * If the optional fourth parameter is TRUE and the inner-most container
+     * is an array, the function will insert the value as a new item at the
+     * specified location in the array, rather than overwriting the existing
+     * value (if any) at that location.
+     *
+     * So set([1, 2, 3], '/1', 4) => [1, 4, 3]
+     * and
+     * So set([1, 2, 3], '/1', 4, true) => [1, 4, 2, 3]
+     *
+     * //  { object } object - The object to set value in
+     * //  { Pointer } pointer - The JSON Pointer (string or array)
+     * //   value - The new value to set
+     * //  { boolean } insert - insert value?
+     * // { object } - The original object, modified with the set value
+     */
+    static set(object: any, pointer: any, value: any, insert?: boolean): any;
+    /**
+     * 'setCopy' function
+     *
+     * Copies an object and uses a JSON Pointer to set a value on the copy.
+     * Also creates any missing sub objects or arrays to contain that value.
+     *
+     * If the optional fourth parameter is TRUE and the inner-most container
+     * is an array, the function will insert the value as a new item at the
+     * specified location in the array, rather than overwriting the existing value.
+     *
+     * //  { object } object - The object to copy and set value in
+     * //  { Pointer } pointer - The JSON Pointer (string or array)
+     * //   value - The value to set
+     * //  { boolean } insert - insert value?
+     * // { object } - The new object with the set value
+     */
+    static setCopy(object: any, pointer: any, value: any, insert?: boolean): any;
+    /**
+     * 'insert' function
+     *
+     * Calls 'set' with insert = TRUE
+     *
+     * //  { object } object - object to insert value in
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * //   value - value to insert
+     * // { object }
+     */
+    static insert(object: any, pointer: any, value: any): any;
+    /**
+     * 'insertCopy' function
+     *
+     * Calls 'setCopy' with insert = TRUE
+     *
+     * //  { object } object - object to insert value in
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * //   value - value to insert
+     * // { object }
+     */
+    static insertCopy(object: any, pointer: any, value: any): any;
+    /**
+     * 'remove' function
+     *
+     * Uses a JSON Pointer to remove a key and its attribute from an object
+     *
+     * //  { object } object - object to delete attribute from
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * // { object }
+     */
+    static remove(object: any, pointer: any): any;
+    /**
+     * 'has' function
+     *
+     * Tests if an object has a value at the location specified by a JSON Pointer
+     *
+     * //  { object } object - object to chek for value
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * // { boolean }
+     */
+    static has(object: any, pointer: any): any;
+    /**
+     * 'dict' function
+     *
+     * Returns a (pointer -> value) dictionary for an object
+     *
+     * //  { object } object - The object to create a dictionary from
+     * // { object } - The resulting dictionary object
+     */
+    static dict(object: any): any;
+    /**
+     * 'forEachDeep' function
+     *
+     * Iterates over own enumerable properties of an object or items in an array
+     * and invokes an iteratee function for each key/value or index/value pair.
+     * By default, iterates over items within objects and arrays after calling
+     * the iteratee function on the containing object or array itself.
+     *
+     * The iteratee is invoked with three arguments: (value, pointer, rootObject),
+     * where pointer is a JSON pointer indicating the location of the current
+     * value within the root object, and rootObject is the root object initially
+     * submitted to th function.
+     *
+     * If a third optional parameter 'bottomUp' is set to TRUE, the iterator
+     * function will be called on sub-objects and arrays after being
+     * called on their contents, rather than before, which is the default.
+     *
+     * This function can also optionally be called directly on a sub-object by
+     * including optional 4th and 5th parameterss to specify the initial
+     * root object and pointer.
+     *
+     * //  { object } object - the initial object or array
+     * //  { (v: any, p?: string, o?: any) => any } function - iteratee function
+     * //  { boolean = false } bottomUp - optional, set to TRUE to reverse direction
+     * //  { object = object } rootObject - optional, root object or array
+     * //  { string = '' } pointer - optional, JSON Pointer to object within rootObject
+     * // { object } - The modified object
+     */
+    static forEachDeep(object: any, fn?: (v: any, p?: string, o?: any) => any, bottomUp?: boolean, pointer?: string, rootObject?: any): void;
+    /**
+     * 'forEachDeepCopy' function
+     *
+     * Similar to forEachDeep, but returns a copy of the original object, with
+     * the same keys and indexes, but with values replaced with the result of
+     * the iteratee function.
+     *
+     * //  { object } object - the initial object or array
+     * //  { (v: any, k?: string, o?: any, p?: any) => any } function - iteratee function
+     * //  { boolean = false } bottomUp - optional, set to TRUE to reverse direction
+     * //  { object = object } rootObject - optional, root object or array
+     * //  { string = '' } pointer - optional, JSON Pointer to object within rootObject
+     * // { object } - The copied object
+     */
+    static forEachDeepCopy(object: any, fn?: (v: any, p?: string, o?: any) => any, bottomUp?: boolean, pointer?: string, rootObject?: any): any;
+    /**
+     * 'escape' function
+     *
+     * Escapes a string reference key
+     *
+     * //  { string } key - string key to escape
+     * // { string } - escaped key
+     */
+    static escape(key: any): any;
+    /**
+     * 'unescape' function
+     *
+     * Unescapes a string reference key
+     *
+     * //  { string } key - string key to unescape
+     * // { string } - unescaped key
+     */
+    static unescape(key: any): any;
+    /**
+     * 'parse' function
+     *
+     * Converts a string JSON Pointer into a array of keys
+     * (if input is already an an array of keys, it is returned unchanged)
+     *
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * //  { boolean = false } errors - Show error if invalid pointer?
+     * // { string[] } - JSON Pointer array of keys
+     */
+    static parse(pointer: any, errors?: boolean): any[];
+    /**
+     * 'compile' function
+     *
+     * Converts an array of keys into a JSON Pointer string
+     * (if input is already a string, it is normalized and returned)
+     *
+     * The optional second parameter is a default which will replace any empty keys.
+     *
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * //  { string | number = '' } defaultValue - Default value
+     * //  { boolean = false } errors - Show error if invalid pointer?
+     * // { string } - JSON Pointer string
+     */
+    static compile(pointer: any, defaultValue?: string, errors?: boolean): any;
+    /**
+     * 'toKey' function
+     *
+     * Extracts name of the final key from a JSON Pointer.
+     *
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * //  { boolean = false } errors - Show error if invalid pointer?
+     * // { string } - the extracted key
+     */
+    static toKey(pointer: any, errors?: boolean): any;
+    /**
+     * 'isJsonPointer' function
+     *
+     * Checks a string or array value to determine if it is a valid JSON Pointer.
+     * Returns true if a string is empty, or starts with '/' or '#/'.
+     * Returns true if an array contains only string values.
+     *
+     * //   value - value to check
+     * // { boolean } - true if value is a valid JSON Pointer, otherwise false
+     */
+    static isJsonPointer(value: any): any;
+    /**
+     * 'isSubPointer' function
+     *
+     * Checks whether one JSON Pointer is a subset of another.
+     *
+     * //  { Pointer } shortPointer - potential subset JSON Pointer
+     * //  { Pointer } longPointer - potential superset JSON Pointer
+     * //  { boolean = false } trueIfMatching - return true if pointers match?
+     * //  { boolean = false } errors - Show error if invalid pointer?
+     * // { boolean } - true if shortPointer is a subset of longPointer, false if not
+     */
+    static isSubPointer(shortPointer: any, longPointer: any, trueIfMatching?: boolean, errors?: boolean): boolean;
+    /**
+     * 'toIndexedPointer' function
+     *
+     * Merges an array of numeric indexes and a generic pointer to create an
+     * indexed pointer for a specific item.
+     *
+     * For example, merging the generic pointer '/foo/-/bar/-/baz' and
+     * the array [4, 2] would result in the indexed pointer '/foo/4/bar/2/baz'
+     *
+     *
+     * //  { Pointer } genericPointer - The generic pointer
+     * //  { number[] } indexArray - The array of numeric indexes
+     * //  { Map<string, number> } arrayMap - An optional array map
+     * // { string } - The merged pointer with indexes
+     */
+    static toIndexedPointer(genericPointer: any, indexArray: any, arrayMap?: Map<string, number>): any;
+    /**
+     * 'toGenericPointer' function
+     *
+     * Compares an indexed pointer to an array map and removes list array
+     * indexes (but leaves tuple arrray indexes and all object keys, including
+     * numeric keys) to create a generic pointer.
+     *
+     * For example, using the indexed pointer '/foo/1/bar/2/baz/3' and
+     * the arrayMap [['/foo', 0], ['/foo/-/bar', 3], ['/foo/-/bar/-/baz', 0]]
+     * would result in the generic pointer '/foo/-/bar/2/baz/-'
+     * Using the indexed pointer '/foo/1/bar/4/baz/3' and the same arrayMap
+     * would result in the generic pointer '/foo/-/bar/-/baz/-'
+     * (the bar array has 3 tuple items, so index 2 is retained, but 4 is removed)
+     *
+     * The structure of the arrayMap is: [['path to array', number of tuple items]...]
+     *
+     *
+     * //  { Pointer } indexedPointer - The indexed pointer (array or string)
+     * //  { Map<string, number> } arrayMap - The optional array map (for preserving tuple indexes)
+     * // { string } - The generic pointer with indexes removed
+     */
+    static toGenericPointer(indexedPointer: any, arrayMap?: Map<string, number>): any;
+    /**
+     * 'toControlPointer' function
+     *
+     * Accepts a JSON Pointer for a data object and returns a JSON Pointer for the
+     * matching control in an Angular FormGroup.
+     *
+     * //  { Pointer } dataPointer - JSON Pointer (string or array) to a data object
+     * //  { FormGroup } formGroup - Angular FormGroup to get value from
+     * //  { boolean = false } controlMustExist - Only return if control exists?
+     * // { Pointer } - JSON Pointer (string) to the formGroup object
+     */
+    static toControlPointer(dataPointer: any, formGroup: any, controlMustExist?: boolean): any;
+    /**
+     * 'toSchemaPointer' function
+     *
+     * Accepts a JSON Pointer to a value inside a data object and a JSON schema
+     * for that object.
+     *
+     * Returns a Pointer to the sub-schema for the value inside the object's schema.
+     *
+     * //  { Pointer } dataPointer - JSON Pointer (string or array) to an object
+     * //   schema - JSON schema for the object
+     * // { Pointer } - JSON Pointer (string) to the object's schema
+     */
+    static toSchemaPointer(dataPointer: any, schema: any): any;
+    /**
+     * 'toDataPointer' function
+     *
+     * Accepts a JSON Pointer to a sub-schema inside a JSON schema and the schema.
+     *
+     * If possible, returns a generic Pointer to the corresponding value inside
+     * the data object described by the JSON schema.
+     *
+     * Returns null if the sub-schema is in an ambiguous location (such as
+     * definitions or additionalProperties) where the corresponding value
+     * location cannot be determined.
+     *
+     * //  { Pointer } schemaPointer - JSON Pointer (string or array) to a JSON schema
+     * //   schema - the JSON schema
+     * //  { boolean = false } errors - Show errors?
+     * // { Pointer } - JSON Pointer (string) to the value in the data object
+     */
+    static toDataPointer(schemaPointer: any, schema: any, errors?: boolean): any;
+    /**
+     * 'parseObjectPath' function
+     *
+     * Parses a JavaScript object path into an array of keys, which
+     * can then be passed to compile() to convert into a string JSON Pointer.
+     *
+     * Based on mike-marcacci's excellent objectpath parse function:
+     * https://github.com/mike-marcacci/objectpath
+     *
+     * //  { Pointer } path - The object path to parse
+     * // { string[] } - The resulting array of keys
+     */
+    static parseObjectPath(path: any): any[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JsonPointer, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<JsonPointer>;
+}
+
+type JsonSchemaFormatNames = 'date' | 'time' | 'date-time' | 'email' | 'hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'uri-template' | 'url' | 'uuid' | 'color' | 'json-pointer' | 'relative-json-pointer' | 'duration' | 'regex';
+
+/**
+ * 'JsonValidators' class
+ *
+ * Provides an extended set of validators to be used by form controls,
+ * compatible with standard JSON Schema validation options.
+ * http://json-schema.org/latest/json-schema-validation.html
+ *
+ * Note: This library is designed as a drop-in replacement for the Angular
+ * Validators library, and except for one small breaking change to the 'pattern'
+ * validator (described below) it can even be imported as a substitute, like so:
+ *
+ *   import { JsonValidators as Validators } from 'json-validators';
+ *
+ * and it should work with existing code as a complete replacement.
+ *
+ * The one exception is the 'pattern' validator, which has been changed to
+ * matche partial values by default (the standard 'pattern' validator wrapped
+ * all patterns in '^' and '$', forcing them to always match an entire value).
+ * However, the old behavior can be restored by simply adding '^' and '$'
+ * around your patterns, or by passing an optional second parameter of TRUE.
+ * This change is to make the 'pattern' validator match the behavior of a
+ * JSON Schema pattern, which allows partial matches, rather than the behavior
+ * of an HTML input control pattern, which does not.
+ *
+ * This library replaces Angular's validators and combination functions
+ * with the following validators and transformation functions:
+ *
+ * Validators:
+ *   For all formControls:     required (*), type, enum, const
+ *   For text formControls:    minLength (*), maxLength (*), pattern (*), format
+ *   For numeric formControls: maximum, exclusiveMaximum,
+ *                             minimum, exclusiveMinimum, multipleOf
+ *   For formGroup objects:    minProperties, maxProperties, dependencies
+ *   For formArray arrays:     minItems, maxItems, uniqueItems, contains
+ *   Not used by JSON Schema:  min (*), max (*), requiredTrue (*), email (*)
+ * (Validators originally included with Angular are maked with (*).)
+ *
+ * NOTE / TODO: The dependencies validator is not complete.
+ * NOTE / TODO: The contains validator is not complete.
+ *
+ * Validators not used by JSON Schema (but included for compatibility)
+ * and their JSON Schema equivalents:
+ *
+ *   Angular validator | JSON Schema equivalent
+ *   ------------------|-----------------------
+ *     min(number)     |   minimum(number)
+ *     max(number)     |   maximum(number)
+ *     requiredTrue()  |   const(true)
+ *     email()         |   format('email')
+ *
+ * Validator transformation functions:
+ *   composeAnyOf, composeOneOf, composeAllOf, composeNot
+ * (Angular's original combination funciton, 'compose', is also included for
+ * backward compatibility, though it is functionally equivalent to composeAllOf,
+ * asside from its more generic error message.)
+ *
+ * All validators have also been extended to accept an optional second argument
+ * which, if passed a TRUE value, causes the validator to perform the opposite
+ * of its original finction. (This is used internally to enable 'not' and
+ * 'composeOneOf' to function and return useful error messages.)
+ *
+ * The 'required' validator has also been overloaded so that if called with
+ * a boolean parameter (or no parameters) it returns the original validator
+ * function (rather than executing it). However, if it is called with an
+ * AbstractControl parameter (as was previously required), it behaves
+ * exactly as before.
+ *
+ * This enables all validators (including 'required') to be constructed in
+ * exactly the same way, so they can be automatically applied using the
+ * equivalent key names and values taken directly from a JSON Schema.
+ *
+ * This source code is partially derived from Angular,
+ * which is Copyright (c) 2014-2017 Google, Inc.
+ * Use of this source code is therefore governed by the same MIT-style license
+ * that can be found in the LICENSE file at https://angular.io/license
+ *
+ * Original Angular Validators:
+ * https://github.com/angular/angular/blob/master/packages/forms/src/validators.ts
+ */
+declare class JsonValidators {
+    /**
+     * Validator functions:
+     *
+     * For all formControls:     required, type, enum, const
+     * For text formControls:    minLength, maxLength, pattern, format
+     * For numeric formControls: maximum, exclusiveMaximum,
+     *                           minimum, exclusiveMinimum, multipleOf
+     * For formGroup objects:    minProperties, maxProperties, dependencies
+     * For formArray arrays:     minItems, maxItems, uniqueItems, contains
+     *
+     * TODO: finish dependencies validator
+     */
+    /**
+     * 'required' validator
+     *
+     * This validator is overloaded, compared to the default required validator.
+     * If called with no parameters, or TRUE, this validator returns the
+     * 'required' validator function (rather than executing it). This matches
+     * the behavior of all other validators in this library.
+     *
+     * If this validator is called with an AbstractControl parameter
+     * (as was previously required) it behaves the same as Angular's default
+     * required validator, and returns an error if the control is empty.
+     *
+     * Old behavior: (if input type = AbstractControl)
+     * // {AbstractControl} control - required control
+     * // {{[key: string]: boolean}} - returns error message if no input
+     *
+     * New behavior: (if no input, or input type = boolean)
+     * // {boolean = true} required? - true to validate, false to disable
+     * // {IValidatorFn} - returns the 'required' validator function itself
+     */
+    static required(input: AbstractControl): ValidationErrors | null;
+    static required(input?: boolean): IValidatorFn;
+    /**
+     * 'type' validator
+     *
+     * Requires a control to only accept values of a specified type,
+     * or one of an array of types.
+     *
+     * Note: SchemaPrimitiveType = 'string'|'number'|'integer'|'boolean'|'null'
+     *
+     * // {SchemaPrimitiveType|SchemaPrimitiveType[]} type - type(s) to accept
+     * // {IValidatorFn}
+     */
+    static type(requiredType: SchemaPrimitiveType | SchemaPrimitiveType[]): IValidatorFn;
+    /**
+     * 'enum' validator
+     *
+     * Requires a control to have a value from an enumerated list of values.
+     *
+     * Converts types as needed to allow string inputs to still correctly
+     * match number, boolean, and null enum values.
+     *
+     * // {any[]} allowedValues - array of acceptable values
+     * // {IValidatorFn}
+     */
+    static enum(allowedValues: any[]): IValidatorFn;
+    /**
+     * 'const' validator
+     *
+     * Requires a control to have a specific value.
+     *
+     * Converts types as needed to allow string inputs to still correctly
+     * match number, boolean, and null values.
+     *
+     * TODO: modify to work with objects
+     *
+     * // {any[]} requiredValue - required value
+     * // {IValidatorFn}
+     */
+    static const(requiredValue: any): IValidatorFn;
+    /**
+     * 'minLength' validator
+     *
+     * Requires a control's text value to be greater than a specified length.
+     *
+     * // {number} minimumLength - minimum allowed string length
+     * // {boolean = false} invert - instead return error object only if valid
+     * // {IValidatorFn}
+     */
+    static minLength(minimumLength: number): IValidatorFn;
+    /**
+     * 'maxLength' validator
+     *
+     * Requires a control's text value to be less than a specified length.
+     *
+     * // {number} maximumLength - maximum allowed string length
+     * // {boolean = false} invert - instead return error object only if valid
+     * // {IValidatorFn}
+     */
+    static maxLength(maximumLength: number): IValidatorFn;
+    /**
+     * 'pattern' validator
+     *
+     * Note: NOT the same as Angular's default pattern validator.
+     *
+     * Requires a control's value to match a specified regular expression pattern.
+     *
+     * This validator changes the behavior of default pattern validator
+     * by replacing RegExp(`^${pattern}$`) with RegExp(`${pattern}`),
+     * which allows for partial matches.
+     *
+     * To return to the default funcitonality, and match the entire string,
+     * pass TRUE as the optional second parameter.
+     *
+     * // {string} pattern - regular expression pattern
+     * // {boolean = false} wholeString - match whole value string?
+     * // {IValidatorFn}
+     */
+    static pattern(pattern: string | RegExp, wholeString?: boolean): IValidatorFn;
+    /**
+     * 'format' validator
+     *
+     * Requires a control to have a value of a certain format.
+     *
+     * This validator currently checks the following formsts:
+     *   date, time, date-time, email, hostname, ipv4, ipv6,
+     *   uri, uri-reference, uri-template, url, uuid, color,
+     *   json-pointer, relative-json-pointer,duration, regex
+     *
+     * Fast format regular expressions copied from AJV:
+     * https://github.com/epoberezkin/ajv/blob/master/lib/compile/formats.js
+     *
+     * // {JsonSchemaFormatNames} requiredFormat - format to check
+     * // {IValidatorFn}
+     */
+    static format(requiredFormat: JsonSchemaFormatNames): IValidatorFn;
+    /**
+     * 'minimum' validator
+     *
+     * Requires a control's numeric value to be greater than or equal to
+     * a minimum amount.
+     *
+     * Any non-numeric value is also valid (according to the HTML forms spec,
+     * a non-numeric value doesn't have a minimum).
+     * https://www.w3.org/TR/html5/forms.html#attr-input-max
+     *
+     * // {number} minimum - minimum allowed value
+     * // {IValidatorFn}
+     */
+    static minimum(minimumValue: number): IValidatorFn;
+    /**
+     * 'exclusiveMinimum' validator
+     *
+     * Requires a control's numeric value to be less than a maximum amount.
+     *
+     * Any non-numeric value is also valid (according to the HTML forms spec,
+     * a non-numeric value doesn't have a maximum).
+     * https://www.w3.org/TR/html5/forms.html#attr-input-max
+     *
+     * // {number} exclusiveMinimumValue - maximum allowed value
+     * // {IValidatorFn}
+     */
+    static exclusiveMinimum(exclusiveMinimumValue: number): IValidatorFn;
+    /**
+     * 'maximum' validator
+     *
+     * Requires a control's numeric value to be less than or equal to
+     * a maximum amount.
+     *
+     * Any non-numeric value is also valid (according to the HTML forms spec,
+     * a non-numeric value doesn't have a maximum).
+     * https://www.w3.org/TR/html5/forms.html#attr-input-max
+     *
+     * // {number} maximumValue - maximum allowed value
+     * // {IValidatorFn}
+     */
+    static maximum(maximumValue: number): IValidatorFn;
+    /**
+     * 'exclusiveMaximum' validator
+     *
+     * Requires a control's numeric value to be less than a maximum amount.
+     *
+     * Any non-numeric value is also valid (according to the HTML forms spec,
+     * a non-numeric value doesn't have a maximum).
+     * https://www.w3.org/TR/html5/forms.html#attr-input-max
+     *
+     * // {number} exclusiveMaximumValue - maximum allowed value
+     * // {IValidatorFn}
+     */
+    static exclusiveMaximum(exclusiveMaximumValue: number): IValidatorFn;
+    /**
+     * 'multipleOf' validator
+     *
+     * Requires a control to have a numeric value that is a multiple
+     * of a specified number.
+     *
+     * // {number} multipleOfValue - number value must be a multiple of
+     * // {IValidatorFn}
+     */
+    static multipleOf(multipleOfValue: number): IValidatorFn;
+    /**
+     * 'minProperties' validator
+     *
+     * Requires a form group to have a minimum number of properties (i.e. have
+     * values entered in a minimum number of controls within the group).
+     *
+     * // {number} minimumProperties - minimum number of properties allowed
+     * // {IValidatorFn}
+     */
+    static minProperties(minimumProperties: number): IValidatorFn;
+    /**
+     * 'maxProperties' validator
+     *
+     * Requires a form group to have a maximum number of properties (i.e. have
+     * values entered in a maximum number of controls within the group).
+     *
+     * Note: Has no effect if the form group does not contain more than the
+     * maximum number of controls.
+     *
+     * // {number} maximumProperties - maximum number of properties allowed
+     * // {IValidatorFn}
+     */
+    static maxProperties(maximumProperties: number): IValidatorFn;
+    /**
+     * 'dependencies' validator
+     *
+     * Requires the controls in a form group to meet additional validation
+     * criteria, depending on the values of other controls in the group.
+     *
+     * Examples:
+     * https://spacetelescope.github.io/understanding-json-schema/reference/object.html#dependencies
+     *
+     * // {any} dependencies - required dependencies
+     * // {IValidatorFn}
+     */
+    static dependencies(dependencies: any): IValidatorFn;
+    /**
+     * 'minItems' validator
+     *
+     * Requires a form array to have a minimum number of values.
+     *
+     * // {number} minimumItems - minimum number of items allowed
+     * // {IValidatorFn}
+     */
+    static minItems(minimumItems: number): IValidatorFn;
+    /**
+     * 'maxItems' validator
+     *
+     * Requires a form array to have a maximum number of values.
+     *
+     * // {number} maximumItems - maximum number of items allowed
+     * // {IValidatorFn}
+     */
+    static maxItems(maximumItems: number): IValidatorFn;
+    /**
+     * 'uniqueItems' validator
+     *
+     * Requires values in a form array to be unique.
+     *
+     * // {boolean = true} unique? - true to validate, false to disable
+     * // {IValidatorFn}
+     */
+    static uniqueItems(unique?: boolean): IValidatorFn;
+    /**
+     * 'contains' validator
+     *
+     * TODO: Complete this validator
+     *
+     * Requires values in a form array to be unique.
+     *
+     * // {boolean = true} unique? - true to validate, false to disable
+     * // {IValidatorFn}
+     */
+    static contains(requiredItem?: boolean): IValidatorFn;
+    /**
+     * No-op validator. Included for backward compatibility.
+     */
+    static nullValidator(control: AbstractControl): ValidationErrors | null;
+    /**
+     * Validator transformation functions:
+     * composeAnyOf, composeOneOf, composeAllOf, composeNot,
+     * compose, composeAsync
+     *
+     * TODO: Add composeAnyOfAsync, composeOneOfAsync,
+     *           composeAllOfAsync, composeNotAsync
+     */
+    /**
+     * 'composeAnyOf' validator combination function
+     *
+     * Accepts an array of validators and returns a single validator that
+     * evaluates to valid if any one or more of the submitted validators are
+     * valid. If every validator is invalid, it returns combined errors from
+     * all validators.
+     *
+     * // {IValidatorFn[]} validators - array of validators to combine
+     * // {IValidatorFn} - single combined validator function
+     */
+    static composeAnyOf(validators: IValidatorFn[]): IValidatorFn;
+    /**
+     * 'composeOneOf' validator combination function
+     *
+     * Accepts an array of validators and returns a single validator that
+     * evaluates to valid only if exactly one of the submitted validators
+     * is valid. Otherwise returns combined information from all validators,
+     * both valid and invalid.
+     *
+     * // {IValidatorFn[]} validators - array of validators to combine
+     * // {IValidatorFn} - single combined validator function
+     */
+    static composeOneOf(validators: IValidatorFn[]): IValidatorFn;
+    /**
+     * 'composeAllOf' validator combination function
+     *
+     * Accepts an array of validators and returns a single validator that
+     * evaluates to valid only if all the submitted validators are individually
+     * valid. Otherwise it returns combined errors from all invalid validators.
+     *
+     * // {IValidatorFn[]} validators - array of validators to combine
+     * // {IValidatorFn} - single combined validator function
+     */
+    static composeAllOf(validators: IValidatorFn[]): IValidatorFn;
+    /**
+     * 'composeNot' validator inversion function
+     *
+     * Accepts a single validator function and inverts its result.
+     * Returns valid if the submitted validator is invalid, and
+     * returns invalid if the submitted validator is valid.
+     * (Note: this function can itself be inverted
+     *   - e.g. composeNot(composeNot(validator)) -
+     *   but this can be confusing and is therefore not recommended.)
+     *
+     * // {IValidatorFn[]} validators - validator(s) to invert
+     * // {IValidatorFn} - new validator function that returns opposite result
+     */
+    static composeNot(validator: IValidatorFn): IValidatorFn;
+    /**
+     * 'compose' validator combination function
+     *
+     * // {IValidatorFn[]} validators - array of validators to combine
+     * // {IValidatorFn} - single combined validator function
+     */
+    static compose(validators: IValidatorFn[]): IValidatorFn;
+    /**
+     * 'composeAsync' async validator combination function
+     *
+     * // {AsyncIValidatorFn[]} async validators - array of async validators
+     * // {AsyncIValidatorFn} - single combined async validator function
+     */
+    static composeAsync(validators: AsyncIValidatorFn[]): AsyncIValidatorFn;
+    /**
+     * Validator that requires controls to have a value greater than a number.
+     */
+    static min(min: number): ValidatorFn;
+    /**
+     * Validator that requires controls to have a value less than a number.
+     */
+    static max(max: number): ValidatorFn;
+    /**
+     * Validator that requires control value to be true.
+     */
+    static requiredTrue(control: AbstractControl): ValidationErrors | null;
+    /**
+     * Validator that performs email validation.
+     */
+    static email(control: AbstractControl): ValidationErrors | null;
+}
+
+/**
+ * JSON Schema function library:
+ *
+ * buildSchemaFromLayout:   TODO: Write this function
+ *
+ * buildSchemaFromData:
+ *
+ * getFromSchema:
+ *
+ * removeRecursiveReferences:
+ *
+ * getInputType:
+ *
+ * checkInlineType:
+ *
+ * isInputRequired:
+ *
+ * updateInputOptions:
+ *
+ * getTitleMapFromOneOf:
+ *
+ * getControlValidators:
+ *
+ * resolveSchemaReferences:
+ *
+ * getSubSchema:
+ *
+ * combineAllOf:
+ *
+ * fixRequiredArrayProperties:
+ */
+/**
+ * 'buildSchemaFromLayout' function
+ *
+ * TODO: Build a JSON Schema from a JSON Form layout
+ *
+ * //   layout - The JSON Form layout
+ * //  - The new JSON Schema
+ */
+declare function buildSchemaFromLayout(layout: any): void;
+/**
+ * 'buildSchemaFromData' function
+ *
+ * Build a JSON Schema from a data object
+ *
+ * //   data - The data object
+ * //  { boolean = false } requireAllFields - Require all fields?
+ * //  { boolean = true } isRoot - is root
+ * //  - The new JSON Schema
+ */
+declare function buildSchemaFromData(data: any, requireAllFields?: boolean, isRoot?: boolean): any;
+/**
+ * 'getFromSchema' function
+ *
+ * Uses a JSON Pointer for a value within a data object to retrieve
+ * the schema for that value within schema for the data object.
+ *
+ * The optional third parameter can also be set to return something else:
+ * 'schema' (default): the schema for the value indicated by the data pointer
+ * 'parentSchema': the schema for the value's parent object or array
+ * 'schemaPointer': a pointer to the value's schema within the object's schema
+ * 'parentSchemaPointer': a pointer to the schema for the value's parent object or array
+ *
+ * //   schema - The schema to get the sub-schema from
+ * //  { Pointer } dataPointer - JSON Pointer (string or array)
+ * //  { string = 'schema' } returnType - what to return?
+ * //  - The located sub-schema
+ */
+declare function getFromSchema(schema: any, dataPointer: any, returnType?: string): any;
+/**
+ * 'removeRecursiveReferences' function
+ *
+ * Checks a JSON Pointer against a map of recursive references and returns
+ * a JSON Pointer to the shallowest equivalent location in the same object.
+ *
+ * Using this functions enables an object to be constructed with unlimited
+ * recursion, while maintaing a fixed set of metadata, such as field data types.
+ * The object can grow as large as it wants, and deeply recursed nodes can
+ * just refer to the metadata for their shallow equivalents, instead of having
+ * to add additional redundant metadata for each recursively added node.
+ *
+ * Example:
+ *
+ * pointer:         '/stuff/and/more/and/more/and/more/and/more/stuff'
+ * recursiveRefMap: [['/stuff/and/more/and/more', '/stuff/and/more/']]
+ * returned:        '/stuff/and/more/stuff'
+ *
+ * //  { Pointer } pointer -
+ * //  { Map<string, string> } recursiveRefMap -
+ * //  { Map<string, number> = new Map() } arrayMap - optional
+ * // { string } -
+ */
+declare function removeRecursiveReferences(pointer: any, recursiveRefMap: any, arrayMap?: Map<any, any>): any;
+/**
+ * 'getInputType' function
+ *
+ * //   schema
+ * //  { any = null } layoutNode
+ * // { string }
+ */
+declare function getInputType(schema: any, layoutNode?: any): any;
+/**
+ * 'checkInlineType' function
+ *
+ * Checks layout and schema nodes for 'inline: true', and converts
+ * 'radios' or 'checkboxes' to 'radios-inline' or 'checkboxes-inline'
+ *
+ * //  { string } controlType -
+ * //   schema -
+ * //  { any = null } layoutNode -
+ * // { string }
+ */
+declare function checkInlineType(controlType: any, schema: any, layoutNode?: any): any;
+/**
+ * 'isInputRequired' function
+ *
+ * Checks a JSON Schema to see if an item is required
+ *
+ * //   schema - the schema to check
+ * //  { string } schemaPointer - the pointer to the item to check
+ * // { boolean } - true if the item is required, false if not
+ */
+declare function isInputRequired(schema: any, schemaPointer: any): any;
+/**
+ * 'updateInputOptions' function
+ *
+ * //   layoutNode
+ * //   schema
+ * //   jsf
+ * // { void }
+ */
+declare function updateInputOptions(layoutNode: any, schema: any, jsf: any): void;
+/**
+ * 'getTitleMapFromOneOf' function
+ *
+ * //  { schema } schema
+ * //  { boolean = null } flatList
+ * //  { boolean = false } validateOnly
+ * // { validators }
+ */
+declare function getTitleMapFromOneOf(schema?: any, flatList?: boolean, validateOnly?: boolean): any;
+/**
+ * 'getControlValidators' function
+ *
+ * //  schema
+ * // { validators }
+ */
+declare function getControlValidators(schema: any): any;
+/**
+ * 'resolveSchemaReferences' function
+ *
+ * Find all $ref links in schema and save links and referenced schemas in
+ * schemaRefLibrary, schemaRecursiveRefMap, and dataRecursiveRefMap
+ *
+ * //  schema
+ * //  schemaRefLibrary
+ * // { Map<string, string> } schemaRecursiveRefMap
+ * // { Map<string, string> } dataRecursiveRefMap
+ * // { Map<string, number> } arrayMap
+ * //
+ */
+declare function resolveSchemaReferences(schema: any, schemaRefLibrary: any, schemaRecursiveRefMap: any, dataRecursiveRefMap: any, arrayMap: any): any;
+/**
+ * 'getSubSchema' function
+ *
+ * //   schema
+ * //  { Pointer } pointer
+ * //  { object } schemaRefLibrary
+ * //  { Map<string, string> } schemaRecursiveRefMap
+ * //  { string[] = [] } usedPointers
+ * //
+ */
+declare function getSubSchema(schema: any, pointer: any, schemaRefLibrary?: any, schemaRecursiveRefMap?: Map<string, string>, usedPointers?: string[]): any;
+/**
+ * 'combineAllOf' function
+ *
+ * Attempt to convert an allOf schema object into
+ * a non-allOf schema object with equivalent rules.
+ *
+ * //   schema - allOf schema object
+ * //  - converted schema object
+ */
+declare function combineAllOf(schema: any): any;
+/**
+ * 'fixRequiredArrayProperties' function
+ *
+ * Fixes an incorrectly placed required list inside an array schema, by moving
+ * it into items.properties or additionalItems.properties, where it belongs.
+ *
+ * //   schema - allOf schema object
+ * //  - converted schema object
+ */
+declare function fixRequiredArrayProperties(schema: any): any;
+
+/**
+ * 'convertSchemaToDraft6' function
+ *
+ * Converts a JSON Schema from draft 1 through 4 format to draft 6 format
+ *
+ * Inspired by on geraintluff's JSON Schema 3 to 4 compatibility function:
+ *   https://github.com/geraintluff/json-schema-compatibility
+ * Also uses suggestions from AJV's JSON Schema 4 to 6 migration guide:
+ *   https://github.com/epoberezkin/ajv/releases/tag/5.0.0
+ * And additional details from the official JSON Schema documentation:
+ *   http://json-schema.org
+ *
+ * //  { object } originalSchema - JSON schema (draft 1, 2, 3, 4, or 6)
+ * //  { OptionObject = {} } options - options: parent schema changed?, schema draft number?
+ * // { object } - JSON schema (draft 6)
+ */
+interface OptionObject {
+    changed?: boolean;
+    draft?: number;
+}
+declare function convertSchemaToDraft6(schema: any, options?: OptionObject): any;
+
+/**
+ * 'mergeSchemas' function
+ *
+ * Merges multiple JSON schemas into a single schema with combined rules.
+ *
+ * If able to logically merge properties from all schemas,
+ * returns a single schema object containing all merged properties.
+ *
+ * Example: ({ a: b, max: 1 }, { c: d, max: 2 }) => { a: b, c: d, max: 1 }
+ *
+ * If unable to logically merge, returns an allOf schema object containing
+ * an array of the original schemas;
+ *
+ * Example: ({ a: b }, { a: d }) => { allOf: [ { a: b }, { a: d } ] }
+ *
+ * //   schemas - one or more input schemas
+ * //  - merged schema
+ */
+declare function mergeSchemas(...schemas: any[]): any;
+
+/**
+ * path2ControlKey takes a datapointer path like /some/pointer/path
+ * and returns something like $some$pointer$path
+ * used mainly to convert paths so it can be used as keys in FormGroups
+ * fot ITE scenarios
+ * @param path
+ * @returns string
+ */
+declare function path2ControlKey(path: string): string;
+/**
+ * FormGroup function library:
+ *
+ * buildFormGroupTemplate:  Builds a FormGroupTemplate from schema
+ *
+ * buildFormGroup:          Builds an Angular FormGroup from a FormGroupTemplate
+ *
+ * mergeValues:
+ *
+ * setRequiredFields:
+ *
+ * formatFormData:
+ *
+ * getControl:
+ *
+ * ---- TODO: ----
+ * TODO: add buildFormGroupTemplateFromLayout function
+ * buildFormGroupTemplateFromLayout: Builds a FormGroupTemplate from a form layout
+ */
+/**
+ * 'buildFormGroupTemplate' function
+ *
+ * Builds a template for an Angular FormGroup from a JSON Schema.
+ *
+ * TODO: add support for pattern properties
+ * https://spacetelescope.github.io/understanding-json-schema/reference/object.html
+ *
+ * //  {any} jsf -
+ * //  {any = null} nodeValue -
+ * //  {boolean = true} mapArrays -
+ * //  {string = ''} schemaPointer -
+ * //  {string = ''} dataPointer -
+ * //  {any = ''} templatePointer -
+ * // {any} -
+ */
+declare function buildFormGroupTemplate(jsf: any, nodeValue?: any, setValues?: boolean, schemaPointer?: string, dataPointer?: string, templatePointer?: string): {
+    controlType: string;
+    controls: any;
+    validators: any;
+    schemaPointer: string;
+    value?: undefined;
+} | {
+    controlType: string;
+    value: {
+        value: any;
+        disabled: any;
+    };
+    validators: any;
+    schemaPointer: string;
+    controls?: undefined;
+};
+/**
+ * 'buildFormGroup' function
+ *
+ * // {any} template -
+ * // {AbstractControl}
+*/
+declare function buildFormGroup(template: any): AbstractControl;
+/**
+ * 'setRequiredFields' function
+ *
+ * // {schema} schema - JSON Schema
+ * // {object} formControlTemplate - Form Control Template object
+ * // {boolean} - true if any fields have been set to required, false if not
+ */
+declare function setRequiredFields(schema: any, formControlTemplate: any): boolean;
+/**
+ * 'formatFormData' function
+ *
+ * // {any} formData - Angular FormGroup data object
+ * // {Map<string, any>} dataMap -
+ * // {Map<string, string>} recursiveRefMap -
+ * // {Map<string, number>} arrayMap -
+ * // {boolean = false} fixErrors - if TRUE, tries to fix data
+ * // {any} - formatted data object
+ */
+declare function formatFormData(formData: any, dataMap: Map<string, any>, recursiveRefMap: Map<string, string>, arrayMap: Map<string, number>, returnEmptyFields?: boolean, fixErrors?: boolean): any;
+/**
+ * 'getControl' function
+ *
+ * Uses a JSON Pointer for a data object to retrieve a control from
+ * an Angular formGroup or formGroup template. (Note: though a formGroup
+ * template is much simpler, its basic structure is idential to a formGroup).
+ *
+ * If the optional third parameter 'returnGroup' is set to TRUE, the group
+ * containing the control is returned, rather than the control itself.
+ *
+ * // {FormGroup} formGroup - Angular FormGroup to get value from
+ * // {Pointer} dataPointer - JSON Pointer (string or array)
+ * // {boolean = false} returnGroup - If true, return group containing control
+ * // {group} - Located value (or null, if no control found)
+ * // {string} schemaPointer - string used for conditional controls coming from schema if/then/else
+ */
+declare function getControl(formGroup: any, dataPointer: Pointer, returnGroup?: boolean, schemaPointer?: string): any;
+/**
+ * 'setControl' function
+ *
+ * Uses a JSON Pointer for a data object to retrieve a control from
+ * an Angular formGroup or formGroup template. (Note: though a formGroup
+ * template is much simpler, its basic structure is idential to a formGroup).
+ *
+ * If the optional third parameter 'returnGroup' is set to TRUE, the group
+ * containing the control is returned, rather than the control itself.
+ *
+ * // {FormGroup} formGroup - Angular FormGroup to get value from
+ * // {Pointer} dataPointer - JSON Pointer (string or array)
+ * // {AbstractControl} control - control used to replace existing or add
+ * // {targetKey} - optional string used as the new key-not implemented as yet
+ */
+declare function setControl(formGroup: any, dataPointer: Pointer, control: AbstractControl, targetKey?: string): any;
+
+declare function buildLayout(jsf: any, widgetLibrary: any): any[];
+/**
+ * 'buildLayoutFromSchema' function
+ *
+ * //   jsf -
+ * //   widgetLibrary -
+ * //   nodeValue -
+ * //  { string = '' } schemaPointer -
+ * //  { string = '' } dataPointer -
+ * //  { boolean = false } arrayItem -
+ * //  { string = null } arrayItemType -
+ * //  { boolean = null } removable -
+ * //  { boolean = false } forRefLibrary -
+ * //  { string = '' } dataPointerPrefix -
+ * //
+ */
+declare function buildLayoutFromSchema(jsf: any, widgetLibrary: any, nodeValue?: any, schemaPointer?: string, dataPointer?: string, arrayItem?: boolean, arrayItemType?: string, removable?: boolean, forRefLibrary?: boolean, dataPointerPrefix?: string, jsonSchema?: any): any;
+/**
+ * 'mapLayout' function
+ *
+ * Creates a new layout by running each element in an existing layout through
+ * an iteratee. Recursively maps within array elements 'items' and 'tabs'.
+ * The iteratee is invoked with four arguments: (value, index, layout, path)
+ *
+ * The returned layout may be longer (or shorter) then the source layout.
+ *
+ * If an item from the source layout returns multiple items (as '*' usually will),
+ * this function will keep all returned items in-line with the surrounding items.
+ *
+ * If an item from the source layout causes an error and returns null, it is
+ * skipped without error, and the function will still return all non-null items.
+ *
+ * //   layout - the layout to map
+ * //  { (v: any, i?: number, l?: any, p?: string) => any }
+ *   function - the funciton to invoke on each element
+ * //  { string|string[] = '' } layoutPointer - the layoutPointer to layout, inside rootLayout
+ * //  { any[] = layout } rootLayout - the root layout, which conatins layout
+ * //
+ */
+declare function mapLayout(layout: any, fn: any, layoutPointer?: string, rootLayout?: any): any[];
+/**
+ * 'getLayoutNode' function
+ * Copy a new layoutNode from layoutRefLibrary
+ *
+ * //   refNode -
+ * //   layoutRefLibrary -
+ * //  { any = null } widgetLibrary -
+ * //  { any = null } nodeValue -
+ * //  copied layoutNode
+ */
+declare function getLayoutNode(refNode: any, jsf: any, widgetLibrary?: any, nodeValue?: any): any;
+/**
+ * 'buildTitleMap' function
+ *
+ * //   titleMap -
+ * //   enumList -
+ * //  { boolean = true } fieldRequired -
+ * //  { boolean = true } flatList -
+ * // { TitleMapItem[] }
+ */
+declare function buildTitleMap(titleMap: any, enumList: any, fieldRequired?: boolean, flatList?: boolean): TitleMapItem[];
+
+declare class SelectComponent implements OnInit, OnDestroy {
+    private jsf;
+    formControl: AbstractControl;
+    controlName: string;
+    controlValue: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options: any;
+    selectList: any[];
+    selectListFlatGroup: any[];
+    isArray: typeof isArray;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    ngOnInit(): void;
+    deselectAll(): void;
+    updateValue(event: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectComponent, "select-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class SelectFrameworkComponent implements OnChanges, OnInit {
+    private jsf;
+    newComponent: ComponentRef<any>;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    readonly widgetContainer: _angular_core.Signal<ViewContainerRef>;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    updateComponent(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectFrameworkComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectFrameworkComponent, "select-framework-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class SelectWidgetComponent implements OnChanges, OnInit {
+    private jsf;
+    newComponent: ComponentRef<any>;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    readonly widgetContainer: _angular_core.Signal<ViewContainerRef>;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    updateComponent(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectWidgetComponent, "select-widget-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class SubmitComponent implements OnInit, OnDestroy {
+    private jsf;
+    formControl: AbstractControl;
+    controlName: string;
+    controlValue: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options: any;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    isValidChangesSubs: Subscription;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SubmitComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SubmitComponent, "submit-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class TabComponent implements OnInit {
+    private jsf;
+    options: any;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabComponent, "tab-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class TabsComponent implements OnInit {
+    private jsf;
+    options: any;
+    itemCount: number;
+    selectedItem: number;
+    showAddTab: boolean;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    ngOnInit(): void;
+    select(index: any): void;
+    updateControl(): void;
+    setTabTitle(item: any, index: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsComponent, "tabs-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class TemplateComponent implements OnInit, OnChanges {
+    private jsf;
+    newComponent: ComponentRef<any>;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    readonly widgetContainer: _angular_core.Signal<ViewContainerRef>;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    updateComponent(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TemplateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TemplateComponent, "template-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class TextareaComponent implements OnInit, OnDestroy {
+    private jsf;
+    formControl: AbstractControl;
+    controlName: string;
+    controlValue: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options: any;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextareaComponent, "textarea-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class SelectCheckboxComponent implements OnInit, OnDestroy {
+    private jsf;
+    private jsfFLService;
+    formControl: AbstractControl;
+    controlName: string;
+    controlValue: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options: any;
+    selectList: any[];
+    selectListFlatGroup: any[];
+    selectValue: any;
+    isArray: typeof isArray;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    frameworkStyles: {
+        daisyui: {
+            selectClass: string;
+            optionClass: string;
+            optionChecked: string;
+            optionUnchecked: string;
+        };
+        "bootstrap-3": {
+            selectClass: string;
+            optionClass: string;
+            optionChecked: string;
+            optionUnchecked: string;
+        };
+        "bootstrap-4": {
+            selectClass: string;
+            optionClass: string;
+            optionChecked: string;
+            optionUnchecked: string;
+        };
+        "bootstrap-5": {
+            selectClass: string;
+            optionClass: string;
+            optionChecked: string;
+            optionUnchecked: string;
+        };
+    };
+    activeFramework: string;
+    ngOnInit(): void;
+    deselectAll(): void;
+    updateValue(event: any): void;
+    onSelectClicked($event: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectCheckboxComponent, "selectcheckbox-widget", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * OrderableDirective
+ *
+ * Enables array elements to be reordered by dragging and dropping.
+ *
+ * Only works for arrays that have at least two elements.
+ *
+ * Also detects arrays-within-arrays, and correctly moves either
+ * the child array element or the parent array element,
+ * depending on the drop targert.
+ *
+ * Listeners for movable element being dragged:
+ * - dragstart: add 'dragging' class to element, set effectAllowed = 'move'
+ * - dragover: set dropEffect = 'move'
+ * - dragend: remove 'dragging' class from element
+ *
+ * Listeners for stationary items being dragged over:
+ * - dragenter: add 'drag-target-...' classes to element
+ * - dragleave: remove 'drag-target-...' classes from element
+ * - drop: remove 'drag-target-...' classes from element, move dropped array item
+ */
+declare class OrderableDirective implements OnInit, OnDestroy {
+    private elementRef;
+    private jsf;
+    private ngZone;
+    arrayLayoutIndex: string;
+    element: any;
+    overParentElement: boolean;
+    overChildElement: boolean;
+    readonly orderable: _angular_core.InputSignal<boolean>;
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    private draggableStateSubscription;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OrderableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OrderableDirective, "[orderable]", never, { "orderable": { "alias": "orderable"; "required": false; "isSignal": true; }; "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class ElementAttributeDirective {
+    private renderer;
+    private elementRef;
+    attributes: {
+        [key: string]: any;
+    };
+    constructor(renderer: Renderer2, elementRef: ElementRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ElementAttributeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ElementAttributeDirective, "[attributes]", never, { "attributes": { "alias": "attributes"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class WidgetLibraryModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WidgetLibraryModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<WidgetLibraryModule, [typeof AddReferenceComponent, typeof OneOfComponent, typeof ButtonComponent, typeof CheckboxComponent, typeof CheckboxesComponent, typeof FileComponent, typeof HiddenComponent, typeof InputComponent, typeof MessageComponent, typeof NoneComponent, typeof NumberComponent, typeof RadiosComponent, typeof RootComponent, typeof SectionComponent, typeof SelectComponent, typeof SelectFrameworkComponent, typeof SelectWidgetComponent, typeof SubmitComponent, typeof TabComponent, typeof TabsComponent, typeof TemplateComponent, typeof TextareaComponent, typeof SelectCheckboxComponent, typeof OrderableDirective, typeof ElementAttributeDirective], [typeof i2.CommonModule, typeof i27.FormsModule, typeof i27.ReactiveFormsModule, typeof i28.SortablejsModule], [typeof AddReferenceComponent, typeof OneOfComponent, typeof ButtonComponent, typeof CheckboxComponent, typeof CheckboxesComponent, typeof FileComponent, typeof HiddenComponent, typeof InputComponent, typeof MessageComponent, typeof NoneComponent, typeof NumberComponent, typeof RadiosComponent, typeof RootComponent, typeof SectionComponent, typeof SelectComponent, typeof SelectFrameworkComponent, typeof SelectWidgetComponent, typeof SubmitComponent, typeof TabComponent, typeof TabsComponent, typeof TemplateComponent, typeof TextareaComponent, typeof SelectCheckboxComponent, typeof OrderableDirective, typeof ElementAttributeDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<WidgetLibraryModule>;
+}
+
+declare class NoFrameworkComponent {
+    readonly layoutNode: _angular_core.InputSignal<any>;
+    readonly layoutIndex: _angular_core.InputSignal<number[]>;
+    readonly dataIndex: _angular_core.InputSignal<number[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NoFrameworkComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NoFrameworkComponent, "no-framework", never, { "layoutNode": { "alias": "layoutNode"; "required": false; "isSignal": true; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; "isSignal": true; }; "dataIndex": { "alias": "dataIndex"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class NoFrameworkModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NoFrameworkModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<NoFrameworkModule, [typeof NoFrameworkComponent], [typeof i2.CommonModule, typeof WidgetLibraryModule], [typeof NoFrameworkComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<NoFrameworkModule>;
+}
+
+declare class JsonSchemaFormModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JsonSchemaFormModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<JsonSchemaFormModule, [typeof JsonSchemaFormComponent], [typeof i2.CommonModule, typeof i27.FormsModule, typeof i27.ReactiveFormsModule, typeof WidgetLibraryModule, typeof NoFrameworkModule], [typeof JsonSchemaFormComponent, typeof WidgetLibraryModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<JsonSchemaFormModule>;
+}
+
+declare class Framework {
+    name: string;
+    text: string;
+    framework: any;
+    widgets?: {
+        [key: string]: any;
+    };
+    stylesheets?: string[];
+    scripts?: string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Framework, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<Framework>;
+}
+
+declare class FrameworkLibraryService {
+    private frameworks;
+    private widgetLibrary;
+    private http;
+    activeFramework: Framework;
+    stylesheets: (HTMLStyleElement | HTMLLinkElement)[];
+    scripts: HTMLScriptElement[];
+    loadExternalAssets: boolean;
+    defaultFramework: string;
+    frameworkLibrary: {
+        [name: string]: Framework;
+    };
+    activeFrameworkName$: Observable<string>;
+    private activeFrameworkNameSubject;
+    private activeFrameworkName;
+    constructor(frameworks: any[]);
+    setLoadExternalAssets(loadExternalAssets?: boolean): void;
+    setFramework(framework?: string | Framework, loadExternalAssets?: boolean): boolean;
+    registerFrameworkWidgets(framework: Framework): boolean;
+    hasFramework(type: string): boolean;
+    getFramework(): any;
+    getFrameworkList(): {
+        name: string;
+        text: string;
+    }[];
+    getFrameworkWidgets(): any;
+    getFrameworkStylesheets(load?: boolean): string[];
+    getFrameworkScripts(load?: boolean): string[];
+    getFrameworkConfig(existingFramework?: any): any;
+    getFrameworkAssetConfig(existingFramework?: any, useAssetRelPath?: boolean): Promise<{
+        stylesheets: string[];
+        scripts: string[];
+    }>;
+    getFrameworkThemes(): {
+        name: string;
+        text: string;
+    }[];
+    requestThemeChange(name: string, validateThemeExists?: boolean, existingFramework?: any): boolean;
+    getActiveTheme(existingFramework?: any): {
+        name: string;
+        text: string;
+    };
+    registerTheme(newTheme: {
+        name: string;
+        text: string;
+    }, existingFramework?: any): boolean;
+    unregisterTheme(name: string, existingFramework?: any): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FrameworkLibraryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FrameworkLibraryService>;
+}
+
+declare const deValidationMessages: any;
+
+declare const enValidationMessages: any;
+
+declare const esValidationMessages: any;
+
+declare const frValidationMessages: any;
+
+declare const itValidationMessages: any;
+
+declare const ptValidationMessages: any;
+
+declare const zhValidationMessages: any;
+
+declare class WidgetLibraryService {
+    defaultWidget: string;
+    widgetLibrary: any;
+    registeredWidgets: any;
+    frameworkWidgets: any;
+    activeWidgets: any;
+    constructor();
+    setActiveWidgets(): boolean;
+    setDefaultWidget(type: string): boolean;
+    hasWidget(type: string, widgetSet?: string): boolean;
+    hasDefaultWidget(type: string): boolean;
+    registerWidget(type: string, widget: any): boolean;
+    unRegisterWidget(type: string): boolean;
+    unRegisterAllWidgets(unRegisterFrameworkWidgets?: boolean): boolean;
+    registerFrameworkWidgets(widgets: any): boolean;
+    unRegisterFrameworkWidgets(): boolean;
+    getWidget(type?: string, widgetSet?: string): any;
+    getAllWidgets(): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WidgetLibraryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WidgetLibraryService>;
+}
+
+declare const BASIC_WIDGETS: (typeof NoneComponent | typeof RootComponent)[];
+
+export { AddReferenceComponent, BASIC_WIDGETS, ButtonComponent, CheckboxComponent, CheckboxesComponent, ElementAttributeDirective, FileComponent, Framework, FrameworkLibraryService, HiddenComponent, InputComponent, JsonPointer, JsonSchemaFormComponent, JsonSchemaFormModule, JsonSchemaFormService, JsonValidators, MessageComponent, NoneComponent, NumberComponent, OneOfComponent, OrderableDirective, RadiosComponent, RootComponent, SectionComponent, SelectCheckboxComponent, SelectComponent, SelectFrameworkComponent, SelectWidgetComponent, SubmitComponent, TabComponent, TabsComponent, TemplateComponent, TextareaComponent, WidgetLibraryModule, WidgetLibraryService, _executeAsyncValidators, _executeValidators, _mergeErrors, _mergeObjects, _toPromise, addClasses, buildFormGroup, buildFormGroupTemplate, buildLayout, buildLayoutFromSchema, buildSchemaFromData, buildSchemaFromLayout, buildTitleMap, checkInlineType, combineAllOf, commonItems, convertSchemaToDraft6, copy, deValidationMessages, enValidationMessages, esValidationMessages, fixRequiredArrayProperties, fixTitle, forEach, forEachCopy, formatFormData, frValidationMessages, getControl, getControlValidators, getFromSchema, getInputType, getLayoutNode, getSubSchema, getTitleMapFromOneOf, getType, hasNonNullValue, hasOwn, hasValue, inArray, isArray, isBoolean, isDate, isDefined, isEmpty, isFunction, isInputRequired, isInteger, isMap, isNumber, isObject, isObservable, isPrimitive, isPromise, isSet, isString, isType, itValidationMessages, mapLayout, mergeFilteredObject, mergeSchemas, path2ControlKey, ptValidationMessages, removeRecursiveReferences, resolveSchemaReferences, setControl, setRequiredFields, toJavaScriptType, toObservable, toSchemaType, toTitleCase, uniqueItems, updateInputOptions, xor, zhValidationMessages };
+export type { AsyncIValidatorFn, ErrorMessages, IValidatorFn, JavaScriptPrimitiveType, JavaScriptType, PlainObject, Pointer, PrimitiveValue, SchemaPrimitiveType, SchemaType, TitleMapItem };