@amazon/vinyl-validation 1.0.0

package/dist/types/ts4.1/validation/NumberSchema.d.ts

@@ -0,0 +1,100 @@
+import { ValueSchema } from './ValueSchema';
+import type { Validator } from './Validator';
+export declare const numberValidators: {
+    /**
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * value.
+     *
+     * @param min The minimum (inclusive) the value may be.
+     */
+    readonly gte: (min: number) => Validator<number, number>;
+    /**
+     * Creates a validator that asserts that the input number is greater than the provided minimum
+     * value.
+     *
+     * @param min The minimum (exclusive) the value may be.
+     */
+    readonly gt: (min: number) => Validator<number, number>;
+    /**
+     * Creates a validator that asserts that the input number is at most the provided maximum
+     * value.
+     *
+     * @param max The maximum (inclusive) the value may be.
+     */
+    readonly lte: (max: number) => Validator<number, number>;
+    /**
+     * Creates a validator that asserts that the input number is less than the provided maximum
+     * value.
+     *
+     * @param max The maximum (exclusive) the value may be.
+     */
+    readonly lt: (max: number) => Validator<number, number>;
+    /**
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * and at most the provided maximum values.
+     *
+     * @param min The minimum (inclusive) value the input may be.
+     * @param max The maximum (inclusive) value the input may be.
+     */
+    readonly within: (min: number, max: number) => Validator<number, number>;
+    /**
+     * Creates a validator that asserts that the input number is finite.
+     */
+    readonly finite: () => Validator<number, number>;
+    /**
+     * Creates a validator that asserts that the input number is a safe integer.
+     */
+    readonly safeInteger: () => Validator<number, number>;
+};
+export declare class NumberSchema extends ValueSchema<number> {
+    private static _base;
+    /**
+     * The base Object validator validating that the input is an object.
+     */
+    static get base(): NumberSchema;
+    /**
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * value.
+     *
+     * @param min The minimum (inclusive) the value may be.
+     */
+    gte(min: number): this;
+    /**
+     * Creates a validator that asserts that the input number is greater than the provided minimum
+     * value.
+     *
+     * @param min The minimum (exclusive) the value may be.
+     */
+    gt(min: number): this;
+    /**
+     * Creates a validator that asserts that the input number is at most the provided maximum
+     * value.
+     *
+     * @param max The maximum (inclusive) the value may be.
+     */
+    lte(max: number): this;
+    /**
+     * Creates a validator that asserts that the input number is less than the provided maximum
+     * value.
+     *
+     * @param max The maximum (exclusive) the value may be.
+     */
+    lt(max: number): this;
+    /**
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * and at most the provided maximum values.
+     *
+     * @param min The minimum (inclusive) value the input may be.
+     * @param max The maximum (inclusive) value the input may be.
+     */
+    within(min: number, max: number): this;
+    /**
+     * Creates a validator that asserts that the input number is finite.
+     */
+    finite(): this;
+    /**
+     * Creates a validator that asserts that the input number is a safe integer.
+     */
+    safeInteger(): this;
+}
+//# sourceMappingURL=NumberSchema.d.ts.map

package/dist/types/ts4.1/validation/ObjectSchema.d.ts

@@ -0,0 +1,56 @@
+import type { AnyRecord, IsPropertyOptional, PartialDeep } from '@amazon/vinyl-util';
+import type { ValidatorWithPartial } from './ValidatorWithPartial';
+import { ValueSchema } from './ValueSchema';
+import type { PropertyValidator } from '../validation/PropertyValidator';
+import type { Equal } from '@amazon/vinyl-util/browserTestUtil';
+export declare const objectValidators: {
+    /**
+     * Creates a validator that validates the input has properties that pass their respective
+     * validators.
+     *
+     * @param propertyValidators
+     */
+    readonly properties: <U extends object>(propertyValidators: {
+        readonly [P in keyof U]-?: PropertyValidator<Required<U>[P], {
+            optional: IsPropertyOptional<U, P>;
+        }>;
+    }) => ValidatorWithPartial<U, object>;
+};
+/**
+ * Chainable object validators.
+ */
+export declare class ObjectSchema<T extends object> extends ValueSchema<T> implements ValidatorWithPartial<T, unknown> {
+    private static _base;
+    /**
+     * The base Object validator validating that the input is an object.
+     */
+    static get base(): ObjectSchema<AnyRecord>;
+    /**
+     * Creates a validator that validates the input has properties that pass their respective
+     * validators.
+     *
+     * @param propertyValidators
+     */
+    extend<U extends object>(propertyValidators: ExtendedPropertyValidators<T, U>): ObjectSchema<U>;
+    /**
+     * Allows all properties to be undefined.
+     */
+    partial(): ObjectSchema<Partial<T>>;
+    /**
+     * Allows all recursive properties to be undefined.
+     */
+    partialDeep(): ObjectSchema<PartialDeep<T>>;
+    /**
+     * Casts the type parameter.
+     */
+    cast<T extends object>(): ObjectSchema<T>;
+}
+export type ExtendedPropertyValidators<T extends object, U extends object> = {
+    [K in keyof U as K extends keyof T ? Equal<U[K], T[K]> extends true ? never : K : K]-?: ExtendedPropertyValidator<U & T, K>;
+} & {
+    [K in keyof U as K extends keyof T ? Equal<U[K], T[K]> extends true ? K : never : never]?: ExtendedPropertyValidator<U & T, K>;
+};
+export type ExtendedPropertyValidator<U extends object, P extends keyof U> = PropertyValidator<Required<U>[P], {
+    optional: IsPropertyOptional<U, P>;
+}>;
+//# sourceMappingURL=ObjectSchema.d.ts.map

