justus 0.1.6 → 0.2.1

package/dist/validators/never.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// validators/never.ts
+var never_exports = {};
+__export(never_exports, {
+  NeverValidator: () => NeverValidator,
+  never: () => never
+});
+module.exports = __toCommonJS(never_exports);
+var import_errors = require("../errors.cjs");
+var import_types = require("../types.cjs");
+var NeverValidator = class extends import_types.AbstractValidator {
+  optional = true;
+  validate(value, options = import_types.defaultValidationOptions) {
+    const { stripForbiddenProperties } = options;
+    if (stripForbiddenProperties || value === void 0)
+      return;
+    throw new import_errors.ValidationError("Forbidden property");
+  }
+};
+var never = new NeverValidator();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NeverValidator,
+  never
+});
+//# sourceMappingURL=never.cjs.map

package/dist/validators/never.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/never.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAgC;AAChC,mBAA4D;AAKrD,IAAM,iBAAN,cAA6B,+BAAyB;AAAA,EAC3D,WAAiB;AAAA,EAEjB,SAAS,OAAgB,UAA6B,uCAAiC;AACrF,UAAM,EAAE,yBAAyB,IAAI;AAGrC,QAAI,4BAA6B,UAAU;AAAY;AACvD,UAAM,IAAI,8BAAgB,oBAAoB;AAAA,EAChD;AACF;AAGO,IAAM,QAAQ,IAAI,eAAe;",
+  "names": []
+}

package/dist/validators/never.d.ts

@@ -0,0 +1,9 @@
+import { AbstractValidator } from '../types';
+import type { ValidationOptions } from '../types';
+/** A `Validator` validating _nothing_. */
+export declare class NeverValidator extends AbstractValidator<never> {
+    optional: true;
+    validate(value: unknown, options?: ValidationOptions): never;
+}
+/** The `Validator` validating _nothing_. */
+export declare const never: NeverValidator;

package/dist/validators/never.mjs

@@ -0,0 +1,18 @@
+// validators/never.ts
+import { ValidationError } from "../errors.mjs";
+import { AbstractValidator, defaultValidationOptions } from "../types.mjs";
+var NeverValidator = class extends AbstractValidator {
+  optional = true;
+  validate(value, options = defaultValidationOptions) {
+    const { stripForbiddenProperties } = options;
+    if (stripForbiddenProperties || value === void 0)
+      return;
+    throw new ValidationError("Forbidden property");
+  }
+};
+var never = new NeverValidator();
+export {
+  NeverValidator,
+  never
+};
+//# sourceMappingURL=never.mjs.map

package/dist/validators/never.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/never.ts"],
+  "mappings": ";AAAA,SAAS,uBAAuB;AAChC,SAAS,mBAAmB,gCAAgC;AAKrD,IAAM,iBAAN,cAA6B,kBAAyB;AAAA,EAC3D,WAAiB;AAAA,EAEjB,SAAS,OAAgB,UAA6B,0BAAiC;AACrF,UAAM,EAAE,yBAAyB,IAAI;AAGrC,QAAI,4BAA6B,UAAU;AAAY;AACvD,UAAM,IAAI,gBAAgB,oBAAoB;AAAA,EAChD;AACF;AAGO,IAAM,QAAQ,IAAI,eAAe;",
+  "names": []
+}

package/dist/validators/number.cjs

