@flix-tech/fp-ts-type-check/lib/index.d.ts

Type validation in runtime

import * as E from 'fp-ts/lib/Either';
export interface ParseError {
    path: string;
    message: string;
}
export declare type ParseResult<A> = E.Either<ParseError, A>;
export declare type Parser<OUT, IN = unknown> = {
    (x: IN): ParseResult<OUT & IN>;
    right?: (x: OUT) => void;
};
export declare const string: Parser<string, unknown>;
export declare const boolean: Parser<boolean, unknown>;
export declare const number: Parser<number, unknown>;
export declare const object: (x: unknown) => E.Left<ParseError> | E.Right<Record<string, unknown>>;
export declare const any: Parser<any>;
export declare const exact: <A>(expected: A) => Parser<A, unknown>;
export declare const and: <OUT, MIDDLE, IN = undefined>(parserA: Parser<MIDDLE, IN>, parserB: Parser<OUT, MIDDLE & IN>) => Parser<MIDDLE & OUT, IN>;
export declare const or: <A, B, IN = undefined>(parserA: Parser<A, IN>, parserB: Parser<B, IN>) => Parser<A | B, IN>;
export declare const oneOf: <A>(allowed: A[]) => Parser<A, unknown>;
export declare const keyOf: <A extends Record<string, unknown>>(allowed: A) => Parser<keyof A, unknown>;
export declare const type: <A, IN = unknown>(propertyParsers: { [K in keyof A]: Parser<A[K], unknown>; }) => Parser<A & IN, IN>;
export declare const optional: <A>(parseBody: Parser<A, unknown>) => Parser<A | undefined, unknown>;
export declare const nullable: <A>(parseBody: Parser<A, unknown>) => Parser<A | null, unknown>;
export declare const arrayOf: <A>(parseBody: Parser<A, unknown>) => Parser<A[], unknown>;
interface HasTypeField {
    type: string;
}
declare type DiscriminatedUnionParsers<T extends HasTypeField> = {
    [K in T['type']]: T extends {
        type: K;
    } ? Parser<T, {
        type: T['type'];
    }> : never;
};
export declare const discriminatedUnion: <A extends HasTypeField>(parsers: DiscriminatedUnionParsers<A>) => Parser<A, unknown>;
export {};