@typed/io/cjs/decoder/Decoder.d.ts

Runtime IO type system

import { Effects, FailEnv, PureEffect } from '@typed/effects';
import { Either } from '@typed/either';
import { Maybe } from '@typed/maybe';
import * as G from '../guard/Guard';
export interface Decoder<A = any> {
    readonly expected: string;
    readonly decode: (i: unknown) => DecodeEffect<A>;
}
export declare type TypeOf<A> = A extends Decoder<infer R> ? R : never;
export declare type DecodeEffect<A> = Effects<DecodeFailure, A>;
export declare const DecodeFailure: unique symbol;
export interface DecodeFailure extends FailEnv<typeof DecodeFailure, DecodeError> {
}
/**
 * An decoding error.
 * Note: Is and MUST continue to be JSON-safe
 */
export interface DecodeError {
    readonly key: Maybe<string>;
    readonly expected: string;
    readonly actual: string;
    readonly errors: ReadonlyArray<DecodeError>;
}
export declare namespace DecodeError {
    const create: (expected: string, actual: string, options?: {
        readonly key?: string;
        readonly errors?: ReadonlyArray<DecodeError>;
    }) => DecodeError;
}
export declare const decode: {
    <A>(decoder: Decoder<A>, input: unknown): Effects<DecodeFailure, A>;
    <A>(decoder: Decoder<A>): (input: unknown) => Effects<DecodeFailure, A>;
};
export declare namespace Decoder {
    const fromGuard: <A>(guard: G.Guard<A>, expected: string) => Decoder<A>;
}
export declare const decodeFailure: (e: DecodeError) => Effects<FailEnv<typeof DecodeFailure, DecodeError>, any>;
export declare function catchDecodeFailure<A>(effect: DecodeEffect<A>): PureEffect<Either<DecodeError, A>>;
export declare function catchDecodeFailure<A, B>(effect: DecodeEffect<A>, onError: (error: DecodeError) => B): PureEffect<Either<readonly [DecodeError, B], A>>;
//# sourceMappingURL=Decoder.d.ts.map