@@ -0,0 +1,153 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// validators/number.ts
+var number_exports = {};
+__export(number_exports, {
+  AnyNumberValidator: () => AnyNumberValidator,
+  NumberValidator: () => NumberValidator,
+  number: () => number
+});
+module.exports = __toCommonJS(number_exports);
+var import_errors = require("../errors.cjs");
+var import_types = require("../types.cjs");
+var PRECISION = 6;
+var MULTIPLIER = Math.pow(10, PRECISION);
+function countDecimals(n) {
+  const match = n.toExponential().match(/^\d+(\.\d+)?e([+-]\d+)$/);
+  if (!match)
+    throw new RangeError(`Can't calculate digits for number "${n}"`);
+  const digits = (match[1] || ".").length - 1 - parseInt(match[2]);
+  return digits < 0 ? 0 : digits;
+}
+var AnyNumberValidator = class extends import_types.AbstractValidator {
+  validate(value) {
+    (0, import_errors.assertValidation)(typeof value == "number", 'Value is not a "number"');
+    (0, import_errors.assertValidation)(!isNaN(value), 'Number is "NaN"');
+    return value;
+  }
+};
+var NumberValidator = class extends import_types.AbstractValidator {
+  #isMultipleOf;
+  allowNaN;
+  exclusiveMaximum;
+  exclusiveMinimum;
+  fromString;
+  maximum;
+  minimum;
+  multipleOf;
+  brand;
+  constructor(constraints = {}) {
+    super();
+    const {
+      allowNaN = false,
+      exclusiveMaximum,
+      exclusiveMinimum,
+      fromString = false,
+      maximum = Number.POSITIVE_INFINITY,
+      minimum = Number.NEGATIVE_INFINITY,
+      multipleOf
+    } = constraints;
+    if ("brand" in constraints)
+      this.brand = constraints.brand;
+    (0, import_errors.assertSchema)(maximum >= minimum, `Constraint "minimum" (${minimum}) is greater than "maximum" (${maximum})`);
+    if (exclusiveMaximum !== void 0) {
+      (0, import_errors.assertSchema)(
+        exclusiveMaximum > minimum,
+        `Constraint "exclusiveMaximum" (${exclusiveMaximum}) must be greater than "minimum" (${minimum})`
+      );
+    }
+    if (exclusiveMinimum !== void 0) {
+      (0, import_errors.assertSchema)(
+        maximum > exclusiveMinimum,
+        `Constraint "maximum" (${maximum}) must be greater than "exclusiveMinimum" (${exclusiveMinimum})`
+      );
+    }
+    if (exclusiveMinimum != void 0 && exclusiveMaximum !== void 0) {
+      (0, import_errors.assertSchema)(
+        exclusiveMaximum > exclusiveMinimum,
+        `Constraint "exclusiveMaximum" (${exclusiveMaximum}) must be greater than "exclusiveMinimum" (${exclusiveMinimum})`
+      );
+    }
+    if (multipleOf !== void 0) {
+      (0, import_errors.assertSchema)(multipleOf > 0, `Constraint "multipleOf" (${multipleOf}) must be greater than zero`);
+      const decimals = countDecimals(multipleOf);
+      if (decimals === 0) {
+        this.#isMultipleOf = (value) => !(value % multipleOf);
+      } else if (decimals <= PRECISION) {
+        this.#isMultipleOf = (value) => {
+          try {
+            if (countDecimals(value) > PRECISION)
+              return false;
+            return !(value * MULTIPLIER % (multipleOf * MULTIPLIER));
+          } catch (error) {
+            throw new import_errors.ValidationError(error.message);
+          }
+        };
+      } else {
+        (0, import_errors.assertSchema)(false, `Constraint "multipleOf" (${multipleOf}) requires too much precision`);
+      }
+    }
+    this.allowNaN = allowNaN;
+    this.exclusiveMaximum = exclusiveMaximum;
+    this.exclusiveMinimum = exclusiveMinimum;
+    this.fromString = fromString;
+    this.maximum = maximum;
+    this.minimum = minimum;
+    this.multipleOf = multipleOf;
+  }
+  validate(value) {
+    if (typeof value == "string" && this.fromString) {
+      const parsed = +`${value}`;
+      (0, import_errors.assertValidation)(!isNaN(parsed), "Number can not be parsed from string");
+      value = parsed;
+    }
+    (0, import_errors.assertValidation)(typeof value == "number", 'Value is not a "number"');
+    if (isNaN(value)) {
+      (0, import_errors.assertValidation)(this.allowNaN, 'Number is "NaN"');
+      return value;
+    }
+    (0, import_errors.assertValidation)(value >= this.minimum, `Number is less than ${this.minimum}`);
+    (0, import_errors.assertValidation)(value <= this.maximum, `Number is greater than ${this.maximum}`);
+    (0, import_errors.assertValidation)(
+      this.exclusiveMinimum == void 0 || value > this.exclusiveMinimum,
+      `Number is less than or equal to ${this.exclusiveMinimum}`
+    );
+    (0, import_errors.assertValidation)(
+      this.exclusiveMaximum == void 0 || value < this.exclusiveMaximum,
+      `Number is greater than or equal to ${this.exclusiveMaximum}`
+    );
+    (0, import_errors.assertValidation)(
+      this.#isMultipleOf ? this.#isMultipleOf(value) : true,
+      `Number is not a multiple of ${this.multipleOf}`
+    );
+    return value;
+  }
+};
+function _number(constraints) {
+  return new NumberValidator(constraints);
+}
+var number = (0, import_types.makeValidatorFactory)(new AnyNumberValidator(), _number);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnyNumberValidator,
+  NumberValidator,
+  number
+});
+//# sourceMappingURL=number.cjs.map

