@anglr/common 8.0.0-beta.20211126121623 → 8.0.0-beta.20211217111139

package/forms/common-forms.internal.d.ts

@@ -0,0 +1,966 @@
+import { AbstractControl } from '@angular/forms';
+import { AbstractControlOptions } from '@angular/forms';
+import { AfterViewInit } from '@angular/core';
+import { AsyncValidatorFn } from '@angular/forms';
+import { ChangeDetectorRef } from '@angular/core';
+import { ComponentRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { Dictionary } from '@jscrpt/common';
+import { ElementRef } from '@angular/core';
+import { FormArray } from '@angular/forms';
+import { FormControl } from '@angular/forms';
+import { FormControlDirective } from '@angular/forms';
+import { FormControlName } from '@angular/forms';
+import { FormGroup } from '@angular/forms';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { Injector } from '@angular/core';
+import { NgForm } from '@angular/forms';
+import { NgModel } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { OnChanges } from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { OnInit } from '@angular/core';
+import { Renderer2 } from '@angular/core';
+import { SimpleChanges } from '@angular/core';
+import { StringDictionary } from '@jscrpt/common';
+import { StringLocalization } from '@anglr/common';
+import { TemplateRef } from '@angular/core';
+import { Type } from '@angular/core';
+import { ValidationErrors } from '@angular/forms';
+import { Validator as Validator_2 } from '@angular/forms';
+import { ValidatorFn } from '@angular/forms';
+
+/**
+ * Gets indication whether hide alerts or not for control
+ * @param form - Form containing controls
+ * @param control - Controls name that will be checked
+ * @param errors - Array of validation errors to be checked for existance
+ */
+export declare function alertHidden(form: NgForm, control: string, errors?: string[]): boolean;
+
+/**
+ * Gets indication whether hide alerts or not for control, with custom indication of submitted
+ * @param form - Form containing controls
+ * @param control - Controls name that will be checked
+ * @param errors - Array of validation errors to be checked for existance
+ * @param submitted - Indication whether form was submitted
+ */
+export declare function alertHiddenCustom(form: NgForm | FormGroup, control: string, errors?: string[], submitted?: boolean): boolean;
+
+/**
+ * Sets async validator for property
+ * @param validator - Instance of async validator or async validator factory
+ */
+export declare function AsyncValidator(validator: AsyncValidatorFn | AsyncValidatorFnFactory): PropertyDecorator;
+
+/**
+ * Class that represents AsyncValidatorFn factory
+ */
+export declare class AsyncValidatorFnFactory<TArg extends Dictionary<any> = any> {
+    private _factoryFn?;
+    /**
+     * Creates instance of AsyncValidatorFnFactory
+     * @param _factoryFn - Function used for creating AsyncValidatorFn
+     */
+    constructor(_factoryFn?: AsyncValidatorFnFactoryFn<TArg>);
+    /**
+     * Gets async validator function factory function
+     */
+    valueOf(): AsyncValidatorFnFactoryFn<TArg>;
+}
+
+/**
+ * Factory function used for creaging AsyncValidatorFn
+ */
+export declare interface AsyncValidatorFnFactoryFn<TArg extends Dictionary<any> = any> {
+    /**
+     * Function that creates AsyncValidatorFn
+     * @param args - Arguments passed for create function from owning class
+     */
+    (args: TArg): AsyncValidatorFn;
+}
+
+/**
+ * Builds form from decorated model, only for properties with non `undefined` value
+ * @param model - Model that can be decorated for enhancing created form group with validation and so on
+ * @param args - Object storing arguments from owning component for customization
+ * @returns
+ */
+export declare function buildFormModel<TModel, TArgs = Record<string, never>>(model: TModel, args?: TArgs): FormGroup;
+
+/**
+ * Sets control options for property
+ * @param options - Options for control that are set
+ */
+export declare function ControlOptions(options: ModelPropertyOptions): PropertyDecorator;
+
+/**
+ * Class used for obtaining current value from owner when needed
+ */
+export declare class CurrentValue<TValue = any> {
+    currentValue: () => TValue;
+    /**
+     * Creates instance of CurrentValue
+     * @param currentValue - Value function used for obtaining current value
+     */
+    constructor(currentValue: () => TValue);
+}
+
+/**
+ * Default implementation of validation error renderer
+ */
+export declare class DefaultValidationErrorRenderer implements ValidationErrorRenderer {
+    protected _errorMessagesExtractor: ErrorMessagesExtractor;
+    protected _control: FormControl;
+    protected _controlElement: HTMLElement;
+    protected _document: Document;
+    protected _injector: Injector;
+    protected _isSubmittedOrDirty: IsSubmittedOrDirtyFunc;
+    protected _options: ValidationErrorsRendererOptions;
+    /**
+     * Html element attribute storing error messages
+     */
+    protected _errorMessageAttr: Attr;
+    /**
+     * Object storing last obtained errors
+     */
+    protected _lastErrors: ValidationErrorsResult;
+    /**
+     * Component used for displaying errors
+     */
+    protected _component: ComponentRef<ValidationErrorsComponent>;
+    /**
+     * Html element that is wrapping errors
+     */
+    wrapperElement: HTMLElement;
+    constructor(_errorMessagesExtractor: ErrorMessagesExtractor, _control: FormControl, _controlElement: HTMLElement, _document: Document, _injector: Injector, _isSubmittedOrDirty: IsSubmittedOrDirtyFunc, _options: ValidationErrorsRendererOptions);
+    /**
+     * Destroys renderer and everything that was rendered
+     */
+    destroy(): void;
+    /**
+     * Updates rendered errors for current state and returns true if errors were rendered, otherwise false
+     * @param errorMessages - Object storing error messages to be used as override
+     * @param onlyShow - Indication that update performs only displaying of existing errors
+     */
+    update(errorMessages?: StringDictionary, onlyShow?: boolean): boolean;
+    /**
+     * Toggles css classes for errors that are currently set
+     * @param add - Indication whether add or remove errors
+     */
+    protected _toggleErrors(add?: boolean): void;
+    /**
+     * Initialize renderer
+     */
+    protected _initialize(): void;
+    /**
+     * Renders error messages
+     * @param add - Indication whether add or remove errors
+     */
+    protected _render(add: boolean): void;
+    /**
+     * Renders divs with errors
+     * @param add - Indication whether add or remove errors
+     */
+    protected _renderDivs(add?: boolean): void;
+    /**
+     * Renders component with errors
+     * @param add - Indication whether add or remove errors
+     */
+    protected _renderComponent(add?: boolean): void;
+    /**
+     * Renders template with errors
+     * @param add - Indication whether add or remove errors
+     */
+    protected _renderTemplate(_add?: boolean): void;
+    /**
+     * Shows wrapper element
+     */
+    protected _show(): void;
+    /**
+     * Hides wrapper element
+     */
+    protected _hide(): void;
+}
+
+/**
+ * Defines property default state as disabled
+ */
+export declare function Disabled(): PropertyDecorator;
+
+/**
+ * Sets email validation for property
+ */
+export declare function Email(): PropertyDecorator;
+
+/**
+ * Service used for extracting error messages from form control
+ */
+export declare class ErrorMessagesExtractor {
+    /**
+     * Dictionary with error names that have defined message
+     */
+    protected _errorMessages: StringDictionary;
+    /**
+     * String localization service
+     */
+    protected _stringLocalization: StringLocalization;
+    constructor(injector: Injector, globalErrorMessages?: StringDictionary);
+    /**
+     * Gets validation errors result for provided control, or null of no errors are present
+     * @param control - Form control instance that should be inspected for errors
+     * @param messages - Object containing error messages that should patch existing error messages
+     */
+    getErrors(control: FormControl, messages?: StringDictionary): ValidationErrorsResult;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorMessagesExtractor, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorMessagesExtractor>;
+}
+
+/**
+ * Defines property value as FormArray
+ */
+export declare function FormArrayProperty(): PropertyDecorator;
+
+/**
+ * Registers async validator for whole FormGroup
+ * @param validator - Instance of async validator or async validator factory
+ */
+export declare function FormGroupAsyncValidator(validator: AsyncValidatorFn | AsyncValidatorFnFactory): ClassDecorator;
+
+/**
+ * Defines property value as FormGroup
+ */
+export declare function FormGroupProperty(): PropertyDecorator;
+
+/**
+ * Registers validator for whole FormGroup
+ * @param validator - Instance of validator or validator factory
+ */
+export declare function FormGroupValidator(validator: ValidatorFn | ValidatorFnFactory): ClassDecorator;
+
+/**
+ * Gets current value from owner object when needed, use this method for obtaining args during customization
+ * @param value - Value that is direct static value or instanceof CurrentValue
+ * @returns
+ */
+export declare function getCurrentValue<TValue>(value: CurrentValue<TValue> | TValue): TValue;
+
+/**
+ * Directive that is attached to parent element of inputs group and handles css class that is added to this element
+ */
+export declare class GroupHasErrorDirective {
+    private _element;
+    /**
+     * Options for this directive
+     */
+    private _options;
+    /**
+     * Array of invalid controls
+     */
+    private _invalidControls;
+    constructor(_element: ElementRef<HTMLElement>);
+    /**
+     * Registers control as invalid control
+     * @param id - Name of control to be registered
+     */
+    registerControl(id: string): void;
+    /**
+     * Unregisters control from invalid controls
+     * @param id - Id of control to be unregistered
+     */
+    unregisterControl(id: string): void;
+    /**
+     * Updates status of element (css classes)
+     */
+    private _updateStatus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupHasErrorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GroupHasErrorDirective, "[groupHasError]", never, {}, {}, never>;
+}
+
+/**
+ * Options for GroupHasErrorDirective
+ */
+export declare interface GroupHasErrorOptions {
+    /**
+     * Css class applied to element when there is an error
+     */
+    cssClass?: string;
+}
+
+/**
+ * Gets indication whether controls have errors
+ * @param form - Form containing controls
+ * @param controls - Array of controls names to be checked for errors
+ */
+export declare function hasError(form: NgForm, controls: string[]): boolean;
+
+/**
+ * Gets indication whether controls have errors, with custom indication of submitted
+ * @param form - Form containing controls
+ * @param controls - Array of controls names to be checked for errors
+ * @param submitted - Indication whether form was submitted
+ */
+export declare function hasErrorCustom(form: NgForm | FormGroup, controls: string[], submitted?: boolean): boolean;
+
+/**
+ * Directive that is attached to control element and handles css classes that are added to this element
+ */
+export declare class HasErrorDirective implements OnInit, OnDestroy {
+    private _element;
+    private _rendererFactory;
+    private _groupHasError;
+    private _formControl;
+    private _formControlName;
+    private _ngModel;
+    private _submittedSvc;
+    protected _stringLocalization: StringLocalization;
+    protected _injector: Injector;
+    /**
+     * Subscriptions that are destroyed with destruction of this directive
+     */
+    private _subscriptions;
+    /**
+     * Unique generated id of control
+     */
+    private _id;
+    /**
+     * Last value of control pristine attribute
+     */
+    private _previousDirty;
+    /**
+     * Indication whether currently are any errors rendered
+     */
+    private _hasErrors;
+    /**
+     * Mutation observer used for observing changes on class of element
+     */
+    private _observer;
+    /**
+     * Gets control which was assigned to this element
+     */
+    private get control();
+    /**
+     * Instance of validation error renderer
+     */
+    renderer: ValidationErrorRenderer;
+    /**
+     * Customized error messages
+     */
+    errorMessages: StringDictionary;
+    constructor(_element: ElementRef<HTMLElement>, _rendererFactory: ValidationErrorRendererFactory, _groupHasError: GroupHasErrorDirective, _formControl: FormControlDirective, _formControlName: FormControlName, _ngModel: NgModel, _submittedSvc: SubmittedService, _stringLocalization: StringLocalization, _injector: Injector);
+    /**
+     * Initialize component
+     */
+    ngOnInit(): void;
+    /**
+     * Called when component is destroyed
+     */
+    ngOnDestroy(): void;
+    /**
+     * Updates status of control and css classes
+     * @param onlyShow - Indication that update performs only displaying of existing errors
+     */
+    private _updateStatus;
+    /**
+     * Toggles registration of control in parent group
+     */
+    private _toggleGroupHasError;
+    /**
+     * Calls action when form is submitted or control is dirty
+     * @param action - Action to be called when form is submitted or control dirty
+     * @param falseAction - Action to be called when form is not submitted and control is not dirty
+     * @param additionalCondition - Additional condition to be evaluated
+     */
+    private _isSubmittedOrDirty;
+    /**
+     * Registers mutation observer which watch for changes of class list
+     */
+    private _registerMutationObserver;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HasErrorDirective, [null, null, { optional: true; skipSelf: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HasErrorDirective, "[hasError]", never, { "errorMessages": "errorMessages"; }, {}, never>;
+}
+
+/**
+ * Module for input validation directives
+ */
+export declare class HasErrorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HasErrorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HasErrorModule, [typeof i1_2.HasErrorDirective, typeof i2_2.GroupHasErrorDirective], never, [typeof i1_2.HasErrorDirective, typeof i2_2.GroupHasErrorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HasErrorModule>;
+}
+
+declare namespace i1 {
+    export {
+        MaxValueNumberValidatorDirective
+    }
+}
+
+declare namespace i1_2 {
+    export {
+        HasErrorDirective
+    }
+}
+
+declare namespace i1_3 {
+    export {
+        RequiredClassDirective
+    }
+}
+
+declare namespace i2 {
+    export {
+        MinValueNumberValidatorDirective
+    }
+}
+
+declare namespace i2_2 {
+    export {
+        GroupHasErrorOptions,
+        GroupHasErrorDirective
+    }
+}
+
+declare namespace i3 {
+    export {
+        NumberInputControlValueAccessor
+    }
+}
+
+declare namespace i4 {
+    export {
+        NumberInputValidatorDirective
+    }
+}
+
+/**
+ * Invalidates `FormControl` when current `FormControl` values changes
+ * @param property - Name of `TModel` control or array of these properties to be invalidated on change
+ * @param opts - Configuration options determine how the control propagates changes and emits events on sibling controls
+ * after updates and validity checks are applied.
+ * * `onlySelf`: When true, only update this control. When false or not supplied,
+ * update all direct ancestors. Default is false.
+ * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
+ * `valueChanges`
+ * observables emit events with the latest status and value when the control is updated.
+ * When false, no events are emitted.
+ * * `markAsTouched` calls also `markAsTouched` on sibling control
+ * * `markAsDirty` calls also `markAsDirty` on sibling control
+ */
+export declare function InvalidateOnChange<TModel = any>(property: Extract<keyof TModel, string> | Extract<keyof TModel, string>[], opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    markAsTouched?: boolean;
+    markAsDirty?: boolean;
+}): PropertyDecorator;
+
+/**
+ * Describes function that is used for performing actions when form is submitted or dirty
+ */
+export declare interface IsSubmittedOrDirtyFunc {
+    /**
+     * Calls action when form is submitted or control is dirty
+     * @param action - Action to be called when form is submitted or control dirty
+     * @param falseAction - Action to be called when form is not submitted and control is not dirty
+     * @param additionalCondition - Additional condition to be evaluated
+     */
+    (action: () => void, falseAction?: () => void, additionalCondition?: boolean): void;
+}
+
+/**
+ * Sets maximal length validation for property
+ * @param maxLength - Maximal value that will be validated against
+ */
+export declare function MaxLength(maxLength: number): PropertyDecorator;
+
+/**
+ * Sets maximal number value validation for property
+ * @param maxValue - Maximal value that will be validated against
+ */
+export declare function MaxValue(maxValue: number): PropertyDecorator;
+
+/**
+ * Directive injecting checking for number max value validator
+ */
+export declare class MaxValueNumberValidatorDirective implements Validator_2, OnChanges {
+    /**
+     * Current max value that is allowed
+     */
+    private _maxValue;
+    /**
+     * Function used for validations
+     */
+    private _validator;
+    /**
+     * Indication whether validator was initialized
+     */
+    private _initialized;
+    /**
+     * Bound max value that is allowed, which overrides value set to attribute maxValue
+     */
+    maxValue?: number;
+    constructor(maxValue: string);
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Validates input and returns validation result
+     * @param control - Control that is being validated
+     * @returns validation results
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaxValueNumberValidatorDirective, [{ attribute: "maxValue"; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MaxValueNumberValidatorDirective, "input[number][maxValue][formControlName],input[number][maxValue][formControl],input[number][maxValue][ngModel]", never, { "maxValue": "maxValue"; }, {}, never>;
+}
+
+/**
+ * Sets minimal length validation on property
+ * @param minLength - Minimal length that will be validated against
+ */
+export declare function MinLength(minLength: number): PropertyDecorator;
+
+/**
+ * Sets min numeral value validation for property
+ * @param value - Minimal value that will be validated against
+ */
+export declare function MinValue(value: number): PropertyDecorator;
+
+/**
+ * Directive injecting checking for number min value validator
+ */
+export declare class MinValueNumberValidatorDirective implements Validator_2, OnChanges {
+    /**
+     * Current min value that is allowed
+     */
+    private _minValue;
+    /**
+     * Function used for validations
+     */
+    private _validator;
+    /**
+     * Indication whether validator was initialized
+     */
+    private _initialized;
+    /**
+     * Bound min value that is allowed, which overrides value set to attribute minValue
+     */
+    minValue?: number;
+    constructor(minValue: string);
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Validates input and returns validation result
+     * @param control - Control that is being validated
+     * @returns validation results
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinValueNumberValidatorDirective, [{ attribute: "minValue"; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MinValueNumberValidatorDirective, "input[number][minValue][formControlName],input[number][minValue][formControl],input[number][minValue][ngModel]", never, { "minValue": "minValue"; }, {}, never>;
+}
+
+/**
+ * Metadata describing whole model
+ */
+export declare interface ModelDecoratorMetadata<TModel = any> {
+    /**
+     * Array of controls metadata
+     */
+    ɵControlsMetadata: Partial<Record<keyof TModel, ModelPropertyDecoratorMetadata>>;
+    /**
+     * Array of validator functions
+     */
+    ɵValidators?: Array<ValidatorFn | ValidatorFnFactory>;
+    /**
+     * Array of async validator functions
+     */
+    ɵAsyncValidators?: Array<AsyncValidatorFn | AsyncValidatorFnFactory>;
+}
+
+/**
+ * Metadata describing model of single property
+ */
+export declare interface ModelPropertyDecoratorMetadata<TArgs extends Dictionary<any> = any> {
+    /**
+     * Indication whether form control will be enabled for property
+     */
+    disabled?: boolean;
+    /**
+     * Type of control that represents this property
+     */
+    type?: typeof FormGroup | typeof FormArray | typeof FormControl;
+    /**
+     * Type of child, used only with combination of type FormArray
+     */
+    childType?: typeof FormGroup | typeof FormArray | typeof FormControl;
+    /**
+     * Array of validator functions
+     */
+    validators?: Array<ValidatorFn | ValidatorFnFactory>;
+    /**
+     * Array of async validator functions
+     */
+    asyncValidators?: Array<AsyncValidatorFn | AsyncValidatorFnFactory>;
+    /**
+     * Object storing additional arguments for customization
+     */
+    args?: TArgs;
+    /**
+     * Options that can be passed to control represented by model property
+     */
+    controlOptions?: ModelPropertyOptions;
+}
+
+/**
+ * Defines metadata for model property
+ * @param metadata - Metadata for model property, used for creating form
+ */
+export declare function ModelPropertyMetadata<TArgs extends Dictionary<any> = any, TModel = any>(metadata: ModelPropertyDecoratorMetadata<TArgs>): PropertyDecorator;
+
+/**
+ * Type that represents options that can be passed to control represented by model property
+ */
+export declare type ModelPropertyOptions = Omit<AbstractControlOptions, keyof Pick<AbstractControlOptions, 'asyncValidators' | 'validators'>>;
+
+/**
+ * Sets validation for number on property
+ */
+declare function Number_2(): PropertyDecorator;
+export { Number_2 as Number }
+
+/**
+ * Value accessor for getting and setting values for number inputs
+ */
+export declare class NumberInputControlValueAccessor implements ControlValueAccessor {
+    private _renderer;
+    private _elementRef;
+    onChange: (_: any) => void;
+    /**
+     * Method that is called when picker was touched
+     */
+    onTouched: () => void;
+    constructor(_renderer: Renderer2, _elementRef: ElementRef);
+    /**
+     * Sets value to select
+     */
+    writeValue(value: any): void;
+    /**
+     * Registers callback that is called when value of select changes
+     */
+    registerOnChange(fn: (data: any) => any): void;
+    /**
+     * Registers callback that is called when select is closed
+     */
+    registerOnTouched(fn: () => any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberInputControlValueAccessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NumberInputControlValueAccessor, "input[number][formControlName],input[number][formControl],input[number][ngModel]", never, {}, {}, never>;
+}
+
+/**
+ * Module for number input components, pipes and directives
+ */
+export declare class NumberInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NumberInputModule, [typeof i1.MaxValueNumberValidatorDirective, typeof i2.MinValueNumberValidatorDirective, typeof i3.NumberInputControlValueAccessor, typeof i4.NumberInputValidatorDirective], never, [typeof i1.MaxValueNumberValidatorDirective, typeof i2.MinValueNumberValidatorDirective, typeof i3.NumberInputControlValueAccessor, typeof i4.NumberInputValidatorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NumberInputModule>;
+}
+
+/**
+ * Is number directive injecting checking for number validator
+ */
+export declare class NumberInputValidatorDirective implements Validator_2 {
+    /**
+     * Validates input and returns validation result
+     * @param control - Control that is being validated
+     * @returns validation results
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberInputValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NumberInputValidatorDirective, "input[number][formControlName],input[number][formControl],input[number][ngModel]", never, {}, {}, never>;
+}
+
+/**
+ * Sets property pattern validation
+ */
+export declare function Pattern(pattern: string | RegExp): PropertyDecorator;
+
+/**
+ * Prepares object for form builder, wraps each property in array
+ * @param value - Object which properties will be wrapped to array
+ */
+export declare function prepareForFormBuilder(value: Dictionary<any>): Dictionary;
+
+/**
+ * Reads filter value from encoded string
+ * @param defaultValue - Default value of filter, which is overriden by values from filterValue
+ * @param filterValue - Encoded string containing filter value
+ * @param reviver - A function that transforms the results. This function is called for each member of the object.
+ */
+export declare function readEncodedFilter<TFilter>(defaultValue: TFilter, filterValue: string, reviver?: (this: any, key: string, value: any) => any): TFilter;
+
+/**
+ * Sets property as required (sets validator)
+ */
+declare function Required_2(): PropertyDecorator;
+export { Required_2 as Required }
+
+/**
+ * Required class directive adds required class to element
+ */
+export declare class RequiredClassDirective implements AfterViewInit {
+    private _formControl;
+    private _formControlName;
+    private _changeDetector;
+    /**
+     * Gets control which was assigned to this element
+     */
+    private get control();
+    /**
+     * Handles css class for required input
+     */
+    required: boolean;
+    constructor(_formControl: FormControlDirective, _formControlName: FormControlName, _changeDetector: ChangeDetectorRef);
+    /**
+     * Called when view was initialized
+     */
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequiredClassDirective, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RequiredClassDirective, "[requiredClass]", never, {}, {}, never>;
+}
+
+/**
+ * Module for required class directive
+ */
+export declare class RequiredClassModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequiredClassModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RequiredClassModule, [typeof i1_3.RequiredClassDirective], never, [typeof i1_3.RequiredClassDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RequiredClassModule>;
+}
+
+/**
+ * Sets property as required if condition is met (sets validator)
+ * @param conditionProperty - Name of property that holds
+ */
+export declare function RequiredIf<TArgs = any>(conditionProperty: keyof TArgs): PropertyDecorator;
+
+/**
+ * Service used for handling submitted state of form
+ */
+export declare class SubmittedService {
+    /**
+     * Subject for indication when submitted changes
+     */
+    private _submittedChangeSubject;
+    /**
+     * Indication whether was form submitted
+     */
+    private _submitted;
+    /**
+     * Gets indication whether was form submitted
+     */
+    get submitted(): boolean;
+    /**
+     * Occurs when indication whether was form submitted changes
+     */
+    get submittedChange(): Observable<void>;
+    /**
+     * Sets submitted to true
+     * @param submitted - If set to false, sets submitted to false
+     */
+    setSubmitted(submitted?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubmittedService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SubmittedService>;
+}
+
+/**
+ * Injection token containing validation error messages
+ */
+export declare const VALIDATION_ERROR_MESSAGES: InjectionToken<StringDictionary>;
+
+/**
+ * Injection token used for injecting global options for ValidationErrorRendererFactory
+ */
+export declare const VALIDATION_ERROR_RENDERER_FACTORY_OPTIONS: InjectionToken<ValidationErrorRendererFactoryOptions>;
+
+/**
+ * Describes service that is used for rendering validation errors
+ */
+export declare interface ValidationErrorRenderer {
+    /**
+     * Html element that is wrapping errors
+     */
+    wrapperElement: HTMLElement;
+    /**
+     * Destroys renderer and everything that was rendered
+     */
+    destroy(): void;
+    /**
+     * Updates rendered errors for current state and returns true if errors were rendered, otherwise false
+     * @param errorMessages - Object storing error messages to be used as override
+     * @param onlyShow - Indication that update performs only displaying of existing errors
+     */
+    update(errorMessages?: StringDictionary, onlyShow?: boolean): boolean;
+}
+
+/**
+ * Describes type that represents ValidationErrorRenderer
+ */
+export declare interface ValidationErrorRendererCtor {
+    /**
+     * Creates instance of ValidationErrorRenderer
+     * @param errorMessagesExtractor - Instance of service used for extracting errors from control
+     * @param control - Control that is being processed for errors
+     * @param controlElement - Html element that represents control that is being processed
+     * @param document - Html document instance, used for manipulation with html
+     * @param injector - Injector used for obtaining dependencies
+     * @param isSubmittedOrDirty - Function used for testing if control is submitted or dirty
+     * @param options - Options for validation errors renderer
+     */
+    new (errorMessagesExtractor: ErrorMessagesExtractor, control: FormControl, controlElement: HTMLElement, document: Document, injector: Injector, isSubmittedOrDirty: IsSubmittedOrDirtyFunc, options: ValidationErrorsRendererOptions): ValidationErrorRenderer;
+}
+
+/**
+ * Service used for creating validation errors renderer
+ */
+export declare class ValidationErrorRendererFactory {
+    protected _errorMessagesExtractor: ErrorMessagesExtractor;
+    protected _document: Document;
+    /**
+     * Options for validation error renderer factory
+     */
+    protected _options: ValidationErrorRendererFactoryOptions;
+    constructor(_errorMessagesExtractor: ErrorMessagesExtractor, _document: Document, options: ValidationErrorRendererFactoryOptions);
+    /**
+     * Creates new instance of ValidationErrorRenderer
+     * @param control - Control that is being processed for errors
+     * @param controlElement - Html element that represents control that is being processed
+     * @param isSubmittedOrDirty - Function used for testing if control is submitted or dirty
+     * @param options - Options for validation errors renderer factory
+     */
+    create(control: FormControl, controlElement: HTMLElement, injector: Injector, isSubmittedOrDirty: IsSubmittedOrDirtyFunc, options: ValidationErrorRendererFactoryOptions): ValidationErrorRenderer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationErrorRendererFactory, [null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidationErrorRendererFactory>;
+}
+
+/**
+ * Options for ValidationErrorRendererFactory
+ */
+export declare interface ValidationErrorRendererFactoryOptions extends ValidationErrorsRendererOptions {
+    /**
+     * Type of ValidationErrorRenderer implementation
+     */
+    rendererType?: ValidationErrorRendererCtor;
+}
+
+/**
+ * Component that is used for rendering validation errors
+ */
+export declare interface ValidationErrorsComponent {
+    /**
+     * Shows validation errors in component
+     * @param errors - Errors to be shown, or null if to be hidden
+     */
+    show(errors: ValidationErrorsResult): void;
+}
+
+/**
+ * Options for ValidationErrorRenderer
+ */
+export declare interface ValidationErrorsRendererOptions {
+    /**
+     * Prefix of css classes applied to element
+     */
+    prefix?: string;
+    /**
+     * Suffix of css classes applied to element
+     */
+    suffix?: string;
+    /**
+     * Css class attached to wrapper div
+     */
+    wrapperDivClass?: string;
+    /**
+     * Component used for rendering validation errors
+     */
+    component?: Type<ValidationErrorsComponent>;
+    /**
+     * Template used for rendering validation errors
+     */
+    template?: TemplateRef<ValidationErrorsTemplateContext>;
+}
+
+/**
+ * Object containing information about validation errors result
+ */
+export declare interface ValidationErrorsResult {
+    /**
+     * Array of error names that are present
+     */
+    errors: string[];
+    /**
+     * Array of error messages that should be displayed
+     */
+    errorMessages: string[];
+}
+
+/**
+ * Context passed to template that is used for rendering validation errors
+ */
+export declare interface ValidationErrorsTemplateContext {
+    /**
+     * Errors to be shown
+     */
+    $implicit: ValidationErrorsResult;
+}
+
+/**
+ * Sets validator for property
+ * @param validator - Instance of validator or validator factory
+ */
+export declare function Validator(validator: ValidatorFn | ValidatorFnFactory): PropertyDecorator;
+
+/**
+ * Class that represents ValidatorFn factory
+ */
+export declare class ValidatorFnFactory<TArg extends Dictionary<any> = any> {
+    private _factoryFn?;
+    /**
+     * Creates instance of ValidatorFnFactory
+     * @param _factoryFn - Function used for creating ValidatorFn
+     */
+    constructor(_factoryFn?: ValidatorFnFactoryFn<TArg>);
+    /**
+     * Gets validator function factory function
+     */
+    valueOf(): ValidatorFnFactoryFn<TArg>;
+}
+
+/**
+ * Factory function used for creaging ValidatorFn
+ */
+export declare interface ValidatorFnFactoryFn<TArg extends Dictionary<any> = any> {
+    /**
+     * Function that creates ValidatorFn
+     * @param args - Arguments passed for create function from owning class
+     */
+    (args: TArg): ValidatorFn;
+}
+
+/**
+ * Validations functions
+ */
+export declare class Validators {
+    /**
+     * Validates control if its value is number
+     * @param control - Control which value to be validated
+     */
+    static number(control: AbstractControl): ValidationErrors | null;
+    /**
+     * Creates validator function that validates control if its value is higher than max value
+     * @param max - Max value that should be validated
+     */
+    static max(max: number | null): ValidatorFn;
+    /**
+     * Creates validator function that validates control if its value is lower than min value
+     * @param min - Min value that should be validated
+     */
+    static min(min: number | null): ValidatorFn;
+}
+
+export { }