@platecms/delta-validation 0.4.1 → 0.7.0

package/src/lib/validation-rules/decimal-count.validation-rule.ts

@@ -0,0 +1,52 @@
+import { ContentValueType } from "@platecms/delta-types";
+import { ValidationErrorDetails } from "../errors/validation-error-details";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { RuleType } from "../enums/rule-types.enum";
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { validationFunctionFromValidateValue } from "./validation-rule-function.factory";
+
+function getDecimalCount(value: number): number {
+  const [_, decimalDigits] = value.toString().split(".");
+  return decimalDigits ? decimalDigits.length : 0;
+}
+
+export function validateValueDecimalCount(
+  value: ContentValueType,
+  ruleInstance: RuleInstance<DecimalCountValidationRuleSettings>,
+): ContentValidationResultType {
+  const num = Number(value);
+  if (Number.isNaN(num)) {
+    return null;
+  }
+
+  const decimalCount = getDecimalCount(num);
+
+  const maxDecimals = ruleInstance.settings.max;
+  const isDefined = maxDecimals != null && maxDecimals !== undefined;
+  if (isDefined && decimalCount > maxDecimals) {
+    return new ValidationErrorDetails(`The number must not have more than ${maxDecimals} decimals.`, ruleInstance);
+  }
+
+  return true;
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const validateDecimalCount = validationFunctionFromValidateValue(validateValueDecimalCount);
+
+/**
+ * A validation rule that checks whether the amount of decimals in a number is between a certain range.
+ * The amount of decimals is counted based on the amount of digits before the last
+ * non-zero digit after the decimal point.
+ * For example: 1.0000 has 0 decimals, 1.0001 has 4 decimals.
+ */
+export class DecimalCountValidationRule extends BaseValidationRule<DecimalCountValidationRuleSettings> {
+  public readonly ruleType: RuleType = RuleType.DECIMAL_COUNT;
+
+  public override validate(values: ContentValueType[]): ContentValidationResultType[] {
+    return validateDecimalCount(values, this);
+  }
+}
+
+export interface DecimalCountValidationRuleSettings {
+  max: number;
+}

package/src/lib/validation-rules/number-between.validation-rule.spec.ts

@@ -0,0 +1,77 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { InvalidValidationRuleSettingsError } from "../errors/invalid-validation-rule-settings.error";
+import { NumberBetweenValidationRule } from "./number-between.validation-rule";
+
+describe("NumberBetweenValidationRule", () => {
+  const rulePrn = PRN.fromString("prn:plate:-1:cxc:validation-rule:1");
+
+  describe("constructor", () => {
+    it("throws an error if min and max are not provided", () => {
+      expect(() => {
+        new NumberBetweenValidationRule(rulePrn, {});
+      }).toThrowError(InvalidValidationRuleSettingsError);
+    });
+  });
+
+  describe("validate", () => {
+    describe("with min and max", () => {
+      let rule: NumberBetweenValidationRule;
+
+      beforeEach(() => {
+        rule = new NumberBetweenValidationRule(rulePrn, {
+          min: 1,
+          max: 2,
+        });
+      });
+
+      it.each([
+        [1, true],
+        [2, true],
+        [1.5, true],
+        [0.9, false],
+        [2.1, false],
+        ["foo", null],
+      ])("returns %s for value within the bounds", (value, expected) => {
+        expect(rule.validate([value])).toBeContentValidationResult([expected]);
+      });
+    });
+
+    describe("with only min", () => {
+      let rule: NumberBetweenValidationRule;
+
+      beforeEach(() => {
+        rule = new NumberBetweenValidationRule(rulePrn, {
+          min: 1,
+        });
+      });
+
+      it.each([
+        [1, true],
+        [1.1, true],
+        [0.9, false],
+        ["foo", null],
+      ])("returns %s for value within the bounds", (value, expected) => {
+        expect(rule.validate([value])).toBeContentValidationResult([expected]);
+      });
+    });
+
+    describe("with only max", () => {
+      let rule: NumberBetweenValidationRule;
+
+      beforeEach(() => {
+        rule = new NumberBetweenValidationRule(rulePrn, {
+          max: 2,
+        });
+      });
+
+      it.each([
+        [2, true],
+        [1.9, true],
+        [2.1, false],
+        ["foo", null],
+      ])("returns %s for value within the bounds", (value, expected) => {
+        expect(rule.validate([value])).toBeContentValidationResult([expected]);
+      });
+    });
+  });
+});

package/src/lib/validation-rules/number-between.validation-rule.ts

@@ -0,0 +1,58 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType } from "@platecms/delta-types";
+import { InvalidValidationRuleSettingsError } from "../errors/invalid-validation-rule-settings.error";
+import { ValidationErrorDetails } from "../errors/validation-error-details";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { RuleType } from "../enums/rule-types.enum";
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { validationFunctionFromValidateValue } from "./validation-rule-function.factory";
+
+export function validateValueNumberBetween(
+  value: ContentValueType,
+  ruleInstance: RuleInstance<NumberBetweenValidationRuleSettings>,
+): ContentValidationResultType {
+  const num = Number(value);
+  if (Number.isNaN(num)) {
+    return null;
+  }
+
+  if (ruleInstance.settings.min != null && num < ruleInstance.settings.min) {
+    return new ValidationErrorDetails(
+      `The value must be greater than or equal ${ruleInstance.settings.min}.`,
+      ruleInstance,
+    );
+  }
+  if (ruleInstance.settings.max != null && num > ruleInstance.settings.max) {
+    return new ValidationErrorDetails(
+      `The value must be less than or equal ${ruleInstance.settings.max}.`,
+      ruleInstance,
+    );
+  }
+  return true;
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const validateNumberBetween = validationFunctionFromValidateValue(validateValueNumberBetween);
+
+/**
+ * A validation rule that checks whether a number is between a certain range.
+ */
+export class NumberBetweenValidationRule extends BaseValidationRule<NumberBetweenValidationRuleSettings> {
+  public readonly ruleType: RuleType = RuleType.NUMBER_BETWEEN;
+
+  public constructor(prn: PRN, settings: NumberBetweenValidationRuleSettings) {
+    if (settings.min == null && settings.max == null) {
+      throw new InvalidValidationRuleSettingsError("Either min or max must be defined.");
+    }
+    super(prn, settings);
+  }
+
+  public override validate(values: ContentValueType[]): ContentValidationResultType[] {
+    return validateNumberBetween(values, this);
+  }
+}
+
+export interface NumberBetweenValidationRuleSettings {
+  min?: number;
+  max?: number;
+}

package/src/lib/validation-rules/relatable-content-types.validation-rule.spec.ts

@@ -0,0 +1,35 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { InvalidValidationArgumentsError } from "../errors/invalid-validation-arguments.error";
+import { RelatableContentTypesValidationRule } from "./relatable-content-types.validation-rule";
+
+describe("RelatableContentTypesValidationRule", () => {
+  const rulePrn = PRN.fromString("prn:plate:-1:cxc:validation-rule:1");
+  const contentItemPrn = PRN.fromString("prn:plate:-1:cxc:content-item:1");
+
+  const allowedContentTypes = [
+    PRN.fromString("prn:plate:-1:cxc:content-type:1"),
+    PRN.fromString("prn:plate:-1:cxc:content-type:2"),
+  ];
+
+  const disallowedContentType = PRN.fromString("prn:plate:-1:cxc:content-type:3");
+
+  let rule: RelatableContentTypesValidationRule;
+
+  beforeEach(() => {
+    rule = new RelatableContentTypesValidationRule(rulePrn, {
+      allowedContentTypes,
+    });
+  });
+
+  it.each([
+    [contentItemPrn, allowedContentTypes[0], true],
+    [contentItemPrn, disallowedContentType, false],
+    ["not a ContentItem", disallowedContentType, false],
+  ])("returns %s for the provided content item", (contentItem, contentType, expected) => {
+    expect(rule.validate([contentItem], [contentType])).toBeContentValidationResult([expected]);
+  });
+
+  it("throws an error if the value does not have a ContentType", () => {
+    expect(() => rule.validate([contentItemPrn])).toThrowError(InvalidValidationArgumentsError);
+  });
+});

package/src/lib/validation-rules/relatable-content-types.validation-rule.ts

@@ -0,0 +1,61 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType } from "@platecms/delta-types";
+import { InvalidValidationArgumentsError } from "../errors/invalid-validation-arguments.error";
+import { ValidationErrorDetails } from "../errors/validation-error-details";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { RuleType } from "../enums/rule-types.enum";
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+
+function validateValueRelatableContentTypes<TContentType>(
+  value: ContentValueType,
+  contentType: TContentType,
+  ruleInstance: RuleInstance<RelatableContentTypesValidationRuleSettings<TContentType>>,
+): ContentValidationResultType {
+  if (contentType === undefined) {
+    throw new InvalidValidationArgumentsError(`Missing attribute 'contentType' for value: ${JSON.stringify(value)}`);
+  }
+
+  if (!ruleInstance.settings.allowedContentTypes.includes(contentType)) {
+    return new ValidationErrorDetails(
+      `The provided content type must be type of ${ruleInstance.settings.allowedContentTypes.join(", ")}`,
+      ruleInstance,
+    );
+  }
+
+  return true;
+}
+
+export function validateRelatableContentTypes<TContentType>(
+  values: ContentValueType[],
+  ruleInstance: RuleInstance<RelatableContentTypesValidationRuleSettings<TContentType>>,
+  contentTypes: TContentType[],
+): ContentValidationResultType[] {
+  if (values.length !== contentTypes.length) {
+    throw new InvalidValidationArgumentsError(`The length of values and contentTypes must be equal.`);
+  }
+
+  return values.map((value, index) => validateValueRelatableContentTypes(value, contentTypes[index], ruleInstance));
+}
+
+/**
+ * A validation rule that checks whether a value (ContentItem) is of a certain ContentType
+ */
+export class RelatableContentTypesValidationRule extends BaseValidationRule<
+  RelatableContentTypesValidationRuleSettings<PRN>
+> {
+  public readonly ruleType: RuleType = RuleType.RELATABLE_CONTENT_TYPES;
+
+  public override validate(values: ContentValueType[], contentTypes?: PRN[]): ContentValidationResultType[] {
+    if (contentTypes === undefined) {
+      throw new InvalidValidationArgumentsError(
+        `Missing attribute 'contentTypes' in values: ${JSON.stringify(values)}`,
+      );
+    }
+
+    return validateRelatableContentTypes(values, this, contentTypes);
+  }
+}
+
+export interface RelatableContentTypesValidationRuleSettings<TContentType> {
+  allowedContentTypes: TContentType[];
+}