package/dist/types/ts4.1/validation/PropertyValidator.d.ts

@@ -0,0 +1,23 @@
+import type { Validator } from '../validation/Validator';
+import type { Merge } from '@amazon/vinyl-util';
+export interface PropertyValidatorOptions {
+    /**
+     * If true, when the property is omitted, the object schema should not fail validation.
+     */
+    readonly optional: boolean;
+}
+/**
+ * A utility type for overriding the options type on a validator.
+ * This will strip the types of the overridden options and set to the new types.
+ */
+export type PropertyValidatorWithOptions<ValidatorType extends PropertyValidator<any, any>, T, Options extends PropertyValidatorOptions> = Omit<ValidatorType, keyof PropertyValidator<any, any>> & PropertyValidator<T, Merge<ValidatorType['options'], Options>>;
+export interface PropertyValidator<T, PropertyOptionsType extends PropertyValidatorOptions> extends Validator<T> {
+    readonly options: PropertyOptionsType;
+    optional(): PropertyValidatorWithOptions<this, T, {
+        readonly optional: true;
+    }>;
+    required(): PropertyValidatorWithOptions<this, T, {
+        readonly optional: false;
+    }>;
+}
+//# sourceMappingURL=PropertyValidator.d.ts.map

package/dist/types/ts4.1/validation/RecordSchema.d.ts

@@ -0,0 +1,58 @@
+import type { ReadonlyRecord } from '@amazon/vinyl-util';
+import { ValueSchema } from './ValueSchema';
+import type { Validator } from './Validator';
+export declare const recordValidators: {
+    /**
+     * Returns a validator that asserts that the object's own enumerable properties has keys and
+     * values that match their respective validators.
+     *
+     * Prototype members are not included.
+     * Numeric keys are validated as strings. For example the object `{ [0]: 1 }` will be passed
+     * to the key validator as '0'.
+     *
+     * @param keyValidator Validates each key.
+     * @param valueValidator Validates each value.
+     */
+    readonly record: <K extends string | symbol, V>(keyValidator: Validator<K>, valueValidator: Validator<V>) => Validator<Record<K, V>, object>;
+};
+/**
+ * Chainable object validators for the Record type.
+ */
+export declare class RecordSchema<T extends ReadonlyRecord<keyof any, any>> extends ValueSchema<T> {
+    private static _base;
+    /**
+     * The base Object validator validating that the input is an object.
+     */
+    static get base(): RecordSchema<Record<keyof any, unknown>>;
+    private static get defaultKeyValidator();
+    /**
+     * Returns a validator that asserts that the object's own enumerable properties has keys and
+     * values that match their respective validators.
+     *
+     * Prototype members are not included.
+     * Numeric keys are validated as strings. For example the object `{ [0]: 1 }` will be passed
+     * to the key validator as '0'.
+     *
+     * @param keyValidator Validates each key.
+     * @param valueValidator Validates each value.
+     */
+    record<K extends string | symbol, V>(keyValidator: Validator<K>, valueValidator: Validator<V>): RecordSchema<ReadonlyRecord<K, V>>;
+    /**
+     * Returns a validator that asserts that the object's own enumerable properties has
+     * string keys and values that match the given validator.
+     *
+     * Prototype members are not included.
+     *
+     * @param valueValidator Validates each value.
+     */
+    recordValues<V>(valueValidator: Validator<V>): RecordSchema<Record<string, V>>;
+    /**
+     * Casts to a ReadonlyRecord
+     */
+    readonly(): RecordSchema<T extends Record<infer K, infer V> ? ReadonlyRecord<K, V> : never>;
+    /**
+     * Casts the type parameter.
+     */
+    cast<T extends ReadonlyRecord<keyof any, unknown>>(): RecordSchema<T>;
+}
+//# sourceMappingURL=RecordSchema.d.ts.map

