@pagopa/io-react-native-iso18013 0.8.1 → 0.8.2

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 (26) hide show
  1. package/lib/module/cbor/cbor/schema.js +1 -1
  2. package/lib/module/cbor/cbor/schema.js.map +1 -1
  3. package/lib/module/iso18013/iso18013-5/request.js +2 -2
  4. package/lib/module/iso18013/iso18013-5/request.js.map +1 -1
  5. package/lib/module/schema.js +10 -10
  6. package/lib/module/schema.js.map +1 -1
  7. package/lib/typescript/src/cbor/cbor/error.d.ts +18 -50
  8. package/lib/typescript/src/cbor/cbor/error.d.ts.map +1 -1
  9. package/lib/typescript/src/cbor/cbor/schema.d.ts +229 -2213
  10. package/lib/typescript/src/cbor/cbor/schema.d.ts.map +1 -1
  11. package/lib/typescript/src/cbor/cbor/schema.utils.d.ts +1 -1
  12. package/lib/typescript/src/cbor/cbor/schema.utils.d.ts.map +1 -1
  13. package/lib/typescript/src/cbor/cose/error.d.ts +18 -50
  14. package/lib/typescript/src/cbor/cose/error.d.ts.map +1 -1
  15. package/lib/typescript/src/iso18013/iso18013-5/error.d.ts +24 -50
  16. package/lib/typescript/src/iso18013/iso18013-5/error.d.ts.map +1 -1
  17. package/lib/typescript/src/iso18013/iso18013-5/request.d.ts +2 -14
  18. package/lib/typescript/src/iso18013/iso18013-5/request.d.ts.map +1 -1
  19. package/lib/typescript/src/iso18013/iso18013-7/error.d.ts +14 -50
  20. package/lib/typescript/src/iso18013/iso18013-7/error.d.ts.map +1 -1
  21. package/lib/typescript/src/schema.d.ts +6 -49
  22. package/lib/typescript/src/schema.d.ts.map +1 -1
  23. package/package.json +2 -2
  24. package/src/cbor/cbor/schema.ts +1 -1
  25. package/src/iso18013/iso18013-5/request.ts +2 -2
  26. package/src/schema.ts +13 -20
package/lib/typescript/src/cbor/cbor/schema.d.ts CHANGED
@@ -3,125 +3,61 @@ export declare enum DocumentTypeEnum {
3
3
  MDL = "org.iso.18013.5.1.mDL",
4
4
  EU_PID = "eu.europa.ec.eudi.pid.1"
5
5
  }
6
- export declare const DocumentType: z.ZodNativeEnum<typeof DocumentTypeEnum>;
6
+ export declare const DocumentType: z.ZodEnum<typeof DocumentTypeEnum>;
7
7
  export type DocumentType = z.infer<typeof DocumentType>;
8
8
  /**
9
9
  * Value contained in a document
10
10
  */
11
11
  export declare const DocumentValue: z.ZodObject<{
12
- digestID: z.ZodOptional<z.ZodNumber>;
12
+ digestID: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
13
13
  random: z.ZodOptional<z.ZodString>;
14
14
  elementIdentifier: z.ZodString;
15
15
  elementValue: z.ZodAny;
16
- }, "strip", z.ZodTypeAny, {
17
- elementIdentifier: string;
18
- digestID?: number | undefined;
19
- random?: string | undefined;
20
- elementValue?: any;
21
- }, {
22
- elementIdentifier: string;
23
- digestID?: number | undefined;
24
- random?: string | undefined;
25
- elementValue?: any;
26
- }>;
16
+ }, z.core.$strip>;
27
17
  export type DocumentValue = z.infer<typeof DocumentValue>;
28
18
  /**
29
19
  * Issuer Auth Unprotected Header Entry
30
20
  */
31
21
  export declare const IssuerAuthUnprotectedHeader: z.ZodObject<{
32
- algorithm: z.ZodOptional<z.ZodString>;
22
+ algorithm: z.ZodOptional<z.ZodCoercedString<unknown>>;
33
23
  kid: z.ZodOptional<z.ZodString>;
34
- x5chain: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
35
- }, "strip", z.ZodTypeAny, {
36
- algorithm?: string | undefined;
37
- kid?: string | undefined;
38
- x5chain?: string[] | undefined;
39
- }, {
40
- algorithm?: string | undefined;
41
- kid?: string | undefined;
42
- x5chain?: string[] | undefined;
43
- }>;
24
+ x5chain: z.ZodOptional<z.ZodArray<z.ZodString>>;
25
+ }, z.core.$strip>;
44
26
  export type IssuerAuthUnprotectedHeader = z.infer<typeof IssuerAuthUnprotectedHeader>;
45
27
  /**
46
28
  * Issuer Auth Payload Validity Info
47
29
  */
48
30
  export declare const IssuerAuthPayloadValidityInfo: z.ZodObject<{
49
- signed: z.ZodDate;
50
- validUntil: z.ZodDate;
51
- validFrom: z.ZodDate;
52
- expectedUpdate: z.ZodOptional<z.ZodDate>;
53
- }, "strip", z.ZodTypeAny, {
54
- signed: Date;
55
- validUntil: Date;
56
- validFrom: Date;
57
- expectedUpdate?: Date | undefined;
58
- }, {
59
- signed: Date;
60
- validUntil: Date;
61
- validFrom: Date;
62
- expectedUpdate?: Date | undefined;
63
- }>;
31
+ signed: z.ZodCoercedDate<unknown>;
32
+ validUntil: z.ZodCoercedDate<unknown>;
33
+ validFrom: z.ZodCoercedDate<unknown>;
34
+ expectedUpdate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
35
+ }, z.core.$strip>;
64
36
  export type IssuerAuthPayloadValidityInfo = z.infer<typeof IssuerAuthPayloadValidityInfo>;
65
37
  /**
66
38
  * Issuer Auth Payload Device Key Info
67
39
  */
68
40
  export declare const IssuerAuthPayloadDeviceKeyInfo: z.ZodObject<{
69
- deviceKey: z.ZodUnion<[z.ZodObject<{
70
- kty: z.ZodEnum<["RSA"]>;
41
+ deviceKey: z.ZodUnion<readonly [z.ZodObject<{
42
+ kty: z.ZodEnum<{
43
+ RSA: "RSA";
44
+ }>;
71
45
  alg: z.ZodString;
72
46
  e: z.ZodString;
73
47
  n: z.ZodString;
74
- }, "strip", z.ZodTypeAny, {
75
- kty: "RSA";
76
- alg: string;
77
- e: string;
78
- n: string;
79
- }, {
80
- kty: "RSA";
81
- alg: string;
82
- e: string;
83
- n: string;
84
- }>, z.ZodObject<{
85
- kty: z.ZodEnum<["EC"]>;
86
- crv: z.ZodEnum<["P-256", "P-384", "P-521"]>;
48
+ }, z.core.$strip>, z.ZodObject<{
49
+ kty: z.ZodEnum<{
50
+ EC: "EC";
51
+ }>;
52
+ crv: z.ZodEnum<{
53
+ "P-256": "P-256";
54
+ "P-384": "P-384";
55
+ "P-521": "P-521";
56
+ }>;
87
57
  x: z.ZodString;
88
58
  y: z.ZodString;
89
- }, "strip", z.ZodTypeAny, {
90
- kty: "EC";
91
- crv: "P-256" | "P-384" | "P-521";
92
- x: string;
93
- y: string;
94
- }, {
95
- kty: "EC";
96
- crv: "P-256" | "P-384" | "P-521";
97
- x: string;
98
- y: string;
99
- }>]>;
100
- }, "strip", z.ZodTypeAny, {
101
- deviceKey: {
102
- kty: "EC";
103
- crv: "P-256" | "P-384" | "P-521";
104
- x: string;
105
- y: string;
106
- } | {
107
- kty: "RSA";
108
- alg: string;
109
- e: string;
110
- n: string;
111
- };
112
- }, {
113
- deviceKey: {
114
- kty: "EC";
115
- crv: "P-256" | "P-384" | "P-521";
116
- x: string;
117
- y: string;
118
- } | {
119
- kty: "RSA";
120
- alg: string;
121
- e: string;
122
- n: string;
123
- };
124
- }>;
59
+ }, z.core.$strip>]>;
60
+ }, z.core.$strip>;
125
61
  export type IssuerAuthPayloadDeviceKeyInfo = z.infer<typeof IssuerAuthPayloadDeviceKeyInfo>;