package/src/lib/validation-rules/string-format.validation-rule.spec.ts

@@ -0,0 +1,43 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { StringFormatValidationRule } from "./string-format.validation-rule";
+
+describe("StringFormatValidationRule", () => {
+  const rulePrn = PRN.fromString("prn:plate:-1:cxc:validation-rule:string-format");
+
+  describe("with an email regex", () => {
+    let rule: StringFormatValidationRule;
+
+    beforeEach(() => {
+      rule = new StringFormatValidationRule(rulePrn, {
+        allowedFormat: "^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$",
+      });
+    });
+
+    it.each([
+      ["david@getplate.com", true],
+      ["david@getplate", false],
+      [123, null],
+    ])("returns %s for the provided value", (value, expected) => {
+      expect(rule.validate([value])).toBeContentValidationResult([expected]);
+    });
+  });
+
+  describe("with a just letters regex", () => {
+    let rule: StringFormatValidationRule;
+
+    beforeEach(() => {
+      rule = new StringFormatValidationRule(rulePrn, {
+        allowedFormat: "^[a-zA-Z]+$",
+      });
+    });
+
+    it.each([
+      ["abc", true],
+      ["abc123", false],
+      ["", false],
+      [123, null],
+    ])("returns %s for the provided value", (value, expected) => {
+      expect(rule.validate([value])).toBeContentValidationResult([expected]);
+    });
+  });
+});

