import { BehaviorSubject, Subject } from 'rxjs';
import * as i0 from '@angular/core';
import { InjectionToken, AfterViewInit, ElementRef, AfterContentInit, EventEmitter, OnInit, QueryList, OnChanges, SimpleChanges, ChangeDetectorRef, ComponentFactoryResolver, ViewContainerRef, ComponentRef, OnDestroy, Renderer2, ModuleWithProviders } from '@angular/core';
import * as i19 from '@angular/forms';
import { UntypedFormControl, NgControl, ControlValueAccessor } from '@angular/forms';
import * as i5 from '@angular/common';

interface Validator {
    (value: any, formProperty: FormProperty, form: PropertyGroup): [{
        [key: string]: any;
    }];
}

type TUnorderedPair<TFirst, TSecond> = [TFirst, TSecond] | [TSecond, TFirst];

declare enum FieldType {
    String = "string",
    Object = "object",
    Array = "array",
    Boolean = "boolean",
    Integer = "integer",
    Number = "number",
    Null = "null"
}
type TNullableFieldType = TUnorderedPair<FieldType.Null, FieldType.String | FieldType.Number | FieldType.Boolean | FieldType.Integer>;
interface Field {
    name: string;
    required: boolean;
    getSchema(): ISchema;
    getButtons(): any;
    getValidators(): {
        path: string;
        validator: Validator;
    }[];
}

interface IOneOf {
    enum?: any[];
    description?: string;
    /** allow additional properties */
    [prop: string]: any;
}
interface IWidget {
    id?: string;
    plugins?: string;
    toolbar?: string;
    /** allow additional properties */
    [prop: string]: any;
}
interface IFieldSet {
    id: string;
    title: string;
    name: string;
    description: string;
    fields: string[];
    /** allow additional properties */
    [prop: string]: any;
}
interface IButton {
    id: string;
    label: string;
    widget?: string | object;
    /** allow additional properties */
    [prop: string]: any;
}
interface IProperties {
    [prop: string]: ISchema;
}
type TSchemaScalarPrimitiveType = 'string' | 'boolean' | 'integer' | 'number';
type TSchemaComplexPrimitiveType = 'object' | 'array';
type TSchemaNullPrimitiveType = 'null';
type TSchemaPrimitiveType = TSchemaComplexPrimitiveType | TSchemaScalarPrimitiveType | TSchemaNullPrimitiveType;
type TSchemaNullableScalarPrimitiveType = TUnorderedPair<TSchemaNullPrimitiveType, TSchemaScalarPrimitiveType>;
type TSchemaPropertyType = FieldType | TNullableFieldType | TSchemaPrimitiveType | TSchemaNullableScalarPrimitiveType;
interface ISchema {
    $schema?: string;
    type?: TSchemaPropertyType;
    title?: string;
    name?: string;
    description?: string;
    placeholder?: string;
    minLength?: number;
    maxLength?: number;
    visibleIf?: any;
    enum?: any[];
    oneOf?: IOneOf[];
    properties?: IProperties;
    order?: string[];
    items?: ISchema;
    buttons?: IButton[];
    required?: string[];
    readOnly?: boolean;
    format?: string;
    widget?: IWidget | any;
    fieldsets?: IFieldSet[];
    /** allow additional properties */
    [prop: string]: any;
}

declare abstract class SchemaValidatorFactory {
    abstract createValidatorFn(schema: any): (value: any) => any;
    abstract getSchema(schema: any, ref: any): any;
    /**
     * Override this method to reset the schema validator instance.<br/>
     * This may be required since some schema validators keep a deep copy<br/>
     * of your schemas and changes at runtime are not recognized by the schema validator.<br/>
     * In this method you should either re-instantiate the schema validator or
     * clear its cache.<br/>
     * Example of re-instantiating schema validator
     * <code>
     *     reset(){
     *         this.zschema = new ZSchema({})
     *     }
     * </code>
     * <br/>
     * Since this method it self does nothing there is <br/>
     * no need to call the <code>super.reset()</code>
     */
    reset(): void;
    /**
     * Override this method if the validator instance supports compiling a schema an resolve all refs and defs.
     * @param schema The schema to be compiled and get its refs, deps, etc. resolved
     * @returns The compiled schema. Per default it does simply return the give schema.
     */
    compile(schema: any): any;
}
declare class ZSchemaValidatorFactory extends SchemaValidatorFactory {
    protected zschema: any;
    constructor();
    private createSchemaValidator;
    reset(): void;
    compile(schema: any): any;
    createValidatorFn(schema: ISchema): (value: any) => {
        [key: string]: boolean;
    };
    getSchema(schema: any, ref: string): any;
    private denormalizeRequiredPropertyPaths;
    private getDefinition;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZSchemaValidatorFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ZSchemaValidatorFactory>;
}

