pema 0.8.1 → 0.8.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/lib/private/InferInputSchema.d.ts +1 -1
  2. package/lib/private/errors.d.ts +1 -1
  3. package/lib/private/index.d.ts +92 -248
  4. package/lib/private/optional.d.ts +1 -1
  5. package/lib/private/spec/bigint.d.ts +3 -3
  6. package/lib/private/spec/biguint.d.ts +3 -3
  7. package/lib/private/spec/int.d.ts +3 -3
  8. package/lib/private/spec/uint.d.ts +3 -3
  9. package/package.json +1 -1
package/lib/private/InferInputSchema.d.ts CHANGED
@@ -5,7 +5,7 @@ import type OptionalType from "#OptionalType";
5
5
  import type Parsed from "#Parsed";
6
6
  import type Schema from "#Schema";
7
7
  import type { ImpliedOptional, UndefinedToOptional } from "@rcompat/type";
8
- type InferInputSchema<S> = S extends DefaultType<infer T, unknown> ? T["infer"] | undefined : S extends OptionalType<infer T> ? T["infer"] | undefined : S extends ObjectType<infer P> ? ImpliedOptional<UndefinedToOptional<{
8
+ type InferInputSchema<S> = S extends DefaultType<infer T, unknown> ? InferInputSchema<T> | undefined : S extends OptionalType<infer T> ? InferInputSchema<T> | undefined : S extends ObjectType<infer P> ? ImpliedOptional<UndefinedToOptional<{
9
9
  [K in keyof P]: InferInputSchema<P[K]>;
10
10
  }>> : S extends Parsed<unknown> ? S["infer"] : S extends {
11
11
  [key: string]: Schema;
package/lib/private/errors.d.ts CHANGED
@@ -8,7 +8,7 @@ declare function too_large(input: unknown, message: string, path?: JSONPointer):
8
8
  declare function out_of_range(input: unknown, message: string, path?: JSONPointer): ParseError;
9
9
  declare function duplicate(input: unknown, message: string, path?: JSONPointer): ParseError;
10
10
  declare function not_in_set(input: unknown, message: string, path?: JSONPointer): ParseError;
11
- declare function field(path: JSONPointer, message: string): ParseError;
11
+ declare function field(path: string, message: string): ParseError;
12
12
  declare const _default: {
13
13
  invalid_type: typeof invalid_type;
14
14
  invalid_format: typeof invalid_format;
package/lib/private/index.d.ts CHANGED
@@ -47,262 +47,106 @@ import type Schema from "#Schema";
47
47
  */
48
48
  declare function schema<const S extends Schema>(s: S): NormalizeSchema<S>;
49
49
  declare namespace schema {
50
- var array: <const S extends Schema>(of: S) => import("#ArrayType").default<NormalizeSchema<S>>;
51
- }
52
- declare namespace schema {
53
- var bigint: import("./BigIntType.js").default<"i64", undefined>;
54
- }
55
- declare namespace schema {
56
- var biguint: import("./BigUintType.js").default<"u64", undefined>;
57
- }
58
- declare namespace schema {
59
- var blob: import("#BlobType").default;
60
- }
61
- declare namespace schema {
62
- var boolean: import("#BooleanType").default<undefined>;
63
- }
64
- declare namespace schema {
65
- var constructor: <const C extends import("@rcompat/type").AbstractNewable>(c: C) => import("#ConstructorType").default<C>;
66
- }
67
- declare namespace schema {
68
- var date: import("#DateType").default<undefined>;
69
- }
70
- declare namespace schema {
71
- var dict: {
50
+ var _a: <const S extends Schema>(of: S) => import("#ArrayType").default<NormalizeSchema<S>>;
51
+ export { _a as array };
52
+ export var _b: import("./BigIntType.js").default<"i64", undefined>;
53
+ export { _b as bigint };
54
+ export var _c: import("./BigUintType.js").default<"u64", undefined>;
55
+ export { _c as biguint };
56
+ export var _d: import("#BlobType").default;
57
+ export { _d as blob };
58
+ export var _e: import("#BooleanType").default<undefined>;
59
+ export { _e as boolean };
60
+ export var _f: <const C extends import("@rcompat/type").AbstractNewable>(c: C) => import("#ConstructorType").default<C>;
61
+ export { _f as constructor };
62
+ export var _g: import("#DateType").default<undefined>;
63
+ export { _g as date };
64
+ export var _h: {
72
65
  (): import("#RecordType").default<import("#StringType").default, import("#StringType").default>;
73
66
  <const Value extends import("#Parsed").default<unknown>>(of: Value): import("#RecordType").default<import("#StringType").default, Value>;
74
67
  };
75
- }
76
- declare namespace schema {
77
- var _a: <T extends readonly string[]>(values: T) => import("#EnumType").default<T>;
78
- export { _a as enum };
79
- }
80
- declare namespace schema {
81
- var f32: import("#NumberType").default<"f32", undefined>;
82
- }
83
- declare namespace schema {
84
- var f64: import("#NumberType").default<"f64", undefined>;
85
- }
86
- declare namespace schema {
87
- var file: import("./FileType.js").default;
88
- }
89
- declare namespace schema {
90
- var _b: import("#FunctionType").default;
91
- export { _b as function };
92
- }
93
- declare namespace schema {
94
- var i128: import("./BigIntType.js").default<"i128", undefined>;
95
- }
96
- declare namespace schema {
97
- var i16: import("./IntType.js").default<"i16", undefined>;
98
- }
99
- declare namespace schema {
100
- var i32: import("./IntType.js").default<"i32", undefined>;
101
- }
102
- declare namespace schema {
103
- var i64: import("./BigIntType.js").default<"i64", undefined>;
104
- }
105
- declare namespace schema {
106
- var i8: import("./IntType.js").default<"i8", undefined>;
107
- }
108
- declare namespace schema {
109
- var int: import("./IntType.js").default<"i32", undefined>;
110
- }
111
- declare namespace schema {
112
- var is: <T>(predicate: (x: unknown) => x is T) => import("#IsType").default<T>;
113
- }
114
- declare namespace schema {
115
- var json: {
68
+ export { _h as dict };
69
+ export var _j: <T extends readonly string[]>(values: T) => import("#EnumType").default<T>;
70
+ export { _j as enum };
71
+ export var _k: import("#NumberType").default<"f32", undefined>;
72
+ export { _k as f32 };
73
+ export var _l: import("#NumberType").default<"f64", undefined>;
74
+ export { _l as f64 };
75
+ export var _m: import("./FileType.js").default;
76
+ export { _m as file };
77
+ export var _o: import("#FunctionType").default;
78
+ export { _o as function };
79
+ export var _p: import("./BigIntType.js").default<"i128", undefined>;
80
+ export { _p as i128 };
81
+ export var _q: import("./IntType.js").default<"i16", undefined>;
82
+ export { _q as i16 };
83
+ export var _r: import("./IntType.js").default<"i32", undefined>;
84
+ export { _r as i32 };
85
+ export var _s: import("./BigIntType.js").default<"i64", undefined>;
86
+ export { _s as i64 };
87
+ export var _t: import("./IntType.js").default<"i8", undefined>;
88
+ export { _t as i8 };
89
+ export var _u: import("./IntType.js").default<"i32", undefined>;
90
+ export { _u as int };
91
+ export var _v: <T>(predicate: (x: unknown) => x is T) => import("#IsType").default<T>;
92
+ export { _v as is };
93
+ export var _w: {
116
94
  (): import("#JSONType").default<undefined>;
117
95
  <S extends import("#JSONType").ParsedJSON>(inner: S): import("#JSONType").default<S>;
118
96
  };
119
- }
120
- declare namespace schema {
121
- var literal: <T extends string | number | boolean>(literal: T) => import("#LiteralType").default<T, undefined>;
122
- }
123
- declare namespace schema {
124
- var _c: import("#NullType").default;
125
- export { _c as null };
126
- }
127
- declare namespace schema {
128
- var number: import("#NumberType").default<"f64", undefined>;
129
- }
130
- declare namespace schema {
131
- var object: <P extends import("@rcompat/type").Dict<Schema> = import("@rcompat/type").Dict<Schema>>(properties: P) => import("#ObjectType").default<keyof P extends never ? {} : { [K in keyof P]: NormalizeSchema<P[K]>; }>;
132
- }
133
- declare namespace schema {
134
- var omit: <P extends import("@rcompat/type").Dict<import("#Parsed").default<unknown>>, K extends keyof P>(type: import("#ObjectType").default<P>, ...keys: K[]) => import("./OmitType.js").default<P, K>;
135
- }
136
- declare namespace schema {
137
- var record: <const Key extends import("./RecordTypeKey.js").default, const Value extends import("#Parsed").default<unknown>>(k: Key, v: Value) => import("#RecordType").default<Key, Value, undefined>;
138
- }
139
- declare namespace schema {
140
- var partial: <const D extends import("./Partialable.js").default>(input: D | import("#ObjectType").default<D>) => import("#PartialType").default<{ -readonly [K in keyof D]: D[K]; }>;
141
- }
142
- declare namespace schema {
143
- var pure: <T>() => import("#PureType").default<T, "PureType">;
144
- }
145
- declare namespace schema {
146
- var string: import("#StringType").default;
147
- }
148
- declare namespace schema {
149
- var symbol: import("./SymbolType.js").default;
150
- }
151
- declare namespace schema {
152
- var tuple: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }>;
153
- }
154
- declare namespace schema {
155
- var u128: import("./BigUintType.js").default<"u128", undefined>;
156
- }
157
- declare namespace schema {
158
- var u16: import("#UintType").default<"u16", undefined>;
159
- }
160
- declare namespace schema {
161
- var u32: import("#UintType").default<"u32", undefined>;
162
- }
163
- declare namespace schema {
164
- var u64: import("./BigUintType.js").default<"u64", undefined>;
165
- }
166
- declare namespace schema {
167
- var u8: import("#UintType").default<"u8", undefined>;
168
- }
169
- declare namespace schema {
170
- var uint: import("#UintType").default<"u32", undefined>;
171
- }
172
- declare namespace schema {
173
- var undefined: import("#UndefinedType").default;
174
- }
175
- declare namespace schema {
176
- var union: {
97
+ export { _w as json };
98
+ export var _x: <T extends string | number | boolean>(literal: T) => import("#LiteralType").default<T, undefined>;
99
+ export { _x as literal };
100
+ export var _y: import("#NullType").default;
101
+ export { _y as null };
102
+ export var _z: import("#NumberType").default<"f64", undefined>;
103
+ export { _z as number };
104
+ export var _0: <P extends import("@rcompat/type").Dict<Schema> = import("@rcompat/type").Dict<Schema>>(properties: P) => import("#ObjectType").default<keyof P extends never ? {} : { [K in keyof P]: NormalizeSchema<P[K]>; }>;
105
+ export { _0 as object };
106
+ export var _1: <P extends import("@rcompat/type").Dict<import("#Parsed").default<unknown>>, K extends keyof P>(type: import("#ObjectType").default<P>, ...keys: K[]) => import("./OmitType.js").default<P, K>;
107
+ export { _1 as omit };
108
+ export var _2: <const Key extends import("./RecordTypeKey.js").default, const Value extends import("#Parsed").default<unknown>>(k: Key, v: Value) => import("#RecordType").default<Key, Value, undefined>;
109
+ export { _2 as record };
110
+ export var _3: <const D extends import("./Partialable.js").default>(input: D | import("#ObjectType").default<D>) => import("#PartialType").default<{ -readonly [K in keyof D]: D[K]; }>;
111
+ export { _3 as partial };
112
+ export var _4: <T>() => import("#PureType").default<T, "PureType">;
113
+ export { _4 as pure };
114
+ export var _5: import("#StringType").default;
115
+ export { _5 as string };
116
+ export var _6: import("./SymbolType.js").default;
117
+ export { _6 as symbol };
118
+ export var _7: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }>;
119
+ export { _7 as tuple };
120
+ export var _8: import("./BigUintType.js").default<"u128", undefined>;
121
+ export { _8 as u128 };
122
+ export var _9: import("#UintType").default<"u16", undefined>;
123
+ export { _9 as u16 };
124
+ export var _10: import("#UintType").default<"u32", undefined>;
125
+ export { _10 as u32 };
126
+ export var _11: import("./BigUintType.js").default<"u64", undefined>;
127
+ export { _11 as u64 };
128
+ export var _12: import("#UintType").default<"u8", undefined>;
129
+ export { _12 as u8 };
130
+ export var _13: import("#UintType").default<"u32", undefined>;
131
+ export { _13 as uint };
132
+ export var _14: import("#UndefinedType").default;
133
+ export { _14 as undefined };
134
+ export var _15: {
177
135
  (): import("#UnionType").default<[]>;
178
136
  <const T extends Schema[]>(...types: T): import("#UnionType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }>;
179
137
  };
180
- }
181
- declare namespace schema {
182
- var unknown: import("#UnknownType").default;
183
- }
184
- declare namespace schema {
185
- var url: import("#URLType").default<undefined>;
186
- }
187
- declare namespace schema {
188
- var uuid: import("#UUIDType").default;
189
- }
190
- declare namespace schema {
191
- var error: (path: import("@rcompat/type").JSONPointer, message: string) => import("./ParseError.js").default;
192
- }
193
- declare namespace schema {
194
- var loose: {
195
- <const S extends Schema>(s: S): NormalizeSchema<S>;
196
- array: <const S extends Schema>(of: S) => import("#ArrayType").default<NormalizeSchema<S>, true>;
197
- bigint: import("./BigIntType.js").default<"i64", true>;
198
- biguint: import("./BigUintType.js").default<"u64", true>;
199
- blob: import("#BlobType").default;
200
- boolean: import("#BooleanType").default<true>;
201
- constructor: <const C extends import("@rcompat/type").AbstractNewable>(c: C) => import("#ConstructorType").default<C>;
202
- date: import("#DateType").default<true>;
203
- dict: {
204
- (): import("#RecordType").default<import("#StringType").default, import("#StringType").default, true>;
205
- <const Value extends import("#Parsed").default<unknown>>(of: Value): import("#RecordType").default<import("#StringType").default, Value, true>;
206
- };
207
- enum: <T extends readonly string[]>(values: T) => import("#EnumType").default<T>;
208
- f32: import("#NumberType").default<"f32", true>;
209
- f64: import("#NumberType").default<"f64", true>;
210
- file: import("./FileType.js").default;
211
- function: import("#FunctionType").default;
212
- i128: import("./BigIntType.js").default<"i128", true>;
213
- i16: import("./IntType.js").default<"i16", true>;
214
- i32: import("./IntType.js").default<"i32", true>;
215
- i64: import("./BigIntType.js").default<"i64", true>;
216
- i8: import("./IntType.js").default<"i8", true>;
217
- int: import("./IntType.js").default<"i32", true>;
218
- is: <T>(predicate: (x: unknown) => x is T) => import("#IsType").default<T>;
219
- json: {
220
- (): import("#JSONType").default<undefined>;
221
- <S extends import("#JSONType").ParsedJSON>(inner: S): import("#JSONType").default<S>;
222
- };
223
- literal: <T extends string | number | boolean>(literal: T) => import("#LiteralType").default<T, true>;
224
- null: import("#NullType").default;
225
- number: import("#NumberType").default<"f64", true>;
226
- object: <P extends import("@rcompat/type").Dict<Schema> = import("@rcompat/type").Dict<Schema>>(properties: P) => import("#ObjectType").default<keyof P extends never ? {} : { [K in keyof P]: NormalizeSchema<P[K]>; }, true>;
227
- omit: <P extends import("@rcompat/type").Dict<import("#Parsed").default<unknown>>, K extends keyof P>(type: import("#ObjectType").default<P>, ...keys: K[]) => import("./OmitType.js").default<P, K, true>;
228
- record: <const Key extends import("./RecordTypeKey.js").default, const Value extends import("#Parsed").default<unknown>>(k: Key, v: Value) => import("#RecordType").default<Key, Value, true>;
229
- partial: <const D extends import("./Partialable.js").default>(input: D | import("#ObjectType").default<D>) => import("#PartialType").default<{ -readonly [K in keyof D]: D[K]; }, true>;
230
- pure: <T>() => import("#PureType").default<T, "PureType">;
231
- string: import("#StringType").default;
232
- symbol: import("./SymbolType.js").default;
233
- tuple: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }, true>;
234
- u128: import("./BigUintType.js").default<"u128", true>;
235
- u16: import("#UintType").default<"u16", true>;
236
- u32: import("#UintType").default<"u32", true>;
237
- u64: import("./BigUintType.js").default<"u64", true>;
238
- u8: import("#UintType").default<"u8", true>;
239
- uint: import("#UintType").default<"u32", true>;
240
- undefined: import("#UndefinedType").default;
241
- union: {
242
- (): import("#UnionType").default<[], true>;
243
- <const T extends Schema[]>(...types: T): import("#UnionType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }, true>;
244
- };
245
- unknown: import("#UnknownType").default;
246
- url: import("#URLType").default<true>;
247
- uuid: import("#UUIDType").default;
248
- };
249
- }
250
- declare namespace schema {
251
- var strict: {
252
- <const S extends Schema>(s: S): NormalizeSchema<S>;
253
- array: <const S extends Schema>(of: S) => import("#ArrayType").default<NormalizeSchema<S>, false>;
254
- bigint: import("./BigIntType.js").default<"i64", false>;
255
- biguint: import("./BigUintType.js").default<"u64", false>;
256
- blob: import("#BlobType").default;
257
- boolean: import("#BooleanType").default<false>;
258
- constructor: <const C extends import("@rcompat/type").AbstractNewable>(c: C) => import("#ConstructorType").default<C>;
259
- date: import("#DateType").default<false>;
260
- dict: {
261
- (): import("#RecordType").default<import("#StringType").default, import("#StringType").default, false>;
262
- <const Value extends import("#Parsed").default<unknown>>(of: Value): import("#RecordType").default<import("#StringType").default, Value, false>;
263
- };
264
- enum: <T extends readonly string[]>(values: T) => import("#EnumType").default<T>;
265
- f32: import("#NumberType").default<"f32", false>;
266
- f64: import("#NumberType").default<"f64", false>;
267
- file: import("./FileType.js").default;
268
- function: import("#FunctionType").default;
269
- i128: import("./BigIntType.js").default<"i128", false>;
270
- i16: import("./IntType.js").default<"i16", false>;
271
- i32: import("./IntType.js").default<"i32", false>;
272
- i64: import("./BigIntType.js").default<"i64", false>;
273
- i8: import("./IntType.js").default<"i8", false>;
274
- int: import("./IntType.js").default<"i32", false>;
275
- is: <T>(predicate: (x: unknown) => x is T) => import("#IsType").default<T>;
276
- json: {
277
- (): import("#JSONType").default<undefined>;
278
- <S extends import("#JSONType").ParsedJSON>(inner: S): import("#JSONType").default<S>;
279
- };
280
- literal: <T extends string | number | boolean>(literal: T) => import("#LiteralType").default<T, false>;
281
- null: import("#NullType").default;
282
- number: import("#NumberType").default<"f64", false>;
283
- object: <P extends import("@rcompat/type").Dict<Schema> = import("@rcompat/type").Dict<Schema>>(properties: P) => import("#ObjectType").default<keyof P extends never ? {} : { [K in keyof P]: NormalizeSchema<P[K]>; }, false>;
284
- omit: <P extends import("@rcompat/type").Dict<import("#Parsed").default<unknown>>, K extends keyof P>(type: import("#ObjectType").default<P>, ...keys: K[]) => import("./OmitType.js").default<P, K, false>;
285
- record: <const Key extends import("./RecordTypeKey.js").default, const Value extends import("#Parsed").default<unknown>>(k: Key, v: Value) => import("#RecordType").default<Key, Value, false>;
286
- partial: <const D extends import("./Partialable.js").default>(input: D | import("#ObjectType").default<D>) => import("#PartialType").default<{ -readonly [K in keyof D]: D[K]; }, false>;
287
- pure: <T>() => import("#PureType").default<T, "PureType">;
288
- string: import("#StringType").default;
289
- symbol: import("./SymbolType.js").default;
290
- tuple: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }, false>;
291
- u128: import("./BigUintType.js").default<"u128", false>;
292
- u16: import("#UintType").default<"u16", false>;
293
- u32: import("#UintType").default<"u32", false>;
294
- u64: import("./BigUintType.js").default<"u64", false>;
295
- u8: import("#UintType").default<"u8", false>;
296
- uint: import("#UintType").default<"u32", false>;
297
- undefined: import("#UndefinedType").default;
298
- union: {
299
- (): import("#UnionType").default<[], false>;
300
- <const T extends Schema[]>(...types: T): import("#UnionType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }, false>;
301
- };
302
- unknown: import("#UnknownType").default;
303
- url: import("#URLType").default<false>;
304
- uuid: import("#UUIDType").default;
305
- };
306
- }
138
+ export { _15 as union };
139
+ export var _16: import("#UnknownType").default;
140
+ export { _16 as unknown };
141
+ export var _17: import("#URLType").default<undefined>;
142
+ export { _17 as url };
143
+ export var _18: import("#UUIDType").default;
144
+ export { _18 as uuid };
145
+ export var error: (path: string, message: string) => import("./ParseError.js").default;
146
+ export { loose };
147
+ export { strict };
148
+ }
149
+ declare function loose<const S extends Schema>(s: S): NormalizeSchema<S>;
150
+ declare function strict<const S extends Schema>(s: S): NormalizeSchema<S>;
307
151
  export default schema;
308
152
  //# sourceMappingURL=index.d.ts.map
package/lib/private/optional.d.ts CHANGED
@@ -1,5 +1,5 @@
1
1
  import OptionalType from "#OptionalType";
2
2
  import type Parsed from "#Parsed";
3
- declare const _default: <const T extends Parsed<unknown>>(type: T) => OptionalType<T>;
4
3
  export default _default;
4
+ declare function _default<const T extends Parsed<unknown>>(type: T): OptionalType<T>;
5
5
  //# sourceMappingURL=optional.d.ts.map
package/lib/private/spec/bigint.d.ts CHANGED
@@ -1,9 +1,9 @@
1
1
  import type BigIntDataType from "#BigIntDataType";
2
2
  import type BigIntType from "#BigIntType";
3
- declare const _default: <T extends BigIntDataType>(t: {
3
+ export default _default;
4
+ declare function _default<T extends BigIntDataType>(t: {
4
5
  vanilla: BigIntType<T>;
5
6
  loose: BigIntType<T, true>;
6
7
  strict: BigIntType<T, false>;
7
- }, min: bigint, max: bigint) => void;
8
- export default _default;
8
+ }, min: bigint, max: bigint): void;
9
9
  //# sourceMappingURL=bigint.d.ts.map
package/lib/private/spec/biguint.d.ts CHANGED
@@ -1,9 +1,9 @@
1
1
  import type BigUintDataType from "#BigUintDataType";
2
2
  import type BigUintType from "#BigUintType";
3
- declare const _default: <T extends BigUintDataType>(t: {
3
+ export default _default;
4
+ declare function _default<T extends BigUintDataType>(t: {
4
5
  vanilla: BigUintType<T>;
5
6
  loose: BigUintType<T, true>;
6
7
  strict: BigUintType<T, false>;
7
- }, min: bigint, max: bigint) => void;
8
- export default _default;
8
+ }, min: bigint, max: bigint): void;
9
9
  //# sourceMappingURL=biguint.d.ts.map
package/lib/private/spec/int.d.ts CHANGED
@@ -1,9 +1,9 @@
1
1
  import type IntDataType from "#IntDataType";
2
2
  import type IntType from "#IntType";
3
- declare const _default: <T extends IntDataType>(t: {
3
+ export default _default;
4
+ declare function _default<T extends IntDataType>(t: {
4
5
  vanilla: IntType<T>;
5
6
  loose: IntType<T, true>;
6
7
  strict: IntType<T, false>;
7
- }, min: number, max: number) => void;
8
- export default _default;
8
+ }, min: number, max: number): void;
9
9
  //# sourceMappingURL=int.d.ts.map
package/lib/private/spec/uint.d.ts CHANGED
@@ -1,9 +1,9 @@
1
1
  import type UintDataType from "#UintDataType";
2
2
  import type UintType from "#UintType";
3
- declare const _default: <T extends UintDataType>(t: {
3
+ export default _default;
4
+ declare function _default<T extends UintDataType>(t: {
4
5
  vanilla: UintType<T>;
5
6
  loose: UintType<T, true>;
6
7
  strict: UintType<T, false>;
7
- }, min: number, max: number) => void;
8
- export default _default;
8
+ }, min: number, max: number): void;
9
9
  //# sourceMappingURL=uint.d.ts.map
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "pema",
3
- "version": "0.8.1",
3
+ "version": "0.8.3",
4
4
  "description": "Primate schema validation",
5
5
  "homepage": "https://primate.run/docs/validation",
6
6
  "bugs": "https://github.com/primate-run/primate/issues",