package/dist/types/ts4.1/validation/SchemaBase.d.ts

@@ -0,0 +1,65 @@
+import type { ValidationErrorMessage, ValidationOptions, Validator } from './Validator';
+import type { PropertyValidator, PropertyValidatorWithOptions } from './PropertyValidator';
+/**
+ * A base class for validation state.
+ * Provides methods for chaining.
+ *
+ * Subclasses should not override constructors.
+ */
+export declare abstract class SchemaBase<T> implements PropertyValidator<T, {
+    readonly optional: false;
+}> {
+    private readonly currentValidator;
+    private readonly previousSchema?;
+    private readonly operation?;
+    __type: import("@amazon/vinyl-util").Invariant<T>;
+    private readonly validator;
+    private _options;
+    get options(): {
+        readonly optional: false;
+    };
+    /**
+     * Constructs the first link in a schema chain.
+     *
+     * @param currentValidator
+     */
+    constructor(currentValidator: Validator<any, any>);
+    /**
+     * Constructs linking to the given previous schema.
+     *
+     * @param currentValidator
+     * @param previousSchema
+     * @param operation
+     */
+    constructor(currentValidator: Validator<any, any>, previousSchema: SchemaBase<any>, operation: (validatorA: Validator<any>, validatorB: Validator<any, any>) => Validator<T>);
+    get description(): string;
+    readonly assert: (input: unknown, origin?: string, path?: readonly string[]) => asserts input is T;
+    readonly isValid: (input: unknown) => input is T;
+    readonly validate: (input: unknown, options?: ValidationOptions, path?: readonly string[]) => readonly ValidationErrorMessage[];
+    /**
+     * Clones this schema, transforming all validators with the given mutator.
+     *
+     * @param transform A transformer which takes an existing validator in the chain and returns
+     * a new one. Validators should be considered to be immutable; transform should not change the
+     * input but instead return a new validator.
+     */
+    protected clone(transform?: (validator: Validator<any>) => Validator<any>): any;
+    protected self(current: Validator<any, any>): any;
+    protected self(currentValidator: Validator<any, any>, previousSchema: SchemaBase<any> | undefined, operation: ((validatorA: Validator<any>, validatorB: Validator<any, any>) => Validator<T>) | undefined): any;
+    /**
+     * Constructs a new schema with a validator chaining the current validator with the
+     * provided next in an AND operation.
+     *
+     * @param nextValidator The validator to run after the current.
+     * @return Returns a new Schema instance the same class with a new validator chaining the
+     * current validator with the given next in an AND operation.
+     */
+    protected chain(nextValidator: Validator<any, any>): any;
+    optional(): PropertyValidatorWithOptions<this, T, {
+        readonly optional: true;
+    }>;
+    required(): PropertyValidatorWithOptions<this, T, {
+        readonly optional: false;
+    }>;
+}
+//# sourceMappingURL=SchemaBase.d.ts.map

package/dist/types/ts4.1/validation/SetSchema.d.ts

@@ -0,0 +1,38 @@
+import type { SetElementType } from '@amazon/vinyl-util';
+import type { Validator } from './Validator';
+import { ValueSchema } from './ValueSchema';
+export declare const setValidators: {
+    /**
+     * Creates a validator that asserts that the input is a set.
+     */
+    readonly isSet: () => Validator<Set<unknown>>;
+    /**
+     * Creates a validator that asserts that every element passes the given validator.
+     *
+     * @param elementValidator
+     */
+    readonly withElements: <U>(elementValidator: Validator<U>) => Validator<Set<U>, ReadonlySet<unknown>>;
+};
+export declare class SetSchema<T extends ReadonlySet<unknown>> extends ValueSchema<T> {
+    private static _base;
+    /**
+     * The base SetSchema instance validating that the input is a Set.
+     */
+    static get base(): SetSchema<Set<unknown>>;
+    /**
+     * Creates a validator that asserts that every element passes the given validator.
+     *
+     * @param elementValidator
+     */
+    withElements<U>(elementValidator: Validator<U>): SetSchema<Set<SetElementType<T> & U>>;
+    /**
+     * Casts to a readonly set.
+     * This is a shallow cast, elements of the array will not be changed.
+     */
+    readonly(): SetSchema<ReadonlySet<SetElementType<T>>>;
+    /**
+     * Casts the parameter type.
+     */
+    cast<T extends ReadonlySet<unknown>>(): SetSchema<T>;
+}
+//# sourceMappingURL=SetSchema.d.ts.map