declare class ValidatorRegistry {
    private validators;
    register(path: string, validator: Validator): void;
    get(path: string): Validator;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ValidatorRegistry, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ValidatorRegistry>;
}

/**
 * General purpose propery binding registry
 */
declare class PropertyBindingRegistry {
    private bindings;
    getPropertyBindings(type: PropertyBindingTypes): PropertyBindings;
    getPropertyBindingsVisibility(): PropertyBindings;
    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyBindingRegistry, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyBindingRegistry>;
}
/**
 * Defines the types of supported property bindings.<br/>
 * For now only <code>visibility</code> is supported.<br/>
 */
declare enum PropertyBindingTypes {
    visibility = 0
}
/**
 * Storage that holds all bindings that are property paths related.<br/>
 */
declare class PropertyBindings {
    sourcesIndex: SimplePropertyIndexer;
    dependenciesIndex: SimplePropertyIndexer;
    add(dependencyPath: string, sourcePropertyPath: string): void;
    findByDependencyPath(dependencyPath: string): string[];
    getBySourcePropertyPath(sourcePropertyPath: string): string[];
    createPathIndex(path: string): string[];
}
/**
 * Simple indexer to store property paths
 */
declare class SimplePropertyIndexer {
    static MARKER: string;
    index: object;
    findOnlyWithValue: boolean;
    private _createPathIndex;
    store(propertyPath: string, value?: any): void;
    private _storeIndex;
    /**
     * Find path in index.<br/>
     * Will find path like:<br/>
     * <ul>
     *     <li>/property/0/prop</li>
     *     <li>/property/0/prop/2/test</li>
     *     <li>/property/0/prop/&#42;/test</li>
     *     <li>/property/&#42;/prop/1/test</li>
     *     <li>/property/&#42;/prop/&#42;/test</li>
     *     <li>/property/1/prop/&#42;/test</li>
     *  </ul>
     * @param path
     */
    find(path: string): IndexerResult;
    _findInIndex(path: string[]): IndexerResult;
    __findIndex(indexerResults: IndexerResult, path: string[], index: object, parent?: string[]): any[];
}
interface IndexerResult {
    /**
     * The path originally searched for
     */
    target: string[];
    /**
     * Flag for the status of found or not found.<br/>
     * Usually <code>results</code> will be empty if no matches found.
     */
    found: boolean;
    /**
     * The result path and values from the index search.<br/>
     * Usually <code>results</code> will be empty if no matches found.
     */
    results: {
        /**
         * The path that matched the <code>target</code>
         * separated in segments
         */
        path: string[];
        /**
         * The value stored at the <code>path</code>
         */
        value: any;
    }[];
}

declare abstract class ExpressionCompilerFactory {
    abstract createExpressionCompiler(): ExpressionCompiler;
    abstract createExpressionCompilerVisibilityIf(): ExpressionCompilerVisibilityIf;
}
interface ExpressionCompiler {
    evaluate(expression: string, context: object): any;
}
interface ExpressionCompilerVisibilityIf {
    evaluate(expression: string, context: ExpressionContextVisibilitIf): any;
}
/**
 * UseCase:<br/>
 * When evaluating the expression of a <code>visibilityIf</code> condition
 * an instance of this definition will be passed as context.<br/>
 * This will give access to the source and target <code>FormProperty</code>.
 */
interface ExpressionContextVisibilitIf {
    /**
     * The source property which has the <code>visibilityIf</code> defined
     */
    source: FormProperty;
    /**
     * The target property given with the <code>visibilityIf</code>
     * <em>path</em> property
     */
    target: FormProperty;
}

declare class JEXLExpressionCompilerFactory extends ExpressionCompilerFactory {
    createExpressionCompiler(): ExpressionCompiler;
    createExpressionCompilerVisibilityIf(): ExpressionCompilerVisibilityIf;
}
declare class JEXLExpressionCompiler implements ExpressionCompiler {
    evaluate(expression: string, context?: object): any;
}
declare class JEXLExpressionCompilerVisibiltyIf implements ExpressionCompilerVisibilityIf {
    evaluate(expression: string, context?: ExpressionContextVisibilitIf): any;
}

declare const LOG_LEVEL: InjectionToken<LogLevel>;
/**
 * Represents the different logging levels of the `console` output.
 */