126
62
  /**
127
63
  * Issuer Auth Payload Object
@@ -130,129 +66,35 @@ export declare const IssuerAuthPayload: z.ZodObject<{
130
66
  docType: z.ZodOptional<z.ZodString>;
131
67
  version: z.ZodOptional<z.ZodString>;
132
68
  validityInfo: z.ZodObject<{
133
- signed: z.ZodDate;
134
- validUntil: z.ZodDate;
135
- validFrom: z.ZodDate;
136
- expectedUpdate: z.ZodOptional<z.ZodDate>;
137
- }, "strip", z.ZodTypeAny, {
138
- signed: Date;
139
- validUntil: Date;
140
- validFrom: Date;
141
- expectedUpdate?: Date | undefined;
142
- }, {
143
- signed: Date;
144
- validUntil: Date;
145
- validFrom: Date;
146
- expectedUpdate?: Date | undefined;
147
- }>;
69
+ signed: z.ZodCoercedDate<unknown>;
70
+ validUntil: z.ZodCoercedDate<unknown>;
71
+ validFrom: z.ZodCoercedDate<unknown>;
72
+ expectedUpdate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
73
+ }, z.core.$strip>;
148
74
  digestAlgorithm: z.ZodOptional<z.ZodString>;
149
75
  deviceKeyInfo: z.ZodObject<{
150
- deviceKey: z.ZodUnion<[z.ZodObject<{
151
- kty: z.ZodEnum<["RSA"]>;
76
+ deviceKey: z.ZodUnion<readonly [z.ZodObject<{
77
+ kty: z.ZodEnum<{
78
+ RSA: "RSA";
79
+ }>;
152
80
  alg: z.ZodString;
153
81
  e: z.ZodString;
154
82
  n: z.ZodString;
155
- }, "strip", z.ZodTypeAny, {
156
- kty: "RSA";
157
- alg: string;
158
- e: string;
159
- n: string;
160
- }, {
161
- kty: "RSA";
162
- alg: string;
163
- e: string;
164
- n: string;
165
- }>, z.ZodObject<{
166
- kty: z.ZodEnum<["EC"]>;
167
- crv: z.ZodEnum<["P-256", "P-384", "P-521"]>;
83
+ }, z.core.$strip>, z.ZodObject<{
84
+ kty: z.ZodEnum<{
85
+ EC: "EC";
86
+ }>;
87
+ crv: z.ZodEnum<{
88
+ "P-256": "P-256";
89
+ "P-384": "P-384";
90
+ "P-521": "P-521";
91
+ }>;
168
92
  x: z.ZodString;
169
93
  y: z.ZodString;
170
- }, "strip", z.ZodTypeAny, {
171
- kty: "EC";
172
- crv: "P-256" | "P-384" | "P-521";
173
- x: string;
174
- y: string;
175
- }, {
176
- kty: "EC";
177
- crv: "P-256" | "P-384" | "P-521";
178
- x: string;
179
- y: string;
180
- }>]>;
181
- }, "strip", z.ZodTypeAny, {
182
- deviceKey: {
183
- kty: "EC";
184
- crv: "P-256" | "P-384" | "P-521";
185
- x: string;
186
- y: string;
187
- } | {
188
- kty: "RSA";
189
- alg: string;
190
- e: string;
191
- n: string;
192
- };
193
- }, {
194
- deviceKey: {
195
- kty: "EC";
196
- crv: "P-256" | "P-384" | "P-521";
197
- x: string;
198
- y: string;
199
- } | {
200
- kty: "RSA";
201
- alg: string;
202
- e: string;
203
- n: string;
204
- };
205
- }>;
94
+ }, z.core.$strip>]>;
95
+ }, z.core.$strip>;
206
96
  valueDigests: z.ZodRecord<z.ZodString, z.ZodAny>;
207
- }, "strip", z.ZodTypeAny, {
208
- validityInfo: {
209
- signed: Date;
210
- validUntil: Date;
211
- validFrom: Date;
212
- expectedUpdate?: Date | undefined;
213
- };
214
- deviceKeyInfo: {
215
- deviceKey: {
216
- kty: "EC";
217
- crv: "P-256" | "P-384" | "P-521";
218
- x: string;
219
- y: string;
220
- } | {
221
- kty: "RSA";
222
- alg: string;
223
- e: string;
224
- n: string;
225
- };
226
- };
227
- valueDigests: Record<string, any>;
228
- docType?: string | undefined;
229
- version?: string | undefined;
230
- digestAlgorithm?: string | undefined;
231
- }, {
232
- validityInfo: {
233
- signed: Date;
234
- validUntil: Date;
235
- validFrom: Date;
236
- expectedUpdate?: Date | undefined;
237
- };
238
- deviceKeyInfo: {
239
- deviceKey: {
240
- kty: "EC";
241
- crv: "P-256" | "P-384" | "P-521";
242
- x: string;
243
- y: string;
244
- } | {
245
- kty: "RSA";
246
- alg: string;
247
- e: string;
248
- n: string;
249
- };
250
- };
251
- valueDigests: Record<string, any>;
252
- docType?: string | undefined;
253
- version?: string | undefined;
254
- digestAlgorithm?: string | undefined;
255
- }>;
97
+ }, z.core.$strip>;
256
98
  export type IssuerAuthPayload = z.infer<typeof IssuerAuthPayload>;
257
99
  /**
258
100
  * Issuer Auth Object
@@ -261,931 +103,158 @@ export declare const IssuerAuth: z.ZodObject<{
261
103
  rawValue: z.ZodOptional<z.ZodString>;
262
104
  protectedHeader: z.ZodOptional<z.ZodString>;
263
105
  unprotectedHeader: z.ZodObject<{
264
- algorithm: z.ZodOptional<z.ZodString>;
106
+ algorithm: z.ZodOptional<z.ZodCoercedString<unknown>>;
265
107
  kid: z.ZodOptional<z.ZodString>;
266
- x5chain: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
267
- }, "strip", z.ZodTypeAny, {
268
- algorithm?: string | undefined;
269
- kid?: string | undefined;
270
- x5chain?: string[] | undefined;
271
- }, {
272
- algorithm?: string | undefined;
273
- kid?: string | undefined;
274
- x5chain?: string[] | undefined;
275
- }>;
108
+ x5chain: z.ZodOptional<z.ZodArray<z.ZodString>>;
109
+ }, z.core.$strip>;
276
110
  payload: z.ZodObject<{
277
111
  docType: z.ZodOptional<z.ZodString>;
278
112
  version: z.ZodOptional<z.ZodString>;
279
113
  validityInfo: z.ZodObject<{
280
- signed: z.ZodDate;
281
- validUntil: z.ZodDate;
282
- validFrom: z.ZodDate;
283
- expectedUpdate: z.ZodOptional<z.ZodDate>;
284
- }, "strip", z.ZodTypeAny, {
285
- signed: Date;
286
- validUntil: Date;
287
- validFrom: Date;
288
- expectedUpdate?: Date | undefined;
289
- }, {
290
- signed: Date;
291
- validUntil: Date;
292
- validFrom: Date;
293
- expectedUpdate?: Date | undefined;
294
- }>;
114
+ signed: z.ZodCoercedDate<unknown>;
115
+ validUntil: z.ZodCoercedDate<unknown>;
116
+ validFrom: z.ZodCoercedDate<unknown>;
117
+ expectedUpdate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
118
+ }, z.core.$strip>;
295
119
  digestAlgorithm: z.ZodOptional<z.ZodString>;
296
120
  deviceKeyInfo: z.ZodObject<{
297
- deviceKey: z.ZodUnion<[z.ZodObject<{
298
- kty: z.ZodEnum<["RSA"]>;
121
+ deviceKey: z.ZodUnion<readonly [z.ZodObject<{
122
+ kty: z.ZodEnum<{
123
+ RSA: "RSA";
124
+ }>;
299
125
  alg: z.ZodString;
300
126
  e: z.ZodString;
301
127
  n: z.ZodString;
302
- }, "strip", z.ZodTypeAny, {
303
- kty: "RSA";
304
- alg: string;
305
- e: string;
306
- n: string;
307
- }, {
308
- kty: "RSA";
309
- alg: string;
310
- e: string;
311
- n: string;
312
- }>, z.ZodObject<{
313
- kty: z.ZodEnum<["EC"]>;
314
- crv: z.ZodEnum<["P-256", "P-384", "P-521"]>;
128
+ }, z.core.$strip>, z.ZodObject<{
129
+ kty: z.ZodEnum<{
130
+ EC: "EC";
131
+ }>;
132
+ crv: z.ZodEnum<{
133
+ "P-256": "P-256";
134
+ "P-384": "P-384";
135
+ "P-521": "P-521";
136
+ }>;
315
137
  x: z.ZodString;
316
138
  y: z.ZodString;
317
- }, "strip", z.ZodTypeAny, {
318
- kty: "EC";
319
- crv: "P-256" | "P-384" | "P-521";
320
- x: string;
321
- y: string;
322
- }, {
323
- kty: "EC";
324
- crv: "P-256" | "P-384" | "P-521";
325
- x: string;
326
- y: string;
327
- }>]>;
328
- }, "strip", z.ZodTypeAny, {
329
- deviceKey: {
330
- kty: "EC";
331
- crv: "P-256" | "P-384" | "P-521";
332
- x: string;
333
- y: string;
334
- } | {
335
- kty: "RSA";
336
- alg: string;
337
- e: string;
338
- n: string;
339
- };
340
- }, {
341
- deviceKey: {
342
- kty: "EC";
343
- crv: "P-256" | "P-384" | "P-521";
344
- x: string;
345
- y: string;
346
- } | {
347
- kty: "RSA";
348
- alg: string;
349
- e: string;
350
- n: string;
351
- };
352
- }>;
139
+ }, z.core.$strip>]>;
140
+ }, z.core.$strip>;
353
141
  valueDigests: z.ZodRecord<z.ZodString, z.ZodAny>;
354
- }, "strip", z.ZodTypeAny, {
355
- validityInfo: {
356
- signed: Date;
357
- validUntil: Date;
358
- validFrom: Date;
359
- expectedUpdate?: Date | undefined;
360
- };
361
- deviceKeyInfo: {
362
- deviceKey: {
363
- kty: "EC";
364
- crv: "P-256" | "P-384" | "P-521";
365
- x: string;
366
- y: string;
367
- } | {
368
- kty: "RSA";
369
- alg: string;
370
- e: string;
371
- n: string;
372
- };
373
- };
374
- valueDigests: Record<string, any>;
375
- docType?: string | undefined;
376
- version?: string | undefined;
377
- digestAlgorithm?: string | undefined;
378
- }, {
379
- validityInfo: {
380
- signed: Date;
381
- validUntil: Date;
382
- validFrom: Date;
383
- expectedUpdate?: Date | undefined;
384
- };
385
- deviceKeyInfo: {
386
- deviceKey: {
387
- kty: "EC";
388
- crv: "P-256" | "P-384" | "P-521";
389
- x: string;
390
- y: string;
391
- } | {
392
- kty: "RSA";
393
- alg: string;
394
- e: string;
395
- n: string;
396
- };
397
- };
398
- valueDigests: Record<string, any>;
399
- docType?: string | undefined;
400
- version?: string | undefined;
401
- digestAlgorithm?: string | undefined;
402
- }>;
142
+ }, z.core.$strip>;
403
143
  signature: z.ZodOptional<z.ZodString>;
404
- }, "strip", z.ZodTypeAny, {
405
- unprotectedHeader: {
406
- algorithm?: string | undefined;
407
- kid?: string | undefined;
408
- x5chain?: string[] | undefined;
409
- };
410
- payload: {
411
- validityInfo: {
412
- signed: Date;
413
- validUntil: Date;
414
- validFrom: Date;
415
- expectedUpdate?: Date | undefined;
416
- };
417
- deviceKeyInfo: {
418
- deviceKey: {
419
- kty: "EC";
420
- crv: "P-256" | "P-384" | "P-521";
421
- x: string;
422
- y: string;
423
- } | {
424
- kty: "RSA";
425
- alg: string;
426
- e: string;
427
- n: string;
428
- };
429
- };
430
- valueDigests: Record<string, any>;
431
- docType?: string | undefined;
432
- version?: string | undefined;
433
- digestAlgorithm?: string | undefined;
434
- };
435
- rawValue?: string | undefined;
436
- protectedHeader?: string | undefined;
437
- signature?: string | undefined;
438
- }, {
439
- unprotectedHeader: {
440
- algorithm?: string | undefined;
441
- kid?: string | undefined;
442
- x5chain?: string[] | undefined;
443
- };
444
- payload: {
445
- validityInfo: {
446
- signed: Date;
447
- validUntil: Date;
448
- validFrom: Date;
449
- expectedUpdate?: Date | undefined;
450
- };
451
- deviceKeyInfo: {
452
- deviceKey: {
453
- kty: "EC";
454
- crv: "P-256" | "P-384" | "P-521";
455
- x: string;
456
- y: string;
457
- } | {
458
- kty: "RSA";
459
- alg: string;
460
- e: string;
461
- n: string;
462
- };
463
- };
464
- valueDigests: Record<string, any>;
465
- docType?: string | undefined;
466
- version?: string | undefined;
467
- digestAlgorithm?: string | undefined;
468
- };
469
- rawValue?: string | undefined;
470
- protectedHeader?: string | undefined;
471
- signature?: string | undefined;
472
- }>;
144
+ }, z.core.$strip>;
473
145
  export type IssuerAuth = z.infer<typeof IssuerAuth>;
474
146
  /**
475
147
  * Issuer signed object
476
148
  */
