1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 | import { Alt2 } from 'fp-ts/lib/Alt'
|
12 | import { Category2 } from 'fp-ts/lib/Category'
|
13 | import { Refinement } from 'fp-ts/lib/function'
|
14 | import { Functor2 } from 'fp-ts/lib/Functor'
|
15 | import * as TE from 'fp-ts/lib/TaskEither'
|
16 | import * as DE from './DecodeError'
|
17 | import * as D from './Decoder'
|
18 | import * as FS from './FreeSemigroup'
|
19 | import * as G from './Guard'
|
20 | import * as K from './Kleisli'
|
21 | import * as S from './Schemable'
|
22 |
|
23 |
|
24 |
|
25 |
|
26 | export interface TaskDecoder<I, A> extends K.Kleisli<TE.URI, I, DecodeError, A> {}
|
27 |
|
28 |
|
29 |
|
30 |
|
31 | export declare type DecodeError = D.DecodeError
|
32 |
|
33 |
|
34 |
|
35 |
|
36 | export declare const error: (actual: unknown, message: string) => DecodeError
|
37 |
|
38 |
|
39 |
|
40 |
|
41 | export declare const success: <A>(a: A) => TE.TaskEither<DecodeError, A>
|
42 |
|
43 |
|
44 |
|
45 |
|
46 | export declare const failure: <A = never>(
|
47 | actual: unknown,
|
48 | message: string
|
49 | ) => TE.TaskEither<FS.FreeSemigroup<DE.DecodeError<string>>, A>
|
50 |
|
51 |
|
52 |
|
53 |
|
54 | export declare const fromDecoder: <I, A>(decoder: D.Decoder<I, A>) => TaskDecoder<I, A>
|
55 |
|
56 |
|
57 |
|
58 |
|
59 | export declare const fromRefinement: <I, A extends I>(
|
60 | refinement: Refinement<I, A>,
|
61 | expected: string
|
62 | ) => TaskDecoder<I, A>
|
63 |
|
64 |
|
65 |
|
66 |
|
67 | export declare const fromGuard: <I, A extends I>(guard: G.Guard<I, A>, expected: string) => TaskDecoder<I, A>
|
68 |
|
69 |
|
70 |
|
71 |
|
72 | export declare const literal: <A extends readonly [S.Literal, ...Array<S.Literal>]>(
|
73 | ...values: A
|
74 | ) => TaskDecoder<unknown, A[number]>
|
75 |
|
76 |
|
77 |
|
78 |
|
79 | export declare const string: TaskDecoder<unknown, string>
|
80 |
|
81 |
|
82 |
|
83 |
|
84 | export declare const number: TaskDecoder<unknown, number>
|
85 |
|
86 |
|
87 |
|
88 |
|
89 | export declare const boolean: TaskDecoder<unknown, boolean>
|
90 |
|
91 |
|
92 |
|
93 |
|
94 | export declare const UnknownArray: TaskDecoder<unknown, Array<unknown>>
|
95 |
|
96 |
|
97 |
|
98 |
|
99 | export declare const UnknownRecord: TaskDecoder<unknown, Record<string, unknown>>
|
100 |
|
101 |
|
102 |
|
103 |
|
104 | export declare const mapLeftWithInput: <I>(
|
105 | f: (input: I, e: DecodeError) => DecodeError
|
106 | ) => <A>(decoder: TaskDecoder<I, A>) => TaskDecoder<I, A>
|
107 |
|
108 |
|
109 |
|
110 |
|
111 | export declare const withMessage: <I>(
|
112 | message: (input: I, e: DecodeError) => string
|
113 | ) => <A>(decoder: TaskDecoder<I, A>) => TaskDecoder<I, A>
|
114 |
|
115 |
|
116 |
|
117 |
|
118 | export declare const refine: <A, B extends A>(
|
119 | refinement: Refinement<A, B>,
|
120 | id: string
|
121 | ) => <I>(from: TaskDecoder<I, A>) => TaskDecoder<I, B>
|
122 |
|
123 |
|
124 |
|
125 |
|
126 | export declare const parse: <A, B>(
|
127 | parser: (a: A) => TE.TaskEither<DecodeError, B>
|
128 | ) => <I>(from: TaskDecoder<I, A>) => TaskDecoder<I, B>
|
129 |
|
130 |
|
131 |
|
132 |
|
133 | export declare const nullable: <I, A>(or: TaskDecoder<I, A>) => TaskDecoder<null | I, null | A>
|
134 |
|
135 |
|
136 |
|
137 |
|
138 | export declare const fromStruct: <P extends Record<string, TaskDecoder<any, any>>>(
|
139 | properties: P
|
140 | ) => TaskDecoder<
|
141 | { [K in keyof P]: K.InputOf<'TaskEither', P[K]> },
|
142 | { [K_1 in keyof P]: K.TypeOf<'TaskEither', P[K_1]> }
|
143 | >
|
144 |
|
145 |
|
146 |
|
147 |
|
148 |
|
149 |
|
150 |
|
151 | export declare const fromType: <P extends Record<string, TaskDecoder<any, any>>>(
|
152 | properties: P
|
153 | ) => TaskDecoder<
|
154 | { [K in keyof P]: K.InputOf<'TaskEither', P[K]> },
|
155 | { [K_1 in keyof P]: K.TypeOf<'TaskEither', P[K_1]> }
|
156 | >
|
157 |
|
158 |
|
159 |
|
160 |
|
161 | export declare const struct: <A>(
|
162 | properties: { [K in keyof A]: TaskDecoder<unknown, A[K]> }
|
163 | ) => TaskDecoder<unknown, { [K_1 in keyof A]: A[K_1] }>
|
164 |
|
165 |
|
166 |
|
167 |
|
168 |
|
169 |
|
170 |
|
171 | export declare const type: <A>(
|
172 | properties: { [K in keyof A]: TaskDecoder<unknown, A[K]> }
|
173 | ) => TaskDecoder<unknown, { [K_1 in keyof A]: A[K_1] }>
|
174 |
|
175 |
|
176 |
|
177 |
|
178 | export declare const fromPartial: <P extends Record<string, TaskDecoder<any, any>>>(
|
179 | properties: P
|
180 | ) => TaskDecoder<
|
181 | Partial<{ [K in keyof P]: K.InputOf<'TaskEither', P[K]> }>,
|
182 | Partial<{ [K_1 in keyof P]: K.TypeOf<'TaskEither', P[K_1]> }>
|
183 | >
|
184 |
|
185 |
|
186 |
|
187 |
|
188 | export declare const partial: <A>(
|
189 | properties: { [K in keyof A]: TaskDecoder<unknown, A[K]> }
|
190 | ) => TaskDecoder<unknown, Partial<{ [K_1 in keyof A]: A[K_1] }>>
|
191 |
|
192 |
|
193 |
|
194 |
|
195 | export declare const fromArray: <I, A>(item: TaskDecoder<I, A>) => TaskDecoder<I[], A[]>
|
196 |
|
197 |
|
198 |
|
199 |
|
200 | export declare const array: <A>(item: TaskDecoder<unknown, A>) => TaskDecoder<unknown, A[]>
|
201 |
|
202 |
|
203 |
|
204 |
|
205 | export declare const fromRecord: <I, A>(
|
206 | codomain: TaskDecoder<I, A>
|
207 | ) => TaskDecoder<Record<string, I>, Record<string, A>>
|
208 |
|
209 |
|
210 |
|
211 |
|
212 | export declare const record: <A>(codomain: TaskDecoder<unknown, A>) => TaskDecoder<unknown, Record<string, A>>
|
213 |
|
214 |
|
215 |
|
216 |
|
217 | export declare const fromTuple: <C extends readonly TaskDecoder<any, any>[]>(
|
218 | ...components: C
|
219 | ) => TaskDecoder<
|
220 | { [K in keyof C]: K.InputOf<'TaskEither', C[K]> },
|
221 | { [K_1 in keyof C]: K.TypeOf<'TaskEither', C[K_1]> }
|
222 | >
|
223 |
|
224 |
|
225 |
|
226 |
|
227 | export declare const tuple: <A extends readonly unknown[]>(
|
228 | ...components: { [K in keyof A]: TaskDecoder<unknown, A[K]> }
|
229 | ) => TaskDecoder<unknown, A>
|
230 |
|
231 |
|
232 |
|
233 |
|
234 | export declare const union: <MS extends readonly [TaskDecoder<any, any>, ...Array<TaskDecoder<any, any>>]>(
|
235 | ...members: MS
|
236 | ) => TaskDecoder<InputOf<MS[keyof MS]>, TypeOf<MS[keyof MS]>>
|
237 |
|
238 |
|
239 |
|
240 |
|
241 | export declare const intersect: <IB, B>(
|
242 | right: TaskDecoder<IB, B>
|
243 | ) => <IA, A>(left: TaskDecoder<IA, A>) => TaskDecoder<IA & IB, A & B>
|
244 |
|
245 |
|
246 |
|
247 |
|
248 | export declare const fromSum: <T extends string>(
|
249 | tag: T
|
250 | ) => <MS extends Record<string, TaskDecoder<any, any>>>(
|
251 | members: MS
|
252 | ) => TaskDecoder<K.InputOf<'TaskEither', MS[keyof MS]>, K.TypeOf<'TaskEither', MS[keyof MS]>>
|
253 |
|
254 |
|
255 |
|
256 |
|
257 | export declare const sum: <T extends string>(
|
258 | tag: T
|
259 | ) => <A>(members: { [K in keyof A]: TaskDecoder<unknown, A[K] & Record<T, K>> }) => TaskDecoder<unknown, A[keyof A]>
|
260 |
|
261 |
|
262 |
|
263 |
|
264 | export declare const lazy: <I, A>(id: string, f: () => TaskDecoder<I, A>) => TaskDecoder<I, A>
|
265 |
|
266 |
|
267 |
|
268 |
|
269 | export declare const readonly: <I, A>(decoder: TaskDecoder<I, A>) => TaskDecoder<I, Readonly<A>>
|
270 |
|
271 |
|
272 |
|
273 |
|
274 | export declare const map: <A, B>(f: (a: A) => B) => <I>(fa: TaskDecoder<I, A>) => TaskDecoder<I, B>
|
275 |
|
276 |
|
277 |
|
278 |
|
279 | export declare const alt: <I, A>(that: () => TaskDecoder<I, A>) => (me: TaskDecoder<I, A>) => TaskDecoder<I, A>
|
280 |
|
281 |
|
282 |
|
283 |
|
284 | export declare const compose: <A, B>(to: TaskDecoder<A, B>) => <I>(from: TaskDecoder<I, A>) => TaskDecoder<I, B>
|
285 |
|
286 |
|
287 |
|
288 |
|
289 | export declare const id: <A>() => TaskDecoder<A, A>
|
290 |
|
291 |
|
292 |
|
293 |
|
294 | export declare const URI = 'io-ts/TaskDecoder'
|
295 |
|
296 |
|
297 |
|
298 |
|
299 | export declare type URI = typeof URI
|
300 | declare module 'fp-ts/lib/HKT' {
|
301 | interface URItoKind2<E, A> {
|
302 | readonly [URI]: TaskDecoder<E, A>
|
303 | }
|
304 | }
|
305 |
|
306 |
|
307 |
|
308 |
|
309 | export declare const Functor: Functor2<URI>
|
310 |
|
311 |
|
312 |
|
313 |
|
314 | export declare const Alt: Alt2<URI>
|
315 |
|
316 |
|
317 |
|
318 |
|
319 | export declare const Category: Category2<URI>
|
320 |
|
321 |
|
322 |
|
323 |
|
324 | export declare const Schemable: S.Schemable2C<URI, unknown>
|
325 |
|
326 |
|
327 |
|
328 |
|
329 | export declare const WithUnknownContainers: S.WithUnknownContainers2C<URI, unknown>
|
330 |
|
331 |
|
332 |
|
333 |
|
334 | export declare const WithUnion: S.WithUnion2C<URI, unknown>
|
335 |
|
336 |
|
337 |
|
338 |
|
339 | export declare const WithRefine: S.WithRefine2C<URI, unknown>
|
340 |
|
341 |
|
342 |
|
343 | export declare type TypeOf<KTD> = K.TypeOf<TE.URI, KTD>
|
344 |
|
345 |
|
346 |
|
347 | export declare type InputOf<KTD> = K.InputOf<TE.URI, KTD>
|
348 |
|
349 |
|
350 |
|
351 | export declare const draw: (e: DecodeError) => string
|