@typed/fp/esm/Decoder.d.ts

Data Structures and Resources for fp-ts

import * as App from 'fp-ts/Applicative';
import * as Ap from 'fp-ts/Apply';
import * as Ch from 'fp-ts/Chain';
import * as F from 'fp-ts/Functor';
import { IO } from 'fp-ts/IO';
import { Json } from 'fp-ts/Json';
import { Monad2 } from 'fp-ts/Monad';
import { Pointed2 } from 'fp-ts/Pointed';
import { Predicate } from 'fp-ts/Predicate';
import { Refinement } from 'fp-ts/Refinement';
import * as DE from './DecodeError';
import { UndoPartial } from './internal';
import { Literal, Schemable2C, WithRefine2C, WithUnion2C } from './Schemable';
import * as T from './These';
/**
 * @category Model
 * @since 0.9.4
 */
export interface Decoder<I, O> {
    readonly decode: (input: I) => T.These<DE.DecodeErrors, O>;
}
/**
 * @category Type-level
 * @since 0.9.4
 */
export declare type InputOf<A> = [A] extends [Decoder<infer I, any>] ? I : never;
/**
 * @category Type-level
 * @since 0.9.4
 */
export declare type OutputOf<A> = [A] extends [Decoder<any, infer O>] ? O : never;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare function fromRefinement<I, O extends I>(refinement: Refinement<I, O>, expected: string): Decoder<I, O>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const compose: <A, O>(second: Decoder<A, O>) => <I>(first: Decoder<I, A>) => Decoder<I, O>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare const string: Decoder<unknown, string>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare const number: Decoder<unknown, number>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare const boolean: Decoder<unknown, boolean>;
/**
 * @category Decoder
 * @since 0.9.5
 */
export declare const dateFromISOString: Decoder<string, Date>;
/**
 * @category Instance
 * @since 0.9.5
 */
export declare const WithRefine: WithRefine2C<URI, unknown>;
/**
 * @category Combinator
 * @since 0.9.5
 */
export declare const refine: <A, B extends A>(refinement: Refinement<A, B>, id: string) => (from: Decoder<unknown, A>) => Decoder<unknown, B>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare const union: <I, O1>(second: Decoder<I, O1>) => <O2>(first: Decoder<I, O2>) => Decoder<I, O1 | O2>;
/**
 * @category Refinement
 * @since 0.9.6
 */
export declare const isDate: (x: unknown) => x is Date;
/**
 * @category Constructor
 * @since 0.9.6
 */
export declare const date: Decoder<unknown, Date>;
/**
 * @category Constructor
 * @since 0.9.6
 */
export declare const sum: <T extends string>(tag: T) => <A>(members: { [K in keyof A]: Decoder<unknown, A[K] & Record<T, K>>; }) => Decoder<unknown, A[keyof A]>;
/**
 * @category Constructor
 * @since 0.9.6
 */
export declare const literal: <A extends readonly Literal[]>(...literals: A) => Decoder<unknown, A[number]>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const nullable: <O2>(first: Decoder<unknown, O2>) => Decoder<unknown, O2 | null>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const optional: <O2>(first: Decoder<unknown, O2>) => Decoder<unknown, O2 | undefined>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare const unknownArray: Decoder<unknown, readonly unknown[]>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare const unknownRecord: Decoder<unknown, {
    readonly [key: string]: unknown;
}>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare const fromArray: <O>(member: Decoder<unknown, O>) => Decoder<readonly unknown[], readonly O[]>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare const array: <O>(member: Decoder<unknown, O>) => Decoder<unknown, readonly O[]>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare const fromStruct: <A extends {
    readonly [key: string]: Decoder<unknown, any>;
}>(properties: A) => Decoder<Readonly<Record<string, unknown>>, Partial<{ readonly [K in keyof A]: OutputOf<A[K]>; }>>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare function missingKeys<A extends {
    readonly [key: string]: Decoder<unknown, any>;
}>(properties: A): Decoder<Readonly<Record<string, unknown>>, Partial<{
    readonly [K in keyof A]: OutputOf<A[K]>;
}>>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare function unexpectedKeys<A extends {
    readonly [key: string]: Decoder<unknown, any>;
}>(properties: A): Decoder<Readonly<Record<string, unknown>>, Partial<{
    readonly [K in keyof A]: OutputOf<A[K]>;
}>>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare function struct<A extends {
    readonly [key: string]: Decoder<unknown, any>;
}>(properties: A): Decoder<unknown, Partial<{
    readonly [K in keyof A]: OutputOf<A[K]>;
}>>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare function fromRecord<A>(decoder: Decoder<unknown, A>): Decoder<Readonly<Record<string, unknown>>, Readonly<Record<string, A>>>;
/**
 * @category Constructor
 * @since 0.9.6
 */
export declare const record: <O>(codomain: Decoder<unknown, O>) => Decoder<unknown, Readonly<Record<string, O>>>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare function fromTuple<A extends readonly unknown[]>(...components: {
    readonly [K in keyof A]: Decoder<unknown, A[K]>;
}): Decoder<readonly unknown[], A>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare function missingIndexes<A extends readonly unknown[]>(...components: {
    readonly [K in keyof A]: Decoder<unknown, A[K]>;
}): Decoder<readonly unknown[], readonly unknown[]>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare function unexpectedIndexes<A extends readonly unknown[]>(...components: {
    readonly [K in keyof A]: Decoder<unknown, A[K]>;
}): Decoder<readonly unknown[], readonly unknown[]>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare function tuple<A extends readonly unknown[]>(...components: {
    readonly [K in keyof A]: Decoder<unknown, A[K]>;
}): Decoder<unknown, A>;
/**
 * @category Combinator
 * @since 0.9.6
 */
