closer to the solution, just need to solve the refreshing when model …

…schema changes without arrays.

dist/definitions/events/model-state-changed-event.d.ts

@@ -0,0 +1,4 @@
+export declare class ModelStateChangedEvent {
+    isValid: boolean;
+    constructor(isValid: boolean);
+}

dist/definitions/events/property-changed-event.d.ts

@@ -0,0 +1,6 @@
+export declare class PropertyChangedEvent {
+    propertyPath: string;
+    newValue: any;
+    oldValue: any;
+    constructor(propertyPath: string, newValue: any, oldValue: any);
+}

dist/definitions/events/property-state-changed-event.d.ts

@@ -0,0 +1,6 @@
+export declare class PropertyStateChangedEvent {
+    property: string;
+    isValid: boolean;
+    error: string;
+    constructor(property: string, isValid: boolean, error?: string);
+}

dist/definitions/exposer.d.ts

@@ -0,0 +1,8 @@
+import { RuleRegistry } from "./rules/rule-registry";
+import { Ruleset } from "./rulesets/ruleset";
+import { RulesetBuilder } from "./rulesets/ruleset-builder";
+import { ValidationGroup } from "./validation-group";
+export declare var ruleRegistry: RuleRegistry;
+export declare function createRuleset(): RulesetBuilder;
+export declare function createGroupWithRules(model: any, rulesCreator: (rulesetBuilder: RulesetBuilder) => Ruleset): ValidationGroup;
+export declare function createGroup(model: any, ruleset: Ruleset): ValidationGroup;

dist/definitions/factories/validation-group-factory.d.ts

@@ -0,0 +1,13 @@
+import { ValidationGroup } from "../validation-group";
+import { Ruleset } from "../rulesets/ruleset";
+import { IModelWatcher } from "../watcher/imodel-watcher";
+import { IRuleResolver } from "../rulesets/irule-resolver";
+import { IFieldErrorProcessor } from "../processors/ifield-error-processor";
+export declare class ValidationGroupFactory {
+    private fieldErrorProcessor;
+    private modelWatcher;
+    private propertyResolver;
+    private ruleResolver;
+    constructor(fieldErrorProcessor: IFieldErrorProcessor, modelWatcher: IModelWatcher, propertyResolver: any, ruleResolver: IRuleResolver);
+    createValidationGroup: (model: any, ruleset: Ruleset) => ValidationGroup;
+}

dist/definitions/helpers/comparer-helper.d.ts

@@ -0,0 +1,4 @@
+export declare class ComparerHelper {
+    static simpleTypeComparer(value1: (string | number), value2: (string | number), isWeak: any): boolean;
+    static dateTimeCompararer(value1: Date, value2: Date): boolean;
+}

dist/definitions/helpers/type-helper.d.ts

@@ -0,0 +1,5 @@
+export declare class TypeHelper {
+    static isDateType(value: any): boolean;
+    static isSimpleType(value: any): boolean;
+    static isArrayType(value: any): boolean;
+}

dist/definitions/index.d.ts

@@ -0,0 +1,38 @@
+export * from "./exposer";
+export * from "./ivalidation-group";
+export * from "./validation-group";
+export * from "./events/model-state-changed-event";
+export * from "./events/property-changed-event";
+export * from "./events/property-state-changed-event";
+export * from "./factories/validation-group-factory";
+export * from "./helpers/comparer-helper";
+export * from "./helpers/type-helper";
+export * from "./processors/field-error-processor";
+export * from "./processors/field-has-error";
+export * from "./processors/ifield-error-processor";
+export * from "./processors/validation-error";
+export * from "./rules/date-validation-rule";
+export * from "./rules/decimal-validation-rule";
+export * from "./rules/email-validation-rule";
+export * from "./rules/equal-validation-rule";
+export * from "./rules/iso-date-validation-rule";
+export * from "./rules/ivalidation-rule";
+export * from "./rules/max-length-validation-rule";
+export * from "./rules/max-value-validation-rule";
+export * from "./rules/min-length-validation-rule";
+export * from "./rules/min-value-validation-rule";
+export * from "./rules/not-equal-validation-rule";
+export * from "./rules/number-validation-rule";
+export * from "./rules/regex-validation-rule";
+export * from "./rules/required-validation-rule";
+export * from "./rules/rule-registry";
+export * from "./rules/step-validation-rule";
+export * from "./rulesets/for-each-rule";
+export * from "./rulesets/irule-resolver";
+export * from "./rulesets/rule-link";
+export * from "./rulesets/rule-resolver";
+export * from "./rulesets/ruleset-builder";
+export * from "./rulesets/ruleset";
+export * from "./watcher/imodel-watcher";
+export * from "./watcher/model-watcher";
+export * from "./watcher/property-watcher";