package/dist/validators/number.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/number.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/validators/number.d.ts

@@ -0,0 +1,48 @@
+import { AbstractValidator } from '../types';
+import type { Branding } from '../types';
+/** Constraints to validate a `number` with. */
+export interface NumberConstraints {
+    /** The value for which a `number` must be multiple of for it to be valid */
+    multipleOf?: number;
+    /** The _inclusive_ maximum value for a valid `number`: `value <= maximum` */
+    maximum?: number;
+    /** The _inclusive_ minimum value for a valid `number`: `value >= minimum` */
+    minimum?: number;
+    /** The _exclusive_ maximum value for a valid `number`: `value < exclusiveMaximum` */
+    exclusiveMaximum?: number;
+    /** The _exclusive_ minimum value for a valid `number`: `value > exclusiveMaximum` */
+    exclusiveMinimum?: number;
+    /** Allow numbers to be parsed from strings (e.g. `123.456` or `0x0CAFE`, default: `false`) */
+    fromString?: boolean;
+    /** Whether to allow `NaN` or not (default: `false`) */
+    allowNaN?: boolean;
+}
+/** Constraints to validate a `number` with extra branding information. */
+export interface BrandedNumberConstraints<B extends string> extends NumberConstraints {
+    /** The _brand_ of the string (will generate a `__brand_${B}` type property */
+    brand: B;
+}
+/** A `Validator` validating any `number`. */
+export declare class AnyNumberValidator extends AbstractValidator<number> {
+    validate(value: unknown): number;
+}
+/** A `Validator` validating `number`s with constaints. */
+export declare class NumberValidator<N extends number = number> extends AbstractValidator<N> {
+    #private;
+    readonly allowNaN: boolean;
+    readonly exclusiveMaximum?: number;
+    readonly exclusiveMinimum?: number;
+    readonly fromString: boolean;
+    readonly maximum: number;
+    readonly minimum: number;
+    readonly multipleOf?: number;
+    readonly brand?: string;
+    constructor(constraints?: NumberConstraints);
+    validate(value: unknown): N;
+}
+declare function _number(constraints: NumberConstraints): NumberValidator<number>;
+declare function _number<N extends number>(constraints: NumberConstraints): NumberValidator<N>;
+declare function _number<B extends string>(constraints: BrandedNumberConstraints<B>): NumberValidator<number & Branding<B>>;
+/** Validate `number`s. */
+export declare const number: typeof _number & AnyNumberValidator;
+export {};

package/dist/validators/number.mjs