package/src/lib/validation-rules/string-format.validation-rule.ts

@@ -0,0 +1,50 @@
+import { ContentValueType } from "@platecms/delta-types";
+import { ValidationErrorDetails } from "../errors/validation-error-details";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { RuleType } from "../enums/rule-types.enum";
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { validationFunctionFromValidateValue } from "./validation-rule-function.factory";
+
+export function validateValueStringFormat(
+  value: ContentValueType,
+  ruleInstance: RuleInstance<StringFormatValidationRuleSettings>,
+): ContentValidationResultType {
+  if (typeof value !== "string") {
+    return null;
+  }
+
+  const { allowedFormat } = ruleInstance.settings;
+  const isDefined = allowedFormat !== undefined && allowedFormat !== null;
+
+  if (!isDefined) {
+    return null;
+  }
+
+  // eslint-disable-next-line require-unicode-regexp
+  const regex = new RegExp(allowedFormat);
+
+  if (!regex.test(value)) {
+    /* @TODO Determine how to display regex error to display what exactly went wrong */
+    return new ValidationErrorDetails(`String does not match the required format`, ruleInstance);
+  }
+
+  return true;
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const validateStringFormat = validationFunctionFromValidateValue(validateValueStringFormat);
+
+/**
+ * A validation rule that checks whether a string matches a certain format.
+ */
+export class StringFormatValidationRule extends BaseValidationRule<StringFormatValidationRuleSettings> {
+  public readonly ruleType: RuleType = RuleType.STRING_FORMAT;
+
+  public override validate(values: ContentValueType[]): ContentValidationResultType[] {
+    return validateStringFormat(values, this);
+  }
+}
+
+export interface StringFormatValidationRuleSettings {
+  allowedFormat: string;
+}

package/src/lib/validation-rules/validation-rule-function.factory.ts

@@ -0,0 +1,23 @@
+import { ContentValueType } from "@platecms/delta-types";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { ContentValidationResultType } from "./base.validation-rule";
+
+/**
+ * Generates a function that validates ContentValue[] against the rule.
+ * The returned function returns array with for each value: true if the value is valid,
+ * ContentValidationErrorDetail if it is invalid, and null if the rule does not apply to the value.
+ * Some validation rules perform validation on the array as a whole, in which case the array will be validated as a whole,
+ * and the result will be returned in the first element of the array. E.g. the CountValidationRule.
+ */
+export function validationFunctionFromValidateValue<TRuleInstanceSettings>(
+  validateValue: (
+    value: ContentValueType,
+    ruleInstance: RuleInstance<TRuleInstanceSettings>,
+  ) => ContentValidationResultType,
+) {
+  return function validate<
+    TRuleInstance extends RuleInstance<TRuleInstanceSettings> = RuleInstance<TRuleInstanceSettings>,
+  >(values: ContentValueType[], ruleInstance: TRuleInstance): ContentValidationResultType[] {
+    return values.map((value) => validateValue(value, ruleInstance));
+  };
+}

package/src/lib/validation-rules/value-type.validation-rule.spec.ts

@@ -0,0 +1,108 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType, ContentValueTypeNames } from "@platecms/delta-types";
+import { ValueTypeValidationRule, ValueTypeValidationRuleSettings } from "./value-type.validation-rule";
+
+describe("ValueTypeValidationRule", () => {
+  const rulePrn = PRN.fromString("prn:plate:-1:cxc:validation-rule:value-type");
+
+  describe.each([
+    [
+      "with allowed string type",
+      { allowedTypes: [ContentValueTypeNames.STRING] },
+      [
+        ["foo", true],
+        [123, false],
+      ],
+    ],
+    [
+      "with allowed number type",
+      { allowedTypes: [ContentValueTypeNames.NUMBER] },
+      [
+        [123, true],
+        ["foo", false],
+      ],
+    ],
+    [
+      "with allowed boolean type",
+      { allowedTypes: [ContentValueTypeNames.BOOLEAN] },
+      [
+        [true, true],
+        ["foo", false],
+      ],
+    ],
+    [
+      "with allowed date type",
+      { allowedTypes: [ContentValueTypeNames.DATE] },
+      [
+        [new Date(), true],
+        ["foo", false],
+      ],
+    ],
+    [
+      "with allowed content item type",
+      { allowedTypes: [ContentValueTypeNames.CONTENT_ITEM] },
+      [
+        [PRN.fromString("prn:plate:-1:cxc:content-item:1"), true],
+        ["foo", false],
+      ],
+    ],
+    [
+      "with allowed asset type",
+      { allowedTypes: [ContentValueTypeNames.ASSET] },
+      [
+        [PRN.fromString("prn:plate:-1:am:asset:1"), true],
+        ["foo", false],
+      ],
+    ],
+    [
+      "with allowed path part type",
+      { allowedTypes: [ContentValueTypeNames.PATH_PART] },
+      [
+        [PRN.fromString("prn:plate:-1:cxc:path-part:1"), true],
+        ["foo", false],
+      ],
+    ],
+    [
+      "with allowed grid placement type",
+      { allowedTypes: [ContentValueTypeNames.GRID_PLACEMENT] },
+      [
+        [PRN.fromString("prn:plate:-1:cxc:grid-placement:1"), true],
+        ["foo", false],
+      ],
+    ],
+    [
+      "with allowed smart text type",
+      { allowedTypes: [ContentValueTypeNames.SMART_TEXT] },
+      [
+        [{ type: "root", children: [] }, true],
+        [PRN.fromString("prn:plate:-1:cxc:grid-placement:1"), false],
+      ],
+    ],
+    [
+      "with incorrect prn",
+      { allowedTypes: [ContentValueTypeNames.CONTENT_ITEM] },
+      [[PRN.fromString("prn:plate:-1:am:asset:1"), false]],
+    ],
+    [
+      "with multiple types",
+      {
+        allowedTypes: [ContentValueTypeNames.STRING, ContentValueTypeNames.CONTENT_ITEM],
+      },
+      [
+        ["foo", true],
+        [PRN.fromString("prn:plate:-1:cxc:content-item:1"), true],
+        [new Date(), false],
+      ],
+    ],
+  ])("%s", (_, ruleConfig, testCases: unknown[]) => {
+    let rule: ValueTypeValidationRule;
+
+    beforeEach(() => {
+      rule = new ValueTypeValidationRule(rulePrn, ruleConfig as ValueTypeValidationRuleSettings);
+    });
+
+    it.each(testCases)("returns %s for the provided value", (value, expected) => {
+      expect(rule.validate([value as ContentValueType])).toBeContentValidationResult([expected]);
+    });
+  });
+});