dist/definitions/ivalidation-group.d.ts

@@ -0,0 +1,10 @@
+import { EventHandler } from "event-js";
+export interface IValidationGroup {
+    propertyStateChangedEvent: EventHandler;
+    modelStateChangedEvent: EventHandler;
+    isValid(): Promise<boolean>;
+    getModelErrors(): Promise<any>;
+    getPropertyError(propertyRoute: string): Promise<any>;
+    changeValidationTarget(model: any): any;
+    release(): void;
+}

dist/definitions/processors/field-error-processor.d.ts

@@ -0,0 +1,10 @@
+import * as Promise from "bluebird";
+import { RuleRegistry } from "../rules/rule-registry";
+import { RuleLink } from "../rulesets/rule-link";
+import { IFieldErrorProcessor } from "./ifield-error-processor";
+export declare class FieldErrorProcessor implements IFieldErrorProcessor {
+    ruleRegistry: RuleRegistry;
+    constructor(ruleRegistry: RuleRegistry);
+    processRuleLink(fieldValue: any, ruleLink: RuleLink): Promise<any>;
+    checkFieldForErrors(fieldValue: any, rules: any): Promise<string>;
+}

dist/definitions/processors/field-has-error.d.ts

@@ -0,0 +1,3 @@
+export declare class FieldHasError extends Error {
+    constructor(message: any);
+}

dist/definitions/processors/ifield-error-processor.d.ts

@@ -0,0 +1,6 @@
+import * as Promise from "bluebird";
+import { RuleLink } from "../rulesets/rule-link";
+export interface IFieldErrorProcessor {
+    processRuleLink(fieldValue: any, ruleLink: RuleLink): Promise<any>;
+    checkFieldForErrors(fieldValue: any, rules: any): Promise<string>;
+}

dist/definitions/processors/validation-error.d.ts

@@ -0,0 +1,5 @@
+export declare class ValidationError {
+    propertyName: string;
+    message: string;
+    constructor(propertyName: string, message: string);
+}

dist/definitions/rules/date-validation-rule.d.ts

@@ -0,0 +1,8 @@
+import * as Promise from "bluebird";
+import { IValidationRule } from "./ivalidation-rule";
+export declare class DateValidationRule implements IValidationRule {
+    ruleName: string;
+    private invalidObjectRegex;
+    validate(value: any): Promise<boolean>;
+    getMessage(value: any): string;
+}

dist/definitions/rules/decimal-validation-rule.d.ts

@@ -0,0 +1,8 @@
+import * as Promise from "bluebird";
+import { IValidationRule } from "./ivalidation-rule";
+export declare class DecimalValidationRule implements IValidationRule {
+    ruleName: string;
+    private decimalRegex;
+    validate(value: any): Promise<boolean>;
+    getMessage(value: any): string;
+}

dist/definitions/rules/email-validation-rule.d.ts

@@ -0,0 +1,8 @@
+import * as Promise from "bluebird";
+import { IValidationRule } from "./ivalidation-rule";
+export declare class EmailValidationRule implements IValidationRule {
+    ruleName: string;
+    private emailRegex;
+    validate(value: any): Promise<boolean>;
+    getMessage(value: any): string;
+}