export declare const intersect: <A, B>(second: Decoder<A, B>) => <C, D>(first: Decoder<C, D>) => Decoder<A & C, B & D>;
/**
 * @category Constructor
 * @since 0.9.6
 */
export declare const lazy: <I, O>(id: string, f: () => Decoder<I, O>) => Decoder<I, O>;
/**
 * @category URI
 * @since 0.9.4
 */
export declare const URI = "@typed/fp/Decoder";
/**
 * @category URI
 * @since 0.9.4
 */
export declare type URI = typeof URI;
declare module 'fp-ts/HKT' {
    interface URItoKind2<E, A> {
        [URI]: Decoder<E, A>;
    }
}
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare const of: <A>(value: A) => Decoder<unknown, A>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const map: <A, B>(f: (value: A) => B) => <I>(decoder: Decoder<I, A>) => Decoder<I, B>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare function condemnWhen(predicate: Predicate<DE.DecodeError>): <I, A>(decoder: Decoder<I, A>) => Decoder<I, A>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const condemn: <I, A>(decoder: Decoder<I, A>) => Decoder<I, A>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare function absolveWhen(predicate: Predicate<DE.DecodeError>): <I, A>(decoder: Decoder<I, A>) => Decoder<I, A>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const absolve: <I, A>(decoder: Decoder<I, A>) => Decoder<I, A>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const condemnUnexpectedKeys: <I, A>(decoder: Decoder<I, A>) => Decoder<I, A>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const condemmMissingKeys: <I, A>(decoder: Decoder<I, A>) => Decoder<I, UndoPartial<A>>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const strict: <I, A>(decoder: Decoder<I, A>) => Decoder<I, UndoPartial<A>>;
/**
 * @category Instance
 * @since 0.9.4
 */
export declare const Pointed: Pointed2<URI>;
/**
 * @category Instance
 * @since 0.9.4
 */
export declare const Functor: F.Functor2<URI>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const bindTo: <N extends string>(name: N) => <E, A>(fa: Decoder<E, A>) => Decoder<E, { readonly [K in N]: A; }>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const flap: <A>(a: A) => <E, B>(fab: Decoder<E, (a: A) => B>) => Decoder<E, B>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const tupled: <E, A>(fa: Decoder<E, A>) => Decoder<E, readonly [A]>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare const fromIO: <A>(io: IO<A>) => Decoder<unknown, {}>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const chain: <A, I, B>(f: (a: A) => Decoder<I, B>) => (decoder: Decoder<I, A>) => Decoder<I, B>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare const Chain: Ch.Chain2<URI>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const ap: <E, A>(fa: Decoder<E, A>) => <B>(fab: Decoder<E, (a: A) => B>) => Decoder<E, B>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const chainFirst: <A, E, B>(f: (a: A) => Decoder<E, B>) => (first: Decoder<E, A>) => Decoder<E, A>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const bind: <N extends string, A, E, B>(name: Exclude<N, keyof A>, f: (a: A) => Decoder<E, B>) => (ma: Decoder<E, A>) => Decoder<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @category Instance
 * @since 0.9.4
 */
export declare const Apply: Ap.Apply2<URI>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const apFirst: <E, B>(second: Decoder<E, B>) => <A>(first: Decoder<E, A>) => Decoder<E, A>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const apS: <N extends string, A, E, B>(name: Exclude<N, keyof A>, fb: Decoder<E, B>) => (fa: Decoder<E, A>) => Decoder<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const apSecond: <E, B>(second: Decoder<E, B>) => <A>(first: Decoder<E, A>) => Decoder<E, B>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const apT: <E, B>(fb: Decoder<E, B>) => <A extends readonly unknown[]>(fas: Decoder<E, A>) => Decoder<E, readonly [...A, B]>;
/**
 * @category Typeclass Constructor
 * @since 0.9.4
 */
export declare const getApplySemigroup: <A, E>(S: import("fp-ts/Semigroup").Semigroup<A>) => import("fp-ts/Semigroup").Semigroup<Decoder<E, A>>;
/**
 * @category Instance
 * @since 0.9.4
 */
export declare const Applicative: App.Applicative2<URI>;
/**
 * @category Combinator
 * @since 0.9.4
 */
export declare const getApplicativeMonoid: <A, E>(M: import("fp-ts/Monoid").Monoid<A>) => import("fp-ts/Monoid").Monoid<Decoder<E, A>>;
/**
 * @category Constructor
 * @since 0.9.4
 */
export declare const Do: Decoder<unknown, {}>;
/**
 * @category Instance
 * @since 0.9.4
 */
export declare const Monad: Monad2<URI>;
/**
 * @category Instance
 * @since 0.9.5
 */
export declare const Schemable: Schemable2C<URI, unknown>;
/**
 * @category Instance
 * @since 0.9.5
 */
export declare const WithUnion: WithUnion2C<URI, unknown>;
/**
 * @category Decoder
 * @since 0.9.5
 */
export declare const jsonParseFromString: Decoder<string, Json>;
/**
 * @category Decoder
 * @since 0.9.5
 */
export declare const jsonParse: Decoder<unknown, Json>;
/**
 * Throw if not a valid decoder. Absolves optional errors
 * @category Interpreter
 * @since 0.9.5
 */
export declare const assert: <I, O>(decoder: Decoder<I, O>) => (i: I) => O;
/**
 * Throw if not a valid decoder. Condemns optional errors
 * @category Interpreter
 * @since 0.9.5
 */
export declare const assertStrict: <I, O>(decoder: Decoder<I, O>) => (i: I) => Required<O>;
//# sourceMappingURL=Decoder.d.ts.map