477
149
  export declare const IssuerSigned: z.ZodObject<{
478
- nameSpaces: z.ZodRecord<z.ZodString, z.ZodPipeline<z.ZodEffects<z.ZodAny, any, any>, z.ZodArray<z.ZodObject<{
479
- digestID: z.ZodOptional<z.ZodNumber>;
150
+ nameSpaces: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodPipe<z.ZodAny, z.ZodTransform<any, any>>, z.ZodArray<z.ZodObject<{
151
+ digestID: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
480
152
  random: z.ZodOptional<z.ZodString>;
481
153
  elementIdentifier: z.ZodString;
482
154
  elementValue: z.ZodAny;
483
- }, "strip", z.ZodTypeAny, {
484
- elementIdentifier: string;
485
- digestID?: number | undefined;
486
- random?: string | undefined;
487
- elementValue?: any;
488
- }, {
489
- elementIdentifier: string;
490
- digestID?: number | undefined;
491
- random?: string | undefined;
492
- elementValue?: any;
493
- }>, "many">>>;
155
+ }, z.core.$strip>>>>;
494
156
  issuerAuth: z.ZodObject<{
495
157
  rawValue: z.ZodOptional<z.ZodString>;
496
158
  protectedHeader: z.ZodOptional<z.ZodString>;
497
159
  unprotectedHeader: z.ZodObject<{
498
- algorithm: z.ZodOptional<z.ZodString>;
160
+ algorithm: z.ZodOptional<z.ZodCoercedString<unknown>>;
499
161
  kid: z.ZodOptional<z.ZodString>;
500
- x5chain: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
501
- }, "strip", z.ZodTypeAny, {
502
- algorithm?: string | undefined;
503
- kid?: string | undefined;
504
- x5chain?: string[] | undefined;
505
- }, {
506
- algorithm?: string | undefined;
507
- kid?: string | undefined;
508
- x5chain?: string[] | undefined;
509
- }>;
162
+ x5chain: z.ZodOptional<z.ZodArray<z.ZodString>>;
163
+ }, z.core.$strip>;
510
164
  payload: z.ZodObject<{
511
165
  docType: z.ZodOptional<z.ZodString>;
512
166
  version: z.ZodOptional<z.ZodString>;
513
167
  validityInfo: z.ZodObject<{
514
- signed: z.ZodDate;
515
- validUntil: z.ZodDate;
516
- validFrom: z.ZodDate;
517
- expectedUpdate: z.ZodOptional<z.ZodDate>;
518
- }, "strip", z.ZodTypeAny, {
519
- signed: Date;
520
- validUntil: Date;
521
- validFrom: Date;
522
- expectedUpdate?: Date | undefined;
523
- }, {
524
- signed: Date;
525
- validUntil: Date;
526
- validFrom: Date;
527
- expectedUpdate?: Date | undefined;
528
- }>;
168
+ signed: z.ZodCoercedDate<unknown>;
169
+ validUntil: z.ZodCoercedDate<unknown>;
170
+ validFrom: z.ZodCoercedDate<unknown>;
171
+ expectedUpdate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
172
+ }, z.core.$strip>;
529
173
  digestAlgorithm: z.ZodOptional<z.ZodString>;
530
174
  deviceKeyInfo: z.ZodObject<{
531
- deviceKey: z.ZodUnion<[z.ZodObject<{
532
- kty: z.ZodEnum<["RSA"]>;
175
+ deviceKey: z.ZodUnion<readonly [z.ZodObject<{
176
+ kty: z.ZodEnum<{
177
+ RSA: "RSA";
178
+ }>;
533
179
  alg: z.ZodString;
534
180
  e: z.ZodString;
535
181
  n: z.ZodString;
536
- }, "strip", z.ZodTypeAny, {
537
- kty: "RSA";
538
- alg: string;
539
- e: string;
540
- n: string;
541
- }, {
542
- kty: "RSA";
543
- alg: string;
544
- e: string;
545
- n: string;
546
- }>, z.ZodObject<{
547
- kty: z.ZodEnum<["EC"]>;
548
- crv: z.ZodEnum<["P-256", "P-384", "P-521"]>;
182
+ }, z.core.$strip>, z.ZodObject<{
183
+ kty: z.ZodEnum<{
184
+ EC: "EC";
185
+ }>;
186
+ crv: z.ZodEnum<{
187
+ "P-256": "P-256";
188
+ "P-384": "P-384";
189
+ "P-521": "P-521";
190
+ }>;
549
191
  x: z.ZodString;
550
192
  y: z.ZodString;
551
- }, "strip", z.ZodTypeAny, {
552
- kty: "EC";
553
- crv: "P-256" | "P-384" | "P-521";
554
- x: string;
555
- y: string;
556
- }, {
557
- kty: "EC";
558
- crv: "P-256" | "P-384" | "P-521";
559
- x: string;
560
- y: string;
561
- }>]>;
562
- }, "strip", z.ZodTypeAny, {
563
- deviceKey: {
564
- kty: "EC";
565
- crv: "P-256" | "P-384" | "P-521";
566
- x: string;
567
- y: string;
568
- } | {
569
- kty: "RSA";
570
- alg: string;
571
- e: string;
572
- n: string;
573
- };
574
- }, {
575
- deviceKey: {
576
- kty: "EC";
577
- crv: "P-256" | "P-384" | "P-521";
578
- x: string;
579
- y: string;
580
- } | {
581
- kty: "RSA";
582
- alg: string;
583
- e: string;
584
- n: string;
585
- };
586
- }>;
193
+ }, z.core.$strip>]>;
194
+ }, z.core.$strip>;
587
195
  valueDigests: z.ZodRecord<z.ZodString, z.ZodAny>;
588
- }, "strip", z.ZodTypeAny, {
589
- validityInfo: {
590
- signed: Date;
591
- validUntil: Date;
592
- validFrom: Date;
593
- expectedUpdate?: Date | undefined;
594
- };
595
- deviceKeyInfo: {
596
- deviceKey: {
597
- kty: "EC";
598
- crv: "P-256" | "P-384" | "P-521";
599
- x: string;
600
- y: string;
601
- } | {
602
- kty: "RSA";
603
- alg: string;
604
- e: string;
605
- n: string;
606
- };
607
- };
608
- valueDigests: Record<string, any>;
609
- docType?: string | undefined;
610
- version?: string | undefined;
611
- digestAlgorithm?: string | undefined;
612
- }, {
613
- validityInfo: {
614
- signed: Date;
615
- validUntil: Date;
616
- validFrom: Date;
617
- expectedUpdate?: Date | undefined;
618
- };
619
- deviceKeyInfo: {
620
- deviceKey: {
621
- kty: "EC";
622
- crv: "P-256" | "P-384" | "P-521";
623
- x: string;
624
- y: string;
625
- } | {
626
- kty: "RSA";
627
- alg: string;
628
- e: string;
629
- n: string;
630
- };
631
- };
632
- valueDigests: Record<string, any>;
633
- docType?: string | undefined;
634
- version?: string | undefined;
635
- digestAlgorithm?: string | undefined;
636
- }>;
196
+ }, z.core.$strip>;
637
197
  signature: z.ZodOptional<z.ZodString>;
638
- }, "strip", z.ZodTypeAny, {
639
- unprotectedHeader: {
640
- algorithm?: string | undefined;
641
- kid?: string | undefined;
642
- x5chain?: string[] | undefined;
643
- };
644
- payload: {
645
- validityInfo: {
646
- signed: Date;
647
- validUntil: Date;
648
- validFrom: Date;
649
- expectedUpdate?: Date | undefined;
650
- };
651
- deviceKeyInfo: {
652
- deviceKey: {
653
- kty: "EC";
654
- crv: "P-256" | "P-384" | "P-521";
655
- x: string;
656
- y: string;
657
- } | {
658
- kty: "RSA";
659
- alg: string;
660
- e: string;
661
- n: string;
662
- };
663
- };
664
- valueDigests: Record<string, any>;
665
- docType?: string | undefined;
666
- version?: string | undefined;
667
- digestAlgorithm?: string | undefined;
668
- };
669
- rawValue?: string | undefined;
670
- protectedHeader?: string | undefined;
671
- signature?: string | undefined;
672
- }, {
673
- unprotectedHeader: {
674
- algorithm?: string | undefined;
675
- kid?: string | undefined;
676
- x5chain?: string[] | undefined;
677
- };
678
- payload: {
679
- validityInfo: {
680
- signed: Date;
681
- validUntil: Date;
682
- validFrom: Date;
683
- expectedUpdate?: Date | undefined;
684
- };
685
- deviceKeyInfo: {
686
- deviceKey: {
687
- kty: "EC";
688
- crv: "P-256" | "P-384" | "P-521";
689
- x: string;
690
- y: string;
691
- } | {
692
- kty: "RSA";
693
- alg: string;
694
- e: string;
695
- n: string;
696
- };
697
- };
698
- valueDigests: Record<string, any>;
699
- docType?: string | undefined;
700
- version?: string | undefined;
701
- digestAlgorithm?: string | undefined;
702
- };
703
- rawValue?: string | undefined;
704
- protectedHeader?: string | undefined;
705
- signature?: string | undefined;
706
- }>;
707
- }, "strip", z.ZodTypeAny, {
708
- nameSpaces: Record<string, {
709
- elementIdentifier: string;
710
- digestID?: number | undefined;
711
- random?: string | undefined;
712
- elementValue?: any;
713
- }[]>;
714
- issuerAuth: {
715
- unprotectedHeader: {
716
- algorithm?: string | undefined;
717
- kid?: string | undefined;
718
- x5chain?: string[] | undefined;
719
- };
720
- payload: {
721
- validityInfo: {
722
- signed: Date;
723
- validUntil: Date;
724
- validFrom: Date;
725
- expectedUpdate?: Date | undefined;
726
- };
727
- deviceKeyInfo: {
728
- deviceKey: {
729
- kty: "EC";
730
- crv: "P-256" | "P-384" | "P-521";
731
- x: string;
732
- y: string;
733
- } | {
734
- kty: "RSA";
735
- alg: string;
736
- e: string;
737
- n: string;
738
- };
739
- };
740
- valueDigests: Record<string, any>;
741
- docType?: string | undefined;
742
- version?: string | undefined;
743
- digestAlgorithm?: string | undefined;
744
- };
745
- rawValue?: string | undefined;
746
- protectedHeader?: string | undefined;
747
- signature?: string | undefined;
748
- };
749
- }, {
750
- nameSpaces: Record<string, any>;
751
- issuerAuth: {
752
- unprotectedHeader: {
753
- algorithm?: string | undefined;
754
- kid?: string | undefined;
755
- x5chain?: string[] | undefined;
756
- };
757
- payload: {
758
- validityInfo: {
759
- signed: Date;
760
- validUntil: Date;
761
- validFrom: Date;
762
- expectedUpdate?: Date | undefined;
763
- };
764
- deviceKeyInfo: {
765
- deviceKey: {
766
- kty: "EC";
767
- crv: "P-256" | "P-384" | "P-521";
768
- x: string;
769
- y: string;
770
- } | {
771
- kty: "RSA";
772
- alg: string;
773
- e: string;
774
- n: string;
775
- };
776
- };
777
- valueDigests: Record<string, any>;
778
- docType?: string | undefined;
779
- version?: string | undefined;
780
- digestAlgorithm?: string | undefined;
781
- };
782
- rawValue?: string | undefined;
783
- protectedHeader?: string | undefined;
784
- signature?: string | undefined;
785
- };
786
- }>;
198
+ }, z.core.$strip>;
199
+ }, z.core.$strip>;
787
200
  export type IssuerSigned = z.infer<typeof IssuerSigned>;
788
201
  /**
789
202
  * mDOC object
790
203
  */