package/dist/types/ts4.1/validation/StringSchema.d.ts

@@ -0,0 +1,68 @@
+import { ValueSchema } from './ValueSchema';
+import type { Validator } from './Validator';
+export declare const stringValidators: {
+    /**
+     * Creates a validator that asserts that the input is not empty.
+     */
+    readonly notEmpty: () => Validator<string, string>;
+    /**
+     * Creates a validator that asserts that the input string has at least the given minimum
+     * length.
+     *
+     * @param min The string must be at least this length.
+     */
+    readonly minLength: (min: number) => Validator<string, string>;
+    /**
+     * Creates a validator that asserts that the input string has at most the given maximum
+     * length.
+     *
+     * @param max The string must be at most this length.
+     */
+    readonly maxLength: (max: number) => Validator<string, string>;
+    /**
+     * Creates a validator that asserts that the input string has no whitespace characters.
+     * Whitespace characters include space, new line, carriage return, and tab.
+     */
+    readonly noWhitespace: () => Validator<string, string>;
+    /**
+     * Creates a validator that asserts that the input string matches the given regex.
+     * @param regex
+     */
+    readonly matches: (regex: RegExp) => Validator<string, string>;
+};
+export declare class StringSchema extends ValueSchema<string> {
+    private static _base;
+    /**
+     * The base SetSchema instance validating that the input is a Set.
+     */
+    static get base(): StringSchema;
+    /**
+     * Creates a validator that asserts that the input is not empty.
+     */
+    notEmpty(): StringSchema;
+    /**
+     * Creates a validator that asserts that the input string has at least the given minimum
+     * length.
+     *
+     * @param min The string must be at least this length.
+     */
+    minLength(min: number): StringSchema;
+    /**
+     * Creates a validator that asserts that the input string has at most the given maximum
+     * length.
+     *
+     * @param max The string must be at most this length.
+     */
+    maxLength(max: number): StringSchema;
+    /**
+     * Creates a validator that asserts that the input string has no whitespace characters.
+     * Whitespace characters include space, new line, carriage return, and tab.
+     */
+    noWhitespace(): StringSchema;
+    /**
+     * Creates a validator that asserts that the input string matches the given regex.
+     * @param regex
+     */
+    matches(regex: RegExp): StringSchema;
+}
+//# sourceMappingURL=StringSchema.d.ts.map

package/dist/types/ts4.1/validation/Validator.d.ts

