boubiyeah

validation.ts

import { Result, Ok, Err, Option, None, Some } from 'space-lift';

export declare abstract class Validator<T> {

abstract validate(value: Value, config?: Configuration, context?: Context): Validation<T>;

map(fn: (value: T) => B): Validator;

filter(fn: (value: T) => boolean): Validator<T>;

flatMap(fn: (value: T) => Result<string, B>): Validator;

transform(fn: (result: Validation<T>) => Result<string | ValidationError[], B>): Validator;

tagged<TAG extends string>(this: Validator<string>): Validator<TAG>;

tagged<TAG extends number>(this: Validator<number>): Validator<TAG>;

export declare type Any = Validator<Value>;

export declare type TypeOf<V extends Any> = V['T'];

export declare type Value = Object | null | undefined;

    transformObjectKeys?: (key: string) => string;

export declare type Validation<T> = Result<ValidationError[], T>;

export declare function success<T>(value: T): Validation<T>;

export declare function failure(context: Context, message: string): Validation<never>;

export declare function typeFailure(value: any, context: Context, expectedType: string): Result<{

export declare function getContext(name: string, parent?: string): Context;

export declare const snakeCaseTransformation: (key: string) => string;

export declare function is<T>(value: Value, validator: Validator<T>): value is T;

export declare class NullValidator extends Validator<null> {

validate(v: Value, _config?: Configuration, c?: Context): Result<ValidationError[], null>;

export declare class UndefinedValidator extends Validator<undefined> {

validate(v: Value, _config?: Configuration, c?: Context): Result<ValidationError[], undefined>;

export declare class StringValidator extends Validator<string> {

validate(v: Value, _config?: Configuration, c?: Context): Result<ValidationError[], string>;

export declare class NumberValidator extends Validator<number> {

validate(v: Value, _config?: Configuration, c?: Context): Result<ValidationError[], number>;

export declare class BooleanValidator extends Validator<boolean> {

validate(v: Value, _config?: Configuration, c?: Context): Result<ValidationError[], boolean>;

export declare class TransformValidator<A, B> extends Validator {

constructor(validator: Validator<A>, f: (a: Validation<A>) => Result<string | ValidationError[], B>);

validate(v: Value, config?: Configuration, c?: Context): Result<ValidationError[], B>;

export declare class ArrayValidator<A> extends Validator<A[]> {

constructor(validator: Validator<A>);

validate(v: Value, config?: Configuration, c?: Context): Ok<ValidationError[], never> | Err<ValidationError[], never> | Ok<never, A[]> | Err<never, A[]>;

export declare function array<A>(validator: Validator<A>): Validator<A[]>;

export declare class TupleValidator extends Validator<any> {

constructor(validators: Validator<any>[]);

validate(v: Value, config?: Configuration, c?: Context): Ok<ValidationError[], never> | Err<ValidationError[], never> | Ok<never, any[]> | Err<never, any[]>;

export declare function tuple<A = never>(): Validator<A[]>;

export declare function tuple<A>(a: Validator<A>): Validator<[A]>;

export declare function tuple<A, B>(a: Validator<A>, b: Validator): Validator<[A, B]>;

export declare function tuple<A, B, C>(a: Validator<A>, b: Validator, c: Validator<C>): Validator<[A, B, C]>;

export declare function tuple<A, B, C, D>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>): Validator<[A, B, C, D]>;

export declare function tuple<A, B, C, D, E>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>): Validator<[A, B, C, D, E]>;

export declare function tuple<A, B, C, D, E, F>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>, f: Validator<F>): Validator<[A, B, C, D, E, F]>;

export declare function tuple<A, B, C, D, E, F, G>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>, f: Validator<F>, g: Validator<G>): Validator<[A, B, C, D, E, F, G]>;

export declare function tuple<A, B, C, D, E, F, G, H>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>, f: Validator<F>, g: Validator<G>, h: Validator<H>): Validator<[A, B, C, D, E, F, G, H]>;

export declare function tuple<A, B, C, D, E, F, G, H, I>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>, f: Validator<F>, g: Validator<G>, h: Validator<H>, i: Validator): Validator<[A, B, C, D, E, F, G, H, I]>;

export declare function tuple<A, B, C, D, E, F, G, H, I, J>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>, f: Validator<F>, g: Validator<G>, h: Validator<H>, i: Validator, j: Validator<J>): Validator<[A, B, C, D, E, F, G, H, I, J]>;

export declare function tuple<A, B, C, D, E, F, G, H, I, J, K>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>, f: Validator<F>, g: Validator<G>, h: Validator<H>, i: Validator, j: Validator<J>, k: Validator<K>): Validator<[A, B, C, D, E, F, G, H, I, J, K]>;

export declare function tuple<A, B, C, D, E, F, G, H, I, J, K, L>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>, f: Validator<F>, g: Validator<G>, h: Validator<H>, i: Validator, j: Validator<J>, k: Validator<K>, l: Validator<L>): Validator<[A, B, C, D, E, F, G, H, I, J, K, L]>;

export declare type Props = Record<string, Any>;