@@ -0,0 +1,126 @@
+// validators/number.ts
+import { assertSchema, assertValidation, ValidationError } from "../errors.mjs";
+import { AbstractValidator, makeValidatorFactory } from "../types.mjs";
+var PRECISION = 6;
+var MULTIPLIER = Math.pow(10, PRECISION);
+function countDecimals(n) {
+  const match = n.toExponential().match(/^\d+(\.\d+)?e([+-]\d+)$/);
+  if (!match)
+    throw new RangeError(`Can't calculate digits for number "${n}"`);
+  const digits = (match[1] || ".").length - 1 - parseInt(match[2]);
+  return digits < 0 ? 0 : digits;
+}
+var AnyNumberValidator = class extends AbstractValidator {
+  validate(value) {
+    assertValidation(typeof value == "number", 'Value is not a "number"');
+    assertValidation(!isNaN(value), 'Number is "NaN"');
+    return value;
+  }
+};
+var NumberValidator = class extends AbstractValidator {
+  #isMultipleOf;
+  allowNaN;
+  exclusiveMaximum;
+  exclusiveMinimum;
+  fromString;
+  maximum;
+  minimum;
+  multipleOf;
+  brand;
+  constructor(constraints = {}) {
+    super();
+    const {
+      allowNaN = false,
+      exclusiveMaximum,
+      exclusiveMinimum,
+      fromString = false,
+      maximum = Number.POSITIVE_INFINITY,
+      minimum = Number.NEGATIVE_INFINITY,
+      multipleOf
+    } = constraints;
+    if ("brand" in constraints)
+      this.brand = constraints.brand;
+    assertSchema(maximum >= minimum, `Constraint "minimum" (${minimum}) is greater than "maximum" (${maximum})`);
+    if (exclusiveMaximum !== void 0) {
+      assertSchema(
+        exclusiveMaximum > minimum,
+        `Constraint "exclusiveMaximum" (${exclusiveMaximum}) must be greater than "minimum" (${minimum})`
+      );
+    }
+    if (exclusiveMinimum !== void 0) {
+      assertSchema(
+        maximum > exclusiveMinimum,
+        `Constraint "maximum" (${maximum}) must be greater than "exclusiveMinimum" (${exclusiveMinimum})`
+      );
+    }
+    if (exclusiveMinimum != void 0 && exclusiveMaximum !== void 0) {
+      assertSchema(
+        exclusiveMaximum > exclusiveMinimum,
+        `Constraint "exclusiveMaximum" (${exclusiveMaximum}) must be greater than "exclusiveMinimum" (${exclusiveMinimum})`
+      );
+    }
+    if (multipleOf !== void 0) {
+      assertSchema(multipleOf > 0, `Constraint "multipleOf" (${multipleOf}) must be greater than zero`);
+      const decimals = countDecimals(multipleOf);
+      if (decimals === 0) {
+        this.#isMultipleOf = (value) => !(value % multipleOf);
+      } else if (decimals <= PRECISION) {
+        this.#isMultipleOf = (value) => {
+          try {
+            if (countDecimals(value) > PRECISION)
+              return false;
+            return !(value * MULTIPLIER % (multipleOf * MULTIPLIER));
+          } catch (error) {
+            throw new ValidationError(error.message);
+          }
+        };
+      } else {
+        assertSchema(false, `Constraint "multipleOf" (${multipleOf}) requires too much precision`);
+      }
+    }
+    this.allowNaN = allowNaN;
+    this.exclusiveMaximum = exclusiveMaximum;
+    this.exclusiveMinimum = exclusiveMinimum;
+    this.fromString = fromString;
+    this.maximum = maximum;
+    this.minimum = minimum;
+    this.multipleOf = multipleOf;
+  }
+  validate(value) {
+    if (typeof value == "string" && this.fromString) {
+      const parsed = +`${value}`;
+      assertValidation(!isNaN(parsed), "Number can not be parsed from string");
+      value = parsed;
+    }
+    assertValidation(typeof value == "number", 'Value is not a "number"');
+    if (isNaN(value)) {
+      assertValidation(this.allowNaN, 'Number is "NaN"');
+      return value;
+    }
+    assertValidation(value >= this.minimum, `Number is less than ${this.minimum}`);
+    assertValidation(value <= this.maximum, `Number is greater than ${this.maximum}`);
+    assertValidation(
+      this.exclusiveMinimum == void 0 || value > this.exclusiveMinimum,
+      `Number is less than or equal to ${this.exclusiveMinimum}`
+    );
+    assertValidation(
+      this.exclusiveMaximum == void 0 || value < this.exclusiveMaximum,
+      `Number is greater than or equal to ${this.exclusiveMaximum}`
+    );
+    assertValidation(
+      this.#isMultipleOf ? this.#isMultipleOf(value) : true,
+      `Number is not a multiple of ${this.multipleOf}`
+    );
+    return value;
+  }
+};
+function _number(constraints) {
+  return new NumberValidator(constraints);
+}
+var number = makeValidatorFactory(new AnyNumberValidator(), _number);
+export {
+  AnyNumberValidator,
+  NumberValidator,
+  number
+};
+//# sourceMappingURL=number.mjs.map

package/dist/validators/number.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/number.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/validators/object.cjs