dist/definitions/rules/equal-validation-rule.d.ts

@@ -0,0 +1,7 @@
+import * as Promise from "bluebird";
+import { IValidationRule } from "./ivalidation-rule";
+export declare class EqualValidationRule implements IValidationRule {
+    ruleName: string;
+    validate(value: any, optionsOrValue: any): Promise<boolean>;
+    getMessage(value: any, optionsOrValue: any): string;
+}

dist/definitions/rules/iso-date-validation-rule.d.ts

@@ -0,0 +1,8 @@
+import * as Promise from "bluebird";
+import { IValidationRule } from "./ivalidation-rule";
+export declare class ISODateValidationRule implements IValidationRule {
+    ruleName: string;
+    private isoDateRegex;
+    validate(value: any): Promise<boolean>;
+    getMessage(value: any): string;
+}

dist/definitions/rules/ivalidation-rule.d.ts

@@ -0,0 +1,6 @@
+import * as Promise from "bluebird";
+export interface IValidationRule {
+    ruleName: string;
+    validate(value: any, options?: any): Promise<boolean>;
+    getMessage(value: any, options?: any): any;
+}

dist/definitions/rules/max-length-validation-rule.d.ts

@@ -0,0 +1,7 @@
+import * as Promise from "bluebird";
+import { IValidationRule } from "./ivalidation-rule";
+export declare class MaxLengthValidationRule implements IValidationRule {
+    ruleName: string;
+    validate(value: any, maxLength: number): Promise<boolean>;
+    getMessage(value: any, maxLength: any): string;
+}

dist/definitions/rules/max-value-validation-rule.d.ts

@@ -0,0 +1,7 @@
+import * as Promise from "bluebird";
+import { IValidationRule } from "./ivalidation-rule";
+export declare class MaxValueValidationRule implements IValidationRule {
+    ruleName: string;
+    validate(value: any, maxValue: number): Promise<boolean>;
+    getMessage(value: any, maxValue: any): string;
+}

dist/definitions/rules/min-length-validation-rule.d.ts

@@ -0,0 +1,7 @@
+import * as Promise from "bluebird";
+import { IValidationRule } from "./ivalidation-rule";
+export declare class MinLengthValidationRule implements IValidationRule {
+    ruleName: string;
+    validate(value: any, minLength: number): Promise<boolean>;
+    getMessage(value: any, minLength: number): string;
+}

dist/definitions/rules/min-value-validation-rule.d.ts

@@ -0,0 +1,7 @@
+import * as Promise from "bluebird";
+import { IValidationRule } from "./ivalidation-rule";
+export declare class MinValueValidationRule implements IValidationRule {
+    ruleName: string;
+    validate(value: any, minValue: number): Promise<boolean>;
+    getMessage(value: any, minValue: number): string;
+}

dist/definitions/rules/not-equal-validation-rule.d.ts

@@ -0,0 +1,7 @@
+import * as Promise from "bluebird";
+import { IValidationRule } from "./ivalidation-rule";
+export declare class NotEqualValidationRule implements IValidationRule {
+    ruleName: string;
+    validate(value: any, optionsOrValue: any): Promise<boolean>;
+    getMessage(value: any, optionsOrValue: any): string;
+}

dist/definitions/rules/number-validation-rule.d.ts

@@ -0,0 +1,8 @@
+import * as Promise from "bluebird";
+import { IValidationRule } from "./ivalidation-rule";
+export declare class NumberValidationRule implements IValidationRule {
+    ruleName: string;
+    private numberRegex;
+    validate(value: any): Promise<boolean>;
+    getMessage(value: any): string;
+}

dist/definitions/rules/regex-validation-rule.d.ts

@@ -0,0 +1,7 @@
+import * as Promise from "bluebird";
+import { IValidationRule } from "./ivalidation-rule";
+export declare class RegexValidationRule implements IValidationRule {
+    ruleName: string;
+    validate(value: any, regexPattern: RegExp): Promise<boolean>;
+    getMessage(value: any, regexPattern: any): string;
+}