    [K in keyof T]: undefined extends T[K] ? K : never;

    [K in keyof T]: undefined extends T[K] ? never : K;

export declare type ObjectOf = {

[K in MandatoryKeys<Unpack>]: Unpack[K];

[K in OptionalKeys<Unpack>]?: Unpack[K];

export declare class ObjectValidator extends Validator<ObjectOf> {

validate(v: Value, config?: Configuration, c?: Context): Ok<ValidationError[], never> | Err<ValidationError[], never> | Ok<never, any> | Err<never, any>;

validate(v: Value, config?: Configuration, c?: Context): Validation<ObjectOf>;

export declare function object(props: P): Validator<ObjectOf>;

export declare function object(props: P): ObjectValidator;

export declare class KeyOfValidator<KEYS extends object> extends Validator<keyof KEYS> {

validate(v: Value, _config?: Configuration, c?: Context): Validation<keyof KEYS>;

export declare function keyof<KEYS extends object>(keys: KEYS): KeyOfValidator<KEYS>;

export declare class DictionaryValidator<K extends string, V> extends Validator<Record<K, V>> {

constructor(domain: Validator<K>, codomain: Validator<V>);

export declare function dictionary<K extends string, V>(domain: Validator<K>, codomain: Validator<V>): Validator<Record<K, V>>;

export declare type Literal = string | number | boolean | null | undefined;

export declare function literal<V extends Literal>(value: V): Validator<V>;

export declare function intersection<A, B>(a: Validator<A>, b: Validator): Validator<A & B>;

export declare function intersection<A, B, C>(a: Validator<A>, b: Validator, c: Validator<C>): Validator<A & B & C>;

export declare function intersection<A, B, C, D>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>): Validator<A & B & C & D>;

export declare function intersection<A, B, C, D, E>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>): Validator<A & B & C & D & E>;

export declare function intersection<A, B, C, D, E, F>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>, f: Validator<F>): Validator<A & B & C & D & E & F>;

export declare class UnionValidator<A> extends Validator<A> {

constructor(validators: Validator<A>[]);

validate(v: Value, config?: Configuration, c?: Context): Err<ValidationError[], never> | Ok<ValidationError[], A>;

export declare class LiteralUnionValidator<A extends Literal> extends Validator<A> {

export declare function union<A, B>(a: Validator<A>, b: Validator): Validator<A | B>;

export declare function union<A extends Literal, B extends Literal>(a: A, b: B): Validator<A | B>;

export declare function union<A, B, C>(a: Validator<A>, b: Validator, c: Validator<C>): Validator<A | B | C>;

export declare function union<A extends Literal, B extends Literal, C extends Literal>(a: A, b: B, c: C): Validator<A | B | C>;

export declare function union<A, B, C, D>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>): Validator<A | B | C | D>;

export declare function union<A extends Literal, B extends Literal, C extends Literal, D extends Literal>(a: A, b: B, c: C, d: D): Validator<A | B | C | D>;

export declare function union<A, B, C, D, E>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>): Validator<A | B | C | D | E>;

export declare function union<A extends Literal, B extends Literal, C extends Literal, D extends Literal, E extends Literal>(a: A, b: B, c: C, d: D, e: E): Validator<A | B | C | D | E>;

export declare function union<A, B, C, D, E, F>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>, f: Validator<F>): Validator<A | B | C | D | E | F>;

export declare function union<A extends Literal, B extends Literal, C extends Literal, D extends Literal, E extends Literal, F extends Literal>(a: A, b: B, c: C, d: D, e: E, f: F): Validator<A | B | C | D | E | F>;

export declare function union<A, B, C, D, E, F, G>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>, f: Validator<F>, g: Validator<G>): Validator<A | B | C | D | E | F | G>;

export declare function union<A extends Literal, B extends Literal, C extends Literal, D extends Literal, E extends Literal, F extends Literal, G extends Literal>(a: A, b: B, c: C, d: D, e: E, f: F, g: G): Validator<A | B | C | D | E | F | G>;

export declare function union<A, B, C, D, E, F, G, H>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>, f: Validator<F>, g: Validator<G>, h: Validator<H>): Validator<A | B | C | D | E | F | G | H>;

export declare function union<A extends Literal, B extends Literal, C extends Literal, D extends Literal, E extends Literal, F extends Literal, G extends Literal, H extends Literal>(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H): Validator<A | B | C | D | E | F | G | H>;

export declare function union<A, B, C, D, E, F, G, H, I>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>, f: Validator<F>, g: Validator<G>, h: Validator<H>, i: Validator): Validator<A | B | C | D | E | F | G | H | I>;