@@ -0,0 +1,129 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// validators/object.ts
+var object_exports = {};
+__export(object_exports, {
+  AnyObjectValidator: () => AnyObjectValidator,
+  ObjectValidator: () => ObjectValidator,
+  object: () => object,
+  objectOf: () => objectOf
+});
+module.exports = __toCommonJS(object_exports);
+var import_errors = require("../errors.cjs");
+var import_schema = require("../schema.cjs");
+var import_types = require("../types.cjs");
+var import_utilities = require("../utilities.cjs");
+var AnyObjectValidator = class extends import_types.AbstractValidator {
+  validate(value) {
+    (0, import_errors.assertValidation)(typeof value == "object", 'Value is not an "object"');
+    (0, import_errors.assertValidation)(value !== null, 'Value is "null"');
+    return value;
+  }
+};
+var ObjectValidator = class extends import_types.AbstractValidator {
+  schema;
+  validators = /* @__PURE__ */ new Map();
+  additionalProperties;
+  constructor(schema) {
+    super();
+    const { [Symbol.justusAdditionalValidator]: additional, ...properties } = schema;
+    if (additional)
+      this.additionalProperties = additional;
+    for (const key of Object.keys(properties)) {
+      this.validators.set(key, (0, import_utilities.getValidator)(properties[key]));
+    }
+    this.schema = schema;
+  }
+  validate(value, options = import_types.defaultValidationOptions) {
+    (0, import_errors.assertValidation)(typeof value === "object", 'Value is not an "object"');
+    (0, import_errors.assertValidation)(value !== null, 'Value is "null"');
+    const { stripAdditionalProperties, stripOptionalNulls } = options;
+    const record = value;
+    const builder = new import_errors.ValidationErrorBuilder();
+    const clone = {};
+    for (const [key, validator] of this.validators.entries()) {
+      const optional = !!validator.optional;
+      const original = record[key];
+      if (stripOptionalNulls && optional && original === null) {
+        continue;
+      }
+      if (original === void 0) {
+        try {
+          const validated = validator.validate(original, options);
+          if (!(optional && validated == void 0))
+            clone[key] = validated;
+        } catch (error) {
+          if (optional)
+            continue;
+          builder.record("Required property missing", key);
+        }
+        continue;
+      }
+      try {
+        const validated = validator.validate(original, options);
+        if (!(optional && validated == void 0))
+          clone[key] = validated;
+      } catch (error) {
+        builder.record(error, key);
+      }
+    }
+    const additionalKeys = Object.keys(record).filter((k) => !this.validators.has(k));
+    const additional = this.additionalProperties;
+    if (additional) {
+      additionalKeys.forEach((key) => {
+        if (record[key] === void 0)
+          return;
+        try {
+          clone[key] = additional.validate(record[key], options);
+        } catch (error) {
+          builder.record(error, key);
+        }
+      });
+    } else if (!stripAdditionalProperties) {
+      additionalKeys.forEach((key) => {
+        if (record[key] !== void 0)
+          builder.record("Unknown property", key);
+      });
+    }
+    return builder.assert(clone);
+  }
+};
+function _object(schema) {
+  const validator = new ObjectValidator(schema);
+  function* iterator() {
+    yield { [Symbol.justusRestValidator]: validator };
+  }
+  return Object.defineProperties(schema, {
+    [Symbol.justusValidator]: { value: validator, enumerable: false },
+    [Symbol.iterator]: { value: iterator, enumerable: false }
+  });
+}
+var object = (0, import_types.makeValidatorFactory)(new AnyObjectValidator(), _object);
+function objectOf(validation) {
+  return new ObjectValidator({ ...(0, import_schema.allowAdditionalProperties)(validation) });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnyObjectValidator,
+  ObjectValidator,
+  object,
+  objectOf
+});
+//# sourceMappingURL=object.cjs.map

package/dist/validators/object.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/validators/object.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/validators/object.d.ts

@@ -0,0 +1,22 @@
+import { AbstractValidator } from '../types';
+import type { InferSchema, InferValidation, Schema, TupleRestParameter, Validation, ValidationOptions, Validator } from '../types';
+/** A `Validator` validating any `object`. */
+export declare class AnyObjectValidator extends AbstractValidator<Record<string, any>> {
+    validate(value: unknown): Record<string, any>;
+}
+/** A `Validator` validating `object`s according to a `Schema`. */
+export declare class ObjectValidator<S extends Schema> extends AbstractValidator<InferSchema<S>> {
+    readonly schema: Readonly<S>;
+    validators: Map<string, Validator<any>>;
+    additionalProperties?: Validator;
+    constructor(schema: S);
+    validate(value: unknown, options?: ValidationOptions): InferSchema<S>;
+}
+declare function _object<S extends Schema>(schema: S): S & {
+    [Symbol.iterator](): Generator<TupleRestParameter<InferSchema<S>>>;
+};
+/** Validate `object`s. */
+export declare const object: typeof _object & AnyObjectValidator;
+/** Validate `Object`s containing only the specified elements. */
+export declare function objectOf<V extends Validation>(validation: V): Validator<Record<string, InferValidation<V>>>;
+export {};