declare const enum LogLevel {
    log = 0,
    warn = 1,
    error = 2,
    off = 3,
    all = 4
}
declare abstract class LogService {
    level: any;
    logLevel: LogLevel;
    constructor(level: any);
    /**
     * Equals `console.warn`
     * @param message
     * @param optionalParams
     */
    abstract warn(message?: any, ...optionalParams: any[]): void;
    /**
     * Equals `console.error`
     * @param message
     * @param optionalParams
     */
    abstract error(message?: any, ...optionalParams: any[]): void;
    /**
     * Equals `console.log`
     * @param message
     * @param optionalParams
     */
    abstract log(message?: any, ...optionalParams: any[]): void;
    isWarnEnabled(): boolean;
    isErrorEnabled(): boolean;
    isLogEnabled(): boolean;
}
/**
 * Very simple abstraction of logging
 */
declare class DefaultLogService extends LogService {
    logLevel: any;
    constructor(logLevel: any);
    warn: {
        (...data: any[]): void;
        (message?: any, ...optionalParams: any[]): void;
    };
    error: {
        (...data: any[]): void;
        (message?: any, ...optionalParams: any[]): void;
    };
    log: {
        (...data: any[]): void;
        (message?: any, ...optionalParams: any[]): void;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultLogService, [{ optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultLogService>;
}

declare abstract class FormProperty {
    private validatorRegistry;
    schema: ISchema;
    protected logger: LogService;
    schemaValidator: Function;
    expressionCompilerVisibiltyIf: ExpressionCompilerVisibilityIf;
    _value: any;
    _errors: any;
    private _valueChanges;
    private _errorsChanges;
    private _visible;
    private _visibilityChanges;
    private _root;
    private _parent;
    private _path;
    _propertyBindingRegistry: PropertyBindingRegistry;
    __canonicalPath: string;
    __canonicalPathNotation: string;
    /**
     * Provides the unique path of this form element.<br/>
     * E.g.:
     * <code>/garage/cars</code>,<br/>
     * <code>/shop/book/0/page/1/</code>
     */
    get _canonicalPath(): string;
    set _canonicalPath(canonicalPath: string);
    /**
     * Uses the unique path provided by the property <code>_canonicalPath</code><br/>
     * but converts it to a HTML Element Attribute ID compliant format.<br/>
     * E.g.:
     * <code>garage.cars</code>,<br/>
     * <code>shop.book.0.page.1.</code>
     */
    get canonicalPathNotation(): string;
    private _rootName;
    /**
     * Provides the HTML Element Attribute ID/NAME compliant representation
     * of the root element.<br/>
     * Represents the HTML FORM NAME.<br/>
     * Only the root <code>FormProperty</code> will provide a value here.
     */
    get rootName(): any;
    constructor(schemaValidatorFactory: SchemaValidatorFactory, validatorRegistry: ValidatorRegistry, expressionCompilerFactory: ExpressionCompilerFactory, schema: ISchema, parent: PropertyGroup, path: string, logger: LogService);
    /**
     * Creates the HTML ID and NAME attribute compliant string.
     */
    private createRootName;
    get valueChanges(): BehaviorSubject<any>;
    get errorsChanges(): BehaviorSubject<any>;
    get type(): TSchemaPropertyType;
    get isNullableType(): boolean;
    get parent(): PropertyGroup;
    get root(): PropertyGroup;
    get path(): string;
    get value(): any;
    get visible(): boolean;
    get valid(): boolean;
    abstract setValue(value: any, onlySelf: boolean): any;
    abstract reset(value: any, onlySelf: boolean): any;
    updateValueAndValidity(onlySelf?: boolean, emitEvent?: boolean): void;
    /**
     * @internal
     */
    abstract _hasValue(): boolean;
    /**
     *  @internal
     */
    abstract _updateValue(): any;
    /**
     * @internal
     */
    _runValidation(): any;
    private mergeErrors;
    private setErrors;
    extendErrors(errors: any): void;
    searchProperty(path: string): FormProperty;
    findRoot(): PropertyGroup;
    private setVisible;
    /**
     * Making use of the expression compiler for the <code>visibleIf</code> condition
     * @param sourceProperty The source property where the `visibleIf` condition is set.
     * @param targetProperty  The target property what provided the `value` on which the `visibleIf` condition will be checked against. May be `null` or `undefined`
     * @param dependencyPath The dependency path of the `targetProperty`
     * @param value The value of the `targetProperty` to check the `visiblityIf` condintion against. May be `null` or `undefined`
     * @param expression The value or expression to check against the `value` for the `targetProperty`. May be `null` or `undefined`
     */
    private __evaluateVisibilityIf;
    /**
     * binds visibility conditions of type `oneOf` and `allOf`.
     * @returns `true` if any visibility binding of type `oneOf` or `allOf` has been processed. Otherwise `false`.
     */
    private __bindVisibility_oneOf_or_allOf;
    /**
     * helper function to recursively bind visibilty in an arbitrary chain oneOf allOf chain
     * @param visbilityElement The element from the visibitly chain. Can be an array from e.g. {"oneOf": [...]} or an element with one property for the dependency path e.g. {"textField1": ...}
     * @param isOneOf Boolean to chain the oberservables as oneOf
     * @param isAllOf Boolean to chain the oberservables as allOf
     * @returns An Array with one
     */
    private __bindConditionalVisiblityChain;
    /**
     * Handles a dependency path in a oneOf or allOf
     * @param dependencyElement An element / object which contains neither a field with oneOf or allOf as name. Handled as dependency path in json
     * @returns An oberservable boolean containing the evaluation of the statement, where the statement is the value of the dependency path field
     */
    private __handleDependencyPath;
    _bindVisibility(): void;
    private registerMissingVisibilityBinding;
    /**
     * Finds all <code>formProperties</code> from a path with wildcards.<br/>
     * e.g: <code>/garage/cars/&#42;/tires/&#42;/name</code><br/>
     * @param target
     * @param propertyPath
     */
    findProperties(target: FormProperty, propertyPath: string): FormProperty[];
    /**
     * Creates canonical paths from a path with wildcards.
     * e.g:<br/>
     * From:<br/>
     * <code>/garage/cars/&#42;/tires/&#42;/name</code><br/>
     * it creates:<br/>
     * <code>/garage/cars/0/tires/0/name</code><br/>
     * <code>/garage/cars/0/tires/1/name</code><br/>
     * <code>/garage/cars/0/tires/2/name</code><br/>
     * <code>/garage/cars/0/tires/3/name</code><br/>
     * <code>/garage/cars/1/tires/0/name</code><br/>
     * <code>/garage/cars/2/tires/1/name</code><br/>
     * <code>/garage/cars/3/tires/2/name</code><br/>
     * <code>/garage/cars/3/tires/3/name</code><br/>
     * <code>/garage/cars/&#42;/tires/&#42;/name</code><br/>
     * <code>/garage/cars/&#42;/tires/2/name</code><br/>
     * <code>/garage/cars/&#42;/tires/3/name</code><br/>
     * <br/>etc...
     * @param target
     * @param path
     * @param parentPath
     */
    findPropertyPaths(target: FormProperty, path: string, parentPath?: string): string[];
}
declare abstract class PropertyGroup extends FormProperty {
    _properties: FormProperty[] | {
        [key: string]: FormProperty;
    };
    get properties(): FormProperty[] | {
        [key: string]: FormProperty;
    };
    set properties(properties: FormProperty[] | {
        [key: string]: FormProperty;
    });
    private _propertyProxyHandler;
    getProperty(path: string): any;
    forEachChild(fn: (formProperty: FormProperty, str: String) => void): void;
    forEachChildRecursive(fn: (formProperty: FormProperty) => void): void;
    _bindVisibility(): void;
    private _bindVisibilityRecursive;
    isRoot(): boolean;
}
declare class ExtendedProxyHandler implements ProxyHandler<FormProperty[] | {
    [key: string]: FormProperty;
}> {
    private logger;
    constructor(logger: LogService);
    /**
     * When a new item is added it will be checked for visibility updates to proceed <br/>
     * if any other field has a binding reference to it.<br/>
     */
    set(target: FormProperty[] | {
        [p: string]: FormProperty;
    }, p: PropertyKey, value: any, receiver: any): boolean;
    get(target: FormProperty[] | {
        [p: string]: FormProperty;
    }, p: PropertyKey, receiver: any): any;
    deleteProperty(target: FormProperty[] | {
        [p: string]: FormProperty;
    }, p: PropertyKey): boolean;
}

interface Action {
    (formProperty: FormProperty, parameters: any): void;
}

declare class ActionRegistry {
    actions: {
        [key: string]: Action;
    };
    clear(): void;
    register(actionId: string, action: Action): void;
    get(actionId: string): Action;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActionRegistry, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ActionRegistry>;
}

interface Binding {
    [eventName: string]: ((event: any, formProperty: FormProperty) => void) | ((event: any, formProperty: FormProperty) => void)[];
}

declare class BindingRegistry {
    bindings: Binding[];
    clear(): void;
    register(path: string, binding: Binding | Binding[]): void;
    get(path: string): Binding[];
    static ɵfac: i0.ɵɵFactoryDeclaration<BindingRegistry, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BindingRegistry>;
}

declare class FormPropertyFactory {
    private schemaValidatorFactory;
    private validatorRegistry;
    private propertyBindingRegistry;
    private expressionCompilerFactory;
    private logger;
    constructor(schemaValidatorFactory: SchemaValidatorFactory, validatorRegistry: ValidatorRegistry, propertyBindingRegistry: PropertyBindingRegistry, expressionCompilerFactory: ExpressionCompilerFactory, logger: LogService);
    createProperty(schema: ISchema, parent?: PropertyGroup, propertyId?: string): FormProperty;
    private isUnionType;
    private isValidNullableUnionType;
    private extractTypeFromNullableUnionType;
}

declare abstract class AtomicProperty extends FormProperty {
    setValue(value: any, onlySelf?: boolean): void;
    reset(value?: any, onlySelf?: boolean): void;
    resetValue(value: any): any;
    _hasValue(): boolean;
    abstract fallbackValue(): any;
    _updateValue(): void;
}

declare class ObjectProperty extends PropertyGroup {
    private formPropertyFactory;
    private propertiesId;
    constructor(formPropertyFactory: FormPropertyFactory, schemaValidatorFactory: SchemaValidatorFactory, validatorRegistry: ValidatorRegistry, expressionCompilerFactory: ExpressionCompilerFactory, schema: ISchema, parent: PropertyGroup, path: string, logger: LogService);
    setValue(value: any, onlySelf: boolean): void;
    reset(value: any, onlySelf?: boolean): void;
    resetProperties(value: any): void;
    createProperties(): void;
    _hasValue(): boolean;
    _updateValue(): void;
    _runValidation(): void;
    private reduceValue;
}

declare class ArrayProperty extends PropertyGroup {
    private formPropertyFactory;
    constructor(formPropertyFactory: FormPropertyFactory, schemaValidatorFactory: SchemaValidatorFactory, validatorRegistry: ValidatorRegistry, expressionCompilerFactory: ExpressionCompilerFactory, schema: ISchema, parent: PropertyGroup, path: string, logger: LogService);
    addItem(value?: any): FormProperty;
    private addProperty;
    removeItem(item: FormProperty): void;
    setValue(value: any, onlySelf: boolean): void;
    _hasValue(): boolean;
    _updateValue(): void;
    private reduceValue;
    reset(value: any, onlySelf?: boolean): void;
    private createProperties;
    private resetProperties;
}

declare class StringProperty extends AtomicProperty {
    fallbackValue(): string;
}

declare class BooleanProperty extends AtomicProperty {
    fallbackValue(): any;
}

declare class NumberProperty extends AtomicProperty {
    fallbackValue(): any;
    setValue(value: any, onlySelf?: boolean): void;
}

declare class NullProperty extends AtomicProperty {
    fallbackValue(): any;
}

declare class SchemaPreprocessor {
    static preprocess(jsonSchema: ISchema, path?: string): any;
    private static checkProperties;
    private static checkAndCreateFieldsets;
    private static checkFieldsUsage;
    private static createFieldsets;
    private static replaceOrderByFieldsets;
    private static normalizeWidget;
    private static checkItems;
    private static recursiveCheck;
    private static removeRecursiveRefProperties;
    /**
     * Enables alias names for JSON schema extensions.
     *
     * Copies the value of each alias JSON schema property
     * to the JSON schema property of ngx-schema-form.
     *
     * @param schema JSON schema to enable alias names.
     */
    private static normalizeExtensions;
    static ɵfac: i0.ɵɵFactoryDeclaration<SchemaPreprocessor, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SchemaPreprocessor>;
}

type TPropertyTypeMapping = {
    [type in FieldType]?: any;
};
declare const PROPERTY_TYPE_MAPPING: TPropertyTypeMapping;

declare abstract class Widget<T extends FormProperty> {
    formProperty: T;
    control: UntypedFormControl;
    errorMessages: string[];
    id: string;
    name: string;
    schema: ISchema;
}
declare class ControlWidget extends Widget<FormProperty> implements AfterViewInit {
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ControlWidget, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ControlWidget, never, never, {}, {}, never, never, true, never>;
}
declare class ArrayLayoutWidget extends Widget<ArrayProperty> implements AfterViewInit {
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayLayoutWidget, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ArrayLayoutWidget, never, never, {}, {}, never, never, true, never>;
}
declare class ObjectLayoutWidget extends Widget<ObjectProperty> implements AfterViewInit {
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectLayoutWidget, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ObjectLayoutWidget, never, never, {}, {}, never, never, true, never>;
}

declare class ArrayWidget extends ArrayLayoutWidget {
    buttonDisabledAdd: boolean;
    buttonDisabledRemove: boolean;
    addItem(): void;
    removeItem(item: FormProperty): void;
    trackByIndex(index: number, item: any): number;
    updateButtonDisabledState(): void;
    isAddButtonDisabled(): boolean;
    isRemoveButtonDisabled(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayWidget, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ArrayWidget, "sf-array-widget", never, {}, {}, never, never, false, never>;
}

declare class CheckboxWidget extends ControlWidget implements AfterViewInit {
    checked: any;
    ngAfterViewInit(): void;
    onCheck(el: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxWidget, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxWidget, "sf-checkbox-widget", never, {}, {}, never, never, false, never>;
}

declare class FileWidget extends ControlWidget implements AfterViewInit {
    protected reader: FileReader;
    protected filedata: any;
    constructor();
    ngAfterViewInit(): void;
    onFileChange($event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileWidget, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileWidget, "sf-file-widget", never, {}, {}, never, never, false, never>;
}

declare class IntegerWidget extends ControlWidget {
    static ɵfac: i0.ɵɵFactoryDeclaration<IntegerWidget, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IntegerWidget, "sf-integer-widget", never, {}, {}, never, never, false, never>;
}

declare class ObjectWidget extends ObjectLayoutWidget {
    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectWidget, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ObjectWidget, "sf-form-object", never, {}, {}, never, never, false, never>;
}

declare class RadioWidget extends ControlWidget {
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioWidget, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RadioWidget, "sf-radio-widget", never, {}, {}, never, never, false, never>;
}

declare class RangeWidget extends ControlWidget {
    static ɵfac: i0.ɵɵFactoryDeclaration<RangeWidget, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RangeWidget, "sf-range-widget", never, {}, {}, never, never, false, never>;
}

declare class SelectWidget extends ControlWidget {
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectWidget, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectWidget, "sf-select-widget", never, {}, {}, never, never, false, never>;
}

declare class StringWidget extends ControlWidget {
    getInputType(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<StringWidget, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StringWidget, "sf-string-widget", never, {}, {}, never, never, false, never>;
}

declare class TextAreaWidget extends ControlWidget {
    static ɵfac: i0.ɵɵFactoryDeclaration<TextAreaWidget, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextAreaWidget, "sf-textarea-widget", never, {}, {}, never, never, false, never>;
}

declare class ButtonWidget {
    button: any;
    formProperty: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonWidget, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonWidget, "sf-button-widget", never, {}, {}, never, never, false, never>;
}

declare class WidgetRegistry {
    private widgets;
    private defaultWidget;
    constructor();
    setDefaultWidget(widget: any): void;
    getDefaultWidget(): any;
    hasWidget(type: string): boolean;
    register(type: string, widget: any): void;
    getWidgetType(type: string): any;
}

declare class DefaultWidgetRegistry extends WidgetRegistry {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultWidgetRegistry, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultWidgetRegistry>;
}

declare class DisableControlDirective {
    private ngControl;
    set disableControl(condition: boolean);
    constructor(ngControl: NgControl);
    static ɵfac: i0.ɵɵFactoryDeclaration<DisableControlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DisableControlDirective, "[disableControl]", never, { "disableControl": { "alias": "disableControl"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TemplateSchemaElement {
    getTextContent(elementRef: ElementRef): string;
}

declare class ButtonComponent extends TemplateSchemaElement implements AfterContentInit {
    private elementRef;
    id: string;
    label: string;
    widget: string | object;
    click: EventEmitter<any>;
    constructor(elementRef: ElementRef);
    private setLabelFromContent;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "sf-button", never, { "id": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "widget": { "alias": "widget"; "required": false; }; }, { "click": "click"; }, never, ["*"], false, never>;
}

declare class ItemComponent extends TemplateSchemaElement implements OnInit {
    private elementRef;
    value: any;
    description: string;
    constructor(elementRef: ElementRef);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ItemComponent, "sf-item", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare abstract class FieldParent extends TemplateSchemaElement {
    name: string;
    type: FieldType | TNullableFieldType;
    get path(): string;
    protected abstract actionRegistry: ActionRegistry;
    protected abstract childButtons: QueryList<ButtonComponent>;
    getButtons(): {
        id: string;
        label: string;
        widget?: string | object;
    }[];
    protected getFieldsValidators(fields: Field[]): {
        path: string;
        validator: Validator;
    }[];
    protected getFieldsSchema(fields: Field[]): ISchema;
}

declare class TemplateSchemaService {
    changes: EventEmitter<any>;
    constructor();
    changed(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateSchemaService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TemplateSchemaService>;
}

declare class FieldComponent extends FieldParent implements Field, OnChanges, AfterContentInit {
    private elementRef;
    private templateSchemaService;
    protected actionRegistry: ActionRegistry;
    childFields: QueryList<FieldComponent>;
    childItems: QueryList<ItemComponent>;
    childButtons: QueryList<ButtonComponent>;
    name: string;
    type: FieldType | TNullableFieldType;
    format: string;
    required: boolean;
    readOnly: boolean;
    title: string;
    description: string;
    placeholder: string;
    widget: string | object;
    validator: Validator;
    schema: ISchema;
    constructor(elementRef: ElementRef, templateSchemaService: TemplateSchemaService, actionRegistry: ActionRegistry);
    getSchema(): ISchema;
    getValidators(): {
        path: string;
        validator: Validator;
    }[];
    ngOnChanges(changes: SimpleChanges): void;
    private getOneOf;
    private setTitleFromContent;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldComponent, "sf-field", never, { "name": { "alias": "name"; "required": false; }; "type": { "alias": "type"; "required": false; }; "format": { "alias": "format"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "widget": { "alias": "widget"; "required": false; }; "validator": { "alias": "validator"; "required": false; }; "schema": { "alias": "schema"; "required": false; }; }, {}, ["childFields", "childItems", "childButtons"], ["*"], false, never>;
}

declare class TerminatorService {
    onDestroy: Subject<boolean>;
    constructor();
    destroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TerminatorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TerminatorService>;
}

declare function useFactory(schemaValidatorFactory: any, validatorRegistry: any, propertyBindingRegistry: any, expressionCompilerFactory: any, logService: any): FormPropertyFactory;
declare class FormComponent implements OnChanges, ControlValueAccessor {
    private formPropertyFactory;
    private actionRegistry;
    private validatorRegistry;
    private bindingRegistry;
    private cdr;
    private terminator;
    schema: ISchema | null;
    model: any;
    actions: {
        [actionId: string]: Action;
    };
    validators: {
        [path: string]: Validator;
    };
    bindings: {
        [path: string]: Binding;
    };
    onChange: EventEmitter<{
        value: any;
    }>;
    modelChange: EventEmitter<any>;
    isValid: EventEmitter<boolean>;
    onErrorChange: EventEmitter<{
        value: any[];
    }>;
    onErrorsChange: EventEmitter<{
        value: any;
    }>;
    rootProperty: FormProperty;
    private onChangeCallback;
    constructor(formPropertyFactory: FormPropertyFactory, actionRegistry: ActionRegistry, validatorRegistry: ValidatorRegistry, bindingRegistry: BindingRegistry, cdr: ChangeDetectorRef, terminator: TerminatorService);
    writeValue(obj: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    ngOnChanges(changes: SimpleChanges): void;
    private setValidators;
    private setActions;
    private setBindings;
    reset(): void;
    private setModel;
    private onValueChanges;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormComponent, "sf-form", never, { "schema": { "alias": "schema"; "required": false; }; "model": { "alias": "model"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "validators": { "alias": "validators"; "required": false; }; "bindings": { "alias": "bindings"; "required": false; }; }, { "onChange": "onChange"; "modelChange": "modelChange"; "isValid": "isValid"; "onErrorChange": "onErrorChange"; "onErrorsChange": "onErrorsChange"; }, never, never, false, never>;
}

declare class TemplateSchemaDirective extends FieldParent implements AfterContentInit {
    protected actionRegistry: ActionRegistry;
    protected validatorRegistry: ValidatorRegistry;
    private formComponent;
    private terminatorService;
    private templateSchemaService;
    childFields: QueryList<FieldComponent>;
    childButtons: QueryList<ButtonComponent>;
    constructor(actionRegistry: ActionRegistry, validatorRegistry: ValidatorRegistry, formComponent: FormComponent, terminatorService: TerminatorService, templateSchemaService: TemplateSchemaService);
    setFormDocumentSchema(fields: FieldComponent[]): void;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateSchemaDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateSchemaDirective, "sf-form[templateSchema]", never, {}, {}, ["childFields", "childButtons"], never, false, never>;
}

declare class TemplateSchemaModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateSchemaModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TemplateSchemaModule, [typeof TemplateSchemaDirective, typeof FieldComponent, typeof ButtonComponent, typeof ItemComponent], [typeof i5.CommonModule], [typeof TemplateSchemaDirective, typeof FieldComponent, typeof ButtonComponent, typeof ItemComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TemplateSchemaModule>;
}

declare class DefaultWidget {
    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultWidget, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DefaultWidget, "sf-default-field", never, {}, {}, never, never, false, never>;
}

declare class WidgetFactory {
    private resolver;
    private registry;
    constructor(registry: WidgetRegistry, resolver: ComponentFactoryResolver);
    createWidget(container: ViewContainerRef, type: string): ComponentRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WidgetFactory>;
}

declare class FormElementComponentAction implements OnInit, OnChanges, OnDestroy {
    private widgetFactory;
    private terminator;
    button: any;
    formProperty: any;
    container: ViewContainerRef;
    private ref;
    private subs;
    constructor(widgetFactory: WidgetFactory, terminator: TerminatorService);
    ngOnInit(): void;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormElementComponentAction, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormElementComponentAction, "sf-form-element-action", never, { "button": { "alias": "button"; "required": false; }; "formProperty": { "alias": "formProperty"; "required": false; }; }, {}, never, never, false, never>;
}

declare class FormElementComponent implements OnInit, OnDestroy {
    private actionRegistry;
    private bindingRegistry;
    private renderer;
    private elementRef;
    private logger;
    private static counter;
    formProperty: FormProperty;
    control: UntypedFormControl;
    widget: Widget<any>;
    buttons: any[];
    unlisten: any[];
    constructor(actionRegistry: ActionRegistry, bindingRegistry: BindingRegistry, renderer: Renderer2, elementRef: ElementRef, logger: LogService);
    ngOnInit(): void;
    private setupBindings;
    private createBinding;
    private parseButtons;
    private createButtonCallback;
    onWidgetInstanciated(widget: Widget<any>): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormElementComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormElementComponent, "sf-form-element", never, { "formProperty": { "alias": "formProperty"; "required": false; }; }, {}, never, never, false, never>;
}

declare class WidgetChooserComponent implements OnInit, OnChanges, OnDestroy {
    private widgetFactory;
    private cdr;
    private terminator;
    widgetInfo: any;
    widgetInstanciated: EventEmitter<any>;
    container: ViewContainerRef;
    private widgetInstance;
    private ref;
    private subs;
    constructor(widgetFactory: WidgetFactory, cdr: ChangeDetectorRef, terminator: TerminatorService);
    ngOnInit(): void;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetChooserComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetChooserComponent, "sf-widget-chooser", never, { "widgetInfo": { "alias": "widgetInfo"; "required": false; }; }, { "widgetInstanciated": "widgetInstanciated"; }, never, never, false, never>;
}

declare class SchemaFormModule {
    static forRoot(): ModuleWithProviders<SchemaFormModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SchemaFormModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SchemaFormModule, [typeof FormElementComponent, typeof FormElementComponentAction, typeof FormComponent, typeof WidgetChooserComponent, typeof DefaultWidget, typeof ArrayWidget, typeof ButtonWidget, typeof ObjectWidget, typeof CheckboxWidget, typeof FileWidget, typeof IntegerWidget, typeof TextAreaWidget, typeof RadioWidget, typeof RangeWidget, typeof SelectWidget, typeof StringWidget, typeof DisableControlDirective], [typeof i5.CommonModule, typeof i19.FormsModule, typeof i19.ReactiveFormsModule], [typeof FormComponent, typeof FormElementComponent, typeof FormElementComponentAction, typeof WidgetChooserComponent, typeof ArrayWidget, typeof ButtonWidget, typeof ObjectWidget, typeof CheckboxWidget, typeof FileWidget, typeof IntegerWidget, typeof TextAreaWidget, typeof RadioWidget, typeof RangeWidget, typeof SelectWidget, typeof StringWidget, typeof DisableControlDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SchemaFormModule>;
}

export { ActionRegistry, ArrayLayoutWidget, ArrayProperty, ArrayWidget, AtomicProperty, BindingRegistry, BooleanProperty, ButtonComponent, ButtonWidget, CheckboxWidget, ControlWidget, DefaultLogService, DefaultWidget, DefaultWidgetRegistry, DisableControlDirective, ExpressionCompilerFactory, ExtendedProxyHandler, FieldComponent, FieldParent, FieldType, FileWidget, FormComponent, FormElementComponent, FormElementComponentAction, FormProperty, FormPropertyFactory, IntegerWidget, ItemComponent, JEXLExpressionCompiler, JEXLExpressionCompilerFactory, JEXLExpressionCompilerVisibiltyIf, LOG_LEVEL, LogLevel, LogService, NullProperty, NumberProperty, ObjectLayoutWidget, ObjectProperty, ObjectWidget, PROPERTY_TYPE_MAPPING, PropertyBindingRegistry, PropertyBindingTypes, PropertyBindings, PropertyGroup, RadioWidget, RangeWidget, SchemaFormModule, SchemaPreprocessor, SchemaValidatorFactory, SelectWidget, SimplePropertyIndexer, StringProperty, StringWidget, TemplateSchemaDirective, TemplateSchemaElement, TemplateSchemaModule, TemplateSchemaService, TerminatorService, TextAreaWidget, ValidatorRegistry, Widget, WidgetChooserComponent, WidgetFactory, WidgetRegistry, ZSchemaValidatorFactory, useFactory };
export type { Action, Binding, ExpressionCompiler, ExpressionCompilerVisibilityIf, ExpressionContextVisibilitIf, Field, IButton, IFieldSet, IOneOf, IProperties, ISchema, IWidget, IndexerResult, TNullableFieldType, TPropertyTypeMapping, TSchemaComplexPrimitiveType, TSchemaNullPrimitiveType, TSchemaNullableScalarPrimitiveType, TSchemaPrimitiveType, TSchemaPropertyType, TSchemaScalarPrimitiveType, Validator };