dist/definitions/rules/required-validation-rule.d.ts

@@ -0,0 +1,7 @@
+import * as Promise from "bluebird";
+import { IValidationRule } from "./ivalidation-rule";
+export declare class RequiredValidaitonRule implements IValidationRule {
+    ruleName: string;
+    validate(value: any, isRequired?: boolean): Promise<boolean>;
+    getMessage(value: any, isRequired: any): string;
+}

dist/definitions/rules/rule-registry.d.ts

@@ -0,0 +1,7 @@
+import { IValidationRule } from "./ivalidation-rule";
+export declare class RuleRegistry {
+    rules: {};
+    registerRule: (validationRule: IValidationRule) => void;
+    unregisterRule: (validationRule: IValidationRule) => void;
+    getRuleNamed: (ruleName: string) => IValidationRule;
+}

dist/definitions/rules/step-validation-rule.d.ts

@@ -0,0 +1,7 @@
+import * as Promise from "bluebird";
+import { IValidationRule } from "./ivalidation-rule";
+export declare class StepValidationRule implements IValidationRule {
+    ruleName: string;
+    validate(value: any, step: number): Promise<boolean>;
+    getMessage(value: any, step: any): string;
+}

dist/definitions/rulesets/for-each-rule.d.ts

@@ -0,0 +1,5 @@
+export declare class ForEachRule<RuleType> {
+    internalRule: RuleType;
+    isForEach: boolean;
+    constructor(internalRule: RuleType);
+}

dist/definitions/rulesets/irule-resolver.d.ts

@@ -0,0 +1,4 @@
+import { Ruleset } from "./ruleset";
+export interface IRuleResolver {
+    resolvePropertyRules(propertyRoute: string, ruleset: Ruleset): any;
+}

dist/definitions/rulesets/rule-link.d.ts

@@ -0,0 +1,6 @@
+export declare class RuleLink {
+    ruleName: string;
+    ruleOptions: any;
+    constructor(ruleName: string, ruleOptions?: any);
+    messageOverride: ((value: any, ruleOptions?: any) => string) | string;
+}

dist/definitions/rulesets/rule-resolver.d.ts

@@ -0,0 +1,12 @@
+import { IRuleResolver } from "./irule-resolver";
+import { PropertyResolver } from "property-resolver";
+import { Ruleset } from "./ruleset";
+export declare class RuleResolver implements IRuleResolver {
+    private propertyResolver;
+    constructor(propertyResolver?: PropertyResolver);
+    isPropertyRoute: (possiblePropertyRoute: string) => boolean;
+    private isIndexRoute;
+    resolvePropertyRules: (propertyRoute: string, ruleset: Ruleset) => any;
+    private getMatchingRuleForProperty;
+    private traverseRulesForRoutes;
+}

dist/definitions/rulesets/ruleset-builder.d.ts

@@ -0,0 +1,15 @@
+import { Ruleset } from "./ruleset";
+import { RuleLink } from "./rule-link";
+export declare class RulesetBuilder {
+    private internalRuleset;
+    currentProperty: string;
+    currentRule: RuleLink;
+    create: () => RulesetBuilder;
+    forProperty: (propertyName: string) => RulesetBuilder;
+    addRule: (rule: string, ruleOptions?: any) => RulesetBuilder;
+    withMessage: (messageOverride: ((value: any, ruleOptions?: any) => string) | string) => RulesetBuilder;
+    addRuleForEach: (rule: string, ruleOptions?: any) => RulesetBuilder;
+    addRuleset: (ruleset: Ruleset) => RulesetBuilder;
+    addRulesetForEach: (ruleset: Ruleset) => RulesetBuilder;
+    build: () => Ruleset;
+}

dist/definitions/rulesets/ruleset.d.ts

