@amazon/vinyl-validation 1.0.0

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

@@ -0,0 +1,128 @@
+import type { 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 type { ExtendedPropertyValidators } from './ObjectSchema';
+import { ObjectSchema } from './ObjectSchema';
+import { RecordSchema } from './RecordSchema';
+import { StringSchema } from './StringSchema';
+import type { 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.7/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.7/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.7/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

package/dist/types/ts4.7/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.7/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.7/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.7/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.7/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.7/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.7/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