@@ -0,0 +1,88 @@
+import type { Invariant } from '@amazon/vinyl-util';
+/**
+ * Represents a validation failure.
+ */
+export interface ValidationErrorMessage {
+    readonly message: string;
+    readonly path: readonly string[];
+}
+export interface ValidationOptions {
+    /**
+     * If true, collect all validation errors.
+     * Default: false
+     */
+    readonly all?: boolean;
+}
+/**
+ * A Validator can assert that an input matches this validator's schema.
+ */
+export interface Validator<Output extends Input, Input = unknown> {
+    /**
+     * Enforces T is in an invariant position.
+     * This prevents a validator with more strict rules is assigned to a less strict type, which
+     * can cause unexpected validation errors.
+     */
+    __type?: Invariant<Output>;
+    /**
+     * A short description of the validator.
+     */
+    readonly description: string;
+    /**
+     * Returns true if the input is valid according to this validator.
+     *
+     * @param input
+     */
+    readonly isValid: (input: Input) => input is Output;
+    /**
+     * Validates the provided input, returning a list of error messages, or an empty array if the
+     * input passes this validator.
+     *
+     * @param input The input to validate.
+     * @param options Validation options.
+     * @param path The current field path to this validator.
+     * @return Returns an array of validation failures. If `options.all` is not true, only the
+     * first error will be returned.
+     */
+    readonly validate: (input: Input, options?: ValidationOptions, path?: readonly string[]) => readonly ValidationErrorMessage[];
+    /**
+     * Validates the given input, asserting that the input is type `T`.
+     * If the input is not valid, a {@link ValidationError} will be thrown.
+     *
+     * @param input The input to validate.
+     * @param origin The error origin. `ErrorOrigin.API` by default.
+     * @param path The current field path to this validator.
+     * @return Returns the input, cast as the validated type T
+     */
+    readonly assert: (input: Input, origin?: string, path?: readonly string[]) => asserts input is Output;
+}
+/**
+ * Creates a message string for a ValidationErrorMessage based on the input and its expectation.
+ *
+ * @param expectationMessage
+ * @param input
+ * @param path
+ * @param inputStringify
+ */
+export declare function createValidationExpectationMessage<Input>(expectationMessage: string, input: Input, path: readonly string[], inputStringify?: (input: Input) => string): string;
+/**
+ * Creates a new basic validator.
+ *
+ * For a deep validator which has sub-fields, use {@link createDeepValidator}.
+ *
+ * @param expectationMessage The message to use to describe what is expected. This will be used in
+ * the error message template.
+ * @param isValid Returns true if the given input is valid.
+ * @param inputStringify Stringifies the input for use as the actual `{actual}` token in the validation
+ * expectation template. Default is `stringifyForPrint` with a 500 character max length.
+ */
+export declare function createValidator<Output extends Input, Input = unknown>(expectationMessage: string, isValid: (input: Input) => boolean, inputStringify?: (input: Input) => string): Validator<Output, Input>;
+/**
+ * Creates a new deep validator.
+ *
+ * For a shallow validator which validates one value, use {@link createValidator}.
+ *
+ * @param description Describes the validator.
+ * @param validate Returns an array of validation failures.
+ */
+export declare function createDeepValidator<Output extends Input, Input = unknown>(description: string, validate: (input: Input, options: ValidationOptions, path: readonly string[]) => readonly ValidationErrorMessage[]): Validator<Output, Input>;
+//# sourceMappingURL=Validator.d.ts.map

package/dist/types/ts4.1/validation/ValidatorWithPartial.d.ts

@@ -0,0 +1,26 @@
+import type { PartialDeep } from '@amazon/vinyl-util';
+import type { Validator } from './Validator';
+export interface ValidatorWithPartial<Output extends Input, Input> extends Validator<Output, Input> {
+    partial(): ValidatorWithPartial<Partial<Output> & Input, Input>;
+    partialDeep(): ValidatorWithPartial<PartialDeep<Output> & Input, Input>;
+}
+/**
+ * Returns true if the given validator is an object validator.
+ * @param validator
+ */
+export declare function isValidatorWithPartial<Output extends Input, Input>(validator: Validator<Output, Input>): validator is ValidatorWithPartial<Output, Input>;
+/**
+ * If the given validator is an object validator, it will be cloned to a deep partial validator,
+ * otherwise returns the validator as is.
+ *
+ * @param validator
+ */
+export declare function maybeToDeepPartial(validator: Validator<any>): Validator<any>;
+/**
+ * If the given validator is an object validator, it will be cloned to a partial validator,
+ * otherwise returns the validator as is.
+ *
+ * @param validator
+ */
+export declare function maybeToPartial(validator: Validator<any>): Validator<any>;
+//# sourceMappingURL=ValidatorWithPartial.d.ts.map

package/dist/types/ts4.1/validation/ValueSchema.d.ts

@@ -0,0 +1,52 @@
+import { SchemaBase } from './SchemaBase';
+import type { Validator } from './Validator';
+export declare const valueValidators: {
+    readonly any: () => Validator<any>;
+    /**
+     * Creates a validator that asserts that the input is nullish.
+     */
+    readonly nullish: () => Validator<null | undefined>;
+    /**
+     * Creates a validator that asserts that the input is strictly null.
+     */
+    readonly null: () => Validator<null>;
+    /**
+     * Creates a validator that asserts that the input is strictly undefined.
+     */
+    readonly undefined: () => Validator<undefined>;
+};
+export declare class ValueSchema<T> extends SchemaBase<T> {
+    /**
+     * Prepends this validator allowing for null or undefined.
+     */
+    maybe(): ValueSchema<T | undefined | null>;
+    /**
+     * Prepends this validator allowing for null.
+     */
+    orNull(): ValueSchema<T | null>;
+    /**
+     * Prepends this validator allowing for undefined.
+     */
+    orUndefined(): ValueSchema<T | undefined>;
+    /**
+     * Returns a validator that asserts if this validator and the next passes.
+     *
+     * @see andValidators
+     *
+     * @param nextValidator The validator to run after the current.
+     * @return Returns a new ValueSchema intersecting this validator and the next.
+     */
+    and<U>(nextValidator: Validator<U>): ValueSchema<T & U>;
+    /**
+     * Returns a validator that asserts if this validator or the next passes.
+     *
+     * Implementation note:
+     * subclasses should not change the schema instance returned unless all chainable validators
+     * accept input type 'unknown'.
+     *
+     * @param nextValidator The validator to run after the current.
+     * @return Returns a new ValueSchema providing the union of this validator and the next.
+     */
+    or<U>(nextValidator: Validator<U, any>): ValueSchema<T | U>;
+}
+//# sourceMappingURL=ValueSchema.d.ts.map

