@amazon/vinyl-validation 1.0.0

package/dist/types/ts3.7/validation/SchemaBase.d.ts

@@ -0,0 +1,65 @@
+import { ValidationErrorMessage, ValidationOptions, Validator } from './Validator';
+import { 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/ts3.7/validation/SetSchema.d.ts

@@ -0,0 +1,38 @@
+import { SetElementType } from '@amazon/vinyl-util';
+import { 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/ts3.7/validation/StringSchema.d.ts

@@ -0,0 +1,68 @@
+import { ValueSchema } from './ValueSchema';
+import { 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/ts3.7/validation/Validator.d.ts

@@ -0,0 +1,88 @@
+import { 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/ts3.7/validation/ValidatorWithPartial.d.ts

@@ -0,0 +1,26 @@
+import { PartialDeep } from '@amazon/vinyl-util';
+import { 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/ts3.7/validation/ValueSchema.d.ts

@@ -0,0 +1,52 @@
+import { SchemaBase } from './SchemaBase';
+import { 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/ts3.7/validation/andValidators.d.ts

@@ -0,0 +1,19 @@
+import { 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/ts3.7/validation/orValidators.d.ts

@@ -0,0 +1,19 @@
+import { 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/ts3.7/validation/typeOfValidators.d.ts

@@ -0,0 +1,15 @@
+import { 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

package/dist/types/ts3.7/validation/validators.d.ts

@@ -0,0 +1,127 @@
+import { AnyRecord, Fun, Primitive, ReadonlyRecord } from '@amazon/vinyl-util';
+import { ArraySchema } from './ArraySchema';
+import { FunctionSchema } from './FunctionSchema';
+import { SetSchema } from './SetSchema';
+import { ValueSchema } from './ValueSchema';
+import { NumberSchema } from './NumberSchema';
+import { ExtendedPropertyValidators, ObjectSchema } from './ObjectSchema';
+import { RecordSchema } from './RecordSchema';
+import { StringSchema } from './StringSchema';
+import { Validator } from './Validator';
+/**
+ * Creates a no-op validator. The value can be any type.
+ */
+export declare function any(): ValueSchema<any>;
+/**
+ * Creates a validator that asserts that the input is an array.
+ */
+export declare function array(): ArraySchema<unknown[]>;
+/**
+ * Creates a validator that asserts that the input is an array and every element passes the
+ * given validator.
+ *
+ * @param elementValidator
+ */
+export declare function array<U>(elementValidator: Validator<U>): ArraySchema<U[]>;
+/**
+ * Creates a validator that asserts that the input is a boolean.
+ */
+export declare function boolean(): ValueSchema<boolean>;
+/**
+ * Creates a validator that asserts that the input is a function.
+ */
+export declare function func(): FunctionSchema<Fun>;
+/**
+ * Validates that the input is an instanceof the given prototype.
+ * @param clazz
+ */
+export declare function instanceOf<T>(clazz: new (...args: any[]) => T): ValueSchema<T>;
+/**
+ * Creates a validator that asserts that the input is nullish or one of the given possible values.
+ *
+ * @param possibleValues
+ */
+export declare function isOneOf<U extends readonly Primitive[]>(...possibleValues: U): ValueSchema<U[number]>;
+/**
+ * Creates a validator that asserts that the input is one of the values of the given enum.
+ *
+ * @param enumObject The enum to validate against.
+ */
+export declare function enumOf<T extends Record<string, Primitive>>(enumObject: T): ValueSchema<T[keyof T]>;
+/**
+ * Creates a validator that asserts that the input is null.
+ */
+export declare function exactlyNull(): Validator<null>;
+/**
+ * Creates a validator that asserts that the input is nullish.
+ */
+export declare function nullish(): Validator<null | undefined>;
+/**
+ * Creates a validator that asserts that the input is a number.
+ */
+export declare function number(): NumberSchema;
+/**
+ * Creates a validator that validates the input has properties that pass their respective
+ * validators.
+ */
+export declare function object<U extends object>(propertyValidators: ExtendedPropertyValidators<AnyRecord, U>): ObjectSchema<U>;
+/**
+ * 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'.
+ *
+ * To assume string keys, use {@link recordValues}
+ *
+ * @param keyValidator Validates each key.
+ * @param valueValidator Validates each value.
+ */
+export declare function record<K extends string | symbol, V>(keyValidator: Validator<K>, valueValidator: Validator<V>): RecordSchema<ReadonlyRecord<K, V>>;
+/**
+ * Returns a validator that asserts that the input 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.
+ */
+export declare function recordValues<V>(valueValidator: Validator<V>): RecordSchema<Record<string, V>>;
+/**
+ * Returns a validator that asserts the input is a set with elements that match the given
+ * element validator.
+ * @param elementValidator
+ */
+export declare function set<U>(elementValidator: Validator<U>): SetSchema<Set<U>>;
+/**
+ * Creates a validator that asserts that the input is type 'string'.
+ */
+export declare function string(): StringSchema;
+/**
+ * Creates a validator that asserts that the input array is a tuple whose elements match
+ * the given validators.
+ *
+ * @param validators
+ */
+export declare function tuple<U extends readonly any[]>(...validators: {
+    [Index in keyof U]: Validator<U[Index]>;
+}): ArraySchema<{
+    [Index in keyof U]: U[Index];
+}>;
+/**
+ * Creates a validator that asserts that the input is type 'symbol'.
+ */
+export declare function symbol(): ValueSchema<symbol>;
+/**
+ * Creates a validator that asserts that the input is strictly undefined.
+ */
+export declare function exactlyUndefined(): ValueSchema<undefined>;
+/**
+ * Returns a custom
+ * @param expectationMessage
+ * @param isValid
+ * @param inputStringify
+ */
+export declare function custom<T>(expectationMessage: string, isValid: (input: unknown) => boolean, inputStringify?: (input: unknown) => string): ValueSchema<T>;
+//# sourceMappingURL=validators.d.ts.map

package/dist/types/ts4.1/index.d.ts

@@ -0,0 +1,18 @@
+/** Auto-generated from build scripts */
+export * from './validation/validators';
+export * from './validation/typeOfValidators';
+export * from './validation/orValidators';
+export * from './validation/andValidators';
+export * from './validation/ValueSchema';
+export * from './validation/ValidatorWithPartial';
+export * from './validation/Validator';
+export * from './validation/StringSchema';
+export * from './validation/SetSchema';
+export * from './validation/SchemaBase';
+export * from './validation/RecordSchema';
+export * from './validation/PropertyValidator';
+export * from './validation/ObjectSchema';
+export * from './validation/NumberSchema';
+export * from './validation/FunctionSchema';
+export * from './validation/ArraySchema';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,86 @@
+import type { ElementType } from '@amazon/vinyl-util';
+import { ValueSchema } from './ValueSchema';
+import type { Validator } from './Validator';
+export declare const arrayValidators: {
+    /**
+     * Creates a validator that asserts that the input is an array.
+     *
+     * Note: arrays can only be readonly by type system, there is no native readonly
+     * js array. This validator assumes mutability, use the ArraySchema readonly() method
+     * to cast to a readonly array.
+     */
+    readonly isArray: () => Validator<unknown[]>;
+    /**
+     * Creates a validator that asserts that every element passes the given validator.
+     *
+     * @param elementValidator
+     */
+    readonly withElements: <U>(elementValidator: Validator<U>) => Validator<U[], readonly unknown[]>;
+    /**
+     * Creates a validator that asserts that the input array is a tuple whose elements match
+     * the given validators.
+     *
+     * @param validators
+     */
+    readonly tuple: <U extends readonly any[]>(...validators: {
+        [Index in keyof U]: Validator<U[Index]>;
+    }) => Validator<{
+        [Index in keyof U]: U[Index];
+    }, readonly unknown[]>;
+    /**
+     * Creates a validator that validates the input array has the given minimum length.
+     * @param min The minimum number of elements (inclusive)
+     */
+    readonly minLength: (min: number) => Validator<readonly unknown[], readonly unknown[]>;
+    /**
+     *
+     * Creates a validator that validates the input array has the given maximum length.
+     * @param max The maximum number of elements (inclusive)
+     */
+    readonly maxLength: (max: number) => Validator<readonly unknown[], readonly unknown[]>;
+};
+export declare class ArraySchema<T extends readonly unknown[]> extends ValueSchema<T> {
+    private static _base;
+    /**
+     * The base ArraySchema instance validating that the input is an Array.
+     */
+    static get base(): ArraySchema<unknown[]>;
+    /**
+     * Creates a validator that asserts that every element passes the given validator.
+     *
+     * @param elementValidator
+     */
+    withElements<U>(elementValidator: Validator<U>): ArraySchema<(ElementType<T> & U)[]>;
+    /**
+     * Creates a validator that asserts that the input array is a tuple whose elements match
+     * the given validators.
+     *
+     * @param validators
+     */
+    tuple<U extends readonly any[]>(...validators: {
+        [Index in keyof U]: Validator<U[Index]>;
+    }): ArraySchema<{
+        [Index in keyof U]: U[Index];
+    }>;
+    /**
+     * Creates a validator that validates the input array has the given minimum length.
+     * @param min The minimum number of elements (inclusive)
+     */
+    minLength(min: number): ArraySchema<T>;
+    /**
+     *
+     * Creates a validator that validates the input array has the given maximum length.
+     * @param max The maximum number of elements (inclusive)
+     */
+    maxLength(max: number): ArraySchema<T>;
+    /**
+     * Casts to a readonly array.
+     * This is a shallow cast, elements of the array will not be changed.
+     */
+    readonly(): ArraySchema<Readonly<T>>;
+    /**
+     * Casts the type parameter.
+     */
+    cast<T extends readonly unknown[]>(): ArraySchema<T>;
+}
+//# sourceMappingURL=ArraySchema.d.ts.map

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

@@ -0,0 +1,21 @@
+import type { Fun } from '@amazon/vinyl-util';
+import { ValueSchema } from './ValueSchema';
+import type { Validator } from './Validator';
+export declare const functionValidators: {
+    readonly length: (max: number) => Validator<Fun, Fun>;
+};
+export declare class FunctionSchema<T extends Fun> extends ValueSchema<T> {
+    private static _base;
+    /**
+     * The base Function validator validating that the input is a function.
+     */
+    static get base(): FunctionSchema<Fun>;
+    length(max: number): FunctionSchema<T>;
+    /**
+     * Casts the function signature.
+     * Function signatures, except for their required number of parameters, cannot be
+     * meaningfully validated.
+     */
+    cast<T extends Fun>(): FunctionSchema<T>;
+}
+//# sourceMappingURL=FunctionSchema.d.ts.map