@sbcore/ng-absolute-validator 14.0.0

package/fesm2020/sbcore-ng-absolute-validator.mjs

@@ -0,0 +1,4480 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Inject, EventEmitter, Component, Optional, Input, Output, ContentChild, Directive, NgModule, APP_INITIALIZER } from '@angular/core';
+import { Subject, debounceTime, takeUntil, of, from, distinctUntilChanged, switchMap, first, map as map$1, firstValueFrom } from 'rxjs';
+import * as i1$2 from '@angular/forms';
+import { FormGroupDirective, NgForm, NG_VALIDATORS, NG_ASYNC_VALIDATORS } from '@angular/forms';
+import * as i1 from '@ngx-translate/core';
+import { TranslateModule, TranslateService, TranslateLoader } from '@ngx-translate/core';
+import * as i3 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import { map, debounceTime as debounceTime$1, distinctUntilChanged as distinctUntilChanged$1, first as first$1 } from 'rxjs/operators';
+import { isValid, parse, isAfter, isBefore } from 'date-fns';
+import * as i1$1 from '@angular/common/http';
+import { HttpClientModule } from '@angular/common/http';
+
+const LIB_CONFIG = new InjectionToken('LIB_CONFIG');
+
+const GlobalConstant = {
+    customObjectName: 'ng_abs',
+    customRulesName: 'validators',
+    customElementName: 'nativeElement',
+    customFieldName: 'field_name',
+    approvedLanguage: [
+        'en', 'ar'
+    ],
+    fileDependentRules: [
+        'image', 'video', 'mimes', 'size'
+    ],
+    fieldDependentRules: [
+        'same', 'confirmed', 'different', 'required_if', 'required_unless', 'required_with', 'required_with_all',
+        'required_without', 'required_without_all'
+    ],
+    filedOnlyDependentRules: [
+        'required_if', 'required_unless', 'required_with', 'required_with_all', 'required_without', 'required_without_all'
+    ],
+    fieldDefaultNameRule: [
+        'required_without', 'required_without_all'
+    ],
+    asyncRules: [
+        'unique', 'exists', 'dimension'
+    ],
+    emitMethods: [
+        'credit_card', 'debit_card', 'strength'
+    ],
+    /****
+     * Credit Card Issuer with Regex Expression
+    ****/
+    credit_card: [
+        { name: 'American Express', id: 'AMEX', regex: '^3[47]' },
+        { name: 'Discover', id: 'DISCOVER', regex: '^(6011|622(12[6-9]|1[3-9][0-9]|[2-8][0-9]{2}|9[0-1][0-9]|92[0-5]|64[4-9])|65)' },
+        { name: 'JCB', id: 'JCB', regex: '^(?:2131|1800|35\d{3})\d{11}$' },
+        { name: 'MasterCard', id: 'MASTER_CARD', regex: '^(5[1-5][0-9]{14}|2(22[1-9][0-9]{12}|2[3-9][0-9]{13}|[3-6][0-9]{14}|7[0-1][0-9]{13}|720[0-9]{12}))$' },
+        { name: 'Diners', id: 'DINERS', regex: '^36' },
+        { name: 'Diners - Carte Blanche', id: 'DINERS_CARTE_BLANCHE', regex: '^30[0-5]' },
+        { name: 'Visa Electron', id: 'VISA_ELECTRON', regex: '^(4026|417500|4508|4844|491(3|7))' },
+        { name: 'Visa', id: 'VISA', regex: '^4[0-9]{12}(?:[0-9]{3})?$' },
+    ],
+    /****
+     * Debit Card Issuer with Regex Expression
+    ****/
+    debit_card: [
+        { name: 'American Express', id: 'AMEX', regex: '^3[47]' },
+        { name: 'Discover', id: 'DISCOVER', regex: '^(6011|622(12[6-9]|1[3-9][0-9]|[2-8][0-9]{2}|9[0-1][0-9]|92[0-5]|64[4-9])|65)' },
+        { name: 'JCB', id: 'JCB', regex: '^(?:2131|1800|35\d{3})\d{11}$' },
+        { name: 'MasterCard', id: 'MASTER_CARD', regex: '^(5[1-5][0-9]{14}|2(22[1-9][0-9]{12}|2[3-9][0-9]{13}|[3-6][0-9]{14}|7[0-1][0-9]{13}|720[0-9]{12}))$' },
+        { name: 'Diners', id: 'DINERS', regex: '^36' },
+        { name: 'Diners - Carte Blanche', id: 'DINERS_CARTE_BLANCHE', regex: '^30[0-5]' },
+        { name: 'Visa Electron', id: 'VISA_ELECTRON', regex: '^(4026|417500|4508|4844|491(3|7))' },
+        { name: 'Visa', id: 'VISA', regex: '^4[0-9]{12}(?:[0-9]{3})?$' },
+    ],
+    /****
+     * String strength validation with Regex Expression
+    ****/
+    strength_default_color: '#6c757d',
+    strength_level: [
+        { id: 'a', description: 'String is of length 8.', regex: '.{8}' },
+        { id: 'b', description: 'String has one uppercase letters.', regex: '(?=.*[A-Z])' },
+        { id: 'c', description: 'String has one special case letter.', regex: '(?=.*[!@#$&*])' },
+        { id: 'd', description: 'String has one digits.', regex: '(?=.*[0-9])' },
+        { id: 'e', description: 'String has one lowercase letters.', regex: '(?=.*[a-z])' },
+    ],
+    strength_color: [
+        { max: 25, color: '#d9534f' },
+        { min: 26, max: 50, color: '#f0ad4e' },
+        { min: 51, max: 75, color: '#5bc0de' },
+        { min: 76, color: '#5cb85c' }
+    ]
+};
+const CUSTOM_OBJECT_NAME = 'ng_abs';
+const DEFAULT_STRENGTH_COLOR = '#6c757d';
+const DEFAULT_DATE_FORMAT = 'dd-MM-yyyy';
+const DEFAULT_LOCALE_LANG = 'en';
+const SUPPORTED_LOCALE_LANGS = ['ar', 'bn', 'de', 'en', 'es', 'fr', 'hi', 'ja', 'pt', 'ru', 'zh'];
+const DEFAULT_TRIGGER_STATE = ['touched', 'dirty'];
+const EMIT_METHODS = ['credit_card', 'debit_card', 'strength'];
+const CROSS_FIELD_VALIDATORS = [
+    'same', 'confirmed', 'different',
+    'required_if', 'required_unless',
+    'required_with', 'required_with_all',
+    'required_without', 'required_without_all'
+];
+const ASYNC_RULES = ['unique', 'exists', 'dimension'];
+const FILE_TYPE_RULES = ['image', 'video', 'mimes', 'size'];
+
+class NgAbsoluteValidatorService {
+    constructor(config) {
+        this.config = config;
+        this.VLIDATOR_CONFIG = {};
+        this.init();
+    }
+    init() {
+        this.VLIDATOR_CONFIG = this.config;
+    }
+    /**
+     * @description This method give is remote locader is enable or not
+     * @returns Boolean
+    **/
+    get remoteLoader() {
+        return (typeof this.VLIDATOR_CONFIG.remoteLoader === 'undefined') ? true : this.VLIDATOR_CONFIG.remoteLoader;
+    }
+    /**
+     * @description This method give is remote locader is enable or not
+     * @returns Boolean
+    **/
+    get strengthBar() {
+        return (typeof this.VLIDATOR_CONFIG.strengthBar === 'undefined') ? true : this.VLIDATOR_CONFIG.strengthBar;
+    }
+    /**
+     * @description This method return the color of the bar based on config
+     * @returns Object
+    **/
+    get strengthColor() {
+        let strColor = this.VLIDATOR_CONFIG.strengthColor;
+        return (typeof strColor === 'object') ? strColor : GlobalConstant.strength_color;
+    }
+    /**
+     * @description This method return the list of regex config to vlidate
+     * @returns Object
+    **/
+    get strengthLevel() {
+        let level = this.VLIDATOR_CONFIG.strengthLevel || {};
+        return Object.assign(GlobalConstant.strength_level, level);
+    }
+    /**
+     * @description This method check is the loader should display or not
+     * @returns boolean
+    **/
+    get delayLoader() {
+        return this.VLIDATOR_CONFIG.delayLoader || 0;
+    }
+    /**
+    * @description This method state of triger validation
+    * @returns boolean
+   **/
+    get showErrorOn() {
+        return (this.VLIDATOR_CONFIG.showErrorOn || DEFAULT_TRIGGER_STATE);
+    }
+}
+NgAbsoluteValidatorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgAbsoluteValidatorService, deps: [{ token: LIB_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+NgAbsoluteValidatorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgAbsoluteValidatorService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgAbsoluteValidatorService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LIB_CONFIG]
+                }] }]; } });
+
+class NgAbsoluteValidatorComponent {
+    constructor(avs, translate, formGroupDirective, ngForm) {
+        this.avs = avs;
+        this.translate = translate;
+        this.formGroupDirective = formGroupDirective;
+        this.ngForm = ngForm;
+        this.indicatorColor = DEFAULT_STRENGTH_COLOR;
+        this.indicatorScore = 0;
+        this.invalid = true;
+        this.dirty = false;
+        this.touched = false;
+        this.isLoaderOn = false;
+        this.isStrengthBarOn = false;
+        this.errorMessage = {};
+        this.ngAbsData = {};
+        this.destroy$ = new Subject();
+        this.loader = true;
+        this.message = {};
+        this.defaultError = true;
+        this.showErrorOn = [];
+        this.onValid = new EventEmitter();
+        this.onValidate = new EventEmitter();
+        const langCode = (navigator.language || DEFAULT_LOCALE_LANG).split('-')[0];
+        this.translate.setDefaultLang(langCode);
+        this.translate.use(DEFAULT_LOCALE_LANG);
+    }
+    ngOnInit() {
+        this.isLoaderOn = this.loader === true ? this.avs.remoteLoader : false;
+        this.isStrengthBarOn = this.avs.strengthBar;
+        this.strength_color = this.avs.strengthColor;
+        this.doCheckAndValidate();
+    }
+    get errorContext() {
+        return {
+            $implicit: this.errorMessage
+        };
+    }
+    get progressContext() {
+        return {
+            $implicit: this.indicatorScore,
+            color: this.indicatorColor
+        };
+    }
+    get isSubmitted() {
+        return this.formGroupDirective?.submitted ?? this.ngForm?.submitted ?? false;
+    }
+    get errorTriggerOn() {
+        if (this.showErrorOn.length > 0) {
+            return this.showErrorOn;
+        }
+        if (this.formGroupDirective?.errorTriggerOn?.length > 0) {
+            return this.formGroupDirective.errorTriggerOn;
+        }
+        if (this.ngForm?.errorTriggerOn?.length > 0) {
+            return this.ngForm.errorTriggerOn;
+        }
+        if (this.avs.showErrorOn.length > 0) {
+            return this.avs.showErrorOn;
+        }
+        return DEFAULT_TRIGGER_STATE;
+    }
+    /**
+     * @description This method check the rule has dependency with another field or not
+     * @return boolean
+    **/
+    get isDisplay() {
+        let isDependent = (this.ngAbsData.validators || [])
+            .some((rule) => CROSS_FIELD_VALIDATORS.includes(rule));
+        if (this.errorTriggerOn.includes('submit')) {
+            return this.isSubmitted && this.invalid;
+        }
+        if (this.errorTriggerOn.includes('always')) {
+            return this.invalid;
+        }
+        return this.invalid
+            && (isDependent || this.errorTriggerOn.every((on) => this.formInstance[on]));
+    }
+    /**
+     * @description This method check and validate the mathod
+     * @return void
+    **/
+    doCheckAndValidate() {
+        this.setNgAbsData(this.formInstance); // Need Only For Reactive Validation
+        this.errorMessage = this.generateMessage(this.formInstance.errors, this.message, true); // Need Only For Reactive Validation
+        this.formInstance.statusChanges.pipe(debounceTime(200), takeUntil(this.destroy$)).subscribe(() => {
+            this.inputValue = this.formInstance.value;
+            this.invalid = this.formInstance.invalid;
+            this.dirty = this.formInstance.dirty;
+            this.touched = this.formInstance.touched;
+            this.errorMessage = this.generateMessage(this.formInstance.errors, this.message, true);
+            this.setNgAbsData(this.formInstance);
+            this.emitedData(this.formInstance);
+        });
+    }
+    /**
+     * @description This method set the validate methods taking from Template/Reactive from
+     * @return void
+    **/
+    setNgAbsData(formInstance) {
+        this.ngAbsData = formInstance[CUSTOM_OBJECT_NAME] || (formInstance.control ? (formInstance.control[CUSTOM_OBJECT_NAME] || {}) : {});
+    }
+    /**
+     * @description This method set strength color with max and min range object
+     * @return void
+    **/
+    getStrengthClass(strengthData) {
+        if (!!!strengthData.strength)
+            return;
+        strengthData = strengthData.strength;
+        this.indicatorScore = strengthData && strengthData.score && !!this.inputValue ? strengthData.score : 0;
+        let strength = this.strength_color.find((v) => (this.indicatorScore >= (v.min || -9999) && this.indicatorScore <= (v.max || 9999)));
+        this.indicatorColor = strength ? strength.color : DEFAULT_STRENGTH_COLOR;
+    }
+    /**
+     * @description This method trigger event and return the validation information
+     * @return void
+    **/
+    emitedData(formInstance) {
+        let emited = {};
+        emited['isValid'] = formInstance.valid;
+        emited['isPending'] = formInstance.pending;
+        if (this.ngAbsData) {
+            this.getStrengthClass(this.ngAbsData);
+            emited['data'] = this.ngAbsData;
+        }
+        this.onValid.emit(emited);
+        this.onValidate.emit(formInstance.errors);
+    }
+    /**
+     * @description This method generate message
+     * @return object
+    **/
+    generateMessage(messageObject, message, is_array = false) {
+        messageObject = Object.assign(messageObject || {}, message);
+        if (is_array) {
+            return Object.keys(messageObject || {}).map(i => messageObject[i]);
+        }
+        else {
+            return messageObject;
+        }
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+NgAbsoluteValidatorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgAbsoluteValidatorComponent, deps: [{ token: NgAbsoluteValidatorService }, { token: i1.TranslateService }, { token: FormGroupDirective, optional: true }, { token: NgForm, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+NgAbsoluteValidatorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: NgAbsoluteValidatorComponent, selector: "ng-absolute-validator", inputs: { formInstance: "formInstance", loader: "loader", message: "message", defaultError: "defaultError", showErrorOn: "showErrorOn" }, outputs: { onValid: "onValid", onValidate: "onValidate" }, queries: [{ propertyName: "absError", first: true, predicate: ["absError"], descendants: true }, { propertyName: "absProgress", first: true, predicate: ["absProgress"], descendants: true }, { propertyName: "absLoader", first: true, predicate: ["absLoader"], descendants: true }], ngImport: i0, template: "<ng-container *ngIf=\"formInstance.pending && isLoaderOn\">\r\n    <div class=\"av-loading-panel\">\r\n        <ng-template [ngTemplateOutlet]=\"absLoader ?? absFbLoader\"></ng-template>\r\n    </div>\r\n</ng-container>\r\n\r\n<ng-container *ngIf=\"(formInstance.control?.ng_abs?.strength || formInstance?.ng_abs?.strength ) && isStrengthBarOn && indicatorScore > 0\">\r\n    <div class=\"av-progress\">\r\n        <ng-template [ngTemplateOutlet]=\"absProgress ?? absFbProgress\" [ngTemplateOutletContext]=\"progressContext\"></ng-template>\r\n    </div>\r\n</ng-container>\r\n\r\n<ng-container *ngIf=\"isDisplay && defaultError && errorMessage.length > 0\">\r\n    <div class=\"av-error-panel\">\r\n        <ng-template [ngTemplateOutlet]=\"absError ?? absFbError\"[ngTemplateOutletContext]=\"errorContext\"></ng-template>\r\n    </div>\r\n</ng-container>\r\n\r\n<ng-template #absFbLoader>\r\n    <div class=\"av-loading\" >\r\n        <div><div></div></div>\r\n        <div><div></div></div>\r\n        <div><div></div></div>\r\n        <div><div></div></div>\r\n        <div><div></div></div>\r\n    </div>\r\n</ng-template>\r\n\r\n<ng-template #absFbProgress>\r\n    <div\r\n\t\tclass=\"av-progress-bar\"\r\n\t\trole=\"progressbar\"\r\n\t\taria-valuenow=\"40\"\r\n\t\taria-valuemin=\"0\"\r\n\t\taria-valuemax=\"100\"\r\n\t\t[style.background-color]=\"indicatorColor\"\r\n\t\t[style.width.%]=\"indicatorScore\">\r\n\t</div>\r\n</ng-template>\r\n\r\n<ng-template #absFbError>\r\n    <ul class=\"av-errors-list\">\r\n        <ng-container *ngFor=\"let error of errorMessage\">\r\n            <li [innerText]=\"error\"></li>\r\n        </ng-container>\r\n    </ul>\r\n</ng-template>\r\n", styles: [".av-progress{display:flex}.av-progress-bar{margin-top:5px;float:left;width:0%;height:3px;font-size:12px;line-height:20px;color:#fff;text-align:center;background-color:#337ab7;box-shadow:inset 0 -1px #00000026;transition:width .6s ease}.av-progress-bar.active,.av-progress.active .av-progress-bar{animation:av-progress-bar-stripes 2s linear infinite}.av-progress-bar-striped,.av-progress-striped .av-progress-bar{background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-size:40px 40px}.av-progress-bar-success{background-color:#5cb85c}.av-progress-bar-info{background-color:#5bc0de}.av-progress-bar-warning{background-color:#f0ad4e}.av-progress-bar-danger{background-color:#d9534f}.av-errors-list{margin:2px 0 3px;padding:0;list-style-type:none;font-size:.9em;color:#dc3545;line-height:1.6em;opacity:1;transition:all .3s ease-in;-o-transition:all .3s ease-in;-moz-transition:all .3s ease-in;-webkit-transition:all .3s ease-in}@keyframes av-loading{0%{left:32px;transform:scale(0)}25%{left:32px;transform:scale(1)}50%{left:100px}75%{left:168px;transform:scale(1)}to{left:168px;transform:scale(0)}}.av-loading{position:relative;width:100%;height:100%}.av-loading>div{position:absolute;transform:translate(-50%,-50%);width:40px;height:40px}.av-loading div>div{width:40px;height:40px;border-radius:50%;background:#f00;position:absolute;top:100px;left:32px;animation:av-loading .8s cubic-bezier(0,.5,.5,1) infinite forwards}.av-loading div:nth-child(1) div{animation:av-loading-2 .8s cubic-bezier(0,.5,.5,1) infinite forwards;background:#dce4eb}.av-loading div:nth-child(2) div{animation-delay:-.4s;background:#bbcedd}.av-loading div:nth-child(3) div{animation-delay:-.2s;background:#85a2b6}.av-loading div:nth-child(4) div{animation-delay:0s;background:#fdfdfd}.av-loading div:nth-child(5) div{animation:av-loading-3 .8s cubic-bezier(0,.5,.5,1) infinite forwards;background:#dce4eb}.av-loading{width:32px!important;height:32px!important;transform:translate(-16px,-16px) scale(.16) translate(16px,16px)}\n"], dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgAbsoluteValidatorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ng-absolute-validator', template: "<ng-container *ngIf=\"formInstance.pending && isLoaderOn\">\r\n    <div class=\"av-loading-panel\">\r\n        <ng-template [ngTemplateOutlet]=\"absLoader ?? absFbLoader\"></ng-template>\r\n    </div>\r\n</ng-container>\r\n\r\n<ng-container *ngIf=\"(formInstance.control?.ng_abs?.strength || formInstance?.ng_abs?.strength ) && isStrengthBarOn && indicatorScore > 0\">\r\n    <div class=\"av-progress\">\r\n        <ng-template [ngTemplateOutlet]=\"absProgress ?? absFbProgress\" [ngTemplateOutletContext]=\"progressContext\"></ng-template>\r\n    </div>\r\n</ng-container>\r\n\r\n<ng-container *ngIf=\"isDisplay && defaultError && errorMessage.length > 0\">\r\n    <div class=\"av-error-panel\">\r\n        <ng-template [ngTemplateOutlet]=\"absError ?? absFbError\"[ngTemplateOutletContext]=\"errorContext\"></ng-template>\r\n    </div>\r\n</ng-container>\r\n\r\n<ng-template #absFbLoader>\r\n    <div class=\"av-loading\" >\r\n        <div><div></div></div>\r\n        <div><div></div></div>\r\n        <div><div></div></div>\r\n        <div><div></div></div>\r\n        <div><div></div></div>\r\n    </div>\r\n</ng-template>\r\n\r\n<ng-template #absFbProgress>\r\n    <div\r\n\t\tclass=\"av-progress-bar\"\r\n\t\trole=\"progressbar\"\r\n\t\taria-valuenow=\"40\"\r\n\t\taria-valuemin=\"0\"\r\n\t\taria-valuemax=\"100\"\r\n\t\t[style.background-color]=\"indicatorColor\"\r\n\t\t[style.width.%]=\"indicatorScore\">\r\n\t</div>\r\n</ng-template>\r\n\r\n<ng-template #absFbError>\r\n    <ul class=\"av-errors-list\">\r\n        <ng-container *ngFor=\"let error of errorMessage\">\r\n            <li [innerText]=\"error\"></li>\r\n        </ng-container>\r\n    </ul>\r\n</ng-template>\r\n", styles: [".av-progress{display:flex}.av-progress-bar{margin-top:5px;float:left;width:0%;height:3px;font-size:12px;line-height:20px;color:#fff;text-align:center;background-color:#337ab7;box-shadow:inset 0 -1px #00000026;transition:width .6s ease}.av-progress-bar.active,.av-progress.active .av-progress-bar{animation:av-progress-bar-stripes 2s linear infinite}.av-progress-bar-striped,.av-progress-striped .av-progress-bar{background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-size:40px 40px}.av-progress-bar-success{background-color:#5cb85c}.av-progress-bar-info{background-color:#5bc0de}.av-progress-bar-warning{background-color:#f0ad4e}.av-progress-bar-danger{background-color:#d9534f}.av-errors-list{margin:2px 0 3px;padding:0;list-style-type:none;font-size:.9em;color:#dc3545;line-height:1.6em;opacity:1;transition:all .3s ease-in;-o-transition:all .3s ease-in;-moz-transition:all .3s ease-in;-webkit-transition:all .3s ease-in}@keyframes av-loading{0%{left:32px;transform:scale(0)}25%{left:32px;transform:scale(1)}50%{left:100px}75%{left:168px;transform:scale(1)}to{left:168px;transform:scale(0)}}.av-loading{position:relative;width:100%;height:100%}.av-loading>div{position:absolute;transform:translate(-50%,-50%);width:40px;height:40px}.av-loading div>div{width:40px;height:40px;border-radius:50%;background:#f00;position:absolute;top:100px;left:32px;animation:av-loading .8s cubic-bezier(0,.5,.5,1) infinite forwards}.av-loading div:nth-child(1) div{animation:av-loading-2 .8s cubic-bezier(0,.5,.5,1) infinite forwards;background:#dce4eb}.av-loading div:nth-child(2) div{animation-delay:-.4s;background:#bbcedd}.av-loading div:nth-child(3) div{animation-delay:-.2s;background:#85a2b6}.av-loading div:nth-child(4) div{animation-delay:0s;background:#fdfdfd}.av-loading div:nth-child(5) div{animation:av-loading-3 .8s cubic-bezier(0,.5,.5,1) infinite forwards;background:#dce4eb}.av-loading{width:32px!important;height:32px!important;transform:translate(-16px,-16px) scale(.16) translate(16px,16px)}\n"] }]
+        }], ctorParameters: function () { return [{ type: NgAbsoluteValidatorService }, { type: i1.TranslateService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FormGroupDirective]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [NgForm]
+                }] }]; }, propDecorators: { formInstance: [{
+                type: Input
+            }], loader: [{
+                type: Input
+            }], message: [{
+                type: Input
+            }], defaultError: [{
+                type: Input
+            }], showErrorOn: [{
+                type: Input
+            }], onValid: [{
+                type: Output
+            }], onValidate: [{
+                type: Output
+            }], absError: [{
+                type: ContentChild,
+                args: ['absError']
+            }], absProgress: [{
+                type: ContentChild,
+                args: ['absProgress']
+            }], absLoader: [{
+                type: ContentChild,
+                args: ['absLoader']
+            }] } });
+
+const toArray = (value, seperator = ',') => {
+    let DataArray = (typeof value === 'string' && value.indexOf(seperator) >= 0)
+        ? value.split(seperator) : (isArray(value) ? value : [value]);
+    return DataArray.filter(item => Boolean(item) && !isEmptyObject(item));
+};
+const isArray = (actualData) => {
+    if (typeof actualData === 'string' && json(actualData)) {
+        actualData = JSON.parse(actualData);
+    }
+    return Array.isArray(actualData);
+};
+const isEmptyObject = (value) => {
+    return (value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        Object.keys(value).length === 0);
+};
+const camelCase = (string) => {
+    return string.toLowerCase()
+        .replace(/[^a-zA-Z0-9]+(.)/g, (m, chr) => chr.toUpperCase());
+};
+const json = (string) => {
+    if (!string)
+        return false;
+    try {
+        JSON.parse(string);
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+};
+const bytesToSize = (bytes, seperator = "") => {
+    let sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    if (bytes == 0)
+        return null;
+    let number = Math.floor(Math.log(bytes) / Math.log(1024)).toString();
+    let i = parseInt(number, 10);
+    if (i === 0)
+        return `${bytes}${seperator}${sizes[i]}`;
+    return `${(bytes / (1024 ** i)).toFixed(1)}${seperator}${sizes[i]}`;
+};
+function toCharClass(chars) {
+    return chars.replace(/[\\\]^-]/g, '\\$&');
+}
+function cloneDeep(data) {
+    return JSON.parse(JSON.stringify(data));
+}
+
+class MessageBuilderService {
+    constructor(ts) {
+        this.ts = ts;
+    }
+    call(langAttr, attribute, ...args) {
+        let message = '';
+        let [lastElement] = args.slice(-1);
+        let template = this.ts.instant(langAttr) || '';
+        let hasCustomTemplate = typeof lastElement === 'object' && Object.keys(lastElement).length > 0;
+        if (hasCustomTemplate && lastElement[langAttr] && lastElement[langAttr][this.ts.currentLang]) {
+            template = lastElement[langAttr][this.ts.currentLang];
+        }
+        if (hasCustomTemplate && lastElement[this.ts.currentLang]) {
+            template = lastElement[this.ts.currentLang];
+        }
+        if (attribute && template) {
+            message = template.replace(':attribute', attribute);
+        }
+        if (args.length === 0) {
+            return message;
+        }
+        args.forEach((v, index) => {
+            let replaceWithOne = `:arg${index}`;
+            let replaceWithMulti = `:arg${index}:`;
+            if (message.includes(replaceWithMulti)) {
+                args = args.splice(index);
+                let argString = toArray(args) ? toArray(args).join(',') : args;
+                message = message.replace(replaceWithMulti, argString);
+            }
+            if (message.includes(replaceWithOne)) {
+                message = message.replace(replaceWithOne, v);
+            }
+        });
+        return message;
+    }
+}
+MessageBuilderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MessageBuilderService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+MessageBuilderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MessageBuilderService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MessageBuilderService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
+
+class HttpRequestService {
+    constructor(http) {
+        this.http = http;
+    }
+    get(action_url, params = {}) {
+        return this.http.get(action_url, { params });
+    }
+    post(action_url, data = {}, params = {}) {
+        return this.http.post(action_url, data, { params });
+    }
+}
+HttpRequestService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: HttpRequestService, deps: [{ token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+HttpRequestService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: HttpRequestService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: HttpRequestService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1$1.HttpClient }]; } });
+
+class UtilService {
+    constructor(http, abs) {
+        this.http = http;
+        this.abs = abs;
+        this.defaultTimeZone = 'DD-MM-YYYY';
+        this.creditCardIssuers = GlobalConstant.credit_card;
+        this.debitCardIssuers = GlobalConstant.debit_card;
+        this.customObjectName = GlobalConstant.customObjectName;
+        this.customRulesName = GlobalConstant.customRulesName;
+        this.stringStrength = [];
+        this.init();
+    }
+    init() {
+        this.stringStrength = this.abs.strengthLevel;
+    }
+    setValidationRules(control, rules, appends = {}) {
+        let customObjectName = this.customObjectName;
+        let customRulesName = this.customRulesName;
+        let ruleArray = Array.isArray(rules) ? rules : [rules];
+        let activeRules = !!control[customObjectName] && !!control[customObjectName][customRulesName] ? control[customObjectName][customRulesName] : [];
+        let finalObject = Object.assign({
+            validators: Array.from(new Set(activeRules.concat(ruleArray)))
+        }, appends);
+        control[customObjectName] = finalObject;
+    }
+    json(string) {
+        if (!string)
+            return false;
+        try {
+            JSON.parse(string);
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    }
+    confirmed(control, args, fieldName = null) {
+        fieldName = fieldName || control['field_name'] || null;
+        let compared_field_name = args || (`${fieldName}_confirmation`);
+        let toCompareWith = control.root.get(compared_field_name);
+        return (control.value === toCompareWith?.value);
+    }
+    same(control, args) {
+        let toCompareWith = control.root.get(args);
+        return (control.value === toCompareWith?.value);
+    }
+    different(control, args) {
+        let toCompareWith = control.root.get(args);
+        return (control.value !== toCompareWith?.value);
+    }
+    required(actualData) {
+        return !!actualData;
+    }
+    requiredIf(control, args) {
+        let [dependent, matchWith] = toArray(args);
+        if (!dependent || !matchWith) {
+            return false;
+        }
+        let toCompareWith = control.root.get(dependent);
+        return (toCompareWith.value === matchWith) ? this.required(control.value) : true;
+    }
+    requiredUnless(control, args) {
+        let [dependent, ...matchWith] = toArray(args);
+        if (!dependent && matchWith.length === 0) {
+            return false;
+        }
+        let toCompareWith = control.root.get(dependent);
+        return matchWith.some(item => item === toCompareWith.value) ? this.required(control.value) : true;
+    }
+    requiredWith(control, args) {
+        let names = toArray(args);
+        let anyHasValue = names.some(name => {
+            const c = control.root.get(name);
+            return c && c.value !== null && c.value !== undefined && c.value !== '';
+        });
+        return anyHasValue ? this.required(control.value) : true;
+    }
+    requiredWithAll(control, args) {
+        let matchWith = toArray(args);
+        let compareWithValue = matchWith.map(name => control.root.get(name).value);
+        return compareWithValue.filter(Boolean).length === matchWith.length ? this.required(control.value) : true;
+    }
+    requiredWithout(control, args) {
+        let matchWith = toArray(args);
+        let compareWithValue = matchWith.map(name => control.root.get(name).value);
+        return compareWithValue.filter(Boolean).length === 0 ? this.required(control.value) : true;
+    }
+    requiredWithoutAll(control, args) {
+        let matchWith = toArray(args);
+        let compareWithValue = matchWith.map(name => control.root.get(name).value);
+        let emptyFieldCount = compareWithValue.filter((value) => value === '' || value === null || value === undefined);
+        return emptyFieldCount.length > 0 ? this.required(control.value) : true;
+    }
+    email(actualData) {
+        return (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(actualData));
+    }
+    above(actualData, toBeData) {
+        return (Number(toBeData) < Number(actualData));
+    }
+    accepted(actualData) {
+        return (actualData || actualData !== false || actualData !== 0);
+    }
+    date(actualData, format = DEFAULT_DATE_FORMAT) {
+        try {
+            return actualData ? isValid(parse(actualData, format || DEFAULT_DATE_FORMAT, new Date())) : true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    dateFormat(actualData, format = DEFAULT_DATE_FORMAT) {
+        try {
+            return actualData ? isValid(parse(actualData, format || DEFAULT_DATE_FORMAT, new Date())) : true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    after(actualData, toBeData) {
+        if (!!!actualData || !!!toBeData) {
+            return false;
+        }
+        let [matchWithDate, matchWithDateFormat = DEFAULT_DATE_FORMAT] = Array.isArray(toBeData) ? toBeData : toBeData.split(',');
+        if (!this.dateFormat(actualData, matchWithDateFormat) || !this.dateFormat(matchWithDate, matchWithDateFormat)) {
+            return false;
+        }
+        return isAfter(parse(actualData, matchWithDateFormat, new Date()), parse(matchWithDate, matchWithDateFormat, new Date()));
+    }
+    before(actualData, toBeData) {
+        if (!!!actualData || !!!toBeData) {
+            return false;
+        }
+        let [matchWithDate, matchWithDateFormat = DEFAULT_DATE_FORMAT] = Array.isArray(toBeData) ? toBeData : toBeData.split(',');
+        if (!this.dateFormat(actualData, matchWithDateFormat) || !this.dateFormat(matchWithDate, matchWithDateFormat)) {
+            return false;
+        }
+        return isBefore(parse(actualData, matchWithDateFormat, new Date()), parse(matchWithDate, matchWithDateFormat, new Date()));
+    }
+    alpha(actualData) {
+        return (/^[a-z]+$/i.test(actualData));
+    }
+    alphaNumeric(actualData) {
+        return (/^[a-z0-9]+$/i.test(actualData));
+    }
+    alphaDash(actualData) {
+        return this.regex(actualData, '^[a-zA-Z0-9-_]+$');
+    }
+    array(actualData) {
+        if (typeof actualData === 'string' && this.json(actualData)) {
+            actualData = JSON.parse(actualData);
+        }
+        return Array.isArray(actualData);
+    }
+    boolean(actualData) {
+        let booleanAccepted = [
+            1, '1', 0, '0', 'true', true, 'false', 'false'
+        ];
+        return booleanAccepted.includes(actualData);
+    }
+    equals(actualData, compared_to_value) {
+        return (actualData == compared_to_value);
+    }
+    endsWith(actualData, end_with) {
+        let _end_with = toArray(end_with);
+        return !_end_with.find((v) => actualData && actualData.endsWith(v));
+    }
+    startsWith(actualData, start_with) {
+        return toArray(start_with).some((v) => actualData && actualData.startsWith(v));
+    }
+    in(actualData, compare) {
+        let toCompare = new Set(toArray(compare).map(v => v.toString()));
+        return toCompare.has(actualData);
+    }
+    notIn(actualData, compare) {
+        return !this.in(actualData, compare);
+    }
+    includes(actualData, compare) {
+        if (!actualData)
+            return false;
+        return toArray(compare).every(v => actualData.includes(v.toString()));
+    }
+    number(actualData) {
+        return !isNaN(actualData);
+    }
+    string(actualData) {
+        return isNaN(actualData);
+    }
+    integer(actualData) {
+        if (!this.number(actualData))
+            return false;
+        return Number.isInteger(Number(actualData));
+    }
+    ip(actualData) {
+        let regexExp = [
+            '^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)',
+            '(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)',
+            '(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)',
+            '(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'
+        ].join("\\.");
+        return this.regex(actualData, regexExp);
+    }
+    ipv4(actualData) {
+        let regexExp = new RegExp('^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$');
+        return regexExp.test(actualData);
+    }
+    ipv6(actualData) {
+        let regexExp = new RegExp('^([0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4}$');
+        return regexExp.test(actualData);
+    }
+    max(actualData, max) {
+        if (!actualData)
+            return false;
+        if (this.integer(actualData)) {
+            return actualData <= max;
+        }
+        else {
+            return (actualData.length <= max);
+        }
+    }
+    min(actualData, min) {
+        if (!!!actualData || !!!min)
+            return false;
+        if (this.integer(actualData)) {
+            return Number(actualData) >= Number(min);
+        }
+        else {
+            return (actualData.length >= min);
+        }
+    }
+    notEquals(actualData, compare_to) {
+        return !this.equals(actualData, compare_to);
+    }
+    range(actualData, range) {
+        let [min, max] = toArray(range);
+        return (Number(min) <= Number(actualData)) && (Number(actualData) <= Number(max));
+    }
+    between(actualData, range) {
+        let [min, max] = toArray(range);
+        return (Number(min) < Number(actualData)) && (Number(actualData) < Number(max));
+    }
+    under(actualData, under) {
+        if (!this.number(actualData))
+            return false;
+        return Number(actualData) < Number(under);
+    }
+    url(actualData) {
+        let regexExp = [
+            '^(?:(?:http(?:s)?|ftp)://)(?:\\S+(?::(?:\\S)*)?@)?(?:(?:[a-z0-9\u00a1-\uffff](?:-)*)',
+            '(?:[a-z0-9\u00a1-\uffff])+)(?:\\.(?:[a-z0-9\u00a1-\uffff](?:-)*)',
+            '(?:[a-z0-9\u00a1-\uffff])+)',
+            '(?:\\.(?:[a-z0-9\u00a1-\uffff]){2,})(?::(?:\\d){2,5})?(?:/(?:\\S)*)?$'
+        ].join('*');
+        return this.regex(actualData, regexExp);
+    }
+    regex(actualData, expression) {
+        let regexExp = new RegExp(expression);
+        return regexExp.test(actualData);
+    }
+    notRegex(actualData, expression) {
+        return !this.regex(actualData, expression);
+    }
+    uuid(actualData) {
+        return this.regex(actualData, '[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}');
+    }
+    unique(args) {
+        let http;
+        let action = args.url;
+        let method = args.method || 'GET';
+        let request = args.request || {};
+        let params = args.params || {};
+        if (action || Object.keys(request).length === 0) {
+            return of(false);
+        }
+        switch (method) {
+            case 'POST':
+                http = this.http.post(action, request, params);
+                break;
+            default:
+                http = this.http.get(action, { ...request, ...params });
+        }
+        return http.pipe(map((data) => (data && data.length === 0)));
+    }
+    exists(args) {
+        let http;
+        let action = args.url;
+        let method = args.method || 'GET';
+        let request = args.request || {};
+        let params = args.params || {};
+        if (!action || Object.keys(request).length === 0) {
+            return of(false);
+        }
+        switch (method) {
+            case 'POST':
+                http = this.http.post(action, request, params);
+                break;
+            default:
+                http = this.http.get(action, { ...request, ...params });
+        }
+        return http.pipe(map((data) => (data && data.length > 0)));
+    }
+    getCreditCardData(number) {
+        if (!number)
+            return;
+        number = number.toString();
+        let card_issuer = this.creditCardIssuers.find((card) => this.regex(number, card.regex));
+        return { issuer: (card_issuer ? card_issuer.name : null) };
+    }
+    creditCard(actualData) {
+        let cardInfo = this.getCreditCardData(actualData);
+        return cardInfo ? !!cardInfo.issuer : false;
+    }
+    getDebitCardData(number) {
+        if (!number)
+            return false;
+        let _number = number.toString();
+        let card_issuer = this.debitCardIssuers.find((card) => this.regex(_number, card.regex));
+        return { issuer: (card_issuer ? card_issuer.name : null) };
+    }
+    debitCard(actualData) {
+        let cardInfo = this.getDebitCardData(actualData);
+        return cardInfo ? !!cardInfo.issuer : false;
+    }
+    cvv(actualData) {
+        return this.regex(actualData, '^[0-9]{3,4}$');
+    }
+    getStrengthData(actualData, compare) {
+        if (!!!actualData)
+            return false;
+        let toCompare = toArray(compare);
+        let allowedStrength = [];
+        let activeStrength = [];
+        let inActiveStrength = [];
+        let strengthScore = 0;
+        let strength_color = this.abs.strengthColor;
+        let validStrength = strength_color[strength_color.length - 1];
+        let allowOnMaxScrore = this.number(toCompare[toCompare.length - 1]) ? toCompare[toCompare.length - 1] : validStrength.min || -9999;
+        let specialChars = "@%+\/'!#$^?:.(){}[]~-_";
+        var letters = new Object();
+        for (var i = 0; i < actualData.length; i++) {
+            let assignScore = specialChars.includes(actualData[i]) ? 8.0 : 5.0;
+            letters[actualData[i]] = (letters[actualData[i]] || 0) + 1;
+            strengthScore += assignScore / letters[actualData[i]];
+        }
+        let variationCount = 0;
+        this.stringStrength.forEach((v) => {
+            if (toCompare.indexOf(v.id) >= 0 || toCompare.length == 0) {
+                allowedStrength.push(v.id);
+                let isValid = this.regex(actualData, v.regex);
+                isValid ? activeStrength.push(v.id) : inActiveStrength.push(v.id);
+                variationCount += isValid ? 1 : 0;
+            }
+        });
+        strengthScore += (variationCount - 1) * 10;
+        strengthScore = Math.round(strengthScore);
+        if (inActiveStrength.length > 0) {
+            strengthScore = (strengthScore >= allowOnMaxScrore) ? allowOnMaxScrore - (inActiveStrength.length * 5) : strengthScore;
+        }
+        let sendObject = {
+            score: strengthScore,
+            allowedStrength: allowedStrength,
+            validFor: activeStrength,
+            validExcept: inActiveStrength,
+            allowOnMaxScore: allowOnMaxScrore
+        };
+        return sendObject;
+    }
+    strength(actualData, compare) {
+        let strength = this.getStrengthData(actualData, compare);
+        return (strength && strength.score >= strength.allowOnMaxScore);
+    }
+    phoneNo(actualData, expression = null) {
+        let regex = /\s*(?:\+?(\d{1,3}))?[\W\D\s]^|()*(\d[\W\D\s]*?\d[\D\W\s]*?\d)[\W\D\s]*(\d[\W\D\s]*?\d[\D\W\s]*?\d)[\W\D\s]*(\d[\W\D\s]*?\d[\D\W\s]*?\d[\W\D\s]*?\d)(?: *x(\d+))?\s*$/g;
+        return this.regex(actualData, expression || regex);
+    }
+    image(fileInstance) {
+        if (!!!fileInstance || fileInstance.length === 0)
+            return false;
+        let file = fileInstance[0];
+        return file.type.startsWith('image/');
+    }
+    video(fileInstance) {
+        if (!!!fileInstance || fileInstance.length === 0)
+            return false;
+        let file = fileInstance[0];
+        return file.type.startsWith('video/');
+    }
+    mimes(fileInstance, compare) {
+        if (!!!fileInstance || fileInstance.length === 0 || !!!compare)
+            return false;
+        let file = fileInstance[0];
+        let ext = file.name.split('.').pop();
+        let acceptType = toArray(compare);
+        let hasMime = acceptType.includes(ext);
+        return !!hasMime;
+    }
+    size(fileInstance, compare) {
+        if (!!!fileInstance || fileInstance.length == 0 || !!!compare)
+            return false;
+        let file = fileInstance[0];
+        return file.size <= compare * 1024;
+    }
+    dimension(fileInstance, compare) {
+        if (!!!fileInstance || fileInstance.length == 0 || compare.length === 0)
+            return of(false);
+        let file = fileInstance[0];
+        let type = file.type;
+        if (!type.startsWith('image/'))
+            return of(false);
+        let dimension = toArray(compare);
+        let image = new Image();
+        let height = 0;
+        let width = 0;
+        let ratio = 0;
+        let heightMatch = 'equal';
+        let widthMatch = 'equal';
+        //max_height=200 | max_height=200 | height = 200
+        //min_width=200  | min_width=200  | width = 200
+        //ratio=1.2
+        dimension.forEach(el => {
+            if (el.includes('_height=') || el.startsWith('height=')) {
+                height = parseInt(el.split('=')[1] || 0);
+                heightMatch = ['max', 'min'].includes((el.split('=')[0]).split('_')[0]) ? (el.split('=')[0]).split('_')[0] : 'equal';
+            }
+            if (el.includes('_width=') || el.startsWith('width=')) {
+                width = parseInt(el.split('=')[1] || 0);
+                widthMatch = ['max', 'min'].includes((el.split('=')[0]).split('_')[0]) ? (el.split('=')[0]).split('_')[0] : 'equal';
+            }
+            if (el.includes('ratio=')) {
+                ratio = parseFloat(el.split('=')[1]);
+            }
+        });
+        image.src = window.URL.createObjectURL(file);
+        return from(new Promise((resolve) => {
+            image.onload = () => {
+                let isValid = false;
+                if (ratio) {
+                    isValid = ((image.width / image.height).toFixed(1) === ratio.toFixed(1));
+                }
+                else {
+                    let isValidWidth = width ? this.doComparison(image.width, width, widthMatch) : true;
+                    let isValidHeight = height ? this.doComparison(image.height, height, heightMatch) : true;
+                    isValid = (isValidWidth && isValidHeight);
+                }
+                resolve(isValid);
+            };
+        }));
+    }
+    doComparison(matchWith, matchTo, operator = 'equal') {
+        let compareState = false;
+        if (operator == 'equal') {
+            compareState = matchWith == matchTo;
+        }
+        if (operator == 'min') {
+            compareState = matchWith >= matchTo;
+        }
+        if (operator == 'max') {
+            compareState = matchWith <= matchTo;
+        }
+        return compareState;
+    }
+}
+UtilService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UtilService, deps: [{ token: HttpRequestService }, { token: NgAbsoluteValidatorService }], target: i0.ɵɵFactoryTarget.Injectable });
+UtilService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UtilService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UtilService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: HttpRequestService }, { type: NgAbsoluteValidatorService }]; } });
+
+class ValidateRuleService {
+    constructor(mb, utl) {
+        this.mb = mb;
+        this.utl = utl;
+        this.subMessageMethod = ['max', 'min'];
+        this.wiredRulesMap = new WeakMap();
+    }
+    gererateRuleAndValidate(fieldName, control, rule, custom_message) {
+        let messages = {};
+        let generateRules = toArray(rule, '|');
+        let activeRules = generateRules.map(v => v.includes(':') ? v.split(':')[0] : v);
+        let isRequiredGroup = !!activeRules.find(v => v.startsWith('required'));
+        if (!isRequiredGroup && !!!control.value) {
+            return null;
+        }
+        for (let i = 0; i < generateRules.length; i++) {
+            let isValid = null;
+            let controlArgs = null;
+            let emitData = {};
+            let rule = generateRules[i];
+            let methodName = rule.includes(':') ? rule.split(':')[0] : rule;
+            let args = rule.includes(':') ? rule.split(':')[1] : '';
+            let mulArg = args.includes(',') ? args.split(',') : [args];
+            let currentRule = methodName;
+            let isCrossFieldRule = CROSS_FIELD_VALIDATORS.includes(currentRule);
+            let messageKey = methodName;
+            methodName = camelCase(methodName);
+            let emitFnName = camelCase(`get_${messageKey}_data`);
+            if (typeof this.utl[methodName] !== 'function' || ASYNC_RULES.indexOf(methodName) >= 0)
+                continue;
+            if (this.subMessageMethod.indexOf(methodName) >= 0) {
+                messageKey = this.getMessageKeyRespectToValue(control.value, messageKey);
+            }
+            if (CROSS_FIELD_VALIDATORS.includes(messageKey)) {
+                controlArgs = control;
+            }
+            else if (FILE_TYPE_RULES.includes(messageKey)) {
+                controlArgs = control['nativeElement'] ? control['nativeElement']['files'] : null;
+            }
+            else {
+                controlArgs = control.value;
+            }
+            isCrossFieldRule && this.wireSiblingWatchers(controlArgs, fieldName, currentRule, args);
+            isValid = this.utl[methodName](controlArgs, args);
+            if (typeof this.utl[emitFnName] === 'function') {
+                emitData[messageKey] = this.utl[emitFnName](control.value, mulArg);
+            }
+            this.utl.setValidationRules(control, activeRules, emitData);
+            if (!isValid) {
+                messages[messageKey] = this.mb.call(messageKey, fieldName, ...mulArg, custom_message);
+                break;
+            }
+        }
+        if (Object.keys(messages).length > 0) {
+            return messages;
+        }
+        else {
+            return null;
+        }
+    }
+    getMessageKeyRespectToValue(value, messageKey) {
+        if (this.utl.array(value)) {
+            return `${messageKey}.array`;
+        }
+        if (this.utl.string(value)) {
+            return `${messageKey}.string`;
+        }
+        if (this.utl.integer(value)) {
+            return `${messageKey}.numeric`;
+        }
+        return messageKey;
+    }
+    wireSiblingWatchers(control, input, rule, dependents) {
+        let ctrlNames = toArray(dependents);
+        if (rule === 'confirmed') {
+            ctrlNames = [dependents || (`${input}_confirmation`)];
+        }
+        let wiredRules = this.wiredRulesMap.get(control);
+        if (!wiredRules) {
+            this.wiredRulesMap.set(control, true);
+            ctrlNames.forEach(name => {
+                let ctrl = control.root.get(name);
+                if (ctrl) {
+                    ctrl.valueChanges.pipe(debounceTime$1(200))
+                        .subscribe(() => control.updateValueAndValidity({ onlySelf: true }));
+                }
+            });
+        }
+    }
+}
+ValidateRuleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ValidateRuleService, deps: [{ token: MessageBuilderService }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Injectable });
+ValidateRuleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ValidateRuleService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ValidateRuleService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: UtilService }]; } });
+
+class RuleDirective {
+    constructor(ruleValidate, el) {
+        this.ruleValidate = ruleValidate;
+        this.el = el;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        return this.ruleValidate.gererateRuleAndValidate(this.fieldName, control, this.rule, this.vmessage);
+    }
+}
+RuleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RuleDirective, deps: [{ token: ValidateRuleService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+RuleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RuleDirective, selector: "[Rule], [rule]", inputs: { rule: ["Rule", "rule"], message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RuleDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RuleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[Rule], [rule]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RuleDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: ValidateRuleService }, { type: i0.ElementRef }]; }, propDecorators: { rule: [{
+                type: Input,
+                args: ['Rule']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class AboveDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.above = 0;
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'above');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.above(value, this.above)) {
+            return { 'above': this.mb.call('above', this.fieldName, this.above, this.vmessage) };
+        }
+        return null;
+    }
+}
+AboveDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AboveDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+AboveDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: AboveDirective, selector: "[above]", inputs: { above: "above", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: AboveDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AboveDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[above]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: AboveDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { above: [{
+                type: Input,
+                args: ['above']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class AcceptedDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'accepted');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.accepted(value)) {
+            return { 'accepted': this.mb.call('accepted', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+AcceptedDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AcceptedDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+AcceptedDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: AcceptedDirective, selector: "[accepted]", inputs: { accepted: "accepted", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: AcceptedDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AcceptedDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[accepted]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: AcceptedDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { accepted: [{
+                type: Input,
+                args: ['accepted']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class AfterDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.after = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'after');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        let [matchWithDate, matchWithDateFormat] = Array.isArray(this.after) ? this.after : this.after.split(',');
+        if (!!value && !this.utl.after(value, this.after)) {
+            return { 'after': this.mb.call('after', this.fieldName, matchWithDate, this.vmessage) };
+        }
+        return null;
+    }
+}
+AfterDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AfterDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+AfterDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: AfterDirective, selector: "[after]", inputs: { after: "after", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: AfterDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AfterDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[after]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: AfterDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { after: [{
+                type: Input,
+                args: ['after']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class AlphaDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'alpha');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.alpha(value)) {
+            return { 'alpha': this.mb.call('alpha', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+AlphaDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AlphaDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+AlphaDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: AlphaDirective, selector: "[alpha]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: AlphaDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AlphaDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[alpha]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: AlphaDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class AlphaNumericDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'alpha_numeric');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.alphaNumeric(value)) {
+            return { 'alpha_numeric': this.mb.call('alpha_numeric', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+AlphaNumericDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AlphaNumericDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+AlphaNumericDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: AlphaNumericDirective, selector: "[alphaNumeric]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: AlphaNumericDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AlphaNumericDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[alphaNumeric]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: AlphaNumericDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class ArrayDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'array');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.array(value)) {
+            return { 'array': this.mb.call('array', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+ArrayDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ArrayDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+ArrayDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: ArrayDirective, selector: "[array]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: ArrayDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ArrayDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[array]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: ArrayDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class BeforeDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.before = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'before');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        let [matchWithDate, matchWithDateFormat] = Array.isArray(this.before) ? this.before : this.before.split(',');
+        if (!!value && !this.utl.before(value, this.before)) {
+            return { 'before': this.mb.call('before', this.fieldName, matchWithDate, this.vmessage) };
+        }
+        return null;
+    }
+}
+BeforeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: BeforeDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+BeforeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: BeforeDirective, selector: "[before]", inputs: { before: "before", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: BeforeDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: BeforeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[before]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: BeforeDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { before: [{
+                type: Input,
+                args: ['before']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class BooleanDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'boolean');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.boolean(value)) {
+            return { 'boolean': this.mb.call('boolean', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+BooleanDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: BooleanDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+BooleanDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: BooleanDirective, selector: "[boolean]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: BooleanDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: BooleanDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[boolean]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: BooleanDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class ConfirmedDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.destroy$ = new Subject();
+        this.wired = false;
+        this.fieldName = 'field';
+        this.confirmed = '';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'confirmed');
+        this.wireSiblingWatchers(control);
+        return this.isValid(control, this.confirmed, this.fieldName);
+    }
+    isValid(control, args, fieldName) {
+        if (!!control.value && !this.utl.confirmed(control, args, fieldName)) {
+            return { 'confirmed': this.mb.call('confirmed', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+    wireSiblingWatchers(control) {
+        if (this.wired)
+            return;
+        let ctrlName = this.confirmed || (`${this.fieldName}_confirmation`);
+        let sibling = control.root.get(ctrlName);
+        if (!sibling)
+            return;
+        this.wired = true;
+        sibling.valueChanges.pipe(debounceTime(200), takeUntil(this.destroy$))
+            .subscribe(() => control.updateValueAndValidity({ onlySelf: true }));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+ConfirmedDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ConfirmedDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+ConfirmedDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: ConfirmedDirective, selector: "[confirmed]", inputs: { confirmed: "confirmed", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: ConfirmedDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ConfirmedDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[confirmed]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: ConfirmedDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { confirmed: [{
+                type: Input,
+                args: ['confirmed']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class DateDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.date = '';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'date');
+        return this.isValid(control.value, this.date || DEFAULT_DATE_FORMAT);
+    }
+    isValid(value, format) {
+        if (!!value && !this.utl.date(value, format)) {
+            return { 'date': this.mb.call('date', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+DateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+DateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: DateDirective, selector: "[date]", inputs: { date: "date", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: DateDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[date]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: DateDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { date: [{
+                type: Input,
+                args: ['date']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class DateFormatDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.dateFormat = '';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'date_format');
+        return this.isValid(control.value, this.dateFormat || DEFAULT_DATE_FORMAT);
+    }
+    isValid(value, format) {
+        if (!!value && !this.utl.dateFormat(value, format)) {
+            return { 'date_format': this.mb.call('date_format', this.fieldName, this.dateFormat, this.vmessage) };
+        }
+        return null;
+    }
+}
+DateFormatDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateFormatDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+DateFormatDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: DateFormatDirective, selector: "[dateFormat]", inputs: { dateFormat: "dateFormat", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: DateFormatDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DateFormatDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dateFormat]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: DateFormatDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { dateFormat: [{
+                type: Input,
+                args: ['dateFormat']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class DifferentDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.destroy$ = new Subject();
+        this.wired = false;
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'different');
+        this.wireSiblingWatchers(control);
+        return this.isValid(control, this.different);
+    }
+    isValid(control, compared_value) {
+        if (!!control.value && !this.utl.different(control, compared_value)) {
+            return { 'different': this.mb.call('different', this.fieldName, this.different, this.vmessage) };
+        }
+        return null;
+    }
+    wireSiblingWatchers(control) {
+        if (this.wired)
+            return;
+        let sibling = control.root.get(this.different);
+        if (!sibling)
+            return;
+        this.wired = true;
+        sibling.valueChanges.pipe(debounceTime(200), takeUntil(this.destroy$)).subscribe(() => {
+            control.updateValueAndValidity({ onlySelf: true });
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+DifferentDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DifferentDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+DifferentDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: DifferentDirective, selector: "[different]", inputs: { different: "different", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: DifferentDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DifferentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[different]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: DifferentDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { different: [{
+                type: Input,
+                args: ['different']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class EmailDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'email');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.email(value)) {
+            return { 'email': this.mb.call('email', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+EmailDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EmailDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+EmailDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: EmailDirective, selector: "[email]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: EmailDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EmailDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[email]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: EmailDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class EndsWithDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.endsWith = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'ends_with');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.endsWith(value, this.endsWith)) {
+            return { 'ends_with': this.mb.call('ends_with', this.fieldName, this.endsWith, this.vmessage) };
+        }
+        return null;
+    }
+}
+EndsWithDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EndsWithDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+EndsWithDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: EndsWithDirective, selector: "[endsWith]", inputs: { endsWith: "endsWith", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: EndsWithDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EndsWithDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[endsWith]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: EndsWithDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { endsWith: [{
+                type: Input,
+                args: ['endsWith']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class EqualsDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.equals = '';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'equals');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.equals(value, this.equals)) {
+            return { 'equals': this.mb.call('equals', this.fieldName, this.equals, this.vmessage) };
+        }
+        return null;
+    }
+}
+EqualsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EqualsDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+EqualsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: EqualsDirective, selector: "[equals]", inputs: { equals: "equals", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: EqualsDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EqualsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[equals]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: EqualsDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { equals: [{
+                type: Input,
+                args: ['equals']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class InDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.in = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'in');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.in(value, this.in)) {
+            return { 'in': this.mb.call('in', this.fieldName, this.in, this.vmessage) };
+        }
+        return null;
+    }
+}
+InDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: InDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+InDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: InDirective, selector: "[in]", inputs: { in: "in", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: InDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: InDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[in]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: InDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { in: [{
+                type: Input,
+                args: ['in']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class IncludesDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.includes = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'includes');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.includes(value, this.includes)) {
+            return { 'includes': this.mb.call('includes', this.fieldName, this.includes, this.vmessage) };
+        }
+        return null;
+    }
+}
+IncludesDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IncludesDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+IncludesDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: IncludesDirective, selector: "[includes]", inputs: { includes: "includes", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: IncludesDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IncludesDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[includes]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: IncludesDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { includes: [{
+                type: Input,
+                args: ['includes']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class IntegerDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'integer');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.integer(value)) {
+            return { 'integer': this.mb.call('integer', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+IntegerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IntegerDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+IntegerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: IntegerDirective, selector: "[integer]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: IntegerDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IntegerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[integer]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: IntegerDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class IpDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'ip');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.ip(value)) {
+            return { 'ip': this.mb.call('ip', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+IpDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IpDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+IpDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: IpDirective, selector: "[ip]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: IpDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IpDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ip]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: IpDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class Ipv4Directive {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'ipv4');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.ipv4(value)) {
+            return { 'ipv4': this.mb.call('ipv4', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+Ipv4Directive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: Ipv4Directive, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+Ipv4Directive.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: Ipv4Directive, selector: "[ipv4]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: Ipv4Directive, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: Ipv4Directive, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ipv4]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: Ipv4Directive, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class Ipv6Directive {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'ipv6');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!this.utl.ipv6(value) && !!value) {
+            return { 'ipv6': this.mb.call('ipv6', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+Ipv6Directive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: Ipv6Directive, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+Ipv6Directive.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: Ipv6Directive, selector: "[ipv6]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: Ipv6Directive, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: Ipv6Directive, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ipv6]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: Ipv6Directive, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class JsonDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'json');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.json(value)) {
+            return { 'json': this.mb.call('json', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+JsonDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: JsonDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+JsonDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: JsonDirective, selector: "[json]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: JsonDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: JsonDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[json]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: JsonDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class MaxDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'max');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        let fnName = 'max.string';
+        if (this.utl.integer(value)) {
+            fnName = 'max.numeric';
+        }
+        if (this.utl.array(value)) {
+            fnName = 'max.array';
+        }
+        if (!this.utl.max(value, this.max) && !!value) {
+            return { 'max': this.mb.call(fnName, this.fieldName, this.max, this.vmessage) };
+        }
+        return null;
+    }
+}
+MaxDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MaxDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+MaxDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: MaxDirective, selector: "[max]", inputs: { max: "max", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: MaxDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MaxDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[max]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: MaxDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { max: [{
+                type: Input,
+                args: ['max']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class MinDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'min');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        let fnName = 'min.string';
+        if (this.utl.integer(value)) {
+            fnName = 'min.numeric';
+        }
+        if (this.utl.array(value)) {
+            fnName = 'min.array';
+        }
+        if (!!value && !this.utl.min(value, this.min)) {
+            return { 'min': this.mb.call(fnName, this.fieldName, this.min, this.vmessage) };
+        }
+        return null;
+    }
+}
+MinDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MinDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+MinDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: MinDirective, selector: "[min]", inputs: { min: "min", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: MinDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MinDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[min]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: MinDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { min: [{
+                type: Input,
+                args: ['min']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class NotEqualsDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'not_equals');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.notEquals(value, this.notEquals)) {
+            return { 'not_equals': this.mb.call('not_equals', this.fieldName, this.notEquals, this.vmessage) };
+        }
+        return null;
+    }
+}
+NotEqualsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NotEqualsDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+NotEqualsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: NotEqualsDirective, selector: "[notEquals]", inputs: { notEquals: "notEquals", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: NotEqualsDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NotEqualsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[notEquals]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: NotEqualsDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { notEquals: [{
+                type: Input,
+                args: ['notEquals']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class NotInDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.notIn = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'not_in');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.notIn(value, this.notIn)) {
+            return { 'not_in': this.mb.call('not_in', this.fieldName, this.notIn, this.vmessage) };
+        }
+        return null;
+    }
+}
+NotInDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NotInDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+NotInDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: NotInDirective, selector: "[notIn]", inputs: { notIn: "notIn", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: NotInDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NotInDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[notIn]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: NotInDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { notIn: [{
+                type: Input,
+                args: ['notIn']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class NumberDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'number');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.number(value)) {
+            return { 'number': this.mb.call('number', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+NumberDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NumberDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+NumberDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: NumberDirective, selector: "[number]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: NumberDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NumberDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[number]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: NumberDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class RangeDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.range = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'range');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!this.utl.range(value, this.range) && !!value) {
+            return { 'range': this.mb.call('range', this.fieldName, ...toArray(this.range), this.vmessage) };
+        }
+        return null;
+    }
+}
+RangeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RangeDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+RangeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RangeDirective, selector: "[range]", inputs: { range: "range", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RangeDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RangeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[range]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RangeDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { range: [{
+                type: Input,
+                args: ['range']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class BetweenDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.between = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'range');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!this.utl.between(value, this.between) && !!value) {
+            return { 'between': this.mb.call('between', this.fieldName, ...toArray(this.between), this.vmessage) };
+        }
+        return null;
+    }
+}
+BetweenDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: BetweenDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+BetweenDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: BetweenDirective, selector: "[between]", inputs: { between: "between", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: BetweenDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: BetweenDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[between]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: BetweenDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { between: [{
+                type: Input,
+                args: ['between']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class RegexDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.regex = '';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'regex');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.regex(value, this.regex)) {
+            return { 'regex': this.mb.call('regex', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+RegexDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RegexDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+RegexDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RegexDirective, selector: "[regex]", inputs: { regex: "regex", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RegexDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RegexDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[regex]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RegexDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { regex: [{
+                type: Input,
+                args: ['regex']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class SameDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.destroy$ = new Subject();
+        this.wired = false;
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'same');
+        this.wireSiblingWatchers(control);
+        return this.isValid(control, this.same);
+    }
+    isValid(control, args) {
+        if (!this.utl.same(control, args) && !!control.value) {
+            return { 'same': this.mb.call('same', this.fieldName, this.same, this.vmessage) };
+        }
+        return null;
+    }
+    wireSiblingWatchers(control) {
+        if (this.wired)
+            return;
+        let sibling = control.root.get(this.same);
+        if (!sibling)
+            return;
+        this.wired = true;
+        sibling.valueChanges.pipe(debounceTime(200), takeUntil(this.destroy$))
+            .subscribe(() => control.updateValueAndValidity({ onlySelf: true }));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+SameDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SameDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+SameDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: SameDirective, selector: "[same]", inputs: { same: "same", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: SameDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SameDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[same]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: SameDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { same: [{
+                type: Input,
+                args: ['same']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class StartsWithDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.startsWith = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'starts_with');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.startsWith(value, this.startsWith)) {
+            return { 'starts_with': this.mb.call('starts_with', this.fieldName, this.startsWith, this.vmessage) };
+        }
+        return null;
+    }
+}
+StartsWithDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: StartsWithDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+StartsWithDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: StartsWithDirective, selector: "[startsWith]", inputs: { startsWith: "startsWith", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: StartsWithDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: StartsWithDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[startsWith]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: StartsWithDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { startsWith: [{
+                type: Input,
+                args: ['startsWith']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class StringDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'string');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!this.utl.string(value) && !!value) {
+            return { 'string': this.mb.call('string', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+StringDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: StringDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+StringDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: StringDirective, selector: "[string]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: StringDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: StringDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[string]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: StringDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class UnderDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'under');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.under(value, this.under)) {
+            return { 'under': this.mb.call('under', this.fieldName, this.under, this.vmessage) };
+        }
+        return null;
+    }
+}
+UnderDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UnderDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+UnderDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: UnderDirective, selector: "[under]", inputs: { under: "under", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: UnderDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UnderDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[under]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: UnderDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { under: [{
+                type: Input,
+                args: ['under']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class UrlDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'url');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.url(value)) {
+            return { 'url': this.mb.call('url', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+UrlDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UrlDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+UrlDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: UrlDirective, selector: "[url]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: UrlDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UrlDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[url]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: UrlDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class AlphaDashDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'alpha_dash');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.alphaDash(value)) {
+            return { 'alpha_dash': this.mb.call('alpha_dash', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+AlphaDashDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AlphaDashDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+AlphaDashDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: AlphaDashDirective, selector: "[alphaDash]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: AlphaDashDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: AlphaDashDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[alphaDash]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: AlphaDashDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class NotRegexDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.notRegex = '';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'not_regex');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.notRegex(value, this.notRegex)) {
+            return { 'not_regex': this.mb.call('not_regex', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+NotRegexDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NotRegexDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+NotRegexDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: NotRegexDirective, selector: "[notRegex]", inputs: { notRegex: "notRegex", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: NotRegexDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NotRegexDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[notRegex]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: NotRegexDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { notRegex: [{
+                type: Input,
+                args: ['notRegex']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class UuidDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'uuid');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.uuid(value)) {
+            return { 'uuid': this.mb.call('uuid', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+UuidDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UuidDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+UuidDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: UuidDirective, selector: "[uuid]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: UuidDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UuidDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[uuid]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: UuidDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class UniqueDirective {
+    constructor(el, utl, mb) {
+        this.el = el;
+        this.utl = utl;
+        this.mb = mb;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'unique');
+        return control.valueChanges.pipe(debounceTime(200), distinctUntilChanged(), switchMap((value) => value ? this.isValid(value) : of(null)), first());
+    }
+    isValid(value) {
+        let cloned = cloneDeep(this.unique);
+        let request = { ...{ [this.unique.field || this.fieldName]: value }, ...cloned['request'] };
+        let unique = Object.assign(cloned, { request });
+        return this.utl.unique(unique).pipe(map$1((isValid) => {
+            return !isValid ? { 'unique': this.mb.call('unique', this.fieldName, this.vmessage) } : null;
+        }));
+    }
+}
+UniqueDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UniqueDirective, deps: [{ token: i0.ElementRef }, { token: UtilService }, { token: MessageBuilderService }], target: i0.ɵɵFactoryTarget.Directive });
+UniqueDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: UniqueDirective, selector: "[unique]", inputs: { unique: "unique", message: "message" }, providers: [{ provide: NG_ASYNC_VALIDATORS, useExisting: UniqueDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UniqueDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[unique]',
+                    providers: [{ provide: NG_ASYNC_VALIDATORS, useExisting: UniqueDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: UtilService }, { type: MessageBuilderService }]; }, propDecorators: { unique: [{
+                type: Input,
+                args: ['unique']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class CreditCardDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'credit_card', {
+            credit_card: this.utl.getCreditCardData(control.value)
+        });
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.creditCard(value)) {
+            return { 'credit_card': this.mb.call('credit_card', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+CreditCardDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CreditCardDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+CreditCardDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: CreditCardDirective, selector: "[creditCard]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: CreditCardDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CreditCardDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[creditCard]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: CreditCardDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class DebitCardDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'debit_card', {
+            debit_card: this.utl.getCreditCardData(control.value)
+        });
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.debitCard(value)) {
+            return { 'debit_card': this.mb.call('debit_card', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+DebitCardDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DebitCardDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+DebitCardDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: DebitCardDirective, selector: "[debitCard]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: DebitCardDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DebitCardDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[debitCard]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: DebitCardDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class CvvDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'cvv');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.cvv(value)) {
+            return { 'cvv': this.mb.call('cvv', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+CvvDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CvvDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+CvvDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: CvvDirective, selector: "[cvv]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: CvvDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CvvDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cvv]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: CvvDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class StrengthDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.strength = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'strength', {
+            strength: this.utl.getStrengthData(control.value, this.strength)
+        });
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.strength(value, this.strength)) {
+            return { 'strength': this.mb.call('strength', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+StrengthDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: StrengthDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+StrengthDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: StrengthDirective, selector: "[strength]", inputs: { strength: "strength", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: StrengthDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: StrengthDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[strength]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: StrengthDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { strength: [{
+                type: Input,
+                args: ['strength']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class PhoneNoDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.PhoneNo = null;
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'phone_no');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.phoneNo(value, this.PhoneNo)) {
+            return { 'phone_no': this.mb.call('phone_no', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+PhoneNoDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PhoneNoDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+PhoneNoDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: PhoneNoDirective, selector: "[PhoneNo]", inputs: { PhoneNo: "PhoneNo", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: PhoneNoDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PhoneNoDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[PhoneNo]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: PhoneNoDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { PhoneNo: [{
+                type: Input,
+                args: ['PhoneNo']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class RequiredDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'required');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!this.utl.required(value)) {
+            return { 'required': this.mb.call('required', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+RequiredDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+RequiredDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RequiredDirective, selector: "[required]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RequiredDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[required]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RequiredDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class RequiredIfDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.destroy$ = new Subject();
+        this.wired = false;
+        this.fieldName = 'field';
+        this.requiredIf = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'required_if');
+        this.wireSiblingWatchers(control);
+        return this.isValid(control, this.requiredIf);
+    }
+    isValid(control, args) {
+        if (!this.utl.requiredIf(control, args)) {
+            let _args = toArray(args);
+            return { 'required_if': this.mb.call('required_if', this.fieldName, ..._args, this.vmessage) };
+        }
+        return null;
+    }
+    wireSiblingWatchers(control) {
+        if (this.wired)
+            return;
+        let [name, ...args] = toArray(this.requiredIf);
+        let sibling = control.root.get(name);
+        if (!sibling)
+            return;
+        this.wired = true;
+        sibling.valueChanges.pipe(debounceTime(200), takeUntil(this.destroy$))
+            .subscribe(() => control.updateValueAndValidity({ onlySelf: true }));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+RequiredIfDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredIfDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+RequiredIfDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RequiredIfDirective, selector: "[requiredIf]", inputs: { requiredIf: "requiredIf", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RequiredIfDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredIfDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[requiredIf]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RequiredIfDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { requiredIf: [{
+                type: Input,
+                args: ['requiredIf']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class RequiredUnlessDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.destroy$ = new Subject();
+        this.wired = false;
+        this.fieldName = 'field';
+        this.requiredUnless = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'required_unless');
+        this.wireSiblingWatchers(control);
+        return this.isValid(control, this.requiredUnless);
+    }
+    isValid(control, args) {
+        if (!this.utl.requiredUnless(control, args)) {
+            return { 'required_unless': this.mb.call('required_unless', this.fieldName, ...toArray(args), this.vmessage) };
+        }
+        return null;
+    }
+    wireSiblingWatchers(control) {
+        if (this.wired)
+            return;
+        let [name, ...args] = toArray(this.requiredUnless);
+        let sibling = control.root.get(name);
+        if (!sibling)
+            return;
+        this.wired = true;
+        sibling.valueChanges.pipe(debounceTime(200), takeUntil(this.destroy$))
+            .subscribe(() => control.updateValueAndValidity({ onlySelf: true }));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+RequiredUnlessDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredUnlessDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+RequiredUnlessDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RequiredUnlessDirective, selector: "[requiredUnless]", inputs: { requiredUnless: "requiredUnless", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RequiredUnlessDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredUnlessDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[requiredUnless]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RequiredUnlessDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { requiredUnless: [{
+                type: Input,
+                args: ['requiredUnless']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class RequiredWithDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.destroy$ = new Subject();
+        this.wired = false;
+        this.fieldName = 'field';
+        this.requiredWith = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'required_with');
+        this.wireSiblingWatchers(control);
+        return this.isValid(control, this.requiredWith);
+    }
+    isValid(control, args) {
+        if (!this.utl.requiredWith(control, args)) {
+            return { 'required_with': this.mb.call('required_with', this.fieldName, ...toArray(args), this.vmessage) };
+        }
+        return null;
+    }
+    wireSiblingWatchers(control) {
+        if (this.wired)
+            return;
+        let names = toArray(this.requiredWith);
+        let siblings = names.map(name => control.root.get(name));
+        if (siblings.filter(Boolean).length !== names.length)
+            return;
+        this.wired = true;
+        siblings.forEach(sibling => {
+            sibling.valueChanges.pipe(debounceTime(200), takeUntil(this.destroy$))
+                .subscribe(() => control.updateValueAndValidity({ onlySelf: true }));
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+RequiredWithDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+RequiredWithDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RequiredWithDirective, selector: "[requiredWith]", inputs: { requiredWith: "requiredWith", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[requiredWith]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { requiredWith: [{
+                type: Input,
+                args: ['requiredWith']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class RequiredWithAllDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.destroy$ = new Subject();
+        this.wired = false;
+        this.fieldName = 'field';
+        this.requiredWithAll = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'required_with_all');
+        this.wireSiblingWatchers(control);
+        return this.isValid(control, this.requiredWithAll);
+    }
+    isValid(control, args) {
+        if (!this.utl.requiredWithAll(control, args)) {
+            return { 'required_with_all': this.mb.call('required_with_all', this.fieldName, ...toArray(args), this.vmessage) };
+        }
+        return null;
+    }
+    wireSiblingWatchers(control) {
+        if (this.wired)
+            return;
+        let names = toArray(this.requiredWithAll);
+        let siblings = names.map(name => control.root.get(name));
+        if (siblings.filter(Boolean).length !== names.length)
+            return;
+        this.wired = true;
+        siblings.forEach(sibling => {
+            sibling.valueChanges.pipe(debounceTime(200), takeUntil(this.destroy$))
+                .subscribe(() => control.updateValueAndValidity({ onlySelf: true }));
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+RequiredWithAllDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithAllDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+RequiredWithAllDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RequiredWithAllDirective, selector: "[requiredWithAll]", inputs: { requiredWithAll: "requiredWithAll", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithAllDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithAllDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[requiredWithAll]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithAllDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { requiredWithAll: [{
+                type: Input,
+                args: ['requiredWithAll']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class RequiredWithoutDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.destroy$ = new Subject();
+        this.wired = false;
+        this.fieldName = 'field';
+        this.requiredWithout = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'required_without');
+        this.wireSiblingWatchers(control);
+        return this.isValid(control, this.requiredWithout);
+    }
+    isValid(control, args) {
+        if (!this.utl.requiredWithout(control, args)) {
+            return { 'required_without': this.mb.call('required_without', this.fieldName, ...toArray(args), this.vmessage) };
+        }
+        return null;
+    }
+    wireSiblingWatchers(control) {
+        if (this.wired)
+            return;
+        let names = toArray(this.requiredWithout);
+        let siblings = names.map(name => control.root.get(name));
+        if (siblings.filter(Boolean).length !== names.length)
+            return;
+        this.wired = true;
+        siblings.forEach(sibling => {
+            sibling.valueChanges.pipe(debounceTime(200), takeUntil(this.destroy$))
+                .subscribe(() => control.updateValueAndValidity({ onlySelf: true }));
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+RequiredWithoutDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithoutDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+RequiredWithoutDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RequiredWithoutDirective, selector: "[requiredWithout]", inputs: { requiredWithout: "requiredWithout", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithoutDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithoutDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[requiredWithout]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithoutDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { requiredWithout: [{
+                type: Input,
+                args: ['requiredWithout']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class RequiredWithoutAllDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.destroy$ = new Subject();
+        this.wired = false;
+        this.fieldName = 'field';
+        this.requiredWithoutAll = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'required_without_all');
+        this.wireSiblingWatchers(control);
+        return this.isValid(control, this.requiredWithoutAll);
+    }
+    isValid(control, args) {
+        if (!this.utl.requiredWithoutAll(control, args)) {
+            return { 'required_without_all': this.mb.call('required_without_all', this.fieldName, ...toArray(args), this.vmessage) };
+        }
+        return null;
+    }
+    wireSiblingWatchers(control) {
+        if (this.wired)
+            return;
+        let names = toArray(this.requiredWithoutAll);
+        let siblings = names.map(name => control.root.get(name));
+        if (siblings.filter(Boolean).length !== names.length)
+            return;
+        this.wired = true;
+        siblings.forEach(sibling => {
+            sibling.valueChanges.pipe(debounceTime(200), takeUntil(this.destroy$))
+                .subscribe(() => control.updateValueAndValidity({ onlySelf: true }));
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+RequiredWithoutAllDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithoutAllDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+RequiredWithoutAllDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RequiredWithoutAllDirective, selector: "[requiredWithoutAll]", inputs: { requiredWithoutAll: "requiredWithoutAll", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithoutAllDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithoutAllDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[requiredWithoutAll]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithoutAllDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { requiredWithoutAll: [{
+                type: Input,
+                args: ['requiredWithoutAll']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class MimesDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.mimes = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'mimes');
+        return this.isValid(this.el.nativeElement.files, this.mimes);
+    }
+    isValid(fileInstance, mimes) {
+        if (!!fileInstance && fileInstance.length > 0 && this.utl.mimes(fileInstance, mimes)) {
+            let _mimes = toArray(mimes);
+            return { 'mimes': this.mb.call('mimes', this.fieldName, ..._mimes, this.vmessage) };
+        }
+        return null;
+    }
+}
+MimesDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MimesDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+MimesDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: MimesDirective, selector: "[mimes]", inputs: { mimes: "mimes", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: MimesDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MimesDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[mimes]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: MimesDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { mimes: [{
+                type: Input,
+                args: ['mimes']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class SizeDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'mimes');
+        return this.isValid(this.el.nativeElement.files, this.size);
+    }
+    isValid(fileInstance, mimes) {
+        if (!!fileInstance && fileInstance.length > 0 && !this.utl.size(fileInstance, mimes)) {
+            return { 'size': this.mb.call('size', this.fieldName, mimes, this.vmessage) };
+        }
+        return null;
+    }
+}
+SizeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SizeDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+SizeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: SizeDirective, selector: "[size]", inputs: { size: "size", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: SizeDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SizeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[size]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: SizeDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { size: [{
+                type: Input,
+                args: ['size']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class DimensionDirective {
+    constructor(el, utl, mb) {
+        this.el = el;
+        this.utl = utl;
+        this.mb = mb;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.dimension = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'dimension');
+        return this.isValid();
+    }
+    isValid() {
+        let files = this.el.nativeElement.files;
+        if (files.length === 0) {
+            return of(null);
+        }
+        return this.utl.dimension(files, this.dimension).pipe(map$1((isValid) => {
+            return !isValid ? { 'dimension': this.mb.call('dimension', this.fieldName, this.dimension, this.vmessage) } : null;
+        }));
+    }
+}
+DimensionDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DimensionDirective, deps: [{ token: i0.ElementRef }, { token: UtilService }, { token: MessageBuilderService }], target: i0.ɵɵFactoryTarget.Directive });
+DimensionDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: DimensionDirective, selector: "[dimension]", inputs: { dimension: "dimension", message: "message" }, providers: [{ provide: NG_ASYNC_VALIDATORS, useExisting: DimensionDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DimensionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dimension]',
+                    providers: [{ provide: NG_ASYNC_VALIDATORS, useExisting: DimensionDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: UtilService }, { type: MessageBuilderService }]; }, propDecorators: { dimension: [{
+                type: Input,
+                args: ['dimension']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class ImageDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'image');
+        return this.isValid(this.el.nativeElement.files);
+    }
+    isValid(fileInstance) {
+        if (!!fileInstance && fileInstance.length > 0 && !this.utl.image(fileInstance)) {
+            return { 'image': this.mb.call('image', this.fieldName, this.message) };
+        }
+        return null;
+    }
+}
+ImageDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+ImageDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: ImageDirective, selector: "[image]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: ImageDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[image]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: ImageDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class VideoDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'video');
+        return this.isValid(this.el.nativeElement.files);
+    }
+    isValid(fileInstance) {
+        if (!!fileInstance && fileInstance.length > 0 && !this.utl.video(fileInstance)) {
+            return { 'video': this.mb.call('video', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+VideoDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: VideoDirective, deps: [{ token: MessageBuilderService }, { token: i0.ElementRef }, { token: UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+VideoDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: VideoDirective, selector: "[video]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: VideoDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: VideoDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[video]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: VideoDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: MessageBuilderService }, { type: i0.ElementRef }, { type: UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+class ExistsDirective {
+    constructor(el, utl, mb) {
+        this.el = el;
+        this.utl = utl;
+        this.mb = mb;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'exists');
+        return control.valueChanges.pipe(debounceTime(200), distinctUntilChanged$1(), switchMap((value) => value ? this.isValid(value) : of(null)), first$1());
+    }
+    isValid(value) {
+        let cloned = cloneDeep(this.exists);
+        let request = { ...{ [this.exists.field || this.fieldName]: value }, ...cloned['request'] };
+        let exists = Object.assign(cloned, { request });
+        return this.utl.exists(exists).pipe(map$1((isValid) => {
+            return !isValid ? { 'exists': this.mb.call('exists', this.fieldName, this.vmessage) } : null;
+        }));
+    }
+}
+ExistsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ExistsDirective, deps: [{ token: i0.ElementRef }, { token: UtilService }, { token: MessageBuilderService }], target: i0.ɵɵFactoryTarget.Directive });
+ExistsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: ExistsDirective, selector: "[exists]", inputs: { exists: "exists", message: "message" }, providers: [{ provide: NG_ASYNC_VALIDATORS, useExisting: ExistsDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ExistsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[exists]',
+                    providers: [{ provide: NG_ASYNC_VALIDATORS, useExisting: ExistsDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: UtilService }, { type: MessageBuilderService }]; }, propDecorators: { exists: [{
+                type: Input,
+                args: ['exists']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+
+const rulesDirectives = [
+    RuleDirective,
+    RequiredDirective, AboveDirective, AcceptedDirective, AfterDirective,
+    AlphaDirective, AlphaNumericDirective, ArrayDirective, UrlDirective,
+    DateDirective, BeforeDirective, BooleanDirective, ConfirmedDirective,
+    DateFormatDirective, DifferentDirective, EmailDirective, InDirective,
+    EqualsDirective, EndsWithDirective, IncludesDirective, Ipv4Directive,
+    SameDirective, IpDirective, Ipv6Directive, JsonDirective, MaxDirective,
+    MinDirective, NotEqualsDirective, NotInDirective, StartsWithDirective,
+    RangeDirective, BetweenDirective, RegexDirective, IntegerDirective,
+    NumberDirective, StringDirective, UnderDirective, NotRegexDirective,
+    UuidDirective, UniqueDirective, CreditCardDirective, DebitCardDirective,
+    CvvDirective, StrengthDirective, PhoneNoDirective, RequiredIfDirective,
+    RequiredUnlessDirective, RequiredWithDirective, RequiredWithAllDirective,
+    RequiredWithoutDirective, RequiredWithoutAllDirective, MimesDirective,
+    SizeDirective, DimensionDirective, ImageDirective, VideoDirective,
+    ExistsDirective, AlphaDashDirective
+];
+class RuleModule {
+}
+RuleModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RuleModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+RuleModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: RuleModule, declarations: [RuleDirective,
+        RequiredDirective, AboveDirective, AcceptedDirective, AfterDirective,
+        AlphaDirective, AlphaNumericDirective, ArrayDirective, UrlDirective,
+        DateDirective, BeforeDirective, BooleanDirective, ConfirmedDirective,
+        DateFormatDirective, DifferentDirective, EmailDirective, InDirective,
+        EqualsDirective, EndsWithDirective, IncludesDirective, Ipv4Directive,
+        SameDirective, IpDirective, Ipv6Directive, JsonDirective, MaxDirective,
+        MinDirective, NotEqualsDirective, NotInDirective, StartsWithDirective,
+        RangeDirective, BetweenDirective, RegexDirective, IntegerDirective,
+        NumberDirective, StringDirective, UnderDirective, NotRegexDirective,
+        UuidDirective, UniqueDirective, CreditCardDirective, DebitCardDirective,
+        CvvDirective, StrengthDirective, PhoneNoDirective, RequiredIfDirective,
+        RequiredUnlessDirective, RequiredWithDirective, RequiredWithAllDirective,
+        RequiredWithoutDirective, RequiredWithoutAllDirective, MimesDirective,
+        SizeDirective, DimensionDirective, ImageDirective, VideoDirective,
+        ExistsDirective, AlphaDashDirective], imports: [CommonModule], exports: [RuleDirective,
+        RequiredDirective, AboveDirective, AcceptedDirective, AfterDirective,
+        AlphaDirective, AlphaNumericDirective, ArrayDirective, UrlDirective,
+        DateDirective, BeforeDirective, BooleanDirective, ConfirmedDirective,
+        DateFormatDirective, DifferentDirective, EmailDirective, InDirective,
+        EqualsDirective, EndsWithDirective, IncludesDirective, Ipv4Directive,
+        SameDirective, IpDirective, Ipv6Directive, JsonDirective, MaxDirective,
+        MinDirective, NotEqualsDirective, NotInDirective, StartsWithDirective,
+        RangeDirective, BetweenDirective, RegexDirective, IntegerDirective,
+        NumberDirective, StringDirective, UnderDirective, NotRegexDirective,
+        UuidDirective, UniqueDirective, CreditCardDirective, DebitCardDirective,
+        CvvDirective, StrengthDirective, PhoneNoDirective, RequiredIfDirective,
+        RequiredUnlessDirective, RequiredWithDirective, RequiredWithAllDirective,
+        RequiredWithoutDirective, RequiredWithoutAllDirective, MimesDirective,
+        SizeDirective, DimensionDirective, ImageDirective, VideoDirective,
+        ExistsDirective, AlphaDashDirective] });
+RuleModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RuleModule, providers: [
+        UtilService,
+        ValidateRuleService,
+        MessageBuilderService,
+    ], imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RuleModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ...rulesDirectives
+                    ],
+                    imports: [
+                        CommonModule
+                    ],
+                    providers: [
+                        UtilService,
+                        ValidateRuleService,
+                        MessageBuilderService,
+                    ],
+                    exports: [
+                        ...rulesDirectives
+                    ],
+                }]
+        }] });
+
+class ReactiveValidator {
+    constructor(rule, utl, mb) {
+        this.rule = rule;
+        this.utl = utl;
+        this.mb = mb;
+        this.fieldDefaultNameRule = GlobalConstant.fieldDefaultNameRule;
+        this.customFieldName = GlobalConstant.customFieldName;
+    }
+    map(rule, message = {}) {
+        return (control) => {
+            let ctrlName = control[this.customFieldName] ?? (control[this.customFieldName] = this.getControlName(control));
+            return ctrlName ? this.rule.gererateRuleAndValidate(ctrlName, control, rule, message) : null;
+        };
+    }
+    unique(exists, message = {}) {
+        return (control) => {
+            if (!this || !this.customFieldName)
+                return of(null);
+            let fieldName = control[this.customFieldName] || null;
+            exists['request'] = { ...{ [exists.field || fieldName]: control.value }, ...exists['request'] };
+            return this.utl.exists(exists).pipe(map$1((isValid) => {
+                return !isValid ? { 'unique': this.mb.call('unique', fieldName, message) } : null;
+            }));
+        };
+    }
+    exists(exists, message = {}) {
+        return (control) => {
+            if (!this || !this.customFieldName)
+                return of(null);
+            let fieldName = control[this.customFieldName] || null;
+            exists['request'] = { ...{ [exists.field || fieldName]: control.value }, ...exists['request'] };
+            return this.utl.exists(exists).pipe(map$1((isValid) => {
+                return !isValid ? { 'exists': this.mb.call('exists', fieldName, message) } : null;
+            }));
+        };
+    }
+    dimension(args, message = {}) {
+        return (control) => {
+            if (!this || !this.customFieldName)
+                return of(null);
+            let fileInstance = control['nativeElement'] ? control['nativeElement'].files : null;
+            let fieldName = control[this.customFieldName] || null;
+            return this.utl.dimension(fileInstance, args).pipe(map$1((isValid) => {
+                return !isValid ? { 'dimension': this.mb.call('dimension', fieldName, args, message) } : null;
+            }));
+        };
+    }
+    getControlName(control) {
+        const parent = control.parent;
+        if (!parent)
+            return null;
+        const controls = parent.controls;
+        const name = Object.keys(controls).find(key => controls[key] === control);
+        return name ?? null;
+    }
+}
+ReactiveValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ReactiveValidator, deps: [{ token: ValidateRuleService }, { token: UtilService }, { token: MessageBuilderService }], target: i0.ɵɵFactoryTarget.Injectable });
+ReactiveValidator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ReactiveValidator });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ReactiveValidator, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: ValidateRuleService }, { type: UtilService }, { type: MessageBuilderService }]; } });
+
+class NativeElementDirective {
+    constructor(el, control) {
+        this.el = el;
+        this.control = control;
+        this.field_name = '';
+        this.setNativElement();
+    }
+    setNativElement() {
+        //setTimeout(()=>{
+        let customElementName = GlobalConstant.customElementName;
+        let customFieldName = GlobalConstant.customFieldName;
+        if (this.control && this.control.control) {
+            this.control.control[customElementName] = this.el.nativeElement;
+            this.control.control[customFieldName] = this.el.nativeElement.name || this.field_name;
+        }
+        //})
+    }
+}
+NativeElementDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NativeElementDirective, deps: [{ token: i0.ElementRef }, { token: i1$2.NgControl }], target: i0.ɵɵFactoryTarget.Directive });
+NativeElementDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: NativeElementDirective, selector: "[formControl],[formControlName]", inputs: { field_name: ["formControlName", "field_name"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NativeElementDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[formControl],[formControlName]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1$2.NgControl }]; }, propDecorators: { field_name: [{
+                type: Input,
+                args: ['formControlName']
+            }] } });
+
+var en = {
+    "above": "The :attribute should be above :arg0.",
+    "accepted": "The :attribute must be accepted.",
+    "after": "The :attribute must be a date after :arg0.",
+    "alpha": "The :attribute may only contain letters.",
+    "alpha_dash": "The :attribute may only contain letters, numbers, dashes and underscores.",
+    "alpha_numeric": "The :attribute may only contain letters and numbers.",
+    "array": "The :attribute must be an array.",
+    "before": "The :attribute must be a date before :arg0.",
+    "boolean": "The :attribute field must be true or false.",
+    "confirmed": "The :attribute confirmation does not match.",
+    "credit_card": "The :attribute must be a valid credit card number.",
+    "cvv": "The :attribute must be a valid CVV number.",
+    "date": "The :attribute is not a valid date.",
+    "date_format": "The :attribute does not match the format :arg0.",
+    "debit_card": "The :attribute must be a valid debit card number.",
+    "different": "The :attribute and :arg0 must be different.",
+    "dimension": "The :attribute has invalid image dimension.",
+    "email": "The :attribute must be a valid email address.",
+    "ends_with": "The :attribute must end with one of the following :arg0:",
+    "equals": "The :attribute must be equal with :arg0",
+    "exists": "The selected :attribute is invalid.",
+    "image": "The :attribute must be a valid image.",
+    "in": "The selected :attribute must be in :arg0:.",
+    "includes": "The :attribute must be contain with :arg0:.",
+    "integer": "The :attribute must be an integer.",
+    "ip": "The :attribute must be a valid IP address.",
+    "ipv4": "The :attribute must be a valid IPv4 address.",
+    "ipv6": "The :attribute must be a valid IPv6 address.",
+    "json": "The :attribute must be a valid JSON string.",
+    "max": {
+        "array": "The :attribute may not have more than :arg0 items.",
+        "numeric": "The :attribute may not be greater than :arg0.",
+        "string": "The :attribute may not be greater than :arg0 characters."
+    },
+    "min": {
+        "array": "The :attribute must have at least :arg0 items.",
+        "numeric": "The :attribute must be at least :arg0.",
+        "string": "The :attribute must be at least :arg0 characters."
+    },
+    "mimes": "The :attribute must be a file of type :arg0:.",
+    "not_equals": "The :attribute must not be equal with :arg0",
+    "not_in": "The selected :attribute must not be in :arg0:.",
+    "not_regex": "The :attribute format is invalid.",
+    "number": "The :attribute must be a number.",
+    "phone_no": "The :attribute must be a valid phone number.",
+    "range": "The :attribute must be between :arg0 and :arg1.",
+    "between": "The :attribute must be between :arg0 and :arg1, exclusive of both.",
+    "regex": "The :attribute format is invalid.",
+    "required": "The :attribute field is required.",
+    "required_if": "The :attribute field is required when :arg0 is :arg1.",
+    "required_unless": "The :attribute field is required unless :arg0 is in :arg1:.",
+    "required_with": "The :attribute field is required when any of :arg0: is present.",
+    "required_with_all": "The :attribute field is required when :arg0: are present.",
+    "required_without": "The :attribute field is required when :arg0: is not present.",
+    "required_without_all": "The :attribute field is required when none of :arg0: are present.",
+    "same": "The :attribute and :arg0 must match.",
+    "size": "The :attribute must be :arg0 KB or less.",
+    "starts_with": "The :attribute must start with one of the following :arg0",
+    "string": "The :attribute must be a string.",
+    "strength": "The :attribute is not strong enough.",
+    "under": "The :attribute must be under :arg0.",
+    "url": "The :attribute format is invalid.",
+    "uuid": "The :attribute must be a valid UUID.",
+    "unique": "The :attribute has already been taken.",
+    "video": "The :attribute must be a valid video."
+};
+
+var de = {
+    "above": "Das Feld :attribute muss über :arg0 liegen.",
+    "accepted": "Das Feld :attribute muss akzeptiert werden.",
+    "after": "Das Feld :attribute muss ein Datum nach :arg0 sein.",
+    "alpha": "Das Feld :attribute darf nur Buchstaben enthalten.",
+    "alpha_dash": "Das Feld :attribute darf nur Buchstaben, Zahlen, Bindestriche und Unterstriche enthalten.",
+    "alpha_numeric": "Das Feld :attribute darf nur Buchstaben und Zahlen enthalten.",
+    "array": "Das Feld :attribute muss ein Array sein.",
+    "before": "Das Feld :attribute muss ein Datum vor :arg0 sein.",
+    "boolean": "Das Feld :attribute muss wahr oder falsch sein.",
+    "confirmed": "Die Bestätigung von :attribute stimmt nicht überein.",
+    "credit_card": "Das Feld :attribute muss eine gültige Kreditkartennummer sein.",
+    "cvv": "Das Feld :attribute muss eine gültige CVV-Nummer sein.",
+    "date": "Das Feld :attribute ist kein gültiges Datum.",
+    "date_format": "Das Feld :attribute entspricht nicht dem Format :arg0.",
+    "debit_card": "Das Feld :attribute muss eine gültige Debitkartennummer sein.",
+    "different": "Die Felder :attribute und :arg0 müssen unterschiedlich sein.",
+    "dimension": "Das Feld :attribute hat eine ungültige Bildgröße.",
+    "email": "Das Feld :attribute muss eine gültige E-Mail-Adresse sein.",
+    "ends_with": "Das Feld :attribute muss mit einem der folgenden Werte enden: :arg0:",
+    "equals": "Das Feld :attribute muss gleich :arg0 sein.",
+    "exists": "Das ausgewählte Feld :attribute ist ungültig.",
+    "image": "Das Feld :attribute muss ein gültiges Bild sein.",
+    "in": "Das ausgewählte Feld :attribute muss in :arg0: enthalten sein.",
+    "includes": "Das Feld :attribute muss :arg0: enthalten.",
+    "integer": "Das Feld :attribute muss eine ganze Zahl sein.",
+    "ip": "Das Feld :attribute muss eine gültige IP-Adresse sein.",
+    "ipv4": "Das Feld :attribute muss eine gültige IPv4-Adresse sein.",
+    "ipv6": "Das Feld :attribute muss eine gültige IPv6-Adresse sein.",
+    "json": "Das Feld :attribute muss eine gültige JSON-Zeichenfolge sein.",
+    "max": {
+        "array": "Das Feld :attribute darf nicht mehr als :arg0 Elemente enthalten.",
+        "numeric": "Das Feld :attribute darf nicht größer als :arg0 sein.",
+        "string": "Das Feld :attribute darf nicht länger als :arg0 Zeichen sein."
+    },
+    "min": {
+        "array": "Das Feld :attribute muss mindestens :arg0 Elemente enthalten.",
+        "numeric": "Das Feld :attribute muss mindestens :arg0 sein.",
+        "string": "Das Feld :attribute muss mindestens :arg0 Zeichen lang sein."
+    },
+    "mimes": "Das Feld :attribute muss eine Datei vom Typ :arg0: sein.",
+    "not_equals": "Das Feld :attribute darf nicht gleich :arg0 sein.",
+    "not_in": "Das ausgewählte Feld :attribute darf nicht in :arg0: enthalten sein.",
+    "not_regex": "Das Format von :attribute ist ungültig.",
+    "number": "Das Feld :attribute muss eine Zahl sein.",
+    "phone_no": "Das Feld :attribute muss eine gültige Telefonnummer sein.",
+    "range": "Das Feld :attribute muss zwischen :arg0 und :arg1 liegen.",
+    "between": "Das :attribute muss zwischen :arg0 und :arg1 liegen, beide ausgeschlossen.",
+    "regex": "Das Format von :attribute ist ungültig.",
+    "required": "Das Feld :attribute ist erforderlich.",
+    "required_if": "Das Feld :attribute ist erforderlich, wenn :arg0 gleich :arg1 ist.",
+    "required_unless": "Das Feld :attribute ist erforderlich, es sei denn, :arg0 ist in :arg1: enthalten.",
+    "required_with": "Das Feld :attribute ist erforderlich, wenn eines der Felder :arg0: vorhanden ist.",
+    "required_with_all": "Das Feld :attribute ist erforderlich, wenn :arg0: vorhanden sind.",
+    "required_without": "Das Feld :attribute ist erforderlich, wenn :arg0: nicht vorhanden ist.",
+    "required_without_all": "Das Feld :attribute ist erforderlich, wenn keines der Felder :arg0: vorhanden ist.",
+    "same": "Die Felder :attribute und :arg0 müssen übereinstimmen.",
+    "size": "Das Feld :attribute darf höchstens :arg0 KB groß sein.",
+    "starts_with": "Das Feld :attribute muss mit einem der folgenden Werte beginnen: :arg0",
+    "string": "Das Feld :attribute muss eine Zeichenfolge sein.",
+    "strength": "Das Feld :attribute ist nicht sicher genug.",
+    "under": "Das Feld :attribute muss unter :arg0 liegen.",
+    "url": "Das Format von :attribute ist ungültig.",
+    "uuid": "Das Feld :attribute muss eine gültige UUID sein.",
+    "unique": "Das Feld :attribute wird bereits verwendet.",
+    "video": "Das Feld :attribute muss ein gültiges Video sein."
+};
+
+var es = {
+    "above": "El campo :attribute debe estar por encima de :arg0.",
+    "accepted": "El campo :attribute debe ser aceptado.",
+    "after": "El campo :attribute debe ser una fecha posterior a :arg0.",
+    "alpha": "El campo :attribute solo puede contener letras.",
+    "alpha_dash": "El campo :attribute solo puede contener letras, números, guiones y guiones bajos.",
+    "alpha_numeric": "El campo :attribute solo puede contener letras y números.",
+    "array": "El campo :attribute debe ser un arreglo.",
+    "before": "El campo :attribute debe ser una fecha anterior a :arg0.",
+    "boolean": "El campo :attribute debe ser verdadero o falso.",
+    "confirmed": "La confirmación de :attribute no coincide.",
+    "credit_card": "El campo :attribute debe ser un número de tarjeta de crédito válido.",
+    "cvv": "El campo :attribute debe ser un número CVV válido.",
+    "date": "El campo :attribute no es una fecha válida.",
+    "date_format": "El campo :attribute no coincide con el formato :arg0.",
+    "debit_card": "El campo :attribute debe ser un número de tarjeta de débito válido.",
+    "different": "Los campos :attribute y :arg0 deben ser diferentes.",
+    "dimension": "El campo :attribute tiene dimensiones de imagen no válidas.",
+    "email": "El campo :attribute debe ser una dirección de correo electrónico válida.",
+    "ends_with": "El campo :attribute debe terminar con uno de los siguientes valores :arg0:",
+    "equals": "El campo :attribute debe ser igual a :arg0",
+    "exists": "El :attribute seleccionado no es válido.",
+    "image": "El campo :attribute debe ser una imagen válida.",
+    "in": "El :attribute seleccionado debe estar entre :arg0:.",
+    "includes": "El campo :attribute debe contener :arg0:.",
+    "integer": "El campo :attribute debe ser un número entero.",
+    "ip": "El campo :attribute debe ser una dirección IP válida.",
+    "ipv4": "El campo :attribute debe ser una dirección IPv4 válida.",
+    "ipv6": "El campo :attribute debe ser una dirección IPv6 válida.",
+    "json": "El campo :attribute debe ser una cadena JSON válida.",
+    "max": {
+        "array": "El campo :attribute no debe tener más de :arg0 elementos.",
+        "numeric": "El campo :attribute no debe ser mayor que :arg0.",
+        "string": "El campo :attribute no debe tener más de :arg0 caracteres."
+    },
+    "min": {
+        "array": "El campo :attribute debe tener al menos :arg0 elementos.",
+        "numeric": "El campo :attribute debe ser al menos :arg0.",
+        "string": "El campo :attribute debe tener al menos :arg0 caracteres."
+    },
+    "mimes": "El campo :attribute debe ser un archivo de tipo :arg0:.",
+    "not_equals": "El campo :attribute no debe ser igual a :arg0",
+    "not_in": "El :attribute seleccionado no debe estar entre :arg0:.",
+    "not_regex": "El formato de :attribute no es válido.",
+    "number": "El campo :attribute debe ser un número.",
+    "phone_no": "El campo :attribute debe ser un número de teléfono válido.",
+    "range": "El campo :attribute debe estar entre :arg0 y :arg1.",
+    "between": "El :attribute debe estar entre :arg0 y :arg1, ambos exclusivos.",
+    "regex": "El formato de :attribute no es válido.",
+    "required": "El campo :attribute es obligatorio.",
+    "required_if": "El campo :attribute es obligatorio cuando :arg0 es :arg1.",
+    "required_unless": "El campo :attribute es obligatorio a menos que :arg0 esté en :arg1:.",
+    "required_with": "El campo :attribute es obligatorio cuando alguno de :arg0: está presente.",
+    "required_with_all": "El campo :attribute es obligatorio cuando :arg0: están presentes.",
+    "required_without": "El campo :attribute es obligatorio cuando :arg0: no está presente.",
+    "required_without_all": "El campo :attribute es obligatorio cuando ninguno de :arg0: está presente.",
+    "same": "Los campos :attribute y :arg0 deben coincidir.",
+    "size": "El campo :attribute debe ser :arg0 KB o menos.",
+    "starts_with": "El campo :attribute debe comenzar con uno de los siguientes valores :arg0",
+    "string": "El campo :attribute debe ser una cadena de texto.",
+    "strength": "El campo :attribute no es lo suficientemente seguro.",
+    "under": "El campo :attribute debe ser menor que :arg0.",
+    "url": "El formato de :attribute no es válido.",
+    "uuid": "El campo :attribute debe ser un UUID válido.",
+    "unique": "El campo :attribute ya ha sido registrado.",
+    "video": "El campo :attribute debe ser un video válido."
+};
+
+var fr = {
+    "above": "Le champ :attribute doit être supérieur à :arg0.",
+    "accepted": "Le champ :attribute doit être accepté.",
+    "after": "Le champ :attribute doit être une date postérieure à :arg0.",
+    "alpha": "Le champ :attribute ne peut contenir que des lettres.",
+    "alpha_dash": "Le champ :attribute ne peut contenir que des lettres, des chiffres, des tirets et des underscores.",
+    "alpha_numeric": "Le champ :attribute ne peut contenir que des lettres et des chiffres.",
+    "array": "Le champ :attribute doit être un tableau.",
+    "before": "Le champ :attribute doit être une date antérieure à :arg0.",
+    "boolean": "Le champ :attribute doit être vrai ou faux.",
+    "confirmed": "La confirmation de :attribute ne correspond pas.",
+    "credit_card": "Le champ :attribute doit être un numéro de carte de crédit valide.",
+    "cvv": "Le champ :attribute doit être un numéro CVV valide.",
+    "date": "Le champ :attribute n'est pas une date valide.",
+    "date_format": "Le champ :attribute ne correspond pas au format :arg0.",
+    "debit_card": "Le champ :attribute doit être un numéro de carte de débit valide.",
+    "different": "Les champs :attribute et :arg0 doivent être différents.",
+    "dimension": "Le champ :attribute a des dimensions d'image non valides.",
+    "email": "Le champ :attribute doit être une adresse e-mail valide.",
+    "ends_with": "Le champ :attribute doit se terminer par l'une des valeurs suivantes :arg0:",
+    "equals": "Le champ :attribute doit être égal à :arg0",
+    "exists": "Le champ :attribute sélectionné n'est pas valide.",
+    "image": "Le champ :attribute doit être une image valide.",
+    "in": "Le champ :attribute sélectionné doit figurer parmi :arg0:.",
+    "includes": "Le champ :attribute doit contenir :arg0:.",
+    "integer": "Le champ :attribute doit être un entier.",
+    "ip": "Le champ :attribute doit être une adresse IP valide.",
+    "ipv4": "Le champ :attribute doit être une adresse IPv4 valide.",
+    "ipv6": "Le champ :attribute doit être une adresse IPv6 valide.",
+    "json": "Le champ :attribute doit être une chaîne JSON valide.",
+    "max": {
+        "array": "Le champ :attribute ne peut pas avoir plus de :arg0 éléments.",
+        "numeric": "Le champ :attribute ne peut pas être supérieur à :arg0.",
+        "string": "Le champ :attribute ne peut pas dépasser :arg0 caractères."
+    },
+    "min": {
+        "array": "Le champ :attribute doit contenir au moins :arg0 éléments.",
+        "numeric": "Le champ :attribute doit être d'au moins :arg0.",
+        "string": "Le champ :attribute doit contenir au moins :arg0 caractères."
+    },
+    "mimes": "Le champ :attribute doit être un fichier de type :arg0:.",
+    "not_equals": "Le champ :attribute ne doit pas être égal à :arg0",
+    "not_in": "Le champ :attribute sélectionné ne doit pas figurer parmi :arg0:.",
+    "not_regex": "Le format de :attribute n'est pas valide.",
+    "number": "Le champ :attribute doit être un nombre.",
+    "phone_no": "Le champ :attribute doit être un numéro de téléphone valide.",
+    "range": "Le champ :attribute doit être compris entre :arg0 et :arg1.",
+    "between": "Le :attribute doit être compris entre :arg0 et :arg1, exclusivement.",
+    "regex": "Le format de :attribute n'est pas valide.",
+    "required": "Le champ :attribute est obligatoire.",
+    "required_if": "Le champ :attribute est obligatoire lorsque :arg0 est :arg1.",
+    "required_unless": "Le champ :attribute est obligatoire à moins que :arg0 ne soit dans :arg1:.",
+    "required_with": "Le champ :attribute est obligatoire lorsque l'un des champs :arg0: est présent.",
+    "required_with_all": "Le champ :attribute est obligatoire lorsque :arg0: sont présents.",
+    "required_without": "Le champ :attribute est obligatoire lorsque :arg0: n'est pas présent.",
+    "required_without_all": "Le champ :attribute est obligatoire lorsque aucun des champs :arg0: n'est présent.",
+    "same": "Les champs :attribute et :arg0 doivent correspondre.",
+    "size": "Le champ :attribute doit faire :arg0 Ko ou moins.",
+    "starts_with": "Le champ :attribute doit commencer par l'une des valeurs suivantes :arg0",
+    "string": "Le champ :attribute doit être une chaîne de caractères.",
+    "strength": "Le champ :attribute n'est pas assez sécurisé.",
+    "under": "Le champ :attribute doit être inférieur à :arg0.",
+    "url": "Le format de :attribute n'est pas valide.",
+    "uuid": "Le champ :attribute doit être un UUID valide.",
+    "unique": "Le champ :attribute est déjà utilisé.",
+    "video": "Le champ :attribute doit être une vidéo valide."
+};
+
+var hi = {
+    "above": ":attribute, :arg0 से अधिक होना चाहिए।",
+    "accepted": ":attribute को स्वीकार करना आवश्यक है।",
+    "after": ":attribute की तारीख :arg0 के बाद की होनी चाहिए।",
+    "alpha": ":attribute में केवल अक्षर होने चाहिए।",
+    "alpha_dash": ":attribute में केवल अक्षर, अंक, डैश (-) और अंडरस्कोर (_) होने चाहिए।",
+    "alpha_numeric": ":attribute में केवल अक्षर और अंक होने चाहिए।",
+    "array": ":attribute एक ऐरे (array) होना चाहिए।",
+    "before": ":attribute की तारीख :arg0 से पहले की होनी चाहिए।",
+    "boolean": ":attribute का मान true या false होना चाहिए।",
+    "confirmed": ":attribute की पुष्टि मेल नहीं खाती।",
+    "credit_card": ":attribute एक मान्य क्रेडिट कार्ड नंबर होना चाहिए।",
+    "cvv": ":attribute एक मान्य CVV नंबर होना चाहिए।",
+    "date": ":attribute एक मान्य तारीख नहीं है।",
+    "date_format": ":attribute प्रारूप :arg0 से मेल नहीं खाता।",
+    "debit_card": ":attribute एक मान्य डेबिट कार्ड नंबर होना चाहिए।",
+    "different": ":attribute और :arg0 अलग-अलग होने चाहिए।",
+    "dimension": ":attribute की इमेज डाइमेंशन मान्य नहीं है।",
+    "email": ":attribute एक मान्य ईमेल पता होना चाहिए।",
+    "ends_with": ":attribute निम्न में से किसी एक के साथ समाप्त होना चाहिए: :arg0:",
+    "equals": ":attribute का मान :arg0 के बराबर होना चाहिए।",
+    "exists": "चयनित :attribute मान्य नहीं है।",
+    "image": ":attribute एक मान्य इमेज होनी चाहिए।",
+    "in": "चयनित :attribute, :arg0: में से एक होना चाहिए।",
+    "includes": ":attribute में :arg0: शामिल होना चाहिए।",
+    "integer": ":attribute एक पूर्णांक (integer) होना चाहिए।",
+    "ip": ":attribute एक मान्य IP पता होना चाहिए।",
+    "ipv4": ":attribute एक मान्य IPv4 पता होना चाहिए।",
+    "ipv6": ":attribute एक मान्य IPv6 पता होना चाहिए।",
+    "json": ":attribute एक मान्य JSON स्ट्रिंग होनी चाहिए।",
+    "max": {
+        "array": ":attribute में :arg0 से अधिक आइटम नहीं होने चाहिए।",
+        "numeric": ":attribute, :arg0 से अधिक नहीं होना चाहिए।",
+        "string": ":attribute, :arg0 वर्णों से अधिक नहीं होना चाहिए।"
+    },
+    "min": {
+        "array": ":attribute में कम से कम :arg0 आइटम होने चाहिए।",
+        "numeric": ":attribute कम से कम :arg0 होना चाहिए।",
+        "string": ":attribute में कम से कम :arg0 वर्ण होने चाहिए।"
+    },
+    "mimes": ":attribute, :arg0: प्रकार की फ़ाइल होनी चाहिए।",
+    "not_equals": ":attribute का मान :arg0 के बराबर नहीं होना चाहिए।",
+    "not_in": "चयनित :attribute, :arg0: में से नहीं होना चाहिए।",
+    "not_regex": ":attribute का प्रारूप अमान्य है।",
+    "number": ":attribute एक संख्या होनी चाहिए।",
+    "phone_no": ":attribute एक मान्य फ़ोन नंबर होना चाहिए।",
+    "range": ":attribute, :arg0 और :arg1 के बीच होना चाहिए।",
+    "between": ":attribute अवश्य :arg0 और :arg1 के बीच होना चाहिए, दोनों को छोड़कर।",
+    "regex": ":attribute का प्रारूप अमान्य है।",
+    "required": ":attribute फ़ील्ड आवश्यक है।",
+    "required_if": "जब :arg0, :arg1 हो, तब :attribute फ़ील्ड आवश्यक है।",
+    "required_unless": ":attribute फ़ील्ड आवश्यक है, जब तक :arg0, :arg1: में न हो।",
+    "required_with": "जब :arg0: में से कोई मौजूद हो, तब :attribute फ़ील्ड आवश्यक है।",
+    "required_with_all": "जब :arg0: मौजूद हों, तब :attribute फ़ील्ड आवश्यक है।",
+    "required_without": "जब :arg0: मौजूद न हो, तब :attribute फ़ील्ड आवश्यक है।",
+    "required_without_all": "जब :arg0: में से कोई भी मौजूद न हो, तब :attribute फ़ील्ड आवश्यक है।",
+    "same": ":attribute और :arg0 एक समान होने चाहिए।",
+    "size": ":attribute अधिकतम :arg0 KB का होना चाहिए।",
+    "starts_with": ":attribute निम्न में से किसी एक से शुरू होना चाहिए: :arg0",
+    "string": ":attribute एक स्ट्रिंग (string) होनी चाहिए।",
+    "strength": ":attribute पर्याप्त मज़बूत नहीं है।",
+    "under": ":attribute, :arg0 से कम होना चाहिए।",
+    "url": ":attribute का प्रारूप अमान्य है।",
+    "uuid": ":attribute एक मान्य UUID होना चाहिए।",
+    "unique": ":attribute पहले से ही उपयोग में है।",
+    "video": ":attribute एक मान्य वीडियो होनी चाहिए।"
+};
+
+var bn = {
+    "above": ":attribute অবশ্যই :arg0-এর বেশি হতে হবে।",
+    "accepted": ":attribute অবশ্যই গ্রহণ করতে হবে।",
+    "after": ":attribute অবশ্যই :arg0-এর পরের একটি তারিখ হতে হবে।",
+    "alpha": ":attribute-এ শুধুমাত্র অক্ষর থাকতে পারে।",
+    "alpha_dash": ":attribute-এ শুধুমাত্র অক্ষর, সংখ্যা, ড্যাশ (-) এবং আন্ডারস্কোর (_) থাকতে পারে।",
+    "alpha_numeric": ":attribute-এ শুধুমাত্র অক্ষর এবং সংখ্যা থাকতে পারে।",
+    "array": ":attribute অবশ্যই একটি অ্যারে (array) হতে হবে।",
+    "before": ":attribute অবশ্যই :arg0-এর আগের একটি তারিখ হতে হবে।",
+    "boolean": ":attribute ফিল্ডটি অবশ্যই true অথবা false হতে হবে।",
+    "confirmed": ":attribute কনফার্মেশন মিলছে না।",
+    "credit_card": ":attribute অবশ্যই একটি বৈধ ক্রেডিট কার্ড নম্বর হতে হবে।",
+    "cvv": ":attribute অবশ্যই একটি বৈধ CVV নম্বর হতে হবে।",
+    "date": ":attribute একটি বৈধ তারিখ নয়।",
+    "date_format": ":attribute ফরম্যাট :arg0-এর সাথে মিলছে না।",
+    "debit_card": ":attribute অবশ্যই একটি বৈধ ডেবিট কার্ড নম্বর হতে হবে।",
+    "different": ":attribute এবং :arg0 অবশ্যই আলাদা হতে হবে।",
+    "dimension": ":attribute-এর ইমেজ ডাইমেনশন সঠিক নয়।",
+    "email": ":attribute অবশ্যই একটি বৈধ ইমেইল ঠিকানা হতে হবে।",
+    "ends_with": ":attribute অবশ্যই নিম্নলিখিত :arg0: এর মধ্যে যেকোনো একটি দিয়ে শেষ হতে হবে",
+    "equals": ":attribute অবশ্যই :arg0-এর সমান হতে হবে",
+    "exists": "নির্বাচিত :attribute অবৈধ।",
+    "image": ":attribute অবশ্যই একটি বৈধ ইমেজ হতে হবে।",
+    "in": "নির্বাচিত :attribute অবশ্যই :arg0:-এর মধ্যে থাকতে হবে।",
+    "includes": ":attribute-তে অবশ্যই :arg0: থাকতে হবে।",
+    "integer": ":attribute অবশ্যই একটি পূর্ণসংখ্যা (integer) হতে হবে।",
+    "ip": ":attribute অবশ্যই একটি বৈধ IP ঠিকানা হতে হবে।",
+    "ipv4": ":attribute অবশ্যই একটি বৈধ IPv4 ঠিকানা হতে হবে।",
+    "ipv6": ":attribute অবশ্যই একটি বৈধ IPv6 ঠিকানা হতে হবে।",
+    "json": ":attribute অবশ্যই একটি বৈধ JSON স্ট্রিং হতে হবে।",
+    "max": {
+        "array": ":attribute-এ :arg0-এর বেশি আইটেম থাকতে পারবে না।",
+        "numeric": ":attribute অবশ্যই :arg0-এর বেশি হতে পারবে না।",
+        "string": ":attribute অবশ্যই :arg0 অক্ষরের বেশি হতে পারবে না।"
+    },
+    "min": {
+        "array": ":attribute-এ অবশ্যই কমপক্ষে :arg0টি আইটেম থাকতে হবে।",
+        "numeric": ":attribute অবশ্যই কমপক্ষে :arg0 হতে হবে।",
+        "string": ":attribute অবশ্যই কমপক্ষে :arg0 অক্ষরের হতে হবে।"
+    },
+    "mimes": ":attribute অবশ্যই :arg0: টাইপের একটি ফাইল হতে হবে।",
+    "not_equals": ":attribute অবশ্যই :arg0-এর সমান হতে পারবে না",
+    "not_in": "নির্বাচিত :attribute অবশ্যই :arg0:-এর মধ্যে থাকতে পারবে না।",
+    "not_regex": ":attribute ফরম্যাট অবৈধ।",
+    "number": ":attribute অবশ্যই একটি সংখ্যা হতে হবে।",
+    "phone_no": ":attribute অবশ্যই একটি বৈধ ফোন নম্বর হতে হবে।",
+    "range": ":attribute অবশ্যই :arg0 এবং :arg1-এর মধ্যে হতে হবে।",
+    "between": ":attribute অবশ্যই :arg0 এবং :arg1-এর মধ্যে হতে হবে, উভয়ই বাদ দিয়ে।",
+    "regex": ":attribute ফরম্যাট অবৈধ।",
+    "required": ":attribute ফিল্ডটি আবশ্যক।",
+    "required_if": "যখন :arg0 হলো :arg1, তখন :attribute ফিল্ডটি আবশ্যক।",
+    "required_unless": ":attribute ফিল্ডটি আবশ্যক, যদি না :arg0, :arg1:-এর মধ্যে থাকে।",
+    "required_with": "যখন :arg0: এর মধ্যে যেকোনো একটি উপস্থিত থাকে, তখন :attribute ফিল্ডটি আবশ্যক।",
+    "required_with_all": "যখন :arg0: উপস্থিত থাকে, তখন :attribute ফিল্ডটি আবশ্যক।",
+    "required_without": "যখন :arg0: উপস্থিত না থাকে, তখন :attribute ফিল্ডটি আবশ্যক।",
+    "required_without_all": "যখন :arg0: এর কোনোটিই উপস্থিত না থাকে, তখন :attribute ফিল্ডটি আবশ্যক।",
+    "same": ":attribute এবং :arg0 অবশ্যই মিলতে হবে।",
+    "size": ":attribute অবশ্যই :arg0 KB অথবা তার কম হতে হবে।",
+    "starts_with": ":attribute অবশ্যই নিম্নলিখিত :arg0 এর মধ্যে যেকোনো একটি দিয়ে শুরু হতে হবে",
+    "string": ":attribute অবশ্যই একটি স্ট্রিং (string) হতে হবে।",
+    "strength": ":attribute যথেষ্ট শক্তিশালী নয়।",
+    "under": ":attribute অবশ্যই :arg0-এর কম হতে হবে।",
+    "url": ":attribute ফরম্যাট অবৈধ।",
+    "uuid": ":attribute অবশ্যই একটি বৈধ UUID হতে হবে।",
+    "unique": ":attribute ইতিমধ্যে ব্যবহৃত হয়েছে।",
+    "video": ":attribute অবশ্যই একটি বৈধ ভিডিও হতে হবে।"
+};
+
+var pt = {
+    "above": "O campo :attribute deve estar acima de :arg0.",
+    "accepted": "O campo :attribute deve ser aceito.",
+    "after": "O campo :attribute deve ser uma data posterior a :arg0.",
+    "alpha": "O campo :attribute pode conter apenas letras.",
+    "alpha_dash": "O campo :attribute pode conter apenas letras, números, hífens e sublinhados.",
+    "alpha_numeric": "O campo :attribute pode conter apenas letras e números.",
+    "array": "O campo :attribute deve ser uma matriz (array).",
+    "before": "O campo :attribute deve ser uma data anterior a :arg0.",
+    "boolean": "O campo :attribute deve ser verdadeiro ou falso.",
+    "confirmed": "A confirmação de :attribute não coincide.",
+    "credit_card": "O campo :attribute deve ser um número de cartão de crédito válido.",
+    "cvv": "O campo :attribute deve ser um número de CVV válido.",
+    "date": "O campo :attribute não é uma data válida.",
+    "date_format": "O campo :attribute não corresponde ao formato :arg0.",
+    "debit_card": "O campo :attribute deve ser um número de cartão de débito válido.",
+    "different": "Os campos :attribute e :arg0 devem ser diferentes.",
+    "dimension": "O campo :attribute tem dimensões de imagem inválidas.",
+    "email": "O campo :attribute deve ser um endereço de e-mail válido.",
+    "ends_with": "O campo :attribute deve terminar com um dos seguintes valores :arg0:",
+    "equals": "O campo :attribute deve ser igual a :arg0",
+    "exists": "O :attribute selecionado é inválido.",
+    "image": "O campo :attribute deve ser uma imagem válida.",
+    "in": "O :attribute selecionado deve estar entre :arg0:.",
+    "includes": "O campo :attribute deve conter :arg0:.",
+    "integer": "O campo :attribute deve ser um número inteiro.",
+    "ip": "O campo :attribute deve ser um endereço IP válido.",
+    "ipv4": "O campo :attribute deve ser um endereço IPv4 válido.",
+    "ipv6": "O campo :attribute deve ser um endereço IPv6 válido.",
+    "json": "O campo :attribute deve ser uma string JSON válida.",
+    "max": {
+        "array": "O campo :attribute não pode ter mais de :arg0 itens.",
+        "numeric": "O campo :attribute não pode ser maior que :arg0.",
+        "string": "O campo :attribute não pode ter mais de :arg0 caracteres."
+    },
+    "min": {
+        "array": "O campo :attribute deve ter pelo menos :arg0 itens.",
+        "numeric": "O campo :attribute deve ser pelo menos :arg0.",
+        "string": "O campo :attribute deve ter pelo menos :arg0 caracteres."
+    },
+    "mimes": "O campo :attribute deve ser um arquivo do tipo :arg0:.",
+    "not_equals": "O campo :attribute não deve ser igual a :arg0",
+    "not_in": "O :attribute selecionado não deve estar entre :arg0:.",
+    "not_regex": "O formato de :attribute é inválido.",
+    "number": "O campo :attribute deve ser um número.",
+    "phone_no": "O campo :attribute deve ser um número de telefone válido.",
+    "range": "O campo :attribute deve estar entre :arg0 e :arg1.",
+    "between": "O campo :attribute deve estar entre :arg0 e :arg1, exclusive.",
+    "regex": "O formato de :attribute é inválido.",
+    "required": "O campo :attribute é obrigatório.",
+    "required_if": "O campo :attribute é obrigatório quando :arg0 é :arg1.",
+    "required_unless": "O campo :attribute é obrigatório, a menos que :arg0 esteja em :arg1:.",
+    "required_with": "O campo :attribute é obrigatório quando algum de :arg0: está presente.",
+    "required_with_all": "O campo :attribute é obrigatório quando :arg0: estão presentes.",
+    "required_without": "O campo :attribute é obrigatório quando :arg0: não está presente.",
+    "required_without_all": "O campo :attribute é obrigatório quando nenhum de :arg0: está presente.",
+    "same": "Os campos :attribute e :arg0 devem coincidir.",
+    "size": "O campo :attribute deve ter :arg0 KB ou menos.",
+    "starts_with": "O campo :attribute deve começar com um dos seguintes valores :arg0",
+    "string": "O campo :attribute deve ser uma string.",
+    "strength": "O campo :attribute não é forte o suficiente.",
+    "under": "O campo :attribute deve ser menor que :arg0.",
+    "url": "O formato de :attribute é inválido.",
+    "uuid": "O campo :attribute deve ser um UUID válido.",
+    "unique": "O campo :attribute já foi registrado.",
+    "video": "O campo :attribute deve ser um vídeo válido."
+};
+
+var ja = {
+    above: ':attributeは:arg0より大きい必要があります。',
+    accepted: ':attributeを承認する必要があります。',
+    after: ':attributeは:arg0より後の日付である必要があります。',
+    alpha: ':attributeには英字のみ使用できます。',
+    alpha_dash: ':attributeには英字、数字、ハイフン、アンダースコアのみ使用できます。',
+    alpha_numeric: ':attributeには英字と数字のみ使用できます。',
+    array: ':attributeは配列である必要があります。',
+    before: ':attributeは:arg0より前の日付である必要があります。',
+    boolean: ':attributeフィールドはtrueまたはfalseである必要があります。',
+    confirmed: ':attributeの確認が一致しません。',
+    credit_card: ':attributeは有効なクレジットカード番号である必要があります。',
+    cvv: ':attributeは有効なCVV番号である必要があります。',
+    date: ':attributeは有効な日付ではありません。',
+    date_format: ':attributeはフォーマット:arg0と一致しません。',
+    debit_card: ':attributeは有効なデビットカード番号である必要があります。',
+    different: ':attributeと:arg0は異なる必要があります。',
+    dimension: ':attributeの画像サイズが無効です。',
+    email: ':attributeは有効なメールアドレスである必要があります。',
+    ends_with: ':attributeは次のいずれかで終わる必要があります: :arg0',
+    equals: ':attributeは:arg0と等しい必要があります',
+    exists: '選択された:attributeは無効です。',
+    image: ':attributeは有効な画像である必要があります。',
+    in: '選択された:attributeは:arg0のいずれかである必要があります。',
+    includes: ':attributeには:arg0を含める必要があります。',
+    integer: ':attributeは整数である必要があります。',
+    ip: ':attributeは有効なIPアドレスである必要があります。',
+    ipv4: ':attributeは有効なIPv4アドレスである必要があります。',
+    ipv6: ':attributeは有効なIPv6アドレスである必要があります。',
+    json: ':attributeは有効なJSON文字列である必要があります。',
+    max: {
+        array: ':attributeは:arg0個を超える項目を含めることはできません。',
+        numeric: ':attributeは:arg0より大きくすることはできません。',
+        string: ':attributeは:arg0文字を超えることはできません。'
+    },
+    min: {
+        array: ':attributeは少なくとも:arg0個の項目を含める必要があります。',
+        numeric: ':attributeは少なくとも:arg0である必要があります。',
+        string: ':attributeは少なくとも:arg0文字である必要があります。'
+    },
+    mimes: ':attributeは:arg0タイプのファイルである必要があります。',
+    not_equals: ':attributeは:arg0と等しくない必要があります',
+    not_in: '選択された:attributeは:arg0に含まれてはいけません。',
+    not_regex: ':attributeの形式が無効です。',
+    number: ':attributeは数値である必要があります。',
+    phone_no: ':attributeは有効な電話番号である必要があります。',
+    range: ':attributeは:arg0から:arg1の間である必要があります。',
+    between: ':attributeは:arg0と:arg1の間(両端を含まない)である必要があります。',
+    regex: ':attributeの形式が無効です。',
+    required: ':attributeフィールドは必須です。',
+    required_if: ':arg0が:arg1の場合、:attributeフィールドは必須です。',
+    required_unless: ':arg0が:arg1に含まれない限り、:attributeフィールドは必須です。',
+    required_with: ':arg0のいずれかが存在する場合、:attributeフィールドは必須です。',
+    required_with_all: ':arg0が存在する場合、:attributeフィールドは必須です。',
+    required_without: ':arg0が存在しない場合、:attributeフィールドは必須です。',
+    required_without_all: ':arg0のいずれも存在しない場合、:attributeフィールドは必須です。',
+    same: ':attributeと:arg0は一致する必要があります。',
+    size: ':attributeは:arg0KB以下である必要があります。',
+    starts_with: ':attributeは次のいずれかで始まる必要があります: :arg0',
+    string: ':attributeは文字列である必要があります。',
+    strength: ':attributeの強度が十分ではありません。',
+    under: ':attributeは:arg0未満である必要があります。',
+    url: ':attributeの形式が無効です。',
+    uuid: ':attributeは有効なUUIDである必要があります。',
+    unique: ':attributeはすでに使用されています。',
+    video: ':attributeは有効な動画である必要があります。',
+};
+
+var zh = {
+    above: ':attributeは:arg0より大きい必要があります。',
+    accepted: ':attributeを承認する必要があります。',
+    after: ':attributeは:arg0より後の日付である必要があります。',
+    alpha: ':attributeには英字のみ使用できます。',
+    alpha_dash: ':attributeには英字、数字、ハイフン、アンダースコアのみ使用できます。',
+    alpha_numeric: ':attributeには英字と数字のみ使用できます。',
+    array: ':attributeは配列である必要があります。',
+    before: ':attributeは:arg0より前の日付である必要があります。',
+    boolean: ':attributeフィールドはtrueまたはfalseである必要があります。',
+    confirmed: ':attributeの確認が一致しません。',
+    credit_card: ':attributeは有効なクレジットカード番号である必要があります。',
+    cvv: ':attributeは有効なCVV番号である必要があります。',
+    date: ':attributeは有効な日付ではありません。',
+    date_format: ':attributeはフォーマット:arg0と一致しません。',
+    debit_card: ':attributeは有効なデビットカード番号である必要があります。',
+    different: ':attributeと:arg0は異なる必要があります。',
+    dimension: ':attributeの画像サイズが無効です。',
+    email: ':attributeは有効なメールアドレスである必要があります。',
+    ends_with: ':attributeは次のいずれかで終わる必要があります: :arg0',
+    equals: ':attributeは:arg0と等しい必要があります',
+    exists: '選択された:attributeは無効です。',
+    image: ':attributeは有効な画像である必要があります。',
+    in: '選択された:attributeは:arg0のいずれかである必要があります。',
+    includes: ':attributeには:arg0を含める必要があります。',
+    integer: ':attributeは整数である必要があります。',
+    ip: ':attributeは有効なIPアドレスである必要があります。',
+    ipv4: ':attributeは有効なIPv4アドレスである必要があります。',
+    ipv6: ':attributeは有効なIPv6アドレスである必要があります。',
+    json: ':attributeは有効なJSON文字列である必要があります。',
+    max: {
+        array: ':attributeは:arg0個を超える項目を含めることはできません。',
+        numeric: ':attributeは:arg0より大きくすることはできません。',
+        string: ':attributeは:arg0文字を超えることはできません。'
+    },
+    min: {
+        array: ':attributeは少なくとも:arg0個の項目を含める必要があります。',
+        numeric: ':attributeは少なくとも:arg0である必要があります。',
+        string: ':attributeは少なくとも:arg0文字である必要があります。'
+    },
+    mimes: ':attributeは:arg0タイプのファイルである必要があります。',
+    not_equals: ':attributeは:arg0と等しくない必要があります',
+    not_in: '選択された:attributeは:arg0に含まれてはいけません。',
+    not_regex: ':attributeの形式が無効です。',
+    number: ':attributeは数値である必要があります。',
+    phone_no: ':attributeは有効な電話番号である必要があります。',
+    range: ':attributeは:arg0から:arg1の間である必要があります。',
+    between: ':attributeは:arg0と:arg1の間(両端を含まない)である必要があります。',
+    regex: ':attributeの形式が無効です。',
+    required: ':attributeフィールドは必須です。',
+    required_if: ':arg0が:arg1の場合、:attributeフィールドは必須です。',
+    required_unless: ':arg0が:arg1に含まれない限り、:attributeフィールドは必須です。',
+    required_with: ':arg0のいずれかが存在する場合、:attributeフィールドは必須です。',
+    required_with_all: ':arg0が存在する場合、:attributeフィールドは必須です。',
+    required_without: ':arg0が存在しない場合、:attributeフィールドは必須です。',
+    required_without_all: ':arg0のいずれも存在しない場合、:attributeフィールドは必須です。',
+    same: ':attributeと:arg0は一致する必要があります。',
+    size: ':attributeは:arg0KB以下である必要があります。',
+    starts_with: ':attributeは次のいずれかで始まる必要があります: :arg0',
+    string: ':attributeは文字列である必要があります。',
+    strength: ':attributeの強度が十分ではありません。',
+    under: ':attributeは:arg0未満である必要があります。',
+    url: ':attributeの形式が無効です。',
+    uuid: ':attributeは有効なUUIDである必要があります。',
+    unique: ':attributeはすでに使用されています。',
+    video: ':attributeは有効な動画である必要があります。',
+};
+
+var ru = {
+    above: 'Поле :attribute должно быть больше :arg0.',
+    accepted: 'Поле :attribute должно быть принято.',
+    after: 'Поле :attribute должно быть датой позже :arg0.',
+    alpha: 'Поле :attribute может содержать только буквы.',
+    alpha_dash: 'Поле :attribute может содержать только буквы, цифры, дефисы и подчёркивания.',
+    alpha_numeric: 'Поле :attribute может содержать только буквы и цифры.',
+    array: 'Поле :attribute должно быть массивом.',
+    before: 'Поле :attribute должно быть датой раньше :arg0.',
+    boolean: 'Поле :attribute должно быть true или false.',
+    confirmed: 'Подтверждение :attribute не совпадает.',
+    credit_card: 'Поле :attribute должно быть действительным номером кредитной карты.',
+    cvv: 'Поле :attribute должно быть действительным номером CVV.',
+    date: 'Поле :attribute не является допустимой датой.',
+    date_format: 'Поле :attribute не соответствует формату :arg0.',
+    debit_card: 'Поле :attribute должно быть действительным номером дебетовой карты.',
+    different: 'Поля :attribute и :arg0 должны отличаться.',
+    dimension: 'Поле :attribute имеет недопустимые размеры изображения.',
+    email: 'Поле :attribute должно быть действительным адресом электронной почты.',
+    ends_with: 'Поле :attribute должно заканчиваться одним из следующих значений: :arg0',
+    equals: 'Поле :attribute должно быть равно :arg0',
+    exists: 'Выбранное значение :attribute недопустимо.',
+    image: 'Поле :attribute должно быть действительным изображением.',
+    in: 'Выбранное значение :attribute должно входить в :arg0.',
+    includes: 'Поле :attribute должно содержать :arg0.',
+    integer: 'Поле :attribute должно быть целым числом.',
+    ip: 'Поле :attribute должно быть действительным IP-адресом.',
+    ipv4: 'Поле :attribute должно быть действительным адресом IPv4.',
+    ipv6: 'Поле :attribute должно быть действительным адресом IPv6.',
+    json: 'Поле :attribute должно быть допустимой строкой JSON.',
+    max: {
+        array: 'Поле :attribute не должно содержать более :arg0 элементов.',
+        numeric: 'Поле :attribute не должно быть больше :arg0.',
+        string: 'Поле :attribute не должно быть длиннее :arg0 символов.'
+    },
+    min: {
+        array: 'Поле :attribute должно содержать не менее :arg0 элементов.',
+        numeric: 'Поле :attribute должно быть не менее :arg0.',
+        string: 'Поле :attribute должно содержать не менее :arg0 символов.'
+    },
+    mimes: 'Поле :attribute должно быть файлом типа :arg0.',
+    not_equals: 'Поле :attribute не должно быть равно :arg0',
+    not_in: 'Выбранное значение :attribute не должно входить в :arg0.',
+    not_regex: 'Формат поля :attribute недопустим.',
+    number: 'Поле :attribute должно быть числом.',
+    phone_no: 'Поле :attribute должно быть действительным номером телефона.',
+    range: 'Поле :attribute должно быть между :arg0 и :arg1.',
+    between: 'Поле :attribute должно быть между :arg0 и :arg1, не включая границы.',
+    regex: 'Формат поля :attribute недопустим.',
+    required: 'Поле :attribute обязательно для заполнения.',
+    required_if: 'Поле :attribute обязательно, если :arg0 равно :arg1.',
+    required_unless: 'Поле :attribute обязательно, если :arg0 не входит в :arg1.',
+    required_with: 'Поле :attribute обязательно, если присутствует одно из :arg0.',
+    required_with_all: 'Поле :attribute обязательно, если присутствуют :arg0.',
+    required_without: 'Поле :attribute обязательно, если :arg0 отсутствует.',
+    required_without_all: 'Поле :attribute обязательно, если ни одно из :arg0 не присутствует.',
+    same: 'Поля :attribute и :arg0 должны совпадать.',
+    size: 'Поле :attribute должно быть :arg0 КБ или меньше.',
+    starts_with: 'Поле :attribute должно начинаться с одного из следующих значений: :arg0',
+    string: 'Поле :attribute должно быть строкой.',
+    strength: 'Поле :attribute недостаточно надёжно.',
+    under: 'Поле :attribute должно быть меньше :arg0.',
+    url: 'Формат поля :attribute недопустим.',
+    uuid: 'Поле :attribute должно быть действительным UUID.',
+    unique: 'Значение поля :attribute уже занято.',
+    video: 'Поле :attribute должно быть действительным видео.',
+};
+
+const BUILT_IN_TRANSLATIONS = { en, de, es, fr, hi, bn, pt, ja, zh, ru };
+class InlineTranslateLoader {
+    constructor(mergeTranslations = {}, replaceTranslations = {}) {
+        this.mergeTranslations = mergeTranslations;
+        this.replaceTranslations = replaceTranslations;
+        this.translations = {};
+        this.init();
+    }
+    init() {
+        this.translations = { ...BUILT_IN_TRANSLATIONS };
+        // Full replace happens first — wipes out all existing keys for that lang
+        for (const lang of Object.keys(this.replaceTranslations)) {
+            this.translations[lang] = { ...this.replaceTranslations[lang] };
+        }
+        // Merge happens second — adds new languages, or patches individual keys
+        for (const lang of Object.keys(this.mergeTranslations)) {
+            this.translations[lang] = {
+                ...(this.translations[lang] || {}),
+                ...this.mergeTranslations[lang]
+            };
+        }
+    }
+    getTranslation(lang) {
+        return of(this.translations[lang] ?? this.translations['en']);
+    }
+}
+
+class ErrorTriggerOnDirective {
+    constructor(FormGroupDirective, NgForm) {
+        this.FormGroupDirective = FormGroupDirective;
+        this.NgForm = NgForm;
+    }
+    set message(triggerState) {
+        this.NgForm && (this.NgForm.errorTriggerOn = triggerState);
+        this.FormGroupDirective && (this.FormGroupDirective.errorTriggerOn = triggerState);
+    }
+}
+ErrorTriggerOnDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ErrorTriggerOnDirective, deps: [{ token: FormGroupDirective, optional: true }, { token: NgForm, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+ErrorTriggerOnDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: ErrorTriggerOnDirective, selector: "form[ErrorTriggerOn]", inputs: { message: ["ErrorTriggerOn", "message"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ErrorTriggerOnDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'form[ErrorTriggerOn]'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FormGroupDirective]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [NgForm]
+                }] }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['ErrorTriggerOn']
+            }] } });
+
+function TranslateLoaderFactory(config) {
+    return new InlineTranslateLoader(config?.translations, config?.replaceTranslations);
+}
+function appInitializerFactory(translate, config) {
+    return () => {
+        const builtIn = SUPPORTED_LOCALE_LANGS;
+        const supported = config?.supportedLanguages?.length ? config.supportedLanguages : builtIn;
+        const browserLang = translate.getBrowserLang();
+        const langToUse = browserLang && supported.includes(browserLang)
+            ? browserLang
+            : (config?.defaultLanguage || DEFAULT_LOCALE_LANG);
+        return firstValueFrom(translate.use(langToUse));
+    };
+}
+class NgAbsoluteValidatorModule {
+    static forRoot(config = {}) {
+        return {
+            ngModule: NgAbsoluteValidatorModule,
+            providers: [
+                { provide: LIB_CONFIG, useValue: config },
+                NgAbsoluteValidatorService,
+                ReactiveValidator
+            ]
+        };
+    }
+}
+NgAbsoluteValidatorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgAbsoluteValidatorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgAbsoluteValidatorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: NgAbsoluteValidatorModule, declarations: [NgAbsoluteValidatorComponent,
+        NativeElementDirective,
+        ErrorTriggerOnDirective], imports: [CommonModule,
+        RuleModule,
+        HttpClientModule, i1.TranslateModule], exports: [RuleModule,
+        NgAbsoluteValidatorComponent,
+        NativeElementDirective,
+        ErrorTriggerOnDirective,
+        TranslateModule] });
+NgAbsoluteValidatorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgAbsoluteValidatorModule, providers: [
+        NgAbsoluteValidatorService,
+        ReactiveValidator,
+        HttpRequestService,
+        {
+            provide: LIB_CONFIG,
+            useValue: {}
+        },
+        {
+            provide: APP_INITIALIZER,
+            useFactory: appInitializerFactory,
+            deps: [TranslateService, LIB_CONFIG],
+            multi: true
+        }
+    ], imports: [CommonModule,
+        RuleModule,
+        HttpClientModule,
+        TranslateModule.forRoot({
+            loader: {
+                provide: TranslateLoader,
+                useFactory: TranslateLoaderFactory,
+                deps: [LIB_CONFIG]
+            },
+            defaultLanguage: DEFAULT_LOCALE_LANG
+        }), RuleModule,
+        TranslateModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgAbsoluteValidatorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        NgAbsoluteValidatorComponent,
+                        NativeElementDirective,
+                        ErrorTriggerOnDirective
+                    ],
+                    imports: [
+                        CommonModule,
+                        RuleModule,
+                        HttpClientModule,
+                        TranslateModule.forRoot({
+                            loader: {
+                                provide: TranslateLoader,
+                                useFactory: TranslateLoaderFactory,
+                                deps: [LIB_CONFIG]
+                            },
+                            defaultLanguage: DEFAULT_LOCALE_LANG
+                        })
+                    ],
+                    providers: [
+                        NgAbsoluteValidatorService,
+                        ReactiveValidator,
+                        HttpRequestService,
+                        {
+                            provide: LIB_CONFIG,
+                            useValue: {}
+                        },
+                        {
+                            provide: APP_INITIALIZER,
+                            useFactory: appInitializerFactory,
+                            deps: [TranslateService, LIB_CONFIG],
+                            multi: true
+                        }
+                    ],
+                    exports: [
+                        RuleModule,
+                        NgAbsoluteValidatorComponent,
+                        NativeElementDirective,
+                        ErrorTriggerOnDirective,
+                        TranslateModule
+                    ]
+                }]
+        }] });
+
+const LOCALE_LANG_LABELS = {
+    en: 'English',
+    es: 'Español',
+    fr: 'Français',
+    de: 'Deutsch',
+    hi: 'हिन्दी',
+    bn: 'বাংলা',
+    pt: 'Português',
+    ar: 'العربية',
+    ja: '日本語',
+    zh: '中文',
+    ru: 'Русский',
+};
+
+/*
+ * Public API Surface of ng-absolute-validator
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AboveDirective, AcceptedDirective, AfterDirective, AlphaDashDirective, AlphaDirective, AlphaNumericDirective, ArrayDirective, BeforeDirective, BetweenDirective, BooleanDirective, ConfirmedDirective, CreditCardDirective, CvvDirective, DateDirective, DateFormatDirective, DebitCardDirective, DifferentDirective, DimensionDirective, EmailDirective, EndsWithDirective, EqualsDirective, ErrorTriggerOnDirective, ExistsDirective, ImageDirective, InDirective, IncludesDirective, IntegerDirective, IpDirective, Ipv4Directive, Ipv6Directive, JsonDirective, LOCALE_LANG_LABELS, MaxDirective, MimesDirective, MinDirective, NativeElementDirective, NgAbsoluteValidatorComponent, NgAbsoluteValidatorModule, NgAbsoluteValidatorService, NotEqualsDirective, NotInDirective, NotRegexDirective, NumberDirective, PhoneNoDirective, RangeDirective, ReactiveValidator, RegexDirective, RequiredDirective, RequiredIfDirective, RequiredUnlessDirective, RequiredWithAllDirective, RequiredWithDirective, RequiredWithoutAllDirective, RequiredWithoutDirective, RuleDirective, RuleModule, SameDirective, SizeDirective, StartsWithDirective, StrengthDirective, StringDirective, TranslateLoaderFactory, UnderDirective, UniqueDirective, UrlDirective, UuidDirective, VideoDirective, appInitializerFactory };
+//# sourceMappingURL=sbcore-ng-absolute-validator.mjs.map