791
204
  export declare const MDOC: z.ZodObject<{
792
- docType: z.ZodNativeEnum<typeof DocumentTypeEnum>;
205
+ docType: z.ZodEnum<typeof DocumentTypeEnum>;
793
206
  issuerSigned: z.ZodObject<{
794
- nameSpaces: z.ZodRecord<z.ZodString, z.ZodPipeline<z.ZodEffects<z.ZodAny, any, any>, z.ZodArray<z.ZodObject<{
795
- digestID: z.ZodOptional<z.ZodNumber>;
207
+ nameSpaces: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodPipe<z.ZodAny, z.ZodTransform<any, any>>, z.ZodArray<z.ZodObject<{
208
+ digestID: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
796
209
  random: z.ZodOptional<z.ZodString>;
797
210
  elementIdentifier: z.ZodString;
798
211
  elementValue: z.ZodAny;
799
- }, "strip", z.ZodTypeAny, {
800
- elementIdentifier: string;
801
- digestID?: number | undefined;
802
- random?: string | undefined;
803
- elementValue?: any;
804
- }, {
805
- elementIdentifier: string;
806
- digestID?: number | undefined;
807
- random?: string | undefined;
808
- elementValue?: any;
809
- }>, "many">>>;
212
+ }, z.core.$strip>>>>;
810
213
  issuerAuth: z.ZodObject<{
811
214
  rawValue: z.ZodOptional<z.ZodString>;
812
215
  protectedHeader: z.ZodOptional<z.ZodString>;
813
216
  unprotectedHeader: z.ZodObject<{
814
- algorithm: z.ZodOptional<z.ZodString>;
217
+ algorithm: z.ZodOptional<z.ZodCoercedString<unknown>>;
815
218
  kid: z.ZodOptional<z.ZodString>;
816
- x5chain: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
817
- }, "strip", z.ZodTypeAny, {
818
- algorithm?: string | undefined;
819
- kid?: string | undefined;
820
- x5chain?: string[] | undefined;
821
- }, {
822
- algorithm?: string | undefined;
823
- kid?: string | undefined;
824
- x5chain?: string[] | undefined;
825
- }>;
219
+ x5chain: z.ZodOptional<z.ZodArray<z.ZodString>>;
220
+ }, z.core.$strip>;
826
221
  payload: z.ZodObject<{
827
222
  docType: z.ZodOptional<z.ZodString>;
828
223
  version: z.ZodOptional<z.ZodString>;
829
224
  validityInfo: z.ZodObject<{
830
- signed: z.ZodDate;
831
- validUntil: z.ZodDate;
832
- validFrom: z.ZodDate;
833
- expectedUpdate: z.ZodOptional<z.ZodDate>;
834
- }, "strip", z.ZodTypeAny, {
835
- signed: Date;
836
- validUntil: Date;
837
- validFrom: Date;
838
- expectedUpdate?: Date | undefined;
839
- }, {
840
- signed: Date;
841
- validUntil: Date;
842
- validFrom: Date;
843
- expectedUpdate?: Date | undefined;
844
- }>;
225
+ signed: z.ZodCoercedDate<unknown>;
226
+ validUntil: z.ZodCoercedDate<unknown>;
227
+ validFrom: z.ZodCoercedDate<unknown>;
228
+ expectedUpdate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
229
+ }, z.core.$strip>;
845
230
  digestAlgorithm: z.ZodOptional<z.ZodString>;
846
231
  deviceKeyInfo: z.ZodObject<{
847
- deviceKey: z.ZodUnion<[z.ZodObject<{
848
- kty: z.ZodEnum<["RSA"]>;
232
+ deviceKey: z.ZodUnion<readonly [z.ZodObject<{
233
+ kty: z.ZodEnum<{
234
+ RSA: "RSA";
235
+ }>;
849
236
  alg: z.ZodString;
850
237
  e: z.ZodString;
851
238
  n: z.ZodString;
852
- }, "strip", z.ZodTypeAny, {
853
- kty: "RSA";
854
- alg: string;
855
- e: string;
856
- n: string;
857
- }, {
858
- kty: "RSA";
859
- alg: string;
860
- e: string;
861
- n: string;
862
- }>, z.ZodObject<{
863
- kty: z.ZodEnum<["EC"]>;
864
- crv: z.ZodEnum<["P-256", "P-384", "P-521"]>;
239
+ }, z.core.$strip>, z.ZodObject<{
240
+ kty: z.ZodEnum<{
241
+ EC: "EC";
242
+ }>;
243
+ crv: z.ZodEnum<{
244
+ "P-256": "P-256";
245
+ "P-384": "P-384";
246
+ "P-521": "P-521";
247
+ }>;
865
248
  x: z.ZodString;
866
249
  y: z.ZodString;
867
- }, "strip", z.ZodTypeAny, {
868
- kty: "EC";
869
- crv: "P-256" | "P-384" | "P-521";
870
- x: string;
871
- y: string;
872
- }, {
873
- kty: "EC";
874
- crv: "P-256" | "P-384" | "P-521";
875
- x: string;
876
- y: string;
877
- }>]>;
878
- }, "strip", z.ZodTypeAny, {
879
- deviceKey: {
880
- kty: "EC";
881
- crv: "P-256" | "P-384" | "P-521";
882
- x: string;
883
- y: string;
884
- } | {
885
- kty: "RSA";
886
- alg: string;
887
- e: string;
888
- n: string;
889
- };
890
- }, {
891
- deviceKey: {
892
- kty: "EC";
893
- crv: "P-256" | "P-384" | "P-521";
894
- x: string;
895
- y: string;
896
- } | {
897
- kty: "RSA";
898
- alg: string;
899
- e: string;
900
- n: string;
901
- };
902
- }>;
250
+ }, z.core.$strip>]>;
251
+ }, z.core.$strip>;
903
252
  valueDigests: z.ZodRecord<z.ZodString, z.ZodAny>;
904
- }, "strip", z.ZodTypeAny, {
905
- validityInfo: {
906
- signed: Date;
907
- validUntil: Date;
908
- validFrom: Date;
909
- expectedUpdate?: Date | undefined;
910
- };
911
- deviceKeyInfo: {
912
- deviceKey: {
913
- kty: "EC";
914
- crv: "P-256" | "P-384" | "P-521";
915
- x: string;
916
- y: string;
917
- } | {
918
- kty: "RSA";
919
- alg: string;
920
- e: string;
921
- n: string;
922
- };
923
- };
924
- valueDigests: Record<string, any>;
925
- docType?: string | undefined;
926
- version?: string | undefined;
927
- digestAlgorithm?: string | undefined;
928
- }, {
929
- validityInfo: {
930
- signed: Date;
931
- validUntil: Date;
932
- validFrom: Date;
933
- expectedUpdate?: Date | undefined;
934
- };
935
- deviceKeyInfo: {
936
- deviceKey: {
937
- kty: "EC";
938
- crv: "P-256" | "P-384" | "P-521";
939
- x: string;
940
- y: string;
941
- } | {
942
- kty: "RSA";
943
- alg: string;
944
- e: string;
945
- n: string;
946
- };
947
- };
948
- valueDigests: Record<string, any>;
949
- docType?: string | undefined;
950
- version?: string | undefined;
951
- digestAlgorithm?: string | undefined;
952
- }>;
253
+ }, z.core.$strip>;
953
254
  signature: z.ZodOptional<z.ZodString>;
954
- }, "strip", z.ZodTypeAny, {
955
- unprotectedHeader: {
956
- algorithm?: string | undefined;
957
- kid?: string | undefined;
958
- x5chain?: string[] | undefined;
959
- };
960
- payload: {
961
- validityInfo: {
962
- signed: Date;
963
- validUntil: Date;
964
- validFrom: Date;
965
- expectedUpdate?: Date | undefined;
966
- };
967
- deviceKeyInfo: {
968
- deviceKey: {
969
- kty: "EC";
970
- crv: "P-256" | "P-384" | "P-521";
971
- x: string;
972
- y: string;
973
- } | {
974
- kty: "RSA";
975
- alg: string;
976
- e: string;
977
- n: string;
978
- };
979
- };
980
- valueDigests: Record<string, any>;
981
- docType?: string | undefined;
982
- version?: string | undefined;
983
- digestAlgorithm?: string | undefined;
984
- };
985
- rawValue?: string | undefined;
986
- protectedHeader?: string | undefined;
987
- signature?: string | undefined;
988
- }, {
989
- unprotectedHeader: {
990
- algorithm?: string | undefined;
991
- kid?: string | undefined;
992
- x5chain?: string[] | undefined;
993
- };
994
- payload: {
995
- validityInfo: {
996
- signed: Date;
997
- validUntil: Date;
998
- validFrom: Date;
999
- expectedUpdate?: Date | undefined;
1000
- };
1001
- deviceKeyInfo: {
1002
- deviceKey: {
1003
- kty: "EC";
1004
- crv: "P-256" | "P-384" | "P-521";
1005
- x: string;
1006
- y: string;
1007
- } | {
1008
- kty: "RSA";
1009
- alg: string;
1010
- e: string;
1011
- n: string;
1012
- };
1013
- };
1014
- valueDigests: Record<string, any>;
1015
- docType?: string | undefined;
1016
- version?: string | undefined;
1017
- digestAlgorithm?: string | undefined;
1018
- };
1019
- rawValue?: string | undefined;
1020
- protectedHeader?: string | undefined;
1021
- signature?: string | undefined;
1022
- }>;
1023
- }, "strip", z.ZodTypeAny, {
1024
- nameSpaces: Record<string, {
1025
- elementIdentifier: string;
1026
- digestID?: number | undefined;
1027
- random?: string | undefined;
1028
- elementValue?: any;
1029
- }[]>;
1030
- issuerAuth: {
1031
- unprotectedHeader: {
1032
- algorithm?: string | undefined;
1033
- kid?: string | undefined;
1034
- x5chain?: string[] | undefined;
1035
- };
1036
- payload: {
1037
- validityInfo: {
1038
- signed: Date;
1039
- validUntil: Date;
1040
- validFrom: Date;
1041
- expectedUpdate?: Date | undefined;
1042
- };
1043
- deviceKeyInfo: {
1044
- deviceKey: {
1045
- kty: "EC";
1046
- crv: "P-256" | "P-384" | "P-521";
1047
- x: string;
1048
- y: string;
1049
- } | {
1050
- kty: "RSA";
1051
- alg: string;
1052
- e: string;
1053
- n: string;
1054
- };
1055
- };
1056
- valueDigests: Record<string, any>;
1057
- docType?: string | undefined;
1058
- version?: string | undefined;
1059
- digestAlgorithm?: string | undefined;
1060
- };
1061
- rawValue?: string | undefined;
1062
- protectedHeader?: string | undefined;
1063
- signature?: string | undefined;
1064
- };
1065
- }, {
1066
- nameSpaces: Record<string, any>;
1067
- issuerAuth: {
1068
- unprotectedHeader: {
1069
- algorithm?: string | undefined;
1070
- kid?: string | undefined;
1071
- x5chain?: string[] | undefined;
1072
- };
1073
- payload: {
1074
- validityInfo: {
1075
- signed: Date;
1076
- validUntil: Date;
1077
- validFrom: Date;
1078
- expectedUpdate?: Date | undefined;
1079
- };
1080
- deviceKeyInfo: {
1081
- deviceKey: {
1082
- kty: "EC";
1083
- crv: "P-256" | "P-384" | "P-521";
1084
- x: string;
1085
- y: string;
1086
- } | {
1087
- kty: "RSA";
1088
- alg: string;
1089
- e: string;
1090
- n: string;
1091
- };
1092
- };
1093
- valueDigests: Record<string, any>;
1094
- docType?: string | undefined;
1095
- version?: string | undefined;
1096
- digestAlgorithm?: string | undefined;
1097
- };
1098
- rawValue?: string | undefined;
1099
- protectedHeader?: string | undefined;
1100
- signature?: string | undefined;
1101
- };
1102
- }>;
1103
- }, "strip", z.ZodTypeAny, {
1104
- docType: DocumentTypeEnum;
1105
- issuerSigned: {
1106
- nameSpaces: Record<string, {
1107
- elementIdentifier: string;
1108
- digestID?: number | undefined;
1109
- random?: string | undefined;
1110
- elementValue?: any;
1111
- }[]>;
1112
- issuerAuth: {
1113
- unprotectedHeader: {
1114
- algorithm?: string | undefined;
1115
- kid?: string | undefined;
1116
- x5chain?: string[] | undefined;
1117
- };
1118
- payload: {
1119
- validityInfo: {
1120
- signed: Date;
1121
- validUntil: Date;
1122
- validFrom: Date;
1123
- expectedUpdate?: Date | undefined;
1124
- };
1125
- deviceKeyInfo: {
1126
- deviceKey: {
1127
- kty: "EC";
1128
- crv: "P-256" | "P-384" | "P-521";
1129
- x: string;
1130
- y: string;
1131
- } | {
1132
- kty: "RSA";
1133
- alg: string;
1134
- e: string;
1135
- n: string;
1136
- };
1137
- };
1138
- valueDigests: Record<string, any>;
1139
- docType?: string | undefined;
1140
- version?: string | undefined;
1141
- digestAlgorithm?: string | undefined;
1142
- };
1143
- rawValue?: string | undefined;
1144
- protectedHeader?: string | undefined;
1145
- signature?: string | undefined;
1146
- };
1147
- };
1148
- }, {
1149
- docType: DocumentTypeEnum;
1150
- issuerSigned: {
1151
- nameSpaces: Record<string, any>;
1152
- issuerAuth: {
1153
- unprotectedHeader: {
1154
- algorithm?: string | undefined;
1155
- kid?: string | undefined;
1156
- x5chain?: string[] | undefined;
1157
- };
1158
- payload: {
1159
- validityInfo: {
1160
- signed: Date;
1161
- validUntil: Date;
1162
- validFrom: Date;
1163
- expectedUpdate?: Date | undefined;
1164
- };
1165
- deviceKeyInfo: {
1166
- deviceKey: {
1167
- kty: "EC";
1168
- crv: "P-256" | "P-384" | "P-521";
1169
- x: string;
1170
- y: string;
1171
- } | {
1172
- kty: "RSA";
1173
- alg: string;
1174
- e: string;
1175
- n: string;
1176
- };
1177
- };
1178
- valueDigests: Record<string, any>;
1179
- docType?: string | undefined;
1180
- version?: string | undefined;
1181
- digestAlgorithm?: string | undefined;
1182
- };
1183
- rawValue?: string | undefined;
1184
- protectedHeader?: string | undefined;
1185
- signature?: string | undefined;
1186
- };
1187
- };
1188
- }>;
255
+ }, z.core.$strip>;
256
+ }, z.core.$strip>;
257
+ }, z.core.$strip>;
1189
258
  export type MDOC = z.infer<typeof MDOC>;
