1 | declare namespace JSVerify {
|
2 | type Arbitrary<T> = ArbitraryLike<T> & ArbitraryFns<T>;
|
3 |
|
4 | interface ArbitraryLike<T> {
|
5 | generator : Generator<T>;
|
6 | show : Show<T>;
|
7 | shrink : Shrink<T>;
|
8 | }
|
9 |
|
10 | interface ArbitraryFns<T> {
|
11 | smap<U>(f : (t : T) => U, g : (u : U) => T, newShow? : Show<U>) : Arbitrary<U>;
|
12 | }
|
13 |
|
14 | function bless<U>(arb : ArbitraryLike<U>) : Arbitrary<U>;
|
15 | function sampler<U>(arb : Arbitrary<U>, genSize? : number) : (sampleSize : number) => U;
|
16 | function small<U>(arb : Arbitrary<U>) : Arbitrary<U>;
|
17 | function suchthat<U>(arb : Arbitrary<U>, predicate : (u : U) => boolean) : Arbitrary<U>;
|
18 |
|
19 | interface Options {
|
20 | tests : number;
|
21 | size : number;
|
22 | quiet : boolean;
|
23 | rngState : string;
|
24 | }
|
25 |
|
26 | interface Result<T> {
|
27 | counterexample : T;
|
28 | tests : number;
|
29 | shrinks : number;
|
30 | exc? : string;
|
31 | rngState : string;
|
32 | }
|
33 |
|
34 | type Generator<T> = GeneratorFn<T> & GeneratorFns<T>;
|
35 | type GeneratorFn<T> = (size : number) => T;
|
36 | interface GeneratorFns<T> {
|
37 | map<U>(f : (t : T) => U) : Generator<U>;
|
38 | flatmap<U>(f : (t : T) => Generator<U>) : Generator<U>;
|
39 | }
|
40 |
|
41 | type Shrink<T> = ShrinkFn<T> & ShrinkFns<T>;
|
42 | type ShrinkFn<T> = (t : T) => T[];
|
43 | interface ShrinkFns<T> {
|
44 | smap<U>(f : (t : T) => U, g : (u : U) => T) : Shrink<U>;
|
45 | }
|
46 |
|
47 | type Show<T> = (t : T) => string;
|
48 | type Property<T> = boolean | void | T;
|
49 | type integerFn = (maxsize : number) => Arbitrary<number>;
|
50 | type integerFn2 = (minsize : number, maxsize : number) => Arbitrary<number>;
|
51 |
|
52 | const integer : Arbitrary<number> & integerFn & integerFn2;
|
53 | const nat : Arbitrary<number> & integerFn;
|
54 | const number : Arbitrary<number> & integerFn & integerFn2;
|
55 |
|
56 | const uint8 : Arbitrary<number>;
|
57 | const uint16 : Arbitrary<number>;
|
58 | const uint32 : Arbitrary<number>;
|
59 | const int8 : Arbitrary<number>;
|
60 | const int16 : Arbitrary<number>;
|
61 | const int32 : Arbitrary<number>;
|
62 |
|
63 | const bool : Arbitrary<boolean>;
|
64 | const datetime : Arbitrary<Date>;
|
65 |
|
66 | function elements<T>(args : T[]) : Arbitrary<T>;
|
67 | const falsy : Arbitrary<any>;
|
68 | function constant<T>(x : T) : Arbitrary<T>;
|
69 |
|
70 | const char : Arbitrary<string>;
|
71 | const asciichar : Arbitrary<string>;
|
72 | const string : Arbitrary<string>;
|
73 | const nestring : Arbitrary<string>;
|
74 | const asciistring : Arbitrary<string>;
|
75 | const asciinestring : Arbitrary<string>;
|
76 |
|
77 |
|
78 | function nonShrink<T>(arb : Arbitrary<T>) : Arbitrary<T>;
|
79 | function either<T, U>(arbA : Arbitrary<T>, arbB : Arbitrary<U>) : Arbitrary<T | U>;
|
80 | function pair<T, U>(arbA : Arbitrary<T>, arbB : Arbitrary<U>) : Arbitrary<[T, U]>;
|
81 |
|
82 | function tuple(arbs : Arbitrary<any>[]) : Arbitrary<any[]>;
|
83 | function sum(arbs : Arbitrary<any>[]) : Arbitrary<any>;
|
84 |
|
85 | function dict<T>(arb : Arbitrary<T>) : Arbitrary<{ [s : string]: T }>;
|
86 | function array<T>(arb : Arbitrary<T>) : Arbitrary<T[]>;
|
87 | function nearray<T>(arb : Arbitrary<T>) : Arbitrary<T[]>;
|
88 | function fn<T>(arb : Arbitrary<T>) : Arbitrary<(a : any) => T>;
|
89 | function fun<T>(arb : Arbitrary<T>) : Arbitrary<(a : any) => T>;
|
90 | const json : Arbitrary<any>;
|
91 | const unit : Arbitrary<any>;
|
92 |
|
93 | function oneOf<T>(gs : Arbitrary<T>[]) : Arbitrary<T>;
|
94 |
|
95 | function forall<A>(arb1 : Arbitrary<A>, prop : (t : A) => Property<A>) : Property<A>;
|
96 | function forall<A, B>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, prop : (t : A, u : B) => Property<any>) : Property<any>;
|
97 | function forall<A, B, C>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, prop : (t : A, u : B, v : C) => Property<any>) : Property<any>;
|
98 | function forall<A, B, C, D>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, prop : (t : A, u : B, v : C, w : D) => Property<any>) : Property<any>;
|
99 | function forall<A, B, C, D, E>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, prop : (t : A, u : B, v : C, w : D, e : E) => Property<any>) : Property<any>;
|
100 | function forall<A, B, C, D, E, F>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, prop : (t : A, u : B, v : C, w : D, e : E, a : F) => Property<any>) : Property<any>;
|
101 | function forall<A, B, C, D, E, F, G>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G) => Property<any>) : Property<any>;
|
102 | function forall<A, B, C, D, E, F, G, H>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, arb8 : Arbitrary<H>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H) => Property<any>) : Property<any>;
|
103 | function forall<A, B, C, D, E, F, G, H, I>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, arb8 : Arbitrary<H>, arb9 : Arbitrary<I>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H, d : I) => Property<any>) : Property<any>;
|
104 | function forall<A, B, C, D, E, F, G, H, I, J>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, arb8 : Arbitrary<H>, arb9 : Arbitrary<I>, arb10 : Arbitrary<J>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H, d : I, f : J) => Property<any>) : Property<any>;
|
105 | function forall(...args : any[]) : Property<any>;
|
106 |
|
107 | function assertForall<A>(arb1 : Arbitrary<A>, prop : (t : A) => Property<A>) : void;
|
108 | function assertForall<A, B>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, prop : (t : A, u : B) => Property<any>) : void;
|
109 | function assertForall<A, B, C>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, prop : (t : A, u : B, v : C) => Property<any>) : void;
|
110 | function assertForall<A, B, C, D>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, prop : (t : A, u : B, v : C, w : D) => Property<any>) : void;
|
111 | function assertForall<A, B, C, D, E>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, prop : (t : A, u : B, v : C, w : D, e : E) => Property<any>) : void;
|
112 | function assertForall<A, B, C, D, E, F>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, prop : (t : A, u : B, v : C, w : D, e : E, a : F) => Property<any>) : void;
|
113 | function assertForall<A, B, C, D, E, F, G>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G) => Property<any>) : void;
|
114 | function assertForall<A, B, C, D, E, F, G, H>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, arb8 : Arbitrary<H>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H) => Property<any>) : void;
|
115 | function assertForall<A, B, C, D, E, F, G, H, I>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, arb8 : Arbitrary<H>, arb9 : Arbitrary<I>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H, d : I) => Property<any>) : void;
|
116 | function assertForall<A, B, C, D, E, F, G, H, I, J>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, arb8 : Arbitrary<H>, arb9 : Arbitrary<I>, arb10 : Arbitrary<J>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H, d : I, f : J) => Property<any>) : void;
|
117 | function assertForall(...args : any[]) : void;
|
118 |
|
119 | function checkForall<A>(arb1 : Arbitrary<A>, prop : (t : A) => Property<A>) : Result<A>;
|
120 | function checkForall<A, B>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, prop : (t : A, u : B) => Property<any>) : Result<any>;
|
121 | function checkForall<A, B, C>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, prop : (t : A, u : B, v : C) => Property<any>) : Result<any>;
|
122 | function checkForall<A, B, C, D>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, prop : (t : A, u : B, v : C, w : D) => Property<any>) : Result<any>;
|
123 | function checkForall<A, B, C, D, E>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, prop : (t : A, u : B, v : C, w : D, e : E) => Property<any>) : Result<any>;
|
124 | function checkForall<A, B, C, D, E, F>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, prop : (t : A, u : B, v : C, w : D, e : E, a : F) => Property<any>) : Result<any>;
|
125 | function checkForall<A, B, C, D, E, F, G>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G) => Property<any>) : Result<any>;
|
126 | function checkForall<A, B, C, D, E, F, G, H>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, arb8 : Arbitrary<H>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H) => Property<any>) : Result<any>;
|
127 | function checkForall<A, B, C, D, E, F, G, H, I>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, arb8 : Arbitrary<H>, arb9 : Arbitrary<I>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H, d : I) => Property<any>) : Result<any>;
|
128 | function checkForall<A, B, C, D, E, F, G, H, I, J>(arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, arb8 : Arbitrary<H>, arb9 : Arbitrary<I>, arb10 : Arbitrary<J>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H, d : I, f : J) => Property<any>) : Result<any>;
|
129 | function checkForall(...args : any[]) : Result<any>;
|
130 |
|
131 | function property<A>(description: String, arb1 : Arbitrary<A>, prop : (t : A) => Property<A>) : any;
|
132 | function property<A, B>(description: String, arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, prop : (t : A, u : B) => Property<any>) : any;
|
133 | function property<A, B, C>(description: String, arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, prop : (t : A, u : B, v : C) => Property<any>) : any;
|
134 | function property<A, B, C, D>(description: String, arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, prop : (t : A, u : B, v : C, w : D) => Property<any>) : any;
|
135 | function property<A, B, C, D, E>(description: String, arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, prop : (t : A, u : B, v : C, w : D, e : E) => Property<any>) : any;
|
136 | function property<A, B, C, D, E, F>(description: String, arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, prop : (t : A, u : B, v : C, w : D, e : E, a : F) => Property<any>) : any;
|
137 | function property<A, B, C, D, E, F, G>(description: String, arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G) => Property<any>) : any;
|
138 | function property<A, B, C, D, E, F, G, H>(description: String, arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, arb8 : Arbitrary<H>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H) => Property<any>) : any;
|
139 | function property<A, B, C, D, E, F, G, H, I>(description: String, arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, arb8 : Arbitrary<H>, arb9 : Arbitrary<I>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H, d : I) => Property<any>) : any;
|
140 | function property<A, B, C, D, E, F, G, H, I, J>(description: String, arb1 : Arbitrary<A>, arb2 : Arbitrary<B>, arb3 : Arbitrary<C>, arb4 : Arbitrary<D>, arb5 : Arbitrary<E>, arb6 : Arbitrary<F>, arb7 : Arbitrary<G>, arb8 : Arbitrary<H>, arb9 : Arbitrary<I>, arb10 : Arbitrary<J>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H, d : I, f : J) => Property<any>) : any;
|
141 | function property(...args : any[]) : Result<any>;
|
142 |
|
143 | function check<T>(prop : Property<T>, opts? : Options) : Result<T>;
|
144 | function assert(prop : Property<any>, opts? : Options) : void;
|
145 |
|
146 | const generator : GeneratorFunctions;
|
147 | const shrink : ShrinkFunctions;
|
148 | const show : ShowFunctions;
|
149 | const random : Random;
|
150 |
|
151 | interface GeneratorFunctions {
|
152 | constant<U>(u : U) : Generator<U>;
|
153 | oneOf<U>(gens : Generator<U>[]) : Generator<U>;
|
154 | recursive<U>(genZ : Generator<U>, f : (u : U) => U) : Generator<U>;
|
155 | pair<T, U>(genA : Generator<T>, genB : Generator<U>) : Generator<[T, U]>;
|
156 | either<T, U>(genA : Generator<T>, genB : Generator<U>) : Generator<T | U>;
|
157 |
|
158 | tuple(gens : Generator<any>[]) : Generator<any[]>;
|
159 | sum(gens : Generator<any>[]) : Generator<any>;
|
160 |
|
161 | array<U>(gen : Generator<U>) : Generator<U[]>;
|
162 | nearray<U>(gen : Generator<U>) : Generator<U[]>;
|
163 | dict<U>(gen : Generator<U>) : Generator<{ [key : string]: U }>;
|
164 |
|
165 | unit : Generator<any>;
|
166 |
|
167 | bless<T>(genLike : GeneratorFn<T>) : Generator<T>;
|
168 | small<T>(gen : Generator<T>) : Generator<T>;
|
169 |
|
170 | combine<A, R>(arb1 : Generator<A>, prop : (t : A) => R) : Generator<R>;
|
171 | combine<A, B, R>(arb1 : Generator<A>, arb2 : Generator<B>, prop : (t : A, u : B) => R) : Generator<R>;
|
172 | combine<A, B, C, R>(arb1 : Generator<A>, arb2 : Generator<B>, arb3 : Generator<C>, prop : (t : A, u : B, v : C) => R) : Generator<R>;
|
173 | combine<A, B, C, D, R>(arb1 : Generator<A>, arb2 : Generator<B>, arb3 : Generator<C>, arb4 : Generator<D>, prop : (t : A, u : B, v : C, w : D) => R) : Generator<R>;
|
174 | combine<A, B, C, D, E, R>(arb1 : Generator<A>, arb2 : Generator<B>, arb3 : Generator<C>, arb4 : Generator<D>, arb5 : Generator<E>, prop : (t : A, u : B, v : C, w : D, e : E) => R) : Generator<R>;
|
175 | combine<A, B, C, D, E, F, R>(arb1 : Generator<A>, arb2 : Generator<B>, arb3 : Generator<C>, arb4 : Generator<D>, arb5 : Generator<E>, arb6 : Generator<F>, prop : (t : A, u : B, v : C, w : D, e : E, a : F) => R) : Generator<R>;
|
176 | combine<A, B, C, D, E, F, G, R>(arb1 : Generator<A>, arb2 : Generator<B>, arb3 : Generator<C>, arb4 : Generator<D>, arb5 : Generator<E>, arb6 : Generator<F>, arb7 : Generator<G>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G) => R) : Generator<R>;
|
177 | combine<A, B, C, D, E, F, G, H, R>(arb1 : Generator<A>, arb2 : Generator<B>, arb3 : Generator<C>, arb4 : Generator<D>, arb5 : Generator<E>, arb6 : Generator<F>, arb7 : Generator<G>, arb8 : Generator<H>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H) => R) : Generator<R>;
|
178 | combine<A, B, C, D, E, F, G, H, I, R>(arb1 : Generator<A>, arb2 : Generator<B>, arb3 : Generator<C>, arb4 : Generator<D>, arb5 : Generator<E>, arb6 : Generator<F>, arb7 : Generator<G>, arb8 : Generator<H>, arb9 : Generator<I>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H, d : I) => R) : Generator<R>;
|
179 | combine<A, B, C, D, E, F, G, H, I, J, R>(arb1 : Generator<A>, arb2 : Generator<B>, arb3 : Generator<C>, arb4 : Generator<D>, arb5 : Generator<E>, arb6 : Generator<F>, arb7 : Generator<G>, arb8 : Generator<H>, arb9 : Generator<I>, arb10 : Generator<J>, prop : (t : A, u : B, v : C, w : D, e : E, a : F, b : G, c : H, d : I, f : J) => R) : Generator<R>;
|
180 | combine<R>(...args : any[]) : Generator<R>;
|
181 | }
|
182 |
|
183 | interface ShrinkFunctions {
|
184 | noop : Shrink<any>;
|
185 | pair<T, U>(shrA : Shrink<T>, shrB : Shrink<U>) : Shrink<[T, U]>;
|
186 | either<T, U>(shrA : Shrink<T>, shrB : Shrink<U>) : Shrink<T | U>;
|
187 |
|
188 | tuple(shrs : Shrink<any>[]) : Shrink<any[]>;
|
189 | sum(shrs : Shrink<any>[]) : Shrink<any>;
|
190 |
|
191 | array<T>(shr : Shrink<T>) : Shrink<T[]>;
|
192 | nearray<T>(shr : Shrink<T>) : Shrink<T[]>;
|
193 |
|
194 | bless<T>(shrinkLike : ShrinkFn<T>) : Shrink<T>;
|
195 | }
|
196 |
|
197 | interface ShowFunctions {
|
198 | def<T>(x : T) : string;
|
199 | pair<T, U>(sA : Show<T>, sB : Show<U>, x : [T, U]) : string;
|
200 | either<T, U>(sA : Show<T>, sB : Show<U>, x : (T | U)) : string;
|
201 |
|
202 | tuple(shs : Show<any>[], x : any[]) : string;
|
203 | sum(shs : Show<any>[], x : any) : string;
|
204 |
|
205 | array<T>(sh : Show<T>, x : T[]) : string;
|
206 | }
|
207 |
|
208 | type Random = RandomInt & RandomFunctions;
|
209 | type RandomInt = (min : number, max : number) => number;
|
210 | interface RandomFunctions {
|
211 | number(min : number, max : number) : number;
|
212 | }
|
213 | }
|
214 |
|
215 | export = JSVerify;
|