package/src/lib/validation-rules/value-type.validation-rule.ts

@@ -0,0 +1,76 @@
+import { InvalidCastError, validateCast } from "@platecms/delta-cast";
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType, ContentValueTypeName, ContentValueTypeNames } from "@platecms/delta-types";
+import { ValidationErrorDetails } from "../errors/validation-error-details";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { RuleType } from "../enums/rule-types.enum";
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { validationFunctionFromValidateValue } from "./validation-rule-function.factory";
+
+/**
+ * Mapping of PRN resource type to Content Value Type Name.
+ */
+const prnResourceTypeToContentValueTypeNameMap: Record<string, ContentValueTypeNames> = {
+  /* eslint-disable @typescript-eslint/naming-convention */
+  "content-item": ContentValueTypeNames.CONTENT_ITEM,
+  asset: ContentValueTypeNames.ASSET,
+  "path-part": ContentValueTypeNames.PATH_PART,
+  "grid-placement": ContentValueTypeNames.GRID_PLACEMENT,
+  tag: ContentValueTypeNames.TAG,
+  "content-type": ContentValueTypeNames.CONTENT_TYPE,
+  /* eslint-enable @typescript-eslint/naming-convention */
+};
+
+export function validateValueValueType(
+  value: ContentValueType,
+  ruleInstance: RuleInstance<ValueTypeValidationRuleSettings>,
+): ContentValidationResultType {
+  if (value instanceof Date && ruleInstance.settings.allowedTypes.includes(ContentValueTypeNames.DATE)) {
+    return true;
+  }
+
+  try {
+    validateCast(value);
+    if (ruleInstance.settings.allowedTypes.includes(ContentValueTypeNames.SMART_TEXT)) {
+      return true;
+    }
+  } catch (error) {
+    if (!(error instanceof InvalidCastError)) {
+      throw error;
+    }
+  }
+
+  if (
+    value instanceof PRN &&
+    ruleInstance.settings.allowedTypes.includes(prnResourceTypeToContentValueTypeNameMap[value.resourceType])
+  ) {
+    return true;
+  }
+
+  if (
+    ruleInstance.settings.allowedTypes.includes((typeof value).toUpperCase() as ContentValueTypeName<ContentValueType>)
+  ) {
+    return true;
+  }
+
+  return new ValidationErrorDetails(`The value must be of the correct type.`, ruleInstance);
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const validateValueType = validationFunctionFromValidateValue(validateValueValueType);
+
+/**
+ * A validation rule that checks whether a value is of a certain ContentValueType
+ */
+export class ValueTypeValidationRule extends BaseValidationRule<ValueTypeValidationRuleSettings> {
+  public readonly ruleType: RuleType = RuleType.VALUE_TYPE;
+
+  public override validate(values: ContentValueType[]): ContentValidationResultType[] {
+    return validateValueType(values, this);
+  }
+}
+
+// The value type can be one or more of the types specified in the ContentValueType type
+export interface ValueTypeValidationRuleSettings {
+  allowedTypes: ContentValueTypeName<ContentValueType>[];
+}

package/src/index.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./lib/errors/invalid-validation-arguments.error"), exports);
-tslib_1.__exportStar(require("./lib/errors/invalid-validation-rule-settings.error"), exports);
-tslib_1.__exportStar(require("./lib/errors/validation.error"), exports);
-tslib_1.__exportStar(require("./lib/errors/validation-error-details"), exports);
-tslib_1.__exportStar(require("./lib/helpers/deserialize-validation-rule"), exports);
-tslib_1.__exportStar(require("./lib/validation-rules/number-between.validation-rule"), exports);
-tslib_1.__exportStar(require("./lib/helpers/rule-to-schema"), exports);
-tslib_1.__exportStar(require("./lib/helpers/schema-builder"), exports);
-tslib_1.__exportStar(require("./lib/enums/rule-types.enum"), exports);
-tslib_1.__exportStar(require("./lib/validation-rules/allowed-values.validation-rule"), exports);
-tslib_1.__exportStar(require("./lib/validation-rules/base.validation-rule"), exports);
-tslib_1.__exportStar(require("./lib/validation-rules/count.validation-rule"), exports);
-tslib_1.__exportStar(require("./lib/validation-rules/date-between.validation-rule"), exports);
-tslib_1.__exportStar(require("./lib/validation-rules/decimal-count.validation-rule"), exports);
-tslib_1.__exportStar(require("./lib/validation-rules/number-between.validation-rule"), exports);
-tslib_1.__exportStar(require("./lib/validation-rules/relatable-content-types.validation-rule"), exports);
-tslib_1.__exportStar(require("./lib/validation-rules/string-format.validation-rule"), exports);
-tslib_1.__exportStar(require("./lib/validation-rules/validation-rule-function.factory"), exports);
-tslib_1.__exportStar(require("./lib/validation-rules/value-type.validation-rule"), exports);
-//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/validation/src/index.ts"],"names":[],"mappings":";;;AAAA,0FAAgE;AAChE,8FAAoE;AACpE,wEAA8C;AAC9C,gFAAsD;AACtD,oFAA0D;AAC1D,gGAAsE;AAEtE,uEAA6C;AAC7C,uEAA6C;AAM7C,sEAA4C;AAE5C,gGAAsE;AACtE,sFAA4D;AAC5D,uFAA6D;AAC7D,8FAAoE;AACpE,+FAAqE;AACrE,gGAAsE;AACtE,yGAA+E;AAC/E,+FAAqE;AACrE,kGAAwE;AACxE,4FAAkE"}

package/src/lib/enums/rule-types.enum.d.ts

@@ -1,10 +0,0 @@
-export declare enum RuleType {
-    ALLOWED_VALUES = "ALLOWED_VALUES",
-    COUNT = "COUNT",
-    DATE_BETWEEN = "DATE_BETWEEN",
-    DECIMAL_COUNT = "DECIMAL_COUNT",
-    NUMBER_BETWEEN = "NUMBER_BETWEEN",
-    RELATABLE_CONTENT_TYPES = "RELATABLE_CONTENT_TYPES",
-    STRING_FORMAT = "STRING_FORMAT",
-    VALUE_TYPE = "VALUE_TYPE"
-}

package/src/lib/enums/rule-types.enum.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuleType = void 0;
-var RuleType;
-(function (RuleType) {
-    RuleType["ALLOWED_VALUES"] = "ALLOWED_VALUES";
-    RuleType["COUNT"] = "COUNT";
-    RuleType["DATE_BETWEEN"] = "DATE_BETWEEN";
-    RuleType["DECIMAL_COUNT"] = "DECIMAL_COUNT";
-    RuleType["NUMBER_BETWEEN"] = "NUMBER_BETWEEN";
-    RuleType["RELATABLE_CONTENT_TYPES"] = "RELATABLE_CONTENT_TYPES";
-    RuleType["STRING_FORMAT"] = "STRING_FORMAT";
-    RuleType["VALUE_TYPE"] = "VALUE_TYPE";
-})(RuleType || (exports.RuleType = RuleType = {}));
-//# sourceMappingURL=rule-types.enum.js.map

package/src/lib/enums/rule-types.enum.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rule-types.enum.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/enums/rule-types.enum.ts"],"names":[],"mappings":";;;AAAA,IAAY,QASX;AATD,WAAY,QAAQ;IAClB,6CAAiC,CAAA;IACjC,2BAAe,CAAA;IACf,yCAA6B,CAAA;IAC7B,2CAA+B,CAAA;IAC/B,6CAAiC,CAAA;IACjC,+DAAmD,CAAA;IACnD,2CAA+B,CAAA;IAC/B,qCAAyB,CAAA;AAC3B,CAAC,EATW,QAAQ,wBAAR,QAAQ,QASnB"}

package/src/lib/errors/invalid-validation-arguments.error.d.ts

@@ -1,2 +0,0 @@
-export declare class InvalidValidationArgumentsError extends Error {
-}

package/src/lib/errors/invalid-validation-arguments.error.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidValidationArgumentsError = void 0;
-class InvalidValidationArgumentsError extends Error {
-}
-exports.InvalidValidationArgumentsError = InvalidValidationArgumentsError;
-//# sourceMappingURL=invalid-validation-arguments.error.js.map

package/src/lib/errors/invalid-validation-arguments.error.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"invalid-validation-arguments.error.js","sourceRoot":"","sources":["../../../../../../../packages/validation/src/lib/errors/invalid-validation-arguments.error.ts"],"names":[],"mappings":";;;AAAA,MAAa,+BAAgC,SAAQ,KAAK;CAAG;AAA7D,0EAA6D"}

package/src/lib/errors/invalid-validation-rule-settings.error.d.ts

@@ -1,2 +0,0 @@
-export declare class InvalidValidationRuleSettingsError extends Error {
-}