1190
259
  /**
1191
260
  * CBOR decoded data containing the status, version and the list of documents
@@ -1193,1228 +262,175 @@ export type MDOC = z.infer<typeof MDOC>;
1193
262
  export declare const Documents: z.ZodObject<{
1194
263
  status: z.ZodOptional<z.ZodNumber>;
1195
264
  version: z.ZodOptional<z.ZodString>;
1196
- documents: z.ZodPipeline<z.ZodEffects<z.ZodAny, any, any>, z.ZodArray<z.ZodObject<{
1197
- docType: z.ZodNativeEnum<typeof DocumentTypeEnum>;
265
+ documents: z.ZodPipe<z.ZodPipe<z.ZodAny, z.ZodTransform<any, any>>, z.ZodArray<z.ZodObject<{
266
+ docType: z.ZodEnum<typeof DocumentTypeEnum>;
1198
267
  issuerSigned: z.ZodObject<{
1199
- nameSpaces: z.ZodRecord<z.ZodString, z.ZodPipeline<z.ZodEffects<z.ZodAny, any, any>, z.ZodArray<z.ZodObject<{
1200
- digestID: z.ZodOptional<z.ZodNumber>;
268
+ nameSpaces: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodPipe<z.ZodAny, z.ZodTransform<any, any>>, z.ZodArray<z.ZodObject<{
269
+ digestID: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
1201
270
  random: z.ZodOptional<z.ZodString>;
1202
271
  elementIdentifier: z.ZodString;
1203
272
  elementValue: z.ZodAny;
1204
- }, "strip", z.ZodTypeAny, {
1205
- elementIdentifier: string;
1206
- digestID?: number | undefined;
1207
- random?: string | undefined;
1208
- elementValue?: any;
1209
- }, {
1210
- elementIdentifier: string;
1211
- digestID?: number | undefined;
1212
- random?: string | undefined;
1213
- elementValue?: any;
1214
- }>, "many">>>;
273
+ }, z.core.$strip>>>>;
1215
274
  issuerAuth: z.ZodObject<{
1216
275
  rawValue: z.ZodOptional<z.ZodString>;
1217
276
  protectedHeader: z.ZodOptional<z.ZodString>;
1218
277
  unprotectedHeader: z.ZodObject<{
1219
- algorithm: z.ZodOptional<z.ZodString>;
278
+ algorithm: z.ZodOptional<z.ZodCoercedString<unknown>>;
1220
279
  kid: z.ZodOptional<z.ZodString>;
1221
- x5chain: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
1222
- }, "strip", z.ZodTypeAny, {
1223
- algorithm?: string | undefined;
1224
- kid?: string | undefined;
1225
- x5chain?: string[] | undefined;
1226
- }, {
1227
- algorithm?: string | undefined;
1228
- kid?: string | undefined;
1229
- x5chain?: string[] | undefined;
1230
- }>;
280
+ x5chain: z.ZodOptional<z.ZodArray<z.ZodString>>;
281
+ }, z.core.$strip>;
1231
282
  payload: z.ZodObject<{
1232
283
  docType: z.ZodOptional<z.ZodString>;
1233
284
  version: z.ZodOptional<z.ZodString>;
1234
285
  validityInfo: z.ZodObject<{
1235
- signed: z.ZodDate;
1236
- validUntil: z.ZodDate;
1237
- validFrom: z.ZodDate;
1238
- expectedUpdate: z.ZodOptional<z.ZodDate>;
1239
- }, "strip", z.ZodTypeAny, {
1240
- signed: Date;
1241
- validUntil: Date;
1242
- validFrom: Date;
1243
- expectedUpdate?: Date | undefined;
1244
- }, {
1245
- signed: Date;
1246
- validUntil: Date;
1247
- validFrom: Date;
1248
- expectedUpdate?: Date | undefined;
1249
- }>;
286
+ signed: z.ZodCoercedDate<unknown>;
287
+ validUntil: z.ZodCoercedDate<unknown>;
288
+ validFrom: z.ZodCoercedDate<unknown>;
289
+ expectedUpdate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
290
+ }, z.core.$strip>;
1250
291
  digestAlgorithm: z.ZodOptional<z.ZodString>;
1251
292
  deviceKeyInfo: z.ZodObject<{
1252
- deviceKey: z.ZodUnion<[z.ZodObject<{
1253
- kty: z.ZodEnum<["RSA"]>;
293
+ deviceKey: z.ZodUnion<readonly [z.ZodObject<{
294
+ kty: z.ZodEnum<{
295
+ RSA: "RSA";
296
+ }>;
1254
297
  alg: z.ZodString;
1255
298
  e: z.ZodString;
1256
299
  n: z.ZodString;
1257
- }, "strip", z.ZodTypeAny, {
1258
- kty: "RSA";
1259
- alg: string;
1260
- e: string;
1261
- n: string;
1262
- }, {
1263
- kty: "RSA";
1264
- alg: string;
1265
- e: string;
1266
- n: string;
1267
- }>, z.ZodObject<{
1268
- kty: z.ZodEnum<["EC"]>;
1269
- crv: z.ZodEnum<["P-256", "P-384", "P-521"]>;
300
+ }, z.core.$strip>, z.ZodObject<{
301
+ kty: z.ZodEnum<{
302
+ EC: "EC";
303
+ }>;
304
+ crv: z.ZodEnum<{
305
+ "P-256": "P-256";
306
+ "P-384": "P-384";
307
+ "P-521": "P-521";
308
+ }>;
1270
309
  x: z.ZodString;
1271
310
  y: z.ZodString;
1272
- }, "strip", z.ZodTypeAny, {
1273
- kty: "EC";
1274
- crv: "P-256" | "P-384" | "P-521";
1275
- x: string;
1276
- y: string;
1277
- }, {
1278
- kty: "EC";
1279
- crv: "P-256" | "P-384" | "P-521";
1280
- x: string;
1281
- y: string;
1282
- }>]>;
1283
- }, "strip", z.ZodTypeAny, {
1284
- deviceKey: {
1285
- kty: "EC";
1286
- crv: "P-256" | "P-384" | "P-521";
1287
- x: string;
1288
- y: string;
1289
- } | {
1290
- kty: "RSA";
1291
- alg: string;
1292
- e: string;
1293
- n: string;
1294
- };
1295
- }, {
1296
- deviceKey: {
1297
- kty: "EC";
1298
- crv: "P-256" | "P-384" | "P-521";
1299
- x: string;
1300
- y: string;
1301
- } | {
1302
- kty: "RSA";
1303
- alg: string;
1304
- e: string;
1305
- n: string;
1306
- };
1307
- }>;
311
+ }, z.core.$strip>]>;
312
+ }, z.core.$strip>;
1308
313
  valueDigests: z.ZodRecord<z.ZodString, z.ZodAny>;
1309
- }, "strip", z.ZodTypeAny, {
1310
- validityInfo: {
1311
- signed: Date;
1312
- validUntil: Date;
1313
- validFrom: Date;
1314
- expectedUpdate?: Date | undefined;
1315
- };
1316
- deviceKeyInfo: {
1317
- deviceKey: {
1318
- kty: "EC";
1319
- crv: "P-256" | "P-384" | "P-521";
1320
- x: string;
1321
- y: string;
1322
- } | {
1323
- kty: "RSA";
1324
- alg: string;
1325
- e: string;
1326
- n: string;
1327
- };
1328
- };
1329
- valueDigests: Record<string, any>;
1330
- docType?: string | undefined;
1331
- version?: string | undefined;
1332
- digestAlgorithm?: string | undefined;
1333
- }, {
1334
- validityInfo: {
1335
- signed: Date;
1336
- validUntil: Date;
1337
- validFrom: Date;
1338
- expectedUpdate?: Date | undefined;
1339
- };
1340
- deviceKeyInfo: {
1341
- deviceKey: {
1342
- kty: "EC";
1343
- crv: "P-256" | "P-384" | "P-521";
1344
- x: string;
1345
- y: string;
1346
- } | {
1347
- kty: "RSA";
1348
- alg: string;
1349
- e: string;
1350
- n: string;
1351
- };
1352
- };
1353
- valueDigests: Record<string, any>;
1354
- docType?: string | undefined;
1355
- version?: string | undefined;
1356
- digestAlgorithm?: string | undefined;
1357
- }>;
314
+ }, z.core.$strip>;
1358
315
  signature: z.ZodOptional<z.ZodString>;
1359
- }, "strip", z.ZodTypeAny, {
1360
- unprotectedHeader: {
1361
- algorithm?: string | undefined;
1362
- kid?: string | undefined;
1363
- x5chain?: string[] | undefined;
1364
- };
1365
- payload: {
1366
- validityInfo: {
1367
- signed: Date;
1368
- validUntil: Date;
1369
- validFrom: Date;
1370
- expectedUpdate?: Date | undefined;
1371
- };
1372
- deviceKeyInfo: {
1373
- deviceKey: {
1374
- kty: "EC";
1375
- crv: "P-256" | "P-384" | "P-521";
1376
- x: string;
1377
- y: string;
1378
- } | {
1379
- kty: "RSA";
1380
- alg: string;
1381
- e: string;
1382
- n: string;
1383
- };
1384
- };
1385
- valueDigests: Record<string, any>;
1386
- docType?: string | undefined;
1387
- version?: string | undefined;
1388
- digestAlgorithm?: string | undefined;
1389
- };
1390
- rawValue?: string | undefined;
1391
- protectedHeader?: string | undefined;
1392
- signature?: string | undefined;
1393
- }, {
1394
- unprotectedHeader: {
1395
- algorithm?: string | undefined;
1396
- kid?: string | undefined;
1397
- x5chain?: string[] | undefined;
1398
- };
1399
- payload: {
1400
- validityInfo: {
1401
- signed: Date;
1402
- validUntil: Date;
1403
- validFrom: Date;
1404
- expectedUpdate?: Date | undefined;
1405
- };
1406
- deviceKeyInfo: {
1407
- deviceKey: {
1408
- kty: "EC";
1409
- crv: "P-256" | "P-384" | "P-521";
1410
- x: string;
1411
- y: string;
1412
- } | {
1413
- kty: "RSA";
1414
- alg: string;
1415
- e: string;
1416
- n: string;
1417
- };
1418
- };
1419
- valueDigests: Record<string, any>;
1420
- docType?: string | undefined;
1421
- version?: string | undefined;
1422
- digestAlgorithm?: string | undefined;
1423
- };
1424
- rawValue?: string | undefined;
1425
- protectedHeader?: string | undefined;
1426
- signature?: string | undefined;
1427
- }>;
1428
- }, "strip", z.ZodTypeAny, {
1429
- nameSpaces: Record<string, {
1430
- elementIdentifier: string;
1431
- digestID?: number | undefined;
1432
- random?: string | undefined;
1433
- elementValue?: any;
1434
- }[]>;
1435
- issuerAuth: {
1436
- unprotectedHeader: {
1437
- algorithm?: string | undefined;
1438
- kid?: string | undefined;
1439
- x5chain?: string[] | undefined;
1440
- };
1441
- payload: {
1442
- validityInfo: {
1443
- signed: Date;
1444
- validUntil: Date;
1445
- validFrom: Date;
1446
- expectedUpdate?: Date | undefined;
1447
- };
1448
- deviceKeyInfo: {
1449
- deviceKey: {
1450
- kty: "EC";
1451
- crv: "P-256" | "P-384" | "P-521";
1452
- x: string;
1453
- y: string;
1454
- } | {
1455
- kty: "RSA";
1456
- alg: string;
1457
- e: string;
1458
- n: string;
1459
- };
1460
- };
1461
- valueDigests: Record<string, any>;
1462
- docType?: string | undefined;
1463
- version?: string | undefined;
1464
- digestAlgorithm?: string | undefined;
1465
- };
1466
- rawValue?: string | undefined;
1467
- protectedHeader?: string | undefined;
1468
- signature?: string | undefined;
1469
- };
1470
- }, {
1471
- nameSpaces: Record<string, any>;
1472
- issuerAuth: {
1473
- unprotectedHeader: {
1474
- algorithm?: string | undefined;
1475
- kid?: string | undefined;
1476
- x5chain?: string[] | undefined;
1477
- };
1478
- payload: {
1479
- validityInfo: {
1480
- signed: Date;
1481
- validUntil: Date;
1482
- validFrom: Date;
1483
- expectedUpdate?: Date | undefined;
1484
- };
1485
- deviceKeyInfo: {
1486
- deviceKey: {
1487
- kty: "EC";
1488
- crv: "P-256" | "P-384" | "P-521";
1489
- x: string;
1490
- y: string;
1491
- } | {
1492
- kty: "RSA";
1493
- alg: string;
1494
- e: string;
1495
- n: string;
1496
- };
1497
- };
1498
- valueDigests: Record<string, any>;
1499
- docType?: string | undefined;
1500
- version?: string | undefined;
1501
- digestAlgorithm?: string | undefined;
1502
- };
1503
- rawValue?: string | undefined;
1504
- protectedHeader?: string | undefined;
1505
- signature?: string | undefined;
1506
- };
1507
- }>;
1508
- }, "strip", z.ZodTypeAny, {
1509
- docType: DocumentTypeEnum;
1510
- issuerSigned: {
1511
- nameSpaces: Record<string, {
1512
- elementIdentifier: string;
1513
- digestID?: number | undefined;
1514
- random?: string | undefined;
1515
- elementValue?: any;
1516
- }[]>;
1517
- issuerAuth: {
1518
- unprotectedHeader: {
1519
- algorithm?: string | undefined;
1520
- kid?: string | undefined;
1521
- x5chain?: string[] | undefined;
1522
- };
1523
- payload: {
1524
- validityInfo: {
1525
- signed: Date;
1526
- validUntil: Date;
1527
- validFrom: Date;
1528
- expectedUpdate?: Date | undefined;
1529
- };
1530
- deviceKeyInfo: {
1531
- deviceKey: {
1532
- kty: "EC";
1533
- crv: "P-256" | "P-384" | "P-521";
1534
- x: string;
1535
- y: string;
1536
- } | {
1537
- kty: "RSA";
1538
- alg: string;
1539
- e: string;
1540
- n: string;
1541
- };
1542
- };
1543
- valueDigests: Record<string, any>;
1544
- docType?: string | undefined;
1545
- version?: string | undefined;
1546
- digestAlgorithm?: string | undefined;
1547
- };
1548
- rawValue?: string | undefined;
1549
- protectedHeader?: string | undefined;
1550
- signature?: string | undefined;
1551
- };
1552
- };
1553
- }, {
1554
- docType: DocumentTypeEnum;
1555
- issuerSigned: {
1556
- nameSpaces: Record<string, any>;
1557
- issuerAuth: {
1558
- unprotectedHeader: {
1559
- algorithm?: string | undefined;
1560
- kid?: string | undefined;
1561
- x5chain?: string[] | undefined;
1562
- };
1563
- payload: {
1564
- validityInfo: {
1565
- signed: Date;
1566
- validUntil: Date;
1567
- validFrom: Date;
1568
- expectedUpdate?: Date | undefined;
1569
- };
1570
- deviceKeyInfo: {
1571
- deviceKey: {
1572
- kty: "EC";
1573
- crv: "P-256" | "P-384" | "P-521";
1574
- x: string;
1575
- y: string;
1576
- } | {
1577
- kty: "RSA";
1578
- alg: string;
1579
- e: string;
1580
- n: string;
1581
- };
1582
- };
1583
- valueDigests: Record<string, any>;
1584
- docType?: string | undefined;
1585
- version?: string | undefined;
1586
- digestAlgorithm?: string | undefined;
1587
- };
1588
- rawValue?: string | undefined;
1589
- protectedHeader?: string | undefined;
1590
- signature?: string | undefined;
1591
- };
1592
- };
1593
- }>, "many">>;
1594
- }, "strip", z.ZodTypeAny, {
1595
- documents: {
1596
- docType: DocumentTypeEnum;
1597
- issuerSigned: {
1598
- nameSpaces: Record<string, {
1599
- elementIdentifier: string;
1600
- digestID?: number | undefined;
1601
- random?: string | undefined;
1602
- elementValue?: any;
1603
- }[]>;
1604
- issuerAuth: {
1605
- unprotectedHeader: {
1606
- algorithm?: string | undefined;
1607
- kid?: string | undefined;
1608
- x5chain?: string[] | undefined;
1609
- };
1610
- payload: {
1611
- validityInfo: {
1612
- signed: Date;
1613
- validUntil: Date;
1614
- validFrom: Date;
1615
- expectedUpdate?: Date | undefined;
1616
- };
1617
- deviceKeyInfo: {
1618
- deviceKey: {
1619
- kty: "EC";
1620
- crv: "P-256" | "P-384" | "P-521";
1621
- x: string;
1622
- y: string;
1623
- } | {
1624
- kty: "RSA";
1625
- alg: string;
1626
- e: string;
1627
- n: string;
1628
- };
1629
- };
1630
- valueDigests: Record<string, any>;
1631
- docType?: string | undefined;
1632
- version?: string | undefined;
1633
- digestAlgorithm?: string | undefined;
1634
- };
1635
- rawValue?: string | undefined;
1636
- protectedHeader?: string | undefined;
1637
- signature?: string | undefined;
1638
- };
1639
- };
1640
- }[];
1641
- status?: number | undefined;
1642
- version?: string | undefined;
1643
- }, {
1644
- status?: number | undefined;
1645
- version?: string | undefined;
1646
- documents?: any;
1647
- }>;
316
+ }, z.core.$strip>;
317
+ }, z.core.$strip>;
318
+ }, z.core.$strip>>>;
319
+ }, z.core.$strip>;
1648
320
  /**
1649
321
  * Documents object from string
1650
322
  */