package/dist/types/ts4.1/validation/andValidators.d.ts

@@ -0,0 +1,19 @@
+import type { Validator } from './Validator';
+/**
+ * Validates that all the given validators pass.
+ */
+export declare function andValidators<A extends Input, B, Input>(validatorA: Validator<A, Input>, validatorB: Validator<B, any>): Validator<A & B, Input>;
+/**
+ * Validates that all the given validators pass.
+ */
+export declare function andValidators<A extends Input, B, C, Input>(validatorA: Validator<A, Input>, validatorB: Validator<B, any>, validatorC: Validator<C, any>): Validator<A & B & C, Input>;
+/**
+ * Validates that all the given validators pass.
+ */
+export declare function andValidators<A extends Input, B, C, D, Input>(validatorA: Validator<A, Input>, validatorB: Validator<B, any>, validatorC: Validator<C, any>, validatorD: Validator<D, any>): Validator<A & B & C & D, any>;
+/**
+ * Validates that all the given validators pass.
+ */
+export declare function andValidators<A extends Input, B, C, D, E, Input>(validatorA: Validator<A, Input>, validatorB: Validator<B, any>, validatorC: Validator<C, any>, validatorD: Validator<D, any>, validatorE: Validator<E, any>): Validator<A & B & C & D & E, any>;
+export declare function andValidators(...validators: Validator<any, any>[]): Validator<any, any>;
+//# sourceMappingURL=andValidators.d.ts.map

package/dist/types/ts4.1/validation/orValidators.d.ts

@@ -0,0 +1,19 @@
+import type { Validator } from './Validator';
+/**
+ * Validates that one of the given validators pass.
+ */
+export declare function orValidators<A, B>(validatorA: Validator<A, any>, validatorB: Validator<B, any>): Validator<A | B, any>;
+/**
+ * Validates that one of the given validators pass.
+ */
+export declare function orValidators<A, B, C>(validatorA: Validator<A, any>, validatorB: Validator<B, any>, validatorC: Validator<C, any>): Validator<A | B | C, any>;
+/**
+ * Validates that one of the given validators pass.
+ */
+export declare function orValidators<A, B, C, D>(validatorA: Validator<A, any>, validatorB: Validator<B, any>, validatorC: Validator<C, any>, validatorD: Validator<D, any>): Validator<A | B | C | D, any>;
+/**
+ * Validates that one of the given validators pass.
+ */
+export declare function orValidators<A, B, C, D, E>(validatorA: Validator<A, any>, validatorB: Validator<B, any>, validatorC: Validator<C, any>, validatorD: Validator<D, any>, validatorE: Validator<E, any>): Validator<A | B | C | D | E, any>;
+export declare function orValidators(...validators: Validator<any, any>[]): Validator<any, any>;
+//# sourceMappingURL=orValidators.d.ts.map

package/dist/types/ts4.1/validation/typeOfValidators.d.ts

@@ -0,0 +1,15 @@
+import type { Validator } from './Validator';
+/**
+ * Validators asserting typeof input matches the expected value.
+ *
+ * Note: bigint is omitted; not all supported platforms can use BigInt.
+ */
+export declare const typeOfValidators: {
+    readonly boolean: Validator<boolean, unknown>;
+    readonly func: Validator<import("@amazon/vinyl-util").Fun, unknown>;
+    readonly number: Validator<number, unknown>;
+    readonly object: Validator<object, unknown>;
+    readonly string: Validator<string, unknown>;
+    readonly symbol: Validator<symbol, unknown>;
+};
+//# sourceMappingURL=typeOfValidators.d.ts.map