breeze-client 2.2.2 → 3.0.0

package/validation/validate.d.ts

@@ -0,0 +1,583 @@
+import { NavigationProperty, DataProperty } from '../metadata/entity-metadata.js';
+import { Entity } from '../entity/entity-aspect.js';
+export declare const INT16_MIN = -32768;
+export declare const INT16_MAX = 32767;
+export declare const INT32_MIN = -2147483648;
+export declare const INT32_MAX = 2147483647;
+export declare const BYTE_MIN = 0;
+export declare const BYTE_MAX = 255;
+/** The entity and property being validated. The {@link ValidationMessageContext} passed to a {@link ValidationFn} extends it with the validator's settings. */
+export interface ValidationContext {
+    /** The entity whose property is being validated. Set when Breeze validates a property of an entity; an entity-level validator gets the entity as its value instead. */
+    entity?: Entity;
+    /** The {@link DataProperty} or {@link NavigationProperty} being validated. Set when Breeze validates a property. */
+    property?: DataProperty | NavigationProperty;
+    /** The name of the property being validated: a property path, such as `address.city`, for a property of a complex object. */
+    propertyName?: string;
+    /** The value that failed validation, so that a message template can show it as `%value%`. Set by {@link Validator.validate} when validation fails. */
+    value?: any;
+}
+/** Used by Validator to compose messages */
+export interface ValidationMessageContext extends ValidationContext {
+    /** The name of the validator. Set by the {@link Validator} constructor. */
+    name?: string;
+    /** The name to show for the property in messages, as `%displayName%`. When it is not set, Breeze uses the property's `displayName`, or else `propertyName`, or `"Value"` when there is no property. */
+    displayName?: string;
+    /** The error message template. Each `%token%` is replaced with the context property of that name, calling it with the context if it is a function. Defaults to the entry for the validator's name in {@link Validator.messageTemplates}. */
+    messageTemplate?: string;
+    /** A message to use instead of `messageTemplate`: a string, or a function that returns one from the context. */
+    message?: string | ((vc: ValidationContext) => string);
+    /** Marks the validator as async when its function returns a promise without being declared
+    `async`, which Breeze cannot see. An `async` function needs no marking. See {@link Validator.isAsync}. */
+    isAsync?: boolean;
+    /** For an async validator, aborted when its result will no longer be used - another run of the
+    same check started, or the entity was detached. Pass it on to `fetch` to cancel the request. */
+    signal?: AbortSignal;
+    [key: string]: any;
+}
+/** Function called to validate an entity or property. Breeze always passes a context: the
+validator's own, with its settings, extended for each call with the entity and property being
+validated - so a validator reads its settings from it, as `ctx.min`.
+
+It may return a promise, for a check that has to ask a server - see {@link Validator.isAsync}. */
+export interface ValidationFn {
+    (value: any, context: ValidationMessageContext): boolean | Promise<boolean>;
+}
+/**
+Instances of the Validator class provide the logic to validate another object and provide a description of any errors
+encountered during the validation process.  They are typically associated with a 'validators' property on the following types: {@link EntityType},
+{@link DataProperty} or {@link NavigationProperty}.
+
+Property-level validators normally arrive with the metadata. The Breeze server sends a
+`validators` array for each data property - for example `required` for a non-nullable
+property, `maxLength` for a string with a maximum length, and a data-type validator such as
+`int32` or `date`. They are not inferred on the client, so metadata written by hand has
+none unless you add them.
+
+To write your own, construct one with a name, a validation function and a context. Several
+basic "Validator" construction methods are also provided as static methods to this class. These methods
+provide a simpler syntax for creating basic validations.
+
+Many of these stock validators are inspired by and implemented to conform to the validators defined at
+http://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations.aspx
+
+Sometimes a custom validator will be required.
+@example
+Most validators will be 'property' level validators, like this.
+@example
+    // v in this function is the value to be validated, in this case a "country" string.
+    const valFn = (v: string | null) => v == null || v.startsWith("US");
+    const countryValidator = new Validator("countryIsUS", valFn, {
+        displayName: "Country",
+        messageTemplate: "'%displayName%' must start with 'US'"
+    });
+
+    // Now plug it into Breeze.
+    // Assume em1 is a preexisting EntityManager.
+    const custType = em1.metadataStore.getAsEntityType("Customer");
+    const countryProp = custType.getProperty("country");
+    // Note that validator is added to a 'DataProperty' validators collection.
+    countryProp.validators.push(countryValidator);
+Entity level validators are also possible
+@example
+    function isValidZipCode(value: string) {
+        const re = /^\d{5}([\-]\d{4})?$/;
+        return re.test(value);
+    }
+
+    // the value in this case will be a Customer entity
+    const valFn = (cust: Customer) => {
+        // This validator only validates US Zip Codes.
+        if (cust.country === "USA") {
+            return isValidZipCode(cust.postalCode);
+        }
+        return true;
+    };
+    const zipCodeValidator = new Validator("zipCodeValidator", valFn,
+        { messageTemplate: "For the US, this is not a valid PostalCode" });
+
+    // Now plug it into Breeze.
+    // Assume em1 is a preexisting EntityManager.
+    const custType = em1.metadataStore.getAsEntityType("Customer");
+    // Note that validator is added to an 'EntityType' validators collection.
+    custType.validators.push(zipCodeValidator);
+What is commonly needed is a way of creating a parameterized function that will itself
+return a new Validator.  This requires the use of a 'context' object.
+@example
+    // create a function that will take in a config object
+    // and will return a validator
+    const numericRangeValidator = (context: { min?: number, max?: number }) => {
+        const valFn = (v: any, ctx: ValidationMessageContext) => {
+            if (v == null) return true;
+            if (typeof v !== "number") return false;
+            if (ctx.min != null && v < ctx.min) return false;
+            if (ctx.max != null && v > ctx.max) return false;
+            return true;
+        };
+        // The last parameter below is the 'context' object that will be passed into the 'ctx' parameter above
+        // when this validator executes. Several other properties, such as displayName will get added to this object as well.
+        return new Validator("numericRange", valFn, {
+            messageTemplate: "'%displayName%' must be a number between the values of %min% and %max%",
+            min: context.min,
+            max: context.max
+        });
+    };
+    // Assume that freightProperty is a DataEntityProperty that describes numeric values.
+    // register the validator
+    freightProperty.validators.push(numericRangeValidator({ min: 100, max: 500 }));
+
+Breeze substitutes context values and functions for the tokens in the messageTemplate when preparing the runtime error message;
+'displayName' is a pre-defined context function that is always available.
+
+Please note that Breeze substitutes the empty string for falsey parameters. That usually works in your favor.
+Sometimes it doesn't as when the 'min' value is zero in which case the message text would have a hole
+where the 'min' value goes, saying: "... an integer between the values of and ...". That is not what you want.
+
+To avoid this effect, you may can bake certain of the context values into the 'messageTemplate' itself
+as shown in this revision to the pertinent part of the previous example:
+@example
+    // ... as before
+    // ... but bake the min/max values into the message template.
+    const template = core.formatString(
+        "'%displayName%' must be a number between the values of %1 and %2",
+        context.min, context.max);
+    return new Validator("numericRange", valFn, {
+        messageTemplate: template,
+        min: context.min,
+        max: context.max
+    });
+
+@param name {String} The name of this validator.
+@param validatorFn {Function} A function to perform validation.
+
+validatorFn(value, context)
+@param validatorFn.value {Object} Value to be validated
+@param validatorFn.context {Object} The same context object passed into the constructor with the following additional properties if not
+otherwise specified.
+@param validatorFn.context.value {Object} The value being validated.
+@param validatorFn.context.name {String} The name of the validator being executed.
+@param validatorFn.context.displayName {String} This will be either the value of the property's 'displayName' property or
+the value of its 'name' property or the string 'Value'
+@param validatorFn.context.messageTemplate {String} This will either be the value of Validator.messageTemplates[ {this validators name}] or null. Validator.messageTemplates
+is an object that is keyed by validator name and that can be added to in order to 'register' your own message for a given validator.
+The following property can also be specified for any validator to force a specific errorMessage string
+@param [validatorFn.context.message] {String} If this property is set it will be used instead of the 'messageTemplate' property when an
+error message is generated.
+
+@param [context] {Object} A free form object whose properties will made available during the validation and error message creation process.
+This object will be passed into the Validator's validation function whenever 'validate' is called. See above for a description
+of additional properties that will be automatically added to this object if not otherwise specified.
+*/
+export declare class Validator {
+    /** The name of this validator, such as `required` or `maxLength`. It picks the default message template and forms part of each {@link ValidationError}'s key. __Read Only__ */
+    name: string;
+    /** The function that performs the validation. It returns `true` if the value is valid. __Read Only__ */
+    valFn: ValidationFn;
+    /** The context this validator was created with, plus `name`, `messageTemplate` and a `displayName` function. It is passed to `valFn` and used to compose error messages. __Read Only__ */
+    context: ValidationMessageContext;
+    /** The context of the most recent call to {@link Validator.validate}: `context` extended with any additional context passed to it. {@link Validator.getMessage} reads it. After a validation that passed, it is `context` again. __Read Only__ */
+    currentContext: ValidationMessageContext;
+    private _baseContext;
+    /**
+    Whether this validator's function returns a promise: an `async` function, or one created with
+    `isAsync: true` in its context. Breeze runs an async validator only when it can wait for the
+    answer - when an entity is saved, and from {@link EntityAspect.validateEntityAsync} and
+    {@link EntityAspect.validatePropertyAsync}. It does not run on a property change, an attach or
+    a query, where nothing could wait for it; editing the property clears its error instead, as it
+    clears the server's. __Read Only__
+    */
+    isAsync: boolean;
+    /** Creates a validator. See the class description for examples.
+    @param name - The validator's name. Also the default `key` of the errors it produces.
+    @param valFn - The function that validates: called with the value (or, for an entity-level
+      validator, the entity) and the context, it returns whether the value is valid.
+    @param context - Settings for the validator and its messages, such as `displayName` and
+      `messageTemplate`. They are available to `valFn` and to the error message template.
+    */
+    constructor(name: string, valFn: ValidationFn, context?: ValidationMessageContext);
+    /**
+    Run this validator against the specified value.  This method will usually be called internally either
+    automatically by an property change, entity attach, query or save operation, or manually as a result of
+    a validateEntity call on the EntityAspect. The resulting ValidationResults are available via the
+    EntityAspect.getValidationErrors method.
+  
+    However, you can also call a validator directly either for testing purposes or some other reason if needed.
+    @example
+        // using one of the predefined validators
+        const validator = Validator.maxLength({ maxLength: 5, displayName: "City" });
+        // null, because "asdf".length <= 5
+        const noError = validator.validate("asdf");
+        const result = validator.validate("adasdfasdf");
+        // extract all of the properties of the 'result'
+        const errMsg = result.errorMessage;
+        const context = result.context;
+        const sameValidator = result.validator;
+    @param value {Object} Value to validate
+    @param additionalContext {Object} Any additional contextual information that the Validator
+    can make use of.
+    @returns {ValidationError|null} A ValidationError if validation fails, null otherwise
+    */
+    validate(value: any, additionalContext?: ValidationMessageContext): ValidationError | null;
+    /**
+    Runs this validator, sync or async, and resolves with a {@link ValidationError} if the value is
+    invalid, or null. Each call has a context of its own, so calls may overlap; unlike
+    {@link Validator.validate}, it does not set {@link Validator.currentContext}.
+    ```ts
+    const ve = await Validator.maxLength({ maxLength: 5 }).validateAsync("adasdfasdf");
+    ```
+    A function that throws or rejects gives an error, as it does in `validate`.
+    @param value - The value to validate.
+    @param additionalContext - Anything else the validator can use, such as the entity and property.
+    */
+    validateAsync(value: any, additionalContext?: ValidationMessageContext): Promise<ValidationError | null>;
+    /**
+    Returns the message generated by the most recent execution of this Validator.
+    @example
+        const v0 = Validator.maxLength({ maxLength: 5, displayName: "City" });
+        v0.validate("adasdfasdf");
+        const errMessage = v0.getMessage();
+    @returns {String}
+    */
+    getMessage(): string;
+    /**
+    Returns the serializable form of this validator: its `name` plus the context it was created with,
+    such as `{ name: "maxLength", maxLength: 50 }`. Breeze uses it when it exports metadata;
+    {@link Validator.fromJSON} reads it back through the factory registered under that name.
+    */
+    toJSON(): ValidationMessageContext;
+    /**
+    Creates a validator instance from a JSON object or an array of instances from an array of JSON objects.
+    @param json {Object} JSON object that represents the serialized version of a validator.
+    */
+    static fromJSON(json: any): any;
+    /**
+    Register a validator instance so that any deserialized metadata can reference it.
+    @param validator {Validator} Validator to register.
+    */
+    static register(validator: Validator): void;
+    /**
+    Register a validator factory so that any deserialized metadata can reference it.
+    @param validatorFactory {Function} A function that optionally takes a context property and returns a Validator instance.
+    @param name {String} The name of the validator.
+    */
+    static registerFactory(validatorFactory: (options?: any) => Validator, name: string): void;
+    /**
+    Map of standard error message templates keyed by validator name.
+    You can add to or modify this object to customize the template used for any validation error message.
+    @example
+        // v in this function is the value to be validated, in this case a "country" string.
+        const valFn = (v: string | null) => v == null || v.startsWith("US");
+        const countryValidator = new Validator("countryIsUS", valFn, { displayName: "Country" });
+        Validator.messageTemplates.countryIsUS = "'%displayName%' must start with 'US'";
+        // This will have a similar effect to this
+        const countryValidator2 = new Validator("countryIsUS", valFn, {
+            displayName: "Country",
+            messageTemplate: "'%displayName%' must start with 'US'"
+        });
+    @property messageTemplates {Object}
+    */
+    static messageTemplates: Record<string, any>;
+    /**
+    Returns a standard 'required value' Validator
+    @example
+        // Assume em1 is a preexisting EntityManager.
+        const custType = em1.metadataStore.getAsEntityType("Customer");
+        const regionProperty = custType.getProperty("region");
+        // Makes "region" on Customer a required property.
+        regionProperty.validators.push(Validator.required());
+        // or to allow empty strings
+        regionProperty.validators.push(Validator.required({ allowEmptyStrings: true }));
+    @param context - An object with `allowEmptyStrings` (boolean) - If this parameter is omitted or false then empty strings do NOT pass validation.
+    @returns {Validator} A new Validator
+    */
+    static required: (context?: any) => Validator;
+    /**
+    Returns a standard maximum string length Validator; the maximum length must be specified
+    @example
+        // Assume em1 is a preexisting EntityManager.
+        const custType = em1.metadataStore.getAsEntityType("Customer");
+        const regionProperty = custType.getProperty("region");
+        // Validates that the value of the region property on Customer will be less than or equal to 5 characters.
+        regionProperty.validators.push(Validator.maxLength({ maxLength: 5 }));
+    @param context - An object with `maxLength` (number).
+    @returns {Validator} A new Validator
+    */
+    static maxLength: (context: any) => Validator;
+    /**
+    Returns a standard string length Validator; both minimum and maximum lengths must be specified.
+    @example
+        // Assume em1 is a preexisting EntityManager.
+        const custType = em1.metadataStore.getAsEntityType("Customer");
+        const regionProperty = custType.getProperty("region");
+        // Validates that the value of the region property on Customer will be
+        // between 2 and 5 characters
+        regionProperty.validators.push(Validator.stringLength({ minLength: 2, maxLength: 5 }));
+    @param context - An object with `maxLength` (number); `minLength` (number).
+    @returns {Validator} A new Validator
+    */
+    static stringLength: (context: any) => Validator;
+    /**
+    Returns a standard string dataType Validator.
+    @example
+        // Assume em1 is a preexisting EntityManager.
+        const custType = em1.metadataStore.getAsEntityType("Customer");
+        const regionProperty = custType.getProperty("region");
+        // Validates that the value of the region property on Customer is a string.
+        regionProperty.validators.push(Validator.string());
+    @returns {Validator} A new Validator
+    */
+    static string: () => Validator;
+    /**
+    Returns a Guid data type Validator.
+    @example
+        // Assume em1 is a preexisting EntityManager.
+        const custType = em1.metadataStore.getAsEntityType("Customer");
+        const customerIdProperty = custType.getProperty("customerID");
+        // Validates that the value of the customerID property on Customer is a Guid.
+        customerIdProperty.validators.push(Validator.guid());
+    @returns {Validator} A new Validator
+    */
+    static guid: () => Validator;
+    /**
+    Returns a ISO 8601 duration string  Validator.
+    @example
+        // Assume em1 is a preexisting EntityManager.
+        const timeLimitType = em1.metadataStore.getAsEntityType("TimeLimit");
+        const maxTimeProperty = timeLimitType.getProperty("maxTime");
+        // Validates that the value of the maxTime property on TimeLimit is a duration.
+        maxTimeProperty.validators.push(Validator.duration());
+    @returns {Validator} A new Validator
+    */
+    static duration: () => Validator;
+    /**
+    Returns a standard numeric data type Validator.
+    @example
+        // Assume em1 is a preexisting EntityManager.
+        const orderType = em1.metadataStore.getAsEntityType("Order");
+        const freightProperty = orderType.getProperty("freight");
+        // Validates that the value of the freight property on Order is a number.
+        freightProperty.validators.push(Validator.number());
+    @returns {Validator} A new Validator
+    */
+    static number: (context?: any) => Validator;
+    /** Another name for {@link Validator.number}, registered as `double` so that metadata naming it imports. The validator it returns is named `number`. */
+    static double: (context?: any) => Validator;
+    /** Another name for {@link Validator.number}, registered as `single` so that metadata naming it imports. The validator it returns is named `number`. */
+    static single: (context?: any) => Validator;
+    /**
+    Returns a standard large integer data type - 64 bit - Validator.
+    @example
+        // Assume em1 is a preexisting EntityManager.
+        const orderType = em1.metadataStore.getAsEntityType("Order");
+        const freightProperty = orderType.getProperty("freight");
+        // Validates that the value of the freight property on Order is within the range of a 64 bit integer.
+        freightProperty.validators.push(Validator.int64());
+    @returns {Validator} A new Validator
+    */
+    static integer: (context?: any) => Validator;
+    /** Another name for {@link Validator.integer}, and the data-type validator for {@link DataType.Int64}: it checks that the value is a whole number, with no range check. The validator it returns is named `integer`. */
+    static int64: (context?: any) => Validator;
+    /**
+    Returns a standard 32 bit integer data type Validator.
+    @example
+        // Assume em1 is a preexisting EntityManager.
+        const orderType = em1.metadataStore.getAsEntityType("Order");
+        const freightProperty = orderType.getProperty("freight");
+        freightProperty.validators.push(Validator.int32());
+    @returns {Validator} A new Validator
+    */
+    static int32: (context?: any) => Validator;
+    /**
+    Returns a standard 16 bit integer data type Validator.
+    @example
+        // Assume em1 is a preexisting EntityManager.
+        const orderType = em1.metadataStore.getAsEntityType("Order");
+        const freightProperty = orderType.getProperty("freight");
+        // Validates that the value of the freight property on Order is within the range of a 16 bit integer.
+        freightProperty.validators.push(Validator.int16());
+    @returns {Validator} A new Validator
+    */
+    static int16: (context?: any) => Validator;
+    /**
+    Returns a standard byte data type Validator. (This is a integer between 0 and 255 inclusive for js purposes).
+    @example
+        // Assume em1 is a preexisting EntityManager.
+        const orderType = em1.metadataStore.getAsEntityType("Order");
+        const freightProperty = orderType.getProperty("freight");
+        // Validates that the value of the freight property on Order is a byte: an integer from 0 to 255.
+        // Probably not a very good validation to place on the freight property.
+        freightProperty.validators.push(Validator.byte());
+    @returns {Validator} A new Validator
+    */
+    static byte: (context?: any) => Validator;
+    /**
+    Returns a standard boolean data type Validator.
+    @example
+        // Assume em1 is a preexisting EntityManager.
+        const productType = em1.metadataStore.getAsEntityType("Product");
+        const discontinuedProperty = productType.getProperty("isDiscontinued");
+        // Validates that the value of the isDiscontinued property on Product is a boolean
+        discontinuedProperty.validators.push(Validator.bool());
+    @returns {Validator} A new Validator
+    */
+    static bool: () => Validator;
+    /** Returns a Validator named `none` that accepts every value. It is the data-type validator for {@link DataType.Binary} and {@link DataType.Undefined}. */
+    static none: () => Validator;
+    /**
+    Returns a standard date data type Validator.
+    @example
+        // Assume em1 is a preexisting EntityManager.
+        const orderType = em1.metadataStore.getAsEntityType("Order");
+        const orderDateProperty = orderType.getProperty("orderDate");
+        // Validates that the value of the orderDate property on Order is a date
+        orderDateProperty.validators.push(Validator.date());
+    @returns {Validator} A new Validator
+    */
+    static date: () => Validator;
+    /**
+    Returns a credit card number validator
+    Performs a luhn algorithm checksum test for plausability
+    catches simple mistakes; only service knows for sure
+    @example
+        // Assume em is a preexisting EntityManager.
+        const personType = em.metadataStore.getAsEntityType("Person");
+        const creditCardProperty = personType.getProperty("creditCard");
+        // Validates that the value of the Person.creditCard property is credit card.
+        creditCardProperty.validators.push(Validator.creditCard());
+    @param [context] {Object} optional parameters to pass through to validation constructor
+    @returns {Validator} A new Validator
+    */
+    static creditCard: (context?: any) => Validator;
+    /**
+    Returns a regular expression validator; the expression must be specified
+    @example
+        // Add validator to a property. Assume em is a preexisting EntityManager.
+        const customerType = em.metadataStore.getAsEntityType("Customer");
+        const regionProperty = customerType.getProperty("region");
+        // Validates that the value of Customer.region is 2 char uppercase alpha.
+        regionProperty.validators.push(Validator.regularExpression({ expression: '^[A-Z]{2}$' }));
+    @param context - An object with `expression` (string) - String form of the regular expression to apply.
+    @returns {Validator} A new Validator
+    */
+    static regularExpression: (context?: any) => Validator;
+    /**
+    Returns the email address validator
+    @example
+        // Assume em is a preexisting EntityManager.
+        const userType = em.metadataStore.getAsEntityType("User");
+        const emailProperty = userType.getProperty("email");
+        // Validates that the value of the User.email property is an email address.
+        emailProperty.validators.push(Validator.emailAddress());
+    @param [context] {Object} optional parameters to pass through to validation constructor
+    @returns {Validator} A new Validator
+    */
+    static emailAddress: (context?: any) => Validator;
+    /**
+    Returns the phone validator
+    Provides basic assertions on the format and will help to eliminate most nonsense input
+    Matches:
+    International dialing prefix: one of nothing, `+`, `0` or `0000` (with or without a trailing break character, if not '+': [-/. ])
+    ```ts
+    ((\+)|(0(\d+)?[-/.\s]))
+    ```
+    Country code: nothing, or `1` to `999` (with or without a trailing break character: [-/. ])
+    ```ts
+    [1-9]\d{,2}[-/.\s]?
+    ```
+    Area code: `(0)` to `(000000)`, or `0` to `000000` (with or without a trailing break character: [-/. ])
+    ```ts
+    ((\(\d{1,6}\)|\d{1,6})[-/.\s]?)?
+    ```
+    Local: one or more digits (with or without a trailing break character: [-/. ])
+    ```ts
+    (\d+[-/.\s]?)+\d+
+    ```
+    @example
+        // Assume em is a preexisting EntityManager.
+        const customerType = em.metadataStore.getAsEntityType("Customer");
+        const phoneProperty = customerType.getProperty("phone");
+        // Validates that the value of the Customer.phone property is phone.
+        phoneProperty.validators.push(Validator.phone());
+    @param [context] {Object} optional parameters to pass through to validation constructor
+    @returns {Validator} A new Validator
+    */
+    static phone: (context?: any) => Validator;
+    /**
+    Returns the URL (protocol required) validator
+    @example
+        // Assume em is a preexisting EntityManager.
+        const supplierType = em.metadataStore.getAsEntityType("Supplier");
+        const homePageProperty = supplierType.getProperty("homePage");
+        // Validates that the value of the Supplier.homePage property is a URL.
+        homePageProperty.validators.push(Validator.url());
+    @param [context] {Object} optional parameters to pass through to validation constructor
+    @returns {Validator} A new Validator
+    */
+    static url: (context?: any) => Validator;
+    /**
+    Creates a regular expression validator with a fixed expression.
+    Many of the stock validators are built with this factory method.
+    Their expressions are often derived from
+    https://github.com/srkirkland/DataAnnotationsExtensions/blob/master/DataAnnotationsExtensions
+    You can try many of them at http://dataannotationsextensions.org/
+    @example
+        // Make a zipcode validator
+        const zipValidator = Validator.makeRegExpValidator(
+            "zipVal",
+            /^\d{5}([\-]\d{4})?$/,
+            "The %displayName% '%value%' is not a valid U.S. zipcode");
+        // Register it.
+        Validator.register(zipValidator);
+        // Add it to a data property. Assume em is a preexisting EntityManager.
+        const custType = em.metadataStore.getAsEntityType("Customer");
+        const zipProperty = custType.getProperty("postalCode");
+        zipProperty.validators.push(zipValidator);
+    @param validatorName {String} name of this validator
+    @param expression {String | RegExp} regular expression to apply
+    @param [defaultMessage] {String} default message for failed validations
+    @param [context] {Object} optional parameters to pass through to validation constructor
+    @returns {Validator} A new Validator
+    */
+    static makeRegExpValidator: typeof makeRegExpValidator;
+}
+export declare function makeRegExpValidator(validatorName: string, expression: RegExp, defaultMessage?: string | null, context?: any): Validator;
+/**
+Describes one failed validation: which validator failed, on which property, and the message to
+show. An entity's current errors are in {@link EntityAspect.getValidationErrors}. The errors a
+server reports for a failed save are added there too, with {@link ValidationError.isServerError} set.
+*/
+export declare class ValidationError {
+    /** The {@link Validator} that produced this error. `undefined` for an error from the server or one created without a validator. __Read Only__ */
+    validator?: Validator;
+    /** The key that identifies this error among an entity's validation errors: the validator's name (or the error name), then `:` and the property name if there is one. Adding an error with the same key replaces the old one. __Read Only__ */
+    key: string;
+    /** The context the error was created with - for a validator, its context when it ran, which for a property error includes `entity`, `property`, `propertyName` and `value`. __Read Only__ */
+    context: any;
+    /** The error message. __Read Only__ */
+    errorMessage: string;
+    /** The {@link DataProperty} or {@link NavigationProperty} this error is about, or `undefined` for an entity-level error. __Read Only__ */
+    property: any;
+    /** The name of the property this error is about - a property path, such as `address.city`, for a property of a complex object - or `undefined` for an entity-level error. __Read Only__ */
+    propertyName?: string;
+    /** Whether this error came from the server in a failed save. Server errors do not block a save, and are cleared when the property is changed or the entity is saved again. __Read Only__ */
+    isServerError: boolean;
+    /**
+    Creates a validation error. Applications usually add one with
+    {@link EntityAspect.addValidationError} after creating it here.
+    @param validator - The Validator that found the error, or `null` for an error found some other way.
+    @param context - The context to record with the error: for a property, its `entity`, `property`,
+      `propertyName` and `value`.
+    @param errorMessage - The message to show.
+    @param key - Identifies the error among the entity's errors. If not given, it is built from the
+      validator's name - or, without a validator, the error message - and the property name; see
+      {@link ValidationError.getKey}.
+    */
+    constructor(validator: Validator | null, context: ValidationContext, errorMessage: string, key?: string);
+    /**
+    Composes a ValidationError 'key' given a validator or an errorName and an optional propertyName
+    @param validatorOrErrorName - A Validator, or an "error name" if no validator is available.
+    @param [propertyName] A property name
+    @returns {String} A ValidationError 'key'
+    */
+    static getKey(validatorOrErrorName: Validator | string, propertyName?: string): string;
+}