1651
- export declare const DocumentsFromString: z.ZodPipeline<z.ZodEffects<z.ZodAny, any, any>, z.ZodObject<{
323
+ export declare const DocumentsFromString: z.ZodPipe<z.ZodPipe<z.ZodAny, z.ZodTransform<any, any>>, z.ZodObject<{
1652
324
  status: z.ZodOptional<z.ZodNumber>;
1653
325
  version: z.ZodOptional<z.ZodString>;
1654
- documents: z.ZodPipeline<z.ZodEffects<z.ZodAny, any, any>, z.ZodArray<z.ZodObject<{
1655
- docType: z.ZodNativeEnum<typeof DocumentTypeEnum>;
326
+ documents: z.ZodPipe<z.ZodPipe<z.ZodAny, z.ZodTransform<any, any>>, z.ZodArray<z.ZodObject<{
327
+ docType: z.ZodEnum<typeof DocumentTypeEnum>;
1656
328
  issuerSigned: z.ZodObject<{
1657
- nameSpaces: z.ZodRecord<z.ZodString, z.ZodPipeline<z.ZodEffects<z.ZodAny, any, any>, z.ZodArray<z.ZodObject<{
1658
- digestID: z.ZodOptional<z.ZodNumber>;
329
+ nameSpaces: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodPipe<z.ZodAny, z.ZodTransform<any, any>>, z.ZodArray<z.ZodObject<{
330
+ digestID: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
1659
331
  random: z.ZodOptional<z.ZodString>;
1660
332
  elementIdentifier: z.ZodString;
1661
333
  elementValue: z.ZodAny;
1662
- }, "strip", z.ZodTypeAny, {
1663
- elementIdentifier: string;
1664
- digestID?: number | undefined;
1665
- random?: string | undefined;
1666
- elementValue?: any;
1667
- }, {
1668
- elementIdentifier: string;
1669
- digestID?: number | undefined;
1670
- random?: string | undefined;
1671
- elementValue?: any;
1672
- }>, "many">>>;
334
+ }, z.core.$strip>>>>;
1673
335
  issuerAuth: z.ZodObject<{
1674
336
  rawValue: z.ZodOptional<z.ZodString>;
1675
337
  protectedHeader: z.ZodOptional<z.ZodString>;
1676
338
  unprotectedHeader: z.ZodObject<{
1677
- algorithm: z.ZodOptional<z.ZodString>;
339
+ algorithm: z.ZodOptional<z.ZodCoercedString<unknown>>;
1678
340
  kid: z.ZodOptional<z.ZodString>;
1679
- x5chain: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
1680
- }, "strip", z.ZodTypeAny, {
1681
- algorithm?: string | undefined;
1682
- kid?: string | undefined;
1683
- x5chain?: string[] | undefined;
1684
- }, {
1685
- algorithm?: string | undefined;
1686
- kid?: string | undefined;
1687
- x5chain?: string[] | undefined;
1688
- }>;
341
+ x5chain: z.ZodOptional<z.ZodArray<z.ZodString>>;
342
+ }, z.core.$strip>;
1689
343
  payload: z.ZodObject<{
1690
344
  docType: z.ZodOptional<z.ZodString>;
1691
345
  version: z.ZodOptional<z.ZodString>;
1692
346
  validityInfo: z.ZodObject<{
1693
- signed: z.ZodDate;
1694
- validUntil: z.ZodDate;
1695
- validFrom: z.ZodDate;
1696
- expectedUpdate: z.ZodOptional<z.ZodDate>;
1697
- }, "strip", z.ZodTypeAny, {
1698
- signed: Date;
1699
- validUntil: Date;
1700
- validFrom: Date;
1701
- expectedUpdate?: Date | undefined;
1702
- }, {
1703
- signed: Date;
1704
- validUntil: Date;
1705
- validFrom: Date;
1706
- expectedUpdate?: Date | undefined;
1707
- }>;
347
+ signed: z.ZodCoercedDate<unknown>;
348
+ validUntil: z.ZodCoercedDate<unknown>;
349
+ validFrom: z.ZodCoercedDate<unknown>;
350
+ expectedUpdate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
351
+ }, z.core.$strip>;
1708
352
  digestAlgorithm: z.ZodOptional<z.ZodString>;
1709
353
  deviceKeyInfo: z.ZodObject<{
1710
- deviceKey: z.ZodUnion<[z.ZodObject<{
1711
- kty: z.ZodEnum<["RSA"]>;
354
+ deviceKey: z.ZodUnion<readonly [z.ZodObject<{
355
+ kty: z.ZodEnum<{
356
+ RSA: "RSA";
357
+ }>;
1712
358
  alg: z.ZodString;
1713
359
  e: z.ZodString;
1714
360
  n: z.ZodString;
1715
- }, "strip", z.ZodTypeAny, {
1716
- kty: "RSA";
1717
- alg: string;
1718
- e: string;
1719
- n: string;
1720
- }, {
1721
- kty: "RSA";
1722
- alg: string;
1723
- e: string;
1724
- n: string;
1725
- }>, z.ZodObject<{
1726
- kty: z.ZodEnum<["EC"]>;
1727
- crv: z.ZodEnum<["P-256", "P-384", "P-521"]>;
361
+ }, z.core.$strip>, z.ZodObject<{
362
+ kty: z.ZodEnum<{
363
+ EC: "EC";
364
+ }>;
365
+ crv: z.ZodEnum<{
366
+ "P-256": "P-256";
367
+ "P-384": "P-384";
368
+ "P-521": "P-521";
369
+ }>;
1728
370
  x: z.ZodString;
1729
371
  y: z.ZodString;
1730
- }, "strip", z.ZodTypeAny, {
1731
- kty: "EC";
1732
- crv: "P-256" | "P-384" | "P-521";
1733
- x: string;
1734
- y: string;
1735
- }, {
1736
- kty: "EC";
1737
- crv: "P-256" | "P-384" | "P-521";
1738
- x: string;
1739
- y: string;
1740
- }>]>;
1741
- }, "strip", z.ZodTypeAny, {
1742
- deviceKey: {
1743
- kty: "EC";
1744
- crv: "P-256" | "P-384" | "P-521";
1745
- x: string;
1746
- y: string;
1747
- } | {
1748
- kty: "RSA";
1749
- alg: string;
1750
- e: string;
1751
- n: string;
1752
- };
1753
- }, {
1754
- deviceKey: {
1755
- kty: "EC";
1756
- crv: "P-256" | "P-384" | "P-521";
1757
- x: string;
1758
- y: string;
1759
- } | {
1760
- kty: "RSA";
1761
- alg: string;
1762
- e: string;
1763
- n: string;
1764
- };
1765
- }>;
372
+ }, z.core.$strip>]>;
373
+ }, z.core.$strip>;
1766
374
  valueDigests: z.ZodRecord<z.ZodString, z.ZodAny>;
1767
- }, "strip", z.ZodTypeAny, {
1768
- validityInfo: {
1769
- signed: Date;
1770
- validUntil: Date;
1771
- validFrom: Date;
1772
- expectedUpdate?: Date | undefined;
1773
- };
1774
- deviceKeyInfo: {
1775
- deviceKey: {
1776
- kty: "EC";
1777
- crv: "P-256" | "P-384" | "P-521";
1778
- x: string;
1779
- y: string;
1780
- } | {
1781
- kty: "RSA";
1782
- alg: string;
1783
- e: string;
1784
- n: string;
1785
- };
1786
- };
1787
- valueDigests: Record<string, any>;
1788
- docType?: string | undefined;
1789
- version?: string | undefined;
1790
- digestAlgorithm?: string | undefined;
1791
- }, {
1792
- validityInfo: {
1793
- signed: Date;
1794
- validUntil: Date;
1795
- validFrom: Date;
1796
- expectedUpdate?: Date | undefined;
1797
- };
1798
- deviceKeyInfo: {
1799
- deviceKey: {
1800
- kty: "EC";
1801
- crv: "P-256" | "P-384" | "P-521";
1802
- x: string;
1803
- y: string;
1804
- } | {
1805
- kty: "RSA";
1806
- alg: string;
1807
- e: string;
1808
- n: string;
1809
- };
1810
- };
1811
- valueDigests: Record<string, any>;
1812
- docType?: string | undefined;
1813
- version?: string | undefined;
1814
- digestAlgorithm?: string | undefined;
1815
- }>;
375
+ }, z.core.$strip>;
1816
376
  signature: z.ZodOptional<z.ZodString>;
1817
- }, "strip", z.ZodTypeAny, {
1818
- unprotectedHeader: {
1819
- algorithm?: string | undefined;
1820
- kid?: string | undefined;
1821
- x5chain?: string[] | undefined;
1822
- };
1823
- payload: {
1824
- validityInfo: {
1825
- signed: Date;
1826
- validUntil: Date;
1827
- validFrom: Date;
1828
- expectedUpdate?: Date | undefined;
1829
- };
1830
- deviceKeyInfo: {
1831
- deviceKey: {
1832
- kty: "EC";
1833
- crv: "P-256" | "P-384" | "P-521";
1834
- x: string;
1835
- y: string;
1836
- } | {
1837
- kty: "RSA";
1838
- alg: string;
1839
- e: string;
1840
- n: string;
1841
- };
1842
- };
1843
- valueDigests: Record<string, any>;
1844
- docType?: string | undefined;
1845
- version?: string | undefined;
1846
- digestAlgorithm?: string | undefined;
1847
- };
1848
- rawValue?: string | undefined;
1849
- protectedHeader?: string | undefined;
1850
- signature?: string | undefined;
1851
- }, {
1852
- unprotectedHeader: {
1853
- algorithm?: string | undefined;
1854
- kid?: string | undefined;
1855
- x5chain?: string[] | undefined;
1856
- };
1857
- payload: {
1858
- validityInfo: {
1859
- signed: Date;
1860
- validUntil: Date;
1861
- validFrom: Date;
1862
- expectedUpdate?: Date | undefined;
1863
- };
1864
- deviceKeyInfo: {
1865
- deviceKey: {
1866
- kty: "EC";
1867
- crv: "P-256" | "P-384" | "P-521";
1868
- x: string;
1869
- y: string;
1870
- } | {
1871
- kty: "RSA";
1872
- alg: string;
1873
- e: string;
1874
- n: string;
1875
- };
1876
- };
1877
- valueDigests: Record<string, any>;
1878
- docType?: string | undefined;
1879
- version?: string | undefined;
1880
- digestAlgorithm?: string | undefined;
1881
- };
1882
- rawValue?: string | undefined;
1883
- protectedHeader?: string | undefined;
1884
- signature?: string | undefined;
1885
- }>;
1886
- }, "strip", z.ZodTypeAny, {
1887
- nameSpaces: Record<string, {
1888
- elementIdentifier: string;
1889
- digestID?: number | undefined;
1890
- random?: string | undefined;
1891
- elementValue?: any;
1892
- }[]>;
1893
- issuerAuth: {
1894
- unprotectedHeader: {
1895
- algorithm?: string | undefined;
1896
- kid?: string | undefined;
1897
- x5chain?: string[] | undefined;
1898
- };
1899
- payload: {
1900
- validityInfo: {
1901
- signed: Date;
1902
- validUntil: Date;
1903
- validFrom: Date;
1904
- expectedUpdate?: Date | undefined;
1905
- };
1906
- deviceKeyInfo: {
1907
- deviceKey: {
1908
- kty: "EC";
1909
- crv: "P-256" | "P-384" | "P-521";
1910
- x: string;
1911
- y: string;
1912
- } | {
1913
- kty: "RSA";
1914
- alg: string;
1915
- e: string;
1916
- n: string;
1917
- };
1918
- };
1919
- valueDigests: Record<string, any>;
1920
- docType?: string | undefined;
1921
- version?: string | undefined;
1922
- digestAlgorithm?: string | undefined;
1923
- };
1924
- rawValue?: string | undefined;
1925
- protectedHeader?: string | undefined;
1926
- signature?: string | undefined;
1927
- };
1928
- }, {
1929
- nameSpaces: Record<string, any>;
1930
- issuerAuth: {
1931
- unprotectedHeader: {
1932
- algorithm?: string | undefined;
1933
- kid?: string | undefined;
1934
- x5chain?: string[] | undefined;
1935
- };
1936
- payload: {
1937
- validityInfo: {
1938
- signed: Date;
1939
- validUntil: Date;
1940
- validFrom: Date;
1941
- expectedUpdate?: Date | undefined;
1942
- };
1943
- deviceKeyInfo: {
1944
- deviceKey: {
1945
- kty: "EC";
1946
- crv: "P-256" | "P-384" | "P-521";
1947
- x: string;
1948
- y: string;
1949
- } | {
1950
- kty: "RSA";
1951
- alg: string;
1952
- e: string;
1953
- n: string;
1954
- };
1955
- };
1956
- valueDigests: Record<string, any>;
1957
- docType?: string | undefined;
1958
- version?: string | undefined;
1959
- digestAlgorithm?: string | undefined;
1960
- };
1961
- rawValue?: string | undefined;
1962
- protectedHeader?: string | undefined;
1963
- signature?: string | undefined;
1964
- };
1965
- }>;
1966
- }, "strip", z.ZodTypeAny, {
1967
- docType: DocumentTypeEnum;
1968
- issuerSigned: {
1969
- nameSpaces: Record<string, {
1970
- elementIdentifier: string;
1971
- digestID?: number | undefined;
1972
- random?: string | undefined;
1973
- elementValue?: any;
1974
- }[]>;
1975
- issuerAuth: {
1976
- unprotectedHeader: {
1977
- algorithm?: string | undefined;
1978
- kid?: string | undefined;
1979
- x5chain?: string[] | undefined;
1980
- };
1981
- payload: {
1982
- validityInfo: {
1983
- signed: Date;
1984
- validUntil: Date;
1985
- validFrom: Date;
1986
- expectedUpdate?: Date | undefined;
1987
- };
1988
- deviceKeyInfo: {
1989
- deviceKey: {
1990
- kty: "EC";
1991
- crv: "P-256" | "P-384" | "P-521";
1992
- x: string;
1993
- y: string;
1994
- } | {
1995
- kty: "RSA";
1996
- alg: string;
1997
- e: string;
1998
- n: string;
1999
- };
2000
- };
2001
- valueDigests: Record<string, any>;
2002
- docType?: string | undefined;
2003
- version?: string | undefined;
2004
- digestAlgorithm?: string | undefined;
2005
- };
2006
- rawValue?: string | undefined;
2007
- protectedHeader?: string | undefined;
2008
- signature?: string | undefined;
2009
- };
2010
- };
2011
- }, {
2012
- docType: DocumentTypeEnum;
2013
- issuerSigned: {
2014
- nameSpaces: Record<string, any>;
2015
- issuerAuth: {
2016
- unprotectedHeader: {
2017
- algorithm?: string | undefined;
2018
- kid?: string | undefined;
2019
- x5chain?: string[] | undefined;
2020
- };
2021
- payload: {
2022
- validityInfo: {
2023
- signed: Date;
2024
- validUntil: Date;
2025
- validFrom: Date;
2026
- expectedUpdate?: Date | undefined;
2027
- };
2028
- deviceKeyInfo: {
2029
- deviceKey: {
2030
- kty: "EC";
2031
- crv: "P-256" | "P-384" | "P-521";
2032
- x: string;
2033
- y: string;
2034
- } | {
2035
- kty: "RSA";
2036
- alg: string;
2037
- e: string;
2038
- n: string;
2039
- };
2040
- };
2041
- valueDigests: Record<string, any>;
2042
- docType?: string | undefined;
2043
- version?: string | undefined;
2044
- digestAlgorithm?: string | undefined;
2045
- };
2046
- rawValue?: string | undefined;
2047
- protectedHeader?: string | undefined;
2048
- signature?: string | undefined;
2049
- };
2050
- };
2051
- }>, "many">>;
2052
- }, "strip", z.ZodTypeAny, {
2053
- documents: {
2054
- docType: DocumentTypeEnum;
2055
- issuerSigned: {
2056
- nameSpaces: Record<string, {
2057
- elementIdentifier: string;
2058
- digestID?: number | undefined;
2059
- random?: string | undefined;
2060
- elementValue?: any;
2061
- }[]>;
2062
- issuerAuth: {
2063
- unprotectedHeader: {
2064
- algorithm?: string | undefined;
2065
- kid?: string | undefined;
2066
- x5chain?: string[] | undefined;
2067
- };
2068
- payload: {
2069
- validityInfo: {
2070
- signed: Date;
2071
- validUntil: Date;
2072
- validFrom: Date;
2073
- expectedUpdate?: Date | undefined;
2074
- };
2075
- deviceKeyInfo: {
2076
- deviceKey: {
2077
- kty: "EC";
2078
- crv: "P-256" | "P-384" | "P-521";
2079
- x: string;
2080
- y: string;
2081
- } | {
2082
- kty: "RSA";
2083
- alg: string;
2084
- e: string;
2085
- n: string;
2086
- };
2087
- };
2088
- valueDigests: Record<string, any>;
2089
- docType?: string | undefined;
2090
- version?: string | undefined;
2091
- digestAlgorithm?: string | undefined;
2092
- };
2093
- rawValue?: string | undefined;
2094
- protectedHeader?: string | undefined;
2095
- signature?: string | undefined;
2096
- };
2097
- };
2098
- }[];
2099
- status?: number | undefined;
2100
- version?: string | undefined;
2101
- }, {
2102
- status?: number | undefined;
2103
- version?: string | undefined;
2104
- documents?: any;
2105
- }>>;
377
+ }, z.core.$strip>;
378
+ }, z.core.$strip>;
379
+ }, z.core.$strip>>>;
380
+ }, z.core.$strip>>;
2106
381
  /**
2107
382
  * IssuerSigned object from string
2108
383
  */