@@ -0,0 +1,9 @@
+import { RuleLink } from "./rule-link";
+import { ForEachRule } from "./for-each-rule";
+export declare class Ruleset {
+    rules: {};
+    private createPropertyEntryIfNeeded;
+    addRule: (property: string, ruleLink: RuleLink | ForEachRule<RuleLink>) => void;
+    addRuleset: (property: string, ruleset: Ruleset | ForEachRule<Ruleset>) => void;
+    getRulesForProperty: (property: string) => any[];
+}

dist/definitions/validation-group.d.ts

@@ -0,0 +1,37 @@
+import * as Promise from "bluebird";
+import { PropertyResolver } from "property-resolver";
+import { EventHandler } from "event-js";
+import { Ruleset } from "./rulesets/ruleset";
+import { IModelWatcher } from "./watcher/imodel-watcher";
+import { IValidationGroup } from "./ivalidation-group";
+import { IFieldErrorProcessor } from "./processors/ifield-error-processor";
+import { IRuleResolver } from "./rulesets/irule-resolver";
+export declare class ValidationGroup implements IValidationGroup {
+    private fieldErrorProcessor;
+    private modelWatcher;
+    private propertyResolver;
+    private ruleResolver;
+    private ruleset;
+    private model;
+    refreshRate: number;
+    private propertyErrors;
+    private activePromiseChain;
+    propertyStateChangedEvent: EventHandler;
+    modelStateChangedEvent: EventHandler;
+    constructor(fieldErrorProcessor: IFieldErrorProcessor, modelWatcher: IModelWatcher, propertyResolver: PropertyResolver, ruleResolver: IRuleResolver, ruleset: Ruleset, model: any, refreshRate?: number);
+    private isRuleset(possibleRuleset);
+    private isForEach(possibleForEach);
+    private onModelChanged;
+    private validatePropertyWithRuleLinks;
+    private validatePropertyWithRuleSet;
+    private validatePropertyWithRules;
+    private validateProperty;
+    private validateModel;
+    private hasErrors;
+    changeValidationTarget: (model: any) => void;
+    isValid: () => Promise<boolean>;
+    getModelErrors: () => Promise<any>;
+    getPropertyError: (propertyRoute: string) => Promise<any>;
+    release: () => void;
+    private waitForValidatorsToFinish;
+}

dist/definitions/watcher/imodel-watcher.d.ts

@@ -0,0 +1,10 @@
+import { EventHandler } from "event-js";
+import { Ruleset } from "../rulesets/ruleset";
+export interface IModelWatcher {
+    scanInterval: any;
+    onPropertyChanged: EventHandler;
+    setupWatcher: (model: any, ruleset: Ruleset, scanInterval) => void;
+    changeWatcherTarget: (model: any) => void;
+    startWatching: () => void;
+    stopWatching: () => void;
+}

dist/definitions/watcher/model-watcher.d.ts

@@ -0,0 +1,23 @@
+import { PropertyResolver } from "property-resolver";
+import { EventHandler } from "event-js";
+import { Ruleset } from "../rulesets/ruleset";
+import { IModelWatcher } from "./imodel-watcher";
+export declare class ModelWatcher implements IModelWatcher {
+    private propertyResolver;
+    private watchCache;
+    private watchCacheKeys;
+    private watcherInterval;
+    private model;
+    private ruleset;
+    scanInterval: any;
+    onPropertyChanged: EventHandler;
+    constructor(propertyResolver?: PropertyResolver);
+    setupWatcher: (model: any, ruleset: Ruleset, scanInterval?: number) => void;
+    changeWatcherTarget: (model: any) => void;
+    startWatching: () => void;
+    stopWatching: () => void;
+    private updateAndNotifyDifferences;
+    private watchProperty;
+    private cacheWatchTargets;
+    private scanProperties;
+}

dist/definitions/watcher/property-watcher.d.ts

@@ -0,0 +1,5 @@
+export declare class PropertyWatcher {
+    propertyPath: string;
+    previousValue: any;
+    constructor(propertyPath: string, previousValue: any);
+}