export declare function union<A extends Literal, B extends Literal, C extends Literal, D extends Literal, E extends Literal, F extends Literal, G extends Literal, H extends Literal, I extends Literal>(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I): Validator<A | B | C | D | E | F | G | H | I>;

export declare function union<A, B, C, D, E, F, G, H, I, J>(a: Validator<A>, b: Validator, c: Validator<C>, d: Validator<D>, e: Validator<E>, f: Validator<F>, g: Validator<G>, h: Validator<H>, i: Validator, j: Validator<J>): Validator<A | B | C | D | E | F | G | H | I | J>;

export declare function union<A extends Literal, B extends Literal, C extends Literal, D extends Literal, E extends Literal, F extends Literal, G extends Literal, H extends Literal, I extends Literal, J extends Literal>(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J): Validator<A | B | C | D | E | F | G | H | I | J>;

export declare class OptionalValidator<V> extends Validator<V | undefined> {

constructor(validator: Validator<V>);

validate(v: Value, config?: Configuration, c?: Context): Ok<ValidationError[], undefined> | Err<ValidationError[], undefined> | Ok<ValidationError[], V> | Err<ValidationError[], V>;

export declare function optional<V>(validator: Validator<V>): Validator<V | undefined>;

export declare class OptionValidator<V> extends Validator<Option<V>> {

validate(v: Value, config?: Configuration, c?: Context): Ok<ValidationError[], None> | Err<ValidationError[], None> | Ok<ValidationError[], Some<V>> | Err<ValidationError[], Some<V>>;

export declare function option<V>(validator: Validator<V>): Validator<Option<V>>;

export declare function recursion<T>(definition: (self: Validator<T>) => Any): Validator<T>;

export declare function errorDebugString(errors: ValidationError[]): string;

declare const nullValidator: NullValidator;

declare const undefinedValidator: UndefinedValidator;

export { nullValidator as null, undefinedValidator as undefined };

export declare const string: StringValidator;

export declare const number: NumberValidator;

export declare const boolean: BooleanValidator;

export declare const isoDate: Validator<Date>;

  "description": "Validation for TypeScript",

    "build": "npm run build-es && npm run build-commonjs",

    "build-es": "tsc validation.ts --outDir es --strict --noUnusedParameters --declaration --lib dom,es5,es6 --module es6 --moduleResolution node",

    "build-commonjs": "tsc validation.ts --outDir commonjs --strict --noUnusedParameters --declaration --lib dom,es5,es6",

    "pretest": "npm run build && tsc test/mocha.d.ts test/global.d.ts test/expect.d.ts test/test.ts --strict",

    "test": "mocha --recursive && node test/testCompilationErrors.js",

    "locale-test": "cross-env LANG=tr_TR npm run test"

  "homepage": "https://github.com/AlexGalays/validation.ts"

		@@ -96,7 +96,7 @@ import { Result, Ok, Err, Option, None, Some } from 'space-lift';
		export declare class ObjectValidator<P extends Props> extends Validator<ObjectOf<P>> {
		private props;
		props: P;
		constructor(props: P);
		validate(v: Value, config?: Configuration, c?: Context): Ok<ValidationError[], never> \| Err<ValidationError[], never> \| Ok<never, any> \| Err<never, any>;
		validate(v: Value, config?: Configuration, c?: Context): Validation<ObjectOf<P>>;
		}
		export declare function object<P extends Props>(props: P): Validator<ObjectOf<P>>;
		export declare function object<P extends Props>(props: P): ObjectValidator<P>;
		export declare class KeyOfValidator<KEYS extends object> extends Validator<keyof KEYS> {
		@@ -103,0 +103,0 @@ private keys;

		@@ -96,7 +96,7 @@ import { Result, Ok, Err, Option, None, Some } from 'space-lift';
		export declare class ObjectValidator<P extends Props> extends Validator<ObjectOf<P>> {
		private props;
		props: P;
		constructor(props: P);
		validate(v: Value, config?: Configuration, c?: Context): Ok<ValidationError[], never> \| Err<ValidationError[], never> \| Ok<never, any> \| Err<never, any>;
		validate(v: Value, config?: Configuration, c?: Context): Validation<ObjectOf<P>>;
		}
		export declare function object<P extends Props>(props: P): Validator<ObjectOf<P>>;
		export declare function object<P extends Props>(props: P): ObjectValidator<P>;
		export declare class KeyOfValidator<KEYS extends object> extends Validator<keyof KEYS> {
		@@ -103,0 +103,0 @@ private keys;

		{
		"name": "validation.ts",
		"version": "0.0.26",
		"version": "0.0.27",
		"description": "Validation for TypeScript",
		@@ -5,0 +5,0 @@ "license": "MIT",

Worsened metrics