2109
- export declare const IssuerSignedFromString: z.ZodPipeline<z.ZodEffects<z.ZodAny, any, any>, z.ZodObject<{
2110
- nameSpaces: z.ZodRecord<z.ZodString, z.ZodPipeline<z.ZodEffects<z.ZodAny, any, any>, z.ZodArray<z.ZodObject<{
2111
- digestID: z.ZodOptional<z.ZodNumber>;
384
+ export declare const IssuerSignedFromString: z.ZodPipe<z.ZodPipe<z.ZodAny, z.ZodTransform<any, any>>, z.ZodObject<{
385
+ nameSpaces: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodPipe<z.ZodAny, z.ZodTransform<any, any>>, z.ZodArray<z.ZodObject<{
386
+ digestID: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
2112
387
  random: z.ZodOptional<z.ZodString>;
2113
388
  elementIdentifier: z.ZodString;
2114
389
  elementValue: z.ZodAny;
2115
- }, "strip", z.ZodTypeAny, {
2116
- elementIdentifier: string;
2117
- digestID?: number | undefined;
2118
- random?: string | undefined;
2119
- elementValue?: any;
2120
- }, {
2121
- elementIdentifier: string;
2122
- digestID?: number | undefined;
2123
- random?: string | undefined;
2124
- elementValue?: any;
2125
- }>, "many">>>;
390
+ }, z.core.$strip>>>>;
2126
391
  issuerAuth: z.ZodObject<{
2127
392
  rawValue: z.ZodOptional<z.ZodString>;
2128
393
  protectedHeader: z.ZodOptional<z.ZodString>;
2129
394
  unprotectedHeader: z.ZodObject<{
2130
- algorithm: z.ZodOptional<z.ZodString>;
395
+ algorithm: z.ZodOptional<z.ZodCoercedString<unknown>>;
2131
396
  kid: z.ZodOptional<z.ZodString>;
2132
- x5chain: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
2133
- }, "strip", z.ZodTypeAny, {
2134
- algorithm?: string | undefined;
2135
- kid?: string | undefined;
2136
- x5chain?: string[] | undefined;
2137
- }, {
2138
- algorithm?: string | undefined;
2139
- kid?: string | undefined;
2140
- x5chain?: string[] | undefined;
2141
- }>;
397
+ x5chain: z.ZodOptional<z.ZodArray<z.ZodString>>;
398
+ }, z.core.$strip>;
2142
399
  payload: z.ZodObject<{
2143
400
  docType: z.ZodOptional<z.ZodString>;
2144
401
  version: z.ZodOptional<z.ZodString>;
2145
402
  validityInfo: z.ZodObject<{
2146
- signed: z.ZodDate;
2147
- validUntil: z.ZodDate;
2148
- validFrom: z.ZodDate;
2149
- expectedUpdate: z.ZodOptional<z.ZodDate>;
2150
- }, "strip", z.ZodTypeAny, {
2151
- signed: Date;
2152
- validUntil: Date;
2153
- validFrom: Date;
2154
- expectedUpdate?: Date | undefined;
2155
- }, {
2156
- signed: Date;
2157
- validUntil: Date;
2158
- validFrom: Date;
2159
- expectedUpdate?: Date | undefined;
2160
- }>;
403
+ signed: z.ZodCoercedDate<unknown>;
404
+ validUntil: z.ZodCoercedDate<unknown>;
405
+ validFrom: z.ZodCoercedDate<unknown>;
406
+ expectedUpdate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
407
+ }, z.core.$strip>;
2161
408
  digestAlgorithm: z.ZodOptional<z.ZodString>;
2162
409
  deviceKeyInfo: z.ZodObject<{
2163
- deviceKey: z.ZodUnion<[z.ZodObject<{
2164
- kty: z.ZodEnum<["RSA"]>;
410
+ deviceKey: z.ZodUnion<readonly [z.ZodObject<{
411
+ kty: z.ZodEnum<{
412
+ RSA: "RSA";
413
+ }>;
2165
414
  alg: z.ZodString;
2166
415
  e: z.ZodString;
2167
416
  n: z.ZodString;
2168
- }, "strip", z.ZodTypeAny, {
2169
- kty: "RSA";
2170
- alg: string;
2171
- e: string;
2172
- n: string;
2173
- }, {
2174
- kty: "RSA";
2175
- alg: string;
2176
- e: string;
2177
- n: string;
2178
- }>, z.ZodObject<{
2179
- kty: z.ZodEnum<["EC"]>;
2180
- crv: z.ZodEnum<["P-256", "P-384", "P-521"]>;
417
+ }, z.core.$strip>, z.ZodObject<{
418
+ kty: z.ZodEnum<{
419
+ EC: "EC";
420
+ }>;
421
+ crv: z.ZodEnum<{
422
+ "P-256": "P-256";
423
+ "P-384": "P-384";
424
+ "P-521": "P-521";
425
+ }>;
2181
426
  x: z.ZodString;
2182
427
  y: z.ZodString;
2183
- }, "strip", z.ZodTypeAny, {
2184
- kty: "EC";
2185
- crv: "P-256" | "P-384" | "P-521";
2186
- x: string;
2187
- y: string;
2188
- }, {
2189
- kty: "EC";
2190
- crv: "P-256" | "P-384" | "P-521";
2191
- x: string;
2192
- y: string;
2193
- }>]>;
2194
- }, "strip", z.ZodTypeAny, {
2195
- deviceKey: {
2196
- kty: "EC";
2197
- crv: "P-256" | "P-384" | "P-521";
2198
- x: string;
2199
- y: string;
2200
- } | {
2201
- kty: "RSA";
2202
- alg: string;
2203
- e: string;
2204
- n: string;
2205
- };
2206
- }, {
2207
- deviceKey: {
2208
- kty: "EC";
2209
- crv: "P-256" | "P-384" | "P-521";
2210
- x: string;
2211
- y: string;
2212
- } | {
2213
- kty: "RSA";
2214
- alg: string;
2215
- e: string;
2216
- n: string;
2217
- };
2218
- }>;
428
+ }, z.core.$strip>]>;
429
+ }, z.core.$strip>;
2219
430
  valueDigests: z.ZodRecord<z.ZodString, z.ZodAny>;
2220
- }, "strip", z.ZodTypeAny, {
2221
- validityInfo: {
2222
- signed: Date;
2223
- validUntil: Date;
2224
- validFrom: Date;
2225
- expectedUpdate?: Date | undefined;
2226
- };
2227
- deviceKeyInfo: {
2228
- deviceKey: {
2229
- kty: "EC";
2230
- crv: "P-256" | "P-384" | "P-521";
2231
- x: string;
2232
- y: string;
2233
- } | {
2234
- kty: "RSA";
2235
- alg: string;
2236
- e: string;
2237
- n: string;
2238
- };
2239
- };
2240
- valueDigests: Record<string, any>;
2241
- docType?: string | undefined;
2242
- version?: string | undefined;
2243
- digestAlgorithm?: string | undefined;
2244
- }, {
2245
- validityInfo: {
2246
- signed: Date;
2247
- validUntil: Date;
2248
- validFrom: Date;
2249
- expectedUpdate?: Date | undefined;
2250
- };
2251
- deviceKeyInfo: {
2252
- deviceKey: {
2253
- kty: "EC";
2254
- crv: "P-256" | "P-384" | "P-521";
2255
- x: string;
2256
- y: string;
2257
- } | {
2258
- kty: "RSA";
2259
- alg: string;
2260
- e: string;
2261
- n: string;
2262
- };
2263
- };
2264
- valueDigests: Record<string, any>;
2265
- docType?: string | undefined;
2266
- version?: string | undefined;
2267
- digestAlgorithm?: string | undefined;
2268
- }>;
431
+ }, z.core.$strip>;
2269
432
  signature: z.ZodOptional<z.ZodString>;
2270
- }, "strip", z.ZodTypeAny, {
2271
- unprotectedHeader: {
2272
- algorithm?: string | undefined;
2273
- kid?: string | undefined;
2274
- x5chain?: string[] | undefined;
2275
- };
2276
- payload: {
2277
- validityInfo: {
2278
- signed: Date;
2279
- validUntil: Date;
2280
- validFrom: Date;
2281
- expectedUpdate?: Date | undefined;
2282
- };
2283
- deviceKeyInfo: {
2284
- deviceKey: {
2285
- kty: "EC";
2286
- crv: "P-256" | "P-384" | "P-521";
2287
- x: string;
2288
- y: string;
2289
- } | {
2290
- kty: "RSA";
2291
- alg: string;
2292
- e: string;
2293
- n: string;
2294
- };
2295
- };
2296
- valueDigests: Record<string, any>;
2297
- docType?: string | undefined;
2298
- version?: string | undefined;
2299
- digestAlgorithm?: string | undefined;
2300
- };
2301
- rawValue?: string | undefined;
2302
- protectedHeader?: string | undefined;
2303
- signature?: string | undefined;
2304
- }, {
2305
- unprotectedHeader: {
2306
- algorithm?: string | undefined;
2307
- kid?: string | undefined;
2308
- x5chain?: string[] | undefined;
2309
- };
2310
- payload: {
2311
- validityInfo: {
2312
- signed: Date;
2313
- validUntil: Date;
2314
- validFrom: Date;
2315
- expectedUpdate?: Date | undefined;
2316
- };
2317
- deviceKeyInfo: {
2318
- deviceKey: {
2319
- kty: "EC";
2320
- crv: "P-256" | "P-384" | "P-521";
2321
- x: string;
2322
- y: string;
2323
- } | {
2324
- kty: "RSA";
2325
- alg: string;
2326
- e: string;
2327
- n: string;
2328
- };
2329
- };
2330
- valueDigests: Record<string, any>;
2331
- docType?: string | undefined;
2332
- version?: string | undefined;
2333
- digestAlgorithm?: string | undefined;
2334
- };
2335
- rawValue?: string | undefined;
2336
- protectedHeader?: string | undefined;
2337
- signature?: string | undefined;
2338
- }>;
2339
- }, "strip", z.ZodTypeAny, {
2340
- nameSpaces: Record<string, {
2341
- elementIdentifier: string;
2342
- digestID?: number | undefined;
2343
- random?: string | undefined;
2344
- elementValue?: any;
2345
- }[]>;
2346
- issuerAuth: {
2347
- unprotectedHeader: {
2348
- algorithm?: string | undefined;
2349
- kid?: string | undefined;
2350
- x5chain?: string[] | undefined;
2351
- };
2352
- payload: {
2353
- validityInfo: {
2354
- signed: Date;
2355
- validUntil: Date;
2356
- validFrom: Date;
2357
- expectedUpdate?: Date | undefined;
2358
- };
2359
- deviceKeyInfo: {
2360
- deviceKey: {
2361
- kty: "EC";
2362
- crv: "P-256" | "P-384" | "P-521";
2363
- x: string;
2364
- y: string;
2365
- } | {
2366
- kty: "RSA";
2367
- alg: string;
2368
- e: string;
2369
- n: string;
2370
- };
2371
- };
2372
- valueDigests: Record<string, any>;
2373
- docType?: string | undefined;
2374
- version?: string | undefined;
2375
- digestAlgorithm?: string | undefined;
2376
- };
2377
- rawValue?: string | undefined;
2378
- protectedHeader?: string | undefined;
2379
- signature?: string | undefined;
2380
- };
2381
- }, {
2382
- nameSpaces: Record<string, any>;
2383
- issuerAuth: {
2384
- unprotectedHeader: {
2385
- algorithm?: string | undefined;
2386
- kid?: string | undefined;
2387
- x5chain?: string[] | undefined;
2388
- };
2389
- payload: {
2390
- validityInfo: {
2391
- signed: Date;
2392
- validUntil: Date;
2393
- validFrom: Date;
2394
- expectedUpdate?: Date | undefined;
2395
- };
2396
- deviceKeyInfo: {
2397
- deviceKey: {
2398
- kty: "EC";
2399
- crv: "P-256" | "P-384" | "P-521";
2400
- x: string;
2401
- y: string;
2402
- } | {
2403
- kty: "RSA";
2404
- alg: string;
2405
- e: string;
2406
- n: string;
2407
- };
2408
- };
2409
- valueDigests: Record<string, any>;
2410
- docType?: string | undefined;
2411
- version?: string | undefined;
2412
- digestAlgorithm?: string | undefined;
2413
- };
2414
- rawValue?: string | undefined;
2415
- protectedHeader?: string | undefined;
2416
- signature?: string | undefined;
2417
- };
2418
- }>>;
433
+ }, z.core.$strip>;
434
+ }, z.core.$strip>>;
2419
435
  export type Documents = z.infer<typeof Documents>;
2420
436
  //# sourceMappingURL=schema.d.ts.map