@sphereon/ssi-sdk.pd-manager 0.34.1-feature.FIDES.1.274 → 0.34.1-feature.IDK.11.48

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 (11) hide show
  1. package/dist/index.cjs +1091 -1092
  2. package/dist/index.cjs.map +1 -1
  3. package/dist/index.d.cts +25 -2151
  4. package/dist/index.d.ts +25 -2151
  5. package/dist/index.js +1084 -1084
  6. package/dist/index.js.map +1 -1
  7. package/package.json +5 -8
  8. package/plugin.schema.json +26 -20
  9. package/src/agent/PDManager.ts +89 -107
  10. package/src/index.ts +2 -4
  11. package/src/types/IPDManager.ts +18 -17
package/dist/index.cjs CHANGED
@@ -6,6 +6,9 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
6
6
  var __getProtoOf = Object.getPrototypeOf;
7
7
  var __hasOwnProp = Object.prototype.hasOwnProperty;
8
8
  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
9
+ var __commonJS = (cb, mod) => function __require() {
10
+ return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
11
+ };
9
12
  var __export = (target, all) => {
10
13
  for (var name in all)
11
14
  __defProp(target, name, { get: all[name], enumerable: true });
@@ -28,1041 +31,1052 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
28
31
  ));
29
32
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
30
33
 
31
- // src/index.ts
32
- var index_exports = {};
33
- __export(index_exports, {
34
- PDManager: () => PDManager,
35
- pdManagerMethods: () => pdManagerMethods,
36
- schema: () => plugin_schema_default
37
- });
38
- module.exports = __toCommonJS(index_exports);
39
-
40
34
  // plugin.schema.json
41
- var plugin_schema_default = {
42
- IPDManager: {
43
- components: {
44
- schemas: {
45
- DeleteDefinitionItemArgs: {
46
- type: "object",
47
- properties: {
48
- itemId: {
49
- type: "string"
50
- }
51
- },
52
- required: ["itemId"],
53
- additionalProperties: false
54
- },
55
- DeleteDefinitionItemsArgs: {
56
- $ref: "#/components/schemas/GetDefinitionItemsArgs"
57
- },
58
- GetDefinitionItemsArgs: {
59
- type: "object",
60
- properties: {
61
- filter: {
62
- $ref: "#/components/schemas/FindDefinitionArgs"
63
- },
64
- opts: {
65
- $ref: "#/components/schemas/FetchOptions"
66
- }
67
- },
68
- additionalProperties: false
69
- },
70
- FindDefinitionArgs: {
71
- type: "array",
72
- items: {
73
- $ref: "#/components/schemas/PresentationDefinitionItemFilter"
74
- }
75
- },
76
- PresentationDefinitionItemFilter: {
77
- $ref: '#/components/schemas/Partial<Omit<PresentationDefinitionItem,("queryPayload"|"dcqlPayload")>>'
78
- },
79
- 'Partial<Omit<PresentationDefinitionItem,("queryPayload"|"dcqlPayload")>>': {
80
- type: "object",
81
- properties: {
82
- id: {
83
- type: "string"
84
- },
85
- queryId: {
86
- type: "string"
87
- },
88
- tenantId: {
89
- type: "string"
90
- },
91
- version: {
92
- type: "string"
93
- },
94
- name: {
95
- type: "string"
96
- },
97
- purpose: {
98
- type: "string"
99
- },
100
- createdAt: {
101
- type: "string",
102
- format: "date-time"
103
- },
104
- lastUpdatedAt: {
105
- type: "string",
106
- format: "date-time"
107
- }
108
- },
109
- additionalProperties: false
110
- },
111
- FetchOptions: {
112
- type: "object",
113
- properties: {
114
- showVersionHistory: {
115
- type: "boolean"
116
- }
117
- },
118
- additionalProperties: false
119
- },
120
- GetDefinitionItemArgs: {
121
- type: "object",
122
- properties: {
123
- itemId: {
124
- type: "string"
125
- }
126
- },
127
- required: ["itemId"],
128
- additionalProperties: false
129
- },
130
- PresentationDefinitionItem: {
131
- type: "object",
132
- properties: {
133
- id: {
134
- type: "string"
135
- },
136
- queryId: {
137
- type: "string"
138
- },
139
- tenantId: {
140
- type: "string"
141
- },
142
- version: {
143
- type: "string"
144
- },
145
- name: {
146
- type: "string"
147
- },
148
- purpose: {
149
- type: "string"
150
- },
151
- dcqlPayload: {
152
- $ref: "#/components/schemas/DcqlQuery"
153
- },
154
- createdAt: {
155
- type: "string",
156
- format: "date-time"
157
- },
158
- lastUpdatedAt: {
159
- type: "string",
160
- format: "date-time"
161
- }
162
- },
163
- required: ["id", "queryId", "version", "query", "createdAt", "lastUpdatedAt"],
164
- additionalProperties: false
165
- },
166
- IPresentationDefinition: {
167
- anyOf: [
168
- {
169
- $ref: "#/components/schemas/PresentationDefinitionV1"
170
- },
171
- {
172
- $ref: "#/components/schemas/PresentationDefinitionV2"
173
- }
174
- ]
175
- },
176
- PresentationDefinitionV1: {
177
- type: "object",
178
- properties: {
179
- id: {
180
- type: "string"
181
- },
182
- name: {
183
- type: "string"
184
- },
185
- purpose: {
186
- type: "string"
187
- },
188
- format: {
189
- $ref: "#/components/schemas/Format"
190
- },
191
- submission_requirements: {
192
- type: "array",
193
- items: {
194
- $ref: "#/components/schemas/SubmissionRequirement"
195
- }
196
- },
197
- input_descriptors: {
198
- type: "array",
199
- items: {
200
- $ref: "#/components/schemas/InputDescriptorV1"
201
- }
202
- }
203
- },
204
- required: ["id", "input_descriptors"],
205
- additionalProperties: false
206
- },
207
- Format: {
208
- type: "object",
209
- properties: {
210
- jwt: {
211
- $ref: "#/components/schemas/JwtObject"
212
- },
213
- jwt_vc: {
214
- $ref: "#/components/schemas/JwtObject"
215
- },
216
- jwt_vc_json: {
217
- $ref: "#/components/schemas/JwtObject"
218
- },
219
- jwt_vp: {
220
- $ref: "#/components/schemas/JwtObject"
221
- },
222
- jwt_vp_json: {
223
- $ref: "#/components/schemas/JwtObject"
224
- },
225
- ldp: {
226
- $ref: "#/components/schemas/LdpObject"
227
- },
228
- ldp_vc: {
229
- $ref: "#/components/schemas/LdpObject"
230
- },
231
- ldp_vp: {
232
- $ref: "#/components/schemas/LdpObject"
233
- },
234
- di: {
235
- $ref: "#/components/schemas/DiObject"
236
- },
237
- di_vc: {
238
- $ref: "#/components/schemas/DiObject"
239
- },
240
- di_vp: {
241
- $ref: "#/components/schemas/DiObject"
242
- },
243
- "dc+sd-jwt": {
244
- $ref: "#/components/schemas/SdJwtObject"
245
- },
246
- mso_mdoc: {
247
- $ref: "#/components/schemas/MsoMdocObject"
248
- }
249
- },
250
- additionalProperties: false
251
- },
252
- JwtObject: {
253
- type: "object",
254
- properties: {
255
- alg: {
256
- type: "array",
257
- items: {
258
- type: "string"
259
- }
260
- }
261
- },
262
- required: ["alg"],
263
- additionalProperties: false
264
- },
265
- LdpObject: {
266
- type: "object",
267
- properties: {
268
- proof_type: {
269
- type: "array",
270
- items: {
271
- type: "string"
272
- }
273
- }
274
- },
275
- required: ["proof_type"],
276
- additionalProperties: false
277
- },
278
- DiObject: {
279
- type: "object",
280
- properties: {
281
- proof_type: {
282
- type: "array",
283
- items: {
284
- type: "string"
285
- }
286
- },
287
- cryptosuite: {
288
- type: "array",
289
- items: {
290
- type: "string"
291
- }
292
- }
293
- },
294
- required: ["proof_type", "cryptosuite"],
295
- additionalProperties: false
296
- },
297
- SdJwtObject: {
298
- type: "object",
299
- properties: {
300
- "sd-jwt_alg_values": {
301
- type: "array",
302
- items: {
303
- type: "string"
304
- }
305
- },
306
- "kb-jwt_alg_values": {
307
- type: "array",
308
- items: {
309
- type: "string"
310
- }
311
- }
312
- },
313
- additionalProperties: false
314
- },
315
- MsoMdocObject: {
316
- type: "object",
317
- properties: {
318
- alg: {
319
- type: "array",
320
- items: {
321
- type: "string"
322
- }
323
- }
324
- },
325
- required: ["alg"],
326
- additionalProperties: false
327
- },
328
- SubmissionRequirement: {
329
- type: "object",
330
- properties: {
331
- name: {
332
- type: "string"
333
- },
334
- purpose: {
335
- type: "string"
336
- },
337
- rule: {
338
- $ref: "#/components/schemas/Rules"
339
- },
340
- count: {
341
- type: "number"
342
- },
343
- min: {
344
- type: "number"
345
- },
346
- max: {
347
- type: "number"
348
- },
349
- from: {
350
- type: "string"
351
- },
352
- from_nested: {
353
- type: "array",
354
- items: {
355
- $ref: "#/components/schemas/SubmissionRequirement"
356
- }
357
- }
358
- },
359
- required: ["rule"],
360
- additionalProperties: false
361
- },
362
- Rules: {
363
- type: "string",
364
- enum: ["all", "pick"]
365
- },
366
- InputDescriptorV1: {
367
- type: "object",
368
- properties: {
369
- id: {
370
- type: "string"
371
- },
372
- name: {
373
- type: "string"
374
- },
375
- purpose: {
376
- type: "string"
377
- },
378
- group: {
379
- type: "array",
380
- items: {
381
- type: "string"
382
- }
383
- },
384
- schema: {
385
- type: "array",
386
- items: {
387
- $ref: "#/components/schemas/Schema"
388
- }
389
- },
390
- issuance: {
391
- type: "array",
392
- items: {
393
- $ref: "#/components/schemas/Issuance"
394
- }
395
- },
396
- constraints: {
397
- $ref: "#/components/schemas/ConstraintsV1"
398
- }
399
- },
400
- required: ["id", "schema"],
401
- additionalProperties: false
402
- },
403
- Schema: {
404
- type: "object",
405
- properties: {
406
- uri: {
407
- type: "string"
408
- },
409
- required: {
410
- type: "boolean"
411
- }
412
- },
413
- required: ["uri"],
414
- additionalProperties: false
415
- },
416
- Issuance: {
417
- type: "object",
418
- properties: {
419
- manifest: {
420
- type: "string"
421
- }
422
- },
423
- additionalProperties: {}
424
- },
425
- ConstraintsV1: {
426
- type: "object",
427
- properties: {
428
- limit_disclosure: {
429
- $ref: "#/components/schemas/Optionality"
430
- },
431
- statuses: {
432
- $ref: "#/components/schemas/Statuses"
433
- },
434
- fields: {
435
- type: "array",
436
- items: {
437
- $ref: "#/components/schemas/FieldV1"
438
- }
439
- },
440
- subject_is_issuer: {
441
- $ref: "#/components/schemas/Optionality"
442
- },
443
- is_holder: {
444
- type: "array",
445
- items: {
446
- $ref: "#/components/schemas/HolderSubject"
447
- }
448
- },
449
- same_subject: {
450
- type: "array",
451
- items: {
452
- $ref: "#/components/schemas/HolderSubject"
453
- }
454
- }
455
- },
456
- additionalProperties: false
457
- },
458
- Optionality: {
459
- type: "string",
460
- enum: ["required", "preferred"]
461
- },
462
- Statuses: {
463
- type: "object",
464
- properties: {
465
- active: {
466
- $ref: "#/components/schemas/PdStatus"
467
- },
468
- suspended: {
469
- $ref: "#/components/schemas/PdStatus"
470
- },
471
- revoked: {
472
- $ref: "#/components/schemas/PdStatus"
473
- }
474
- },
475
- additionalProperties: false
476
- },
477
- PdStatus: {
478
- type: "object",
479
- properties: {
480
- directive: {
481
- $ref: "#/components/schemas/Directives"
482
- }
483
- },
484
- additionalProperties: false
485
- },
486
- Directives: {
487
- type: "string",
488
- enum: ["required", "allowed", "disallowed"]
489
- },
490
- FieldV1: {
491
- type: "object",
492
- properties: {
493
- id: {
494
- type: "string"
495
- },
496
- path: {
35
+ var require_plugin_schema = __commonJS({
36
+ "plugin.schema.json"(exports, module2) {
37
+ module2.exports = {
38
+ IPDManager: {
39
+ components: {
40
+ schemas: {
41
+ DeleteDefinitionItemArgs: {
42
+ type: "object",
43
+ properties: {
44
+ itemId: {
45
+ type: "string"
46
+ }
47
+ },
48
+ required: ["itemId"],
49
+ additionalProperties: false
50
+ },
51
+ DeleteDefinitionItemsArgs: {
52
+ $ref: "#/components/schemas/GetDefinitionItemsArgs"
53
+ },
54
+ GetDefinitionItemsArgs: {
55
+ type: "object",
56
+ properties: {
57
+ filter: {
58
+ $ref: "#/components/schemas/FindDefinitionArgs"
59
+ },
60
+ opts: {
61
+ $ref: "#/components/schemas/FetchOptions"
62
+ }
63
+ },
64
+ additionalProperties: false
65
+ },
66
+ FindDefinitionArgs: {
497
67
  type: "array",
498
68
  items: {
499
- type: "string"
69
+ $ref: "#/components/schemas/PresentationDefinitionItemFilter"
500
70
  }
501
71
  },
502
- purpose: {
503
- type: "string"
504
- },
505
- filter: {
506
- $ref: "#/components/schemas/FilterV1"
507
- },
508
- predicate: {
509
- $ref: "#/components/schemas/Optionality"
510
- }
511
- },
512
- required: ["path"],
513
- additionalProperties: false
514
- },
515
- FilterV1: {
516
- type: "object",
517
- properties: {
518
- const: {
519
- $ref: "#/components/schemas/OneOfNumberStringBoolean"
520
- },
521
- enum: {
522
- type: "array",
523
- items: {
524
- $ref: "#/components/schemas/OneOfNumberStringBoolean"
525
- }
526
- },
527
- exclusiveMinimum: {
528
- $ref: "#/components/schemas/OneOfNumberString"
529
- },
530
- exclusiveMaximum: {
531
- $ref: "#/components/schemas/OneOfNumberString"
532
- },
533
- format: {
534
- type: "string"
535
- },
536
- minLength: {
537
- type: "number"
538
- },
539
- maxLength: {
540
- type: "number"
541
- },
542
- minimum: {
543
- $ref: "#/components/schemas/OneOfNumberString"
544
- },
545
- maximum: {
546
- $ref: "#/components/schemas/OneOfNumberString"
547
- },
548
- not: {
549
- type: "object"
550
- },
551
- pattern: {
552
- type: "string"
553
- },
554
- type: {
555
- type: "string"
556
- }
557
- },
558
- additionalProperties: false
559
- },
560
- OneOfNumberStringBoolean: {
561
- type: ["boolean", "number", "string"]
562
- },
563
- OneOfNumberString: {
564
- type: ["number", "string"]
565
- },
566
- HolderSubject: {
567
- type: "object",
568
- properties: {
569
- field_id: {
570
- type: "array",
571
- items: {
572
- type: "string"
573
- }
574
- },
575
- directive: {
576
- $ref: "#/components/schemas/Optionality"
577
- }
578
- },
579
- required: ["field_id", "directive"],
580
- additionalProperties: false
581
- },
582
- PresentationDefinitionV2: {
583
- type: "object",
584
- properties: {
585
- id: {
586
- type: "string"
587
- },
588
- name: {
589
- type: "string"
590
- },
591
- purpose: {
592
- type: "string"
593
- },
594
- format: {
595
- $ref: "#/components/schemas/Format"
596
- },
597
- submission_requirements: {
598
- type: "array",
599
- items: {
600
- $ref: "#/components/schemas/SubmissionRequirement"
601
- }
602
- },
603
- input_descriptors: {
604
- type: "array",
605
- items: {
606
- $ref: "#/components/schemas/InputDescriptorV2"
607
- }
608
- },
609
- frame: {
72
+ PresentationDefinitionItemFilter: {
73
+ $ref: '#/components/schemas/Partial<Omit<PresentationDefinitionItem,("definitionPayload"|"dcqlPayload")>>'
74
+ },
75
+ 'Partial<Omit<PresentationDefinitionItem,("definitionPayload"|"dcqlPayload")>>': {
76
+ type: "object",
77
+ properties: {
78
+ id: {
79
+ type: "string"
80
+ },
81
+ definitionId: {
82
+ type: "string"
83
+ },
84
+ tenantId: {
85
+ type: "string"
86
+ },
87
+ version: {
88
+ type: "string"
89
+ },
90
+ name: {
91
+ type: "string"
92
+ },
93
+ purpose: {
94
+ type: "string"
95
+ },
96
+ createdAt: {
97
+ type: "string",
98
+ format: "date-time"
99
+ },
100
+ lastUpdatedAt: {
101
+ type: "string",
102
+ format: "date-time"
103
+ }
104
+ },
105
+ additionalProperties: false
106
+ },
107
+ FetchOptions: {
108
+ type: "object",
109
+ properties: {
110
+ showVersionHistory: {
111
+ type: "boolean"
112
+ }
113
+ },
114
+ additionalProperties: false
115
+ },
116
+ GetDefinitionItemArgs: {
117
+ type: "object",
118
+ properties: {
119
+ itemId: {
120
+ type: "string"
121
+ }
122
+ },
123
+ required: ["itemId"],
124
+ additionalProperties: false
125
+ },
126
+ PresentationDefinitionItem: {
127
+ type: "object",
128
+ properties: {
129
+ id: {
130
+ type: "string"
131
+ },
132
+ definitionId: {
133
+ type: "string"
134
+ },
135
+ tenantId: {
136
+ type: "string"
137
+ },
138
+ version: {
139
+ type: "string"
140
+ },
141
+ name: {
142
+ type: "string"
143
+ },
144
+ purpose: {
145
+ type: "string"
146
+ },
147
+ definitionPayload: {
148
+ $ref: "#/components/schemas/IPresentationDefinition"
149
+ },
150
+ dcqlPayload: {
151
+ $ref: "#/components/schemas/DcqlQueryREST"
152
+ },
153
+ createdAt: {
154
+ type: "string",
155
+ format: "date-time"
156
+ },
157
+ lastUpdatedAt: {
158
+ type: "string",
159
+ format: "date-time"
160
+ }
161
+ },
162
+ required: ["id", "definitionId", "version", "definitionPayload", "createdAt", "lastUpdatedAt"],
163
+ additionalProperties: false
164
+ },
165
+ IPresentationDefinition: {
166
+ anyOf: [
167
+ {
168
+ $ref: "#/components/schemas/PresentationDefinitionV1"
169
+ },
170
+ {
171
+ $ref: "#/components/schemas/PresentationDefinitionV2"
172
+ }
173
+ ]
174
+ },
175
+ PresentationDefinitionV1: {
176
+ type: "object",
177
+ properties: {
178
+ id: {
179
+ type: "string"
180
+ },
181
+ name: {
182
+ type: "string"
183
+ },
184
+ purpose: {
185
+ type: "string"
186
+ },
187
+ format: {
188
+ $ref: "#/components/schemas/Format"
189
+ },
190
+ submission_requirements: {
191
+ type: "array",
192
+ items: {
193
+ $ref: "#/components/schemas/SubmissionRequirement"
194
+ }
195
+ },
196
+ input_descriptors: {
197
+ type: "array",
198
+ items: {
199
+ $ref: "#/components/schemas/InputDescriptorV1"
200
+ }
201
+ }
202
+ },
203
+ required: ["id", "input_descriptors"],
204
+ additionalProperties: false
205
+ },
206
+ Format: {
207
+ type: "object",
208
+ properties: {
209
+ jwt: {
210
+ $ref: "#/components/schemas/JwtObject"
211
+ },
212
+ jwt_vc: {
213
+ $ref: "#/components/schemas/JwtObject"
214
+ },
215
+ jwt_vc_json: {
216
+ $ref: "#/components/schemas/JwtObject"
217
+ },
218
+ jwt_vp: {
219
+ $ref: "#/components/schemas/JwtObject"
220
+ },
221
+ jwt_vp_json: {
222
+ $ref: "#/components/schemas/JwtObject"
223
+ },
224
+ ldp: {
225
+ $ref: "#/components/schemas/LdpObject"
226
+ },
227
+ ldp_vc: {
228
+ $ref: "#/components/schemas/LdpObject"
229
+ },
230
+ ldp_vp: {
231
+ $ref: "#/components/schemas/LdpObject"
232
+ },
233
+ di: {
234
+ $ref: "#/components/schemas/DiObject"
235
+ },
236
+ di_vc: {
237
+ $ref: "#/components/schemas/DiObject"
238
+ },
239
+ di_vp: {
240
+ $ref: "#/components/schemas/DiObject"
241
+ },
242
+ "vc+sd-jwt": {
243
+ $ref: "#/components/schemas/SdJwtObject"
244
+ },
245
+ mso_mdoc: {
246
+ $ref: "#/components/schemas/MsoMdocObject"
247
+ }
248
+ },
249
+ additionalProperties: false
250
+ },
251
+ JwtObject: {
252
+ type: "object",
253
+ properties: {
254
+ alg: {
255
+ type: "array",
256
+ items: {
257
+ type: "string"
258
+ }
259
+ }
260
+ },
261
+ required: ["alg"],
262
+ additionalProperties: false
263
+ },
264
+ LdpObject: {
265
+ type: "object",
266
+ properties: {
267
+ proof_type: {
268
+ type: "array",
269
+ items: {
270
+ type: "string"
271
+ }
272
+ }
273
+ },
274
+ required: ["proof_type"],
275
+ additionalProperties: false
276
+ },
277
+ DiObject: {
278
+ type: "object",
279
+ properties: {
280
+ proof_type: {
281
+ type: "array",
282
+ items: {
283
+ type: "string"
284
+ }
285
+ },
286
+ cryptosuite: {
287
+ type: "array",
288
+ items: {
289
+ type: "string"
290
+ }
291
+ }
292
+ },
293
+ required: ["proof_type", "cryptosuite"],
294
+ additionalProperties: false
295
+ },
296
+ SdJwtObject: {
297
+ type: "object",
298
+ properties: {
299
+ "sd-jwt_alg_values": {
300
+ type: "array",
301
+ items: {
302
+ type: "string"
303
+ }
304
+ },
305
+ "kb-jwt_alg_values": {
306
+ type: "array",
307
+ items: {
308
+ type: "string"
309
+ }
310
+ }
311
+ },
312
+ additionalProperties: false
313
+ },
314
+ MsoMdocObject: {
315
+ type: "object",
316
+ properties: {
317
+ alg: {
318
+ type: "array",
319
+ items: {
320
+ type: "string"
321
+ }
322
+ }
323
+ },
324
+ required: ["alg"],
325
+ additionalProperties: false
326
+ },
327
+ SubmissionRequirement: {
328
+ type: "object",
329
+ properties: {
330
+ name: {
331
+ type: "string"
332
+ },
333
+ purpose: {
334
+ type: "string"
335
+ },
336
+ rule: {
337
+ $ref: "#/components/schemas/Rules"
338
+ },
339
+ count: {
340
+ type: "number"
341
+ },
342
+ min: {
343
+ type: "number"
344
+ },
345
+ max: {
346
+ type: "number"
347
+ },
348
+ from: {
349
+ type: "string"
350
+ },
351
+ from_nested: {
352
+ type: "array",
353
+ items: {
354
+ $ref: "#/components/schemas/SubmissionRequirement"
355
+ }
356
+ }
357
+ },
358
+ required: ["rule"],
359
+ additionalProperties: false
360
+ },
361
+ Rules: {
362
+ type: "string",
363
+ enum: ["all", "pick"]
364
+ },
365
+ InputDescriptorV1: {
366
+ type: "object",
367
+ properties: {
368
+ id: {
369
+ type: "string"
370
+ },
371
+ name: {
372
+ type: "string"
373
+ },
374
+ purpose: {
375
+ type: "string"
376
+ },
377
+ group: {
378
+ type: "array",
379
+ items: {
380
+ type: "string"
381
+ }
382
+ },
383
+ schema: {
384
+ type: "array",
385
+ items: {
386
+ $ref: "#/components/schemas/Schema"
387
+ }
388
+ },
389
+ issuance: {
390
+ type: "array",
391
+ items: {
392
+ $ref: "#/components/schemas/Issuance"
393
+ }
394
+ },
395
+ constraints: {
396
+ $ref: "#/components/schemas/ConstraintsV1"
397
+ }
398
+ },
399
+ required: ["id", "schema"],
400
+ additionalProperties: false
401
+ },
402
+ Schema: {
403
+ type: "object",
404
+ properties: {
405
+ uri: {
406
+ type: "string"
407
+ },
408
+ required: {
409
+ type: "boolean"
410
+ }
411
+ },
412
+ required: ["uri"],
413
+ additionalProperties: false
414
+ },
415
+ Issuance: {
416
+ type: "object",
417
+ properties: {
418
+ manifest: {
419
+ type: "string"
420
+ }
421
+ },
422
+ additionalProperties: {}
423
+ },
424
+ ConstraintsV1: {
425
+ type: "object",
426
+ properties: {
427
+ limit_disclosure: {
428
+ $ref: "#/components/schemas/Optionality"
429
+ },
430
+ statuses: {
431
+ $ref: "#/components/schemas/Statuses"
432
+ },
433
+ fields: {
434
+ type: "array",
435
+ items: {
436
+ $ref: "#/components/schemas/FieldV1"
437
+ }
438
+ },
439
+ subject_is_issuer: {
440
+ $ref: "#/components/schemas/Optionality"
441
+ },
442
+ is_holder: {
443
+ type: "array",
444
+ items: {
445
+ $ref: "#/components/schemas/HolderSubject"
446
+ }
447
+ },
448
+ same_subject: {
449
+ type: "array",
450
+ items: {
451
+ $ref: "#/components/schemas/HolderSubject"
452
+ }
453
+ }
454
+ },
455
+ additionalProperties: false
456
+ },
457
+ Optionality: {
458
+ type: "string",
459
+ enum: ["required", "preferred"]
460
+ },
461
+ Statuses: {
462
+ type: "object",
463
+ properties: {
464
+ active: {
465
+ $ref: "#/components/schemas/PdStatus"
466
+ },
467
+ suspended: {
468
+ $ref: "#/components/schemas/PdStatus"
469
+ },
470
+ revoked: {
471
+ $ref: "#/components/schemas/PdStatus"
472
+ }
473
+ },
474
+ additionalProperties: false
475
+ },
476
+ PdStatus: {
477
+ type: "object",
478
+ properties: {
479
+ directive: {
480
+ $ref: "#/components/schemas/Directives"
481
+ }
482
+ },
483
+ additionalProperties: false
484
+ },
485
+ Directives: {
486
+ type: "string",
487
+ enum: ["required", "allowed", "disallowed"]
488
+ },
489
+ FieldV1: {
490
+ type: "object",
491
+ properties: {
492
+ id: {
493
+ type: "string"
494
+ },
495
+ path: {
496
+ type: "array",
497
+ items: {
498
+ type: "string"
499
+ }
500
+ },
501
+ purpose: {
502
+ type: "string"
503
+ },
504
+ filter: {
505
+ $ref: "#/components/schemas/FilterV1"
506
+ },
507
+ predicate: {
508
+ $ref: "#/components/schemas/Optionality"
509
+ }
510
+ },
511
+ required: ["path"],
512
+ additionalProperties: false
513
+ },
514
+ FilterV1: {
515
+ type: "object",
516
+ properties: {
517
+ const: {
518
+ $ref: "#/components/schemas/OneOfNumberStringBoolean"
519
+ },
520
+ enum: {
521
+ type: "array",
522
+ items: {
523
+ $ref: "#/components/schemas/OneOfNumberStringBoolean"
524
+ }
525
+ },
526
+ exclusiveMinimum: {
527
+ $ref: "#/components/schemas/OneOfNumberString"
528
+ },
529
+ exclusiveMaximum: {
530
+ $ref: "#/components/schemas/OneOfNumberString"
531
+ },
532
+ format: {
533
+ type: "string"
534
+ },
535
+ minLength: {
536
+ type: "number"
537
+ },
538
+ maxLength: {
539
+ type: "number"
540
+ },
541
+ minimum: {
542
+ $ref: "#/components/schemas/OneOfNumberString"
543
+ },
544
+ maximum: {
545
+ $ref: "#/components/schemas/OneOfNumberString"
546
+ },
547
+ not: {
548
+ type: "object"
549
+ },
550
+ pattern: {
551
+ type: "string"
552
+ },
553
+ type: {
554
+ type: "string"
555
+ }
556
+ },
557
+ additionalProperties: false
558
+ },
559
+ OneOfNumberStringBoolean: {
560
+ type: ["boolean", "number", "string"]
561
+ },
562
+ OneOfNumberString: {
563
+ type: ["number", "string"]
564
+ },
565
+ HolderSubject: {
566
+ type: "object",
567
+ properties: {
568
+ field_id: {
569
+ type: "array",
570
+ items: {
571
+ type: "string"
572
+ }
573
+ },
574
+ directive: {
575
+ $ref: "#/components/schemas/Optionality"
576
+ }
577
+ },
578
+ required: ["field_id", "directive"],
579
+ additionalProperties: false
580
+ },
581
+ PresentationDefinitionV2: {
582
+ type: "object",
583
+ properties: {
584
+ id: {
585
+ type: "string"
586
+ },
587
+ name: {
588
+ type: "string"
589
+ },
590
+ purpose: {
591
+ type: "string"
592
+ },
593
+ format: {
594
+ $ref: "#/components/schemas/Format"
595
+ },
596
+ submission_requirements: {
597
+ type: "array",
598
+ items: {
599
+ $ref: "#/components/schemas/SubmissionRequirement"
600
+ }
601
+ },
602
+ input_descriptors: {
603
+ type: "array",
604
+ items: {
605
+ $ref: "#/components/schemas/InputDescriptorV2"
606
+ }
607
+ },
608
+ frame: {
609
+ type: "object"
610
+ }
611
+ },
612
+ required: ["id", "input_descriptors"],
613
+ additionalProperties: false
614
+ },
615
+ InputDescriptorV2: {
616
+ type: "object",
617
+ properties: {
618
+ id: {
619
+ type: "string"
620
+ },
621
+ name: {
622
+ type: "string"
623
+ },
624
+ purpose: {
625
+ type: "string"
626
+ },
627
+ format: {
628
+ $ref: "#/components/schemas/Format"
629
+ },
630
+ group: {
631
+ type: "array",
632
+ items: {
633
+ type: "string"
634
+ }
635
+ },
636
+ issuance: {
637
+ type: "array",
638
+ items: {
639
+ $ref: "#/components/schemas/Issuance"
640
+ }
641
+ },
642
+ constraints: {
643
+ $ref: "#/components/schemas/ConstraintsV2"
644
+ }
645
+ },
646
+ required: ["id", "constraints"],
647
+ additionalProperties: false
648
+ },
649
+ ConstraintsV2: {
650
+ type: "object",
651
+ properties: {
652
+ limit_disclosure: {
653
+ $ref: "#/components/schemas/Optionality"
654
+ },
655
+ statuses: {
656
+ $ref: "#/components/schemas/Statuses"
657
+ },
658
+ fields: {
659
+ type: "array",
660
+ items: {
661
+ $ref: "#/components/schemas/FieldV2"
662
+ }
663
+ },
664
+ subject_is_issuer: {
665
+ $ref: "#/components/schemas/Optionality"
666
+ },
667
+ is_holder: {
668
+ type: "array",
669
+ items: {
670
+ $ref: "#/components/schemas/HolderSubject"
671
+ }
672
+ },
673
+ same_subject: {
674
+ type: "array",
675
+ items: {
676
+ $ref: "#/components/schemas/HolderSubject"
677
+ }
678
+ }
679
+ },
680
+ additionalProperties: false
681
+ },
682
+ FieldV2: {
683
+ type: "object",
684
+ properties: {
685
+ id: {
686
+ type: "string"
687
+ },
688
+ path: {
689
+ type: "array",
690
+ items: {
691
+ type: "string"
692
+ }
693
+ },
694
+ purpose: {
695
+ type: "string"
696
+ },
697
+ filter: {
698
+ $ref: "#/components/schemas/FilterV2"
699
+ },
700
+ predicate: {
701
+ $ref: "#/components/schemas/Optionality"
702
+ },
703
+ intent_to_retain: {
704
+ type: "boolean"
705
+ },
706
+ name: {
707
+ type: "string"
708
+ },
709
+ optional: {
710
+ type: "boolean"
711
+ }
712
+ },
713
+ required: ["path"],
714
+ additionalProperties: false
715
+ },
716
+ FilterV2: {
717
+ type: "object",
718
+ properties: {
719
+ const: {
720
+ $ref: "#/components/schemas/OneOfNumberStringBoolean"
721
+ },
722
+ enum: {
723
+ type: "array",
724
+ items: {
725
+ $ref: "#/components/schemas/OneOfNumberStringBoolean"
726
+ }
727
+ },
728
+ exclusiveMinimum: {
729
+ $ref: "#/components/schemas/OneOfNumberString"
730
+ },
731
+ exclusiveMaximum: {
732
+ $ref: "#/components/schemas/OneOfNumberString"
733
+ },
734
+ format: {
735
+ type: "string"
736
+ },
737
+ formatMaximum: {
738
+ type: "string"
739
+ },
740
+ formatMinimum: {
741
+ type: "string"
742
+ },
743
+ formatExclusiveMaximum: {
744
+ type: "string"
745
+ },
746
+ formatExclusiveMinimum: {
747
+ type: "string"
748
+ },
749
+ minLength: {
750
+ type: "number"
751
+ },
752
+ maxLength: {
753
+ type: "number"
754
+ },
755
+ minimum: {
756
+ $ref: "#/components/schemas/OneOfNumberString"
757
+ },
758
+ maximum: {
759
+ $ref: "#/components/schemas/OneOfNumberString"
760
+ },
761
+ not: {
762
+ type: "object"
763
+ },
764
+ pattern: {
765
+ type: "string"
766
+ },
767
+ type: {
768
+ type: "string"
769
+ },
770
+ contains: {
771
+ $ref: "#/components/schemas/FilterV2"
772
+ },
773
+ items: {
774
+ $ref: "#/components/schemas/FilterV2Items"
775
+ }
776
+ },
777
+ additionalProperties: false
778
+ },
779
+ FilterV2Items: {
780
+ type: "object",
781
+ properties: {
782
+ const: {
783
+ $ref: "#/components/schemas/OneOfNumberStringBoolean"
784
+ },
785
+ enum: {
786
+ type: "array",
787
+ items: {
788
+ $ref: "#/components/schemas/OneOfNumberStringBoolean"
789
+ }
790
+ },
791
+ exclusiveMinimum: {
792
+ $ref: "#/components/schemas/OneOfNumberString"
793
+ },
794
+ exclusiveMaximum: {
795
+ $ref: "#/components/schemas/OneOfNumberString"
796
+ },
797
+ format: {
798
+ type: "string"
799
+ },
800
+ formatMaximum: {
801
+ type: "string"
802
+ },
803
+ formatMinimum: {
804
+ type: "string"
805
+ },
806
+ formatExclusiveMaximum: {
807
+ type: "string"
808
+ },
809
+ formatExclusiveMinimum: {
810
+ type: "string"
811
+ },
812
+ minLength: {
813
+ type: "number"
814
+ },
815
+ maxLength: {
816
+ type: "number"
817
+ },
818
+ minimum: {
819
+ $ref: "#/components/schemas/OneOfNumberString"
820
+ },
821
+ maximum: {
822
+ $ref: "#/components/schemas/OneOfNumberString"
823
+ },
824
+ not: {
825
+ type: "object"
826
+ },
827
+ pattern: {
828
+ type: "string"
829
+ },
830
+ type: {
831
+ type: "string"
832
+ },
833
+ contains: {
834
+ $ref: "#/components/schemas/FilterV2"
835
+ },
836
+ items: {
837
+ $ref: "#/components/schemas/FilterV2Items"
838
+ }
839
+ },
840
+ additionalProperties: false
841
+ },
842
+ DcqlQueryREST: {
843
+ type: "object",
844
+ properties: {
845
+ credentials: {
846
+ type: "array",
847
+ items: {
848
+ $ref: "#/components/schemas/DcqlCredentialQuery"
849
+ }
850
+ }
851
+ },
852
+ required: ["credentials"],
853
+ additionalProperties: false
854
+ },
855
+ DcqlCredentialQuery: {
856
+ type: "object",
857
+ properties: {
858
+ id: {
859
+ type: "string"
860
+ },
861
+ format: {
862
+ type: "string"
863
+ },
864
+ alg: {
865
+ type: "array",
866
+ items: {
867
+ type: "string"
868
+ }
869
+ },
870
+ claims: {
871
+ type: "array",
872
+ items: {
873
+ $ref: "#/components/schemas/DcqlClaim"
874
+ }
875
+ },
876
+ meta: {
877
+ $ref: "#/components/schemas/Record<string,any>"
878
+ }
879
+ },
880
+ required: ["id", "format", "claims"],
881
+ additionalProperties: false
882
+ },
883
+ DcqlClaim: {
884
+ type: "object",
885
+ properties: {
886
+ namespace: {
887
+ type: "string"
888
+ },
889
+ claim_name: {
890
+ type: "string"
891
+ },
892
+ filter: {
893
+ $ref: "#/components/schemas/DcqlFilter"
894
+ }
895
+ },
896
+ required: ["namespace", "claim_name"],
897
+ additionalProperties: false
898
+ },
899
+ DcqlFilter: {
900
+ type: "object",
901
+ properties: {
902
+ type: {
903
+ type: "string",
904
+ enum: ["string", "number", "boolean"]
905
+ },
906
+ pattern: {
907
+ type: "string"
908
+ },
909
+ minimum: {
910
+ type: "number"
911
+ },
912
+ maximum: {
913
+ type: "number"
914
+ }
915
+ },
916
+ required: ["type"],
917
+ additionalProperties: false
918
+ },
919
+ "Record<string,any>": {
610
920
  type: "object"
611
- }
612
- },
613
- required: ["id", "input_descriptors"],
614
- additionalProperties: false
615
- },
616
- InputDescriptorV2: {
617
- type: "object",
618
- properties: {
619
- id: {
620
- type: "string"
621
- },
622
- name: {
623
- type: "string"
624
- },
625
- purpose: {
626
- type: "string"
627
921
  },
628
- format: {
629
- $ref: "#/components/schemas/Format"
630
- },
631
- group: {
632
- type: "array",
633
- items: {
634
- type: "string"
635
- }
636
- },
637
- issuance: {
638
- type: "array",
639
- items: {
640
- $ref: "#/components/schemas/Issuance"
641
- }
922
+ HasDefinitionItemArgs: {
923
+ $ref: "#/components/schemas/GetDefinitionItemArgs"
924
+ },
925
+ HasDefinitionItemsArgs: {
926
+ $ref: "#/components/schemas/GetDefinitionItemsArgs"
927
+ },
928
+ PersistDefinitionArgs: {
929
+ type: "object",
930
+ properties: {
931
+ definitionItem: {
932
+ $ref: "#/components/schemas/PersistPresentationDefinitionItem"
933
+ },
934
+ opts: {
935
+ $ref: "#/components/schemas/PersistOptions"
936
+ }
937
+ },
938
+ required: ["definitionItem"],
939
+ additionalProperties: false
940
+ },
941
+ PersistPresentationDefinitionItem: {
942
+ type: "object",
943
+ additionalProperties: false,
944
+ properties: {
945
+ id: {
946
+ type: "string"
947
+ },
948
+ definitionId: {
949
+ type: "string"
950
+ },
951
+ version: {
952
+ type: "string"
953
+ },
954
+ tenantId: {
955
+ type: "string"
956
+ },
957
+ name: {
958
+ type: "string"
959
+ },
960
+ purpose: {
961
+ type: "string"
962
+ },
963
+ definitionPayload: {
964
+ $ref: "#/components/schemas/IPresentationDefinition"
965
+ },
966
+ dcqlPayload: {
967
+ $ref: "#/components/schemas/DcqlQueryREST"
968
+ }
969
+ },
970
+ required: ["definitionPayload"]
971
+ },
972
+ PersistOptions: {
973
+ type: "object",
974
+ properties: {
975
+ versionControlMode: {
976
+ $ref: "#/components/schemas/VersionControlMode"
977
+ },
978
+ versionIncrementReleaseType: {
979
+ $ref: "#/components/schemas/ReleaseType"
980
+ }
981
+ },
982
+ additionalProperties: false
983
+ },
984
+ VersionControlMode: {
985
+ type: "string",
986
+ enum: ["AutoIncrement", "Manual", "Overwrite", "OverwriteLatest"]
642
987
  },
643
- constraints: {
644
- $ref: "#/components/schemas/ConstraintsV2"
988
+ ReleaseType: {
989
+ type: "string",
990
+ enum: ["major", "premajor", "minor", "preminor", "patch", "prepatch", "prerelease", "release"]
645
991
  }
646
992
  },
647
- required: ["id", "constraints"],
648
- additionalProperties: false
649
- },
650
- ConstraintsV2: {
651
- type: "object",
652
- properties: {
653
- limit_disclosure: {
654
- $ref: "#/components/schemas/Optionality"
655
- },
656
- statuses: {
657
- $ref: "#/components/schemas/Statuses"
658
- },
659
- fields: {
660
- type: "array",
661
- items: {
662
- $ref: "#/components/schemas/FieldV2"
993
+ methods: {
994
+ pdmDeleteDefinition: {
995
+ description: "Delete a single presentation definition records by primary key",
996
+ arguments: {
997
+ $ref: "#/components/schemas/DeleteDefinitionItemArgs"
998
+ },
999
+ returnType: {
1000
+ type: "boolean"
663
1001
  }
664
1002
  },
665
- subject_is_issuer: {
666
- $ref: "#/components/schemas/Optionality"
667
- },
668
- is_holder: {
669
- type: "array",
670
- items: {
671
- $ref: "#/components/schemas/HolderSubject"
1003
+ pdmDeleteDefinitions: {
1004
+ description: "Delete multiple presentation definitions records using filters",
1005
+ arguments: {
1006
+ $ref: "#/components/schemas/DeleteDefinitionItemsArgs"
1007
+ },
1008
+ returnType: {
1009
+ type: "number"
672
1010
  }
673
1011
  },
674
- same_subject: {
675
- type: "array",
676
- items: {
677
- $ref: "#/components/schemas/HolderSubject"
1012
+ pdmGetDefinition: {
1013
+ description: "Get a single presentation definition records by primary key",
1014
+ arguments: {
1015
+ $ref: "#/components/schemas/GetDefinitionItemArgs"
1016
+ },
1017
+ returnType: {
1018
+ $ref: "#/components/schemas/PresentationDefinitionItem"
678
1019
  }
679
- }
680
- },
681
- additionalProperties: false
682
- },
683
- FieldV2: {
684
- type: "object",
685
- properties: {
686
- id: {
687
- type: "string"
688
1020
  },
689
- path: {
690
- type: "array",
691
- items: {
692
- type: "string"
1021
+ pdmGetDefinitions: {
1022
+ description: "Find one or more presentation definition records using filters",
1023
+ arguments: {
1024
+ $ref: "#/components/schemas/GetDefinitionItemsArgs"
1025
+ },
1026
+ returnType: {
1027
+ type: "array",
1028
+ items: {
1029
+ $ref: "#/components/schemas/PresentationDefinitionItem"
1030
+ }
693
1031
  }
694
1032
  },
695
- purpose: {
696
- type: "string"
697
- },
698
- filter: {
699
- $ref: "#/components/schemas/FilterV2"
700
- },
701
- predicate: {
702
- $ref: "#/components/schemas/Optionality"
703
- },
704
- intent_to_retain: {
705
- type: "boolean"
706
- },
707
- name: {
708
- type: "string"
709
- },
710
- optional: {
711
- type: "boolean"
712
- }
713
- },
714
- required: ["path"],
715
- additionalProperties: false
716
- },
717
- FilterV2: {
718
- type: "object",
719
- properties: {
720
- const: {
721
- $ref: "#/components/schemas/OneOfNumberStringBoolean"
722
- },
723
- enum: {
724
- type: "array",
725
- items: {
726
- $ref: "#/components/schemas/OneOfNumberStringBoolean"
1033
+ pdmHasDefinition: {
1034
+ description: "Checks whether a presentation definition record exists by primary key",
1035
+ arguments: {
1036
+ $ref: "#/components/schemas/HasDefinitionItemArgs"
1037
+ },
1038
+ returnType: {
1039
+ type: "boolean"
727
1040
  }
728
1041
  },
729
- exclusiveMinimum: {
730
- $ref: "#/components/schemas/OneOfNumberString"
731
- },
732
- exclusiveMaximum: {
733
- $ref: "#/components/schemas/OneOfNumberString"
734
- },
735
- format: {
736
- type: "string"
737
- },
738
- formatMaximum: {
739
- type: "string"
740
- },
741
- formatMinimum: {
742
- type: "string"
743
- },
744
- formatExclusiveMaximum: {
745
- type: "string"
746
- },
747
- formatExclusiveMinimum: {
748
- type: "string"
749
- },
750
- minLength: {
751
- type: "number"
752
- },
753
- maxLength: {
754
- type: "number"
755
- },
756
- minimum: {
757
- $ref: "#/components/schemas/OneOfNumberString"
758
- },
759
- maximum: {
760
- $ref: "#/components/schemas/OneOfNumberString"
761
- },
762
- not: {
763
- type: "object"
764
- },
765
- pattern: {
766
- type: "string"
767
- },
768
- type: {
769
- type: "string"
770
- },
771
- contains: {
772
- $ref: "#/components/schemas/FilterV2"
773
- },
774
- items: {
775
- $ref: "#/components/schemas/FilterV2Items"
776
- }
777
- },
778
- additionalProperties: false
779
- },
780
- FilterV2Items: {
781
- type: "object",
782
- properties: {
783
- const: {
784
- $ref: "#/components/schemas/OneOfNumberStringBoolean"
785
- },
786
- enum: {
787
- type: "array",
788
- items: {
789
- $ref: "#/components/schemas/OneOfNumberStringBoolean"
1042
+ pdmHasDefinitions: {
1043
+ description: "Checks whether one or more presentation definition records exist using filters",
1044
+ arguments: {
1045
+ $ref: "#/components/schemas/HasDefinitionItemsArgs"
1046
+ },
1047
+ returnType: {
1048
+ type: "boolean"
790
1049
  }
791
1050
  },
792
- exclusiveMinimum: {
793
- $ref: "#/components/schemas/OneOfNumberString"
794
- },
795
- exclusiveMaximum: {
796
- $ref: "#/components/schemas/OneOfNumberString"
797
- },
798
- format: {
799
- type: "string"
800
- },
801
- formatMaximum: {
802
- type: "string"
803
- },
804
- formatMinimum: {
805
- type: "string"
806
- },
807
- formatExclusiveMaximum: {
808
- type: "string"
809
- },
810
- formatExclusiveMinimum: {
811
- type: "string"
812
- },
813
- minLength: {
814
- type: "number"
815
- },
816
- maxLength: {
817
- type: "number"
818
- },
819
- minimum: {
820
- $ref: "#/components/schemas/OneOfNumberString"
821
- },
822
- maximum: {
823
- $ref: "#/components/schemas/OneOfNumberString"
824
- },
825
- not: {
826
- type: "object"
827
- },
828
- pattern: {
829
- type: "string"
830
- },
831
- type: {
832
- type: "string"
833
- },
834
- contains: {
835
- $ref: "#/components/schemas/FilterV2"
836
- },
837
- items: {
838
- $ref: "#/components/schemas/FilterV2Items"
839
- }
840
- },
841
- additionalProperties: false
842
- },
843
- DcqlQuery: {
844
- type: "object",
845
- properties: {
846
- credentials: {
847
- type: "array",
848
- items: {
849
- $ref: "#/components/schemas/DcqlCredentialQuery"
850
- }
851
- }
852
- },
853
- required: ["credentials"],
854
- additionalProperties: false
855
- },
856
- DcqlCredentialQuery: {
857
- type: "object",
858
- properties: {
859
- id: {
860
- type: "string"
861
- },
862
- format: {
863
- type: "string"
864
- },
865
- alg: {
866
- type: "array",
867
- items: {
868
- type: "string"
1051
+ pdmPersistDefinition: {
1052
+ description: "Check in a presentation definition. It has version control logic which will add or update presentation definition records and has settings for automatic version numbering.",
1053
+ arguments: {
1054
+ $ref: "#/components/schemas/PersistDefinitionArgs"
1055
+ },
1056
+ returnType: {
1057
+ $ref: "#/components/schemas/PresentationDefinitionItem"
869
1058
  }
870
- },
871
- claims: {
872
- type: "array",
873
- items: {
874
- $ref: "#/components/schemas/DcqlClaim"
875
- }
876
- },
877
- meta: {
878
- $ref: "#/components/schemas/Record<string,any>"
879
- }
880
- },
881
- required: ["id", "format", "claims"],
882
- additionalProperties: false
883
- },
884
- DcqlClaim: {
885
- type: "object",
886
- properties: {
887
- namespace: {
888
- type: "string"
889
- },
890
- claim_name: {
891
- type: "string"
892
- },
893
- filter: {
894
- $ref: "#/components/schemas/DcqlFilter"
895
- }
896
- },
897
- required: ["namespace", "claim_name"],
898
- additionalProperties: false
899
- },
900
- DcqlFilter: {
901
- type: "object",
902
- properties: {
903
- type: {
904
- type: "string",
905
- enum: ["string", "number", "boolean"]
906
- },
907
- pattern: {
908
- type: "string"
909
- },
910
- minimum: {
911
- type: "number"
912
- },
913
- maximum: {
914
- type: "number"
915
- }
916
- },
917
- required: ["type"],
918
- additionalProperties: false
919
- },
920
- "Record<string,any>": {
921
- type: "object"
922
- },
923
- HasDefinitionItemArgs: {
924
- $ref: "#/components/schemas/GetDefinitionItemArgs"
925
- },
926
- HasDefinitionItemsArgs: {
927
- $ref: "#/components/schemas/GetDefinitionItemsArgs"
928
- },
929
- PersistDefinitionArgs: {
930
- type: "object",
931
- properties: {
932
- queryItem: {
933
- $ref: "#/components/schemas/PersistPresentationDefinitionItem"
934
- },
935
- opts: {
936
- $ref: "#/components/schemas/PersistOptions"
937
1059
  }
938
- },
939
- required: ["queryItem"],
940
- additionalProperties: false
941
- },
942
- PersistPresentationDefinitionItem: {
943
- type: "object",
944
- additionalProperties: false,
945
- properties: {
946
- id: {
947
- type: "string"
948
- },
949
- queryId: {
950
- type: "string"
951
- },
952
- version: {
953
- type: "string"
954
- },
955
- tenantId: {
956
- type: "string"
957
- },
958
- name: {
959
- type: "string"
960
- },
961
- purpose: {
962
- type: "string"
963
- },
964
- dcqlPayload: {
965
- $ref: "#/components/schemas/DcqlQuery"
966
- }
967
- },
968
- required: ["queryPayload"]
969
- },
970
- PersistOptions: {
971
- type: "object",
972
- properties: {
973
- versionControlMode: {
974
- $ref: "#/components/schemas/VersionControlMode"
975
- },
976
- versionIncrementReleaseType: {
977
- $ref: "#/components/schemas/ReleaseType"
978
- }
979
- },
980
- additionalProperties: false
981
- },
982
- VersionControlMode: {
983
- type: "string",
984
- enum: ["AutoIncrement", "Manual", "Overwrite", "OverwriteLatest"]
985
- },
986
- ReleaseType: {
987
- type: "string",
988
- enum: ["major", "premajor", "minor", "preminor", "patch", "prepatch", "prerelease", "release"]
989
- }
990
- },
991
- methods: {
992
- pdmDeleteDefinition: {
993
- description: "Delete a single presentation query records by primary key",
994
- arguments: {
995
- $ref: "#/components/schemas/DeleteDefinitionItemArgs"
996
- },
997
- returnType: {
998
- type: "boolean"
999
- }
1000
- },
1001
- pdmDeleteDefinitions: {
1002
- description: "Delete multiple presentation querys records using filters",
1003
- arguments: {
1004
- $ref: "#/components/schemas/DeleteDefinitionItemsArgs"
1005
- },
1006
- returnType: {
1007
- type: "number"
1008
- }
1009
- },
1010
- pdmGetDefinition: {
1011
- description: "Get a single presentation query records by primary key",
1012
- arguments: {
1013
- $ref: "#/components/schemas/GetDefinitionItemArgs"
1014
- },
1015
- returnType: {
1016
- $ref: "#/components/schemas/PresentationDefinitionItem"
1017
- }
1018
- },
1019
- pdmGetDefinitions: {
1020
- description: "Find one or more presentation query records using filters",
1021
- arguments: {
1022
- $ref: "#/components/schemas/GetDefinitionItemsArgs"
1023
- },
1024
- returnType: {
1025
- type: "array",
1026
- items: {
1027
- $ref: "#/components/schemas/PresentationDefinitionItem"
1028
- }
1029
- }
1030
- },
1031
- pdmHasDefinition: {
1032
- description: "Checks whether a presentation query record exists by primary key",
1033
- arguments: {
1034
- $ref: "#/components/schemas/HasDefinitionItemArgs"
1035
- },
1036
- returnType: {
1037
- type: "boolean"
1038
- }
1039
- },
1040
- pdmHasDefinitions: {
1041
- description: "Checks whether one or more presentation query records exist using filters",
1042
- arguments: {
1043
- $ref: "#/components/schemas/HasDefinitionItemsArgs"
1044
- },
1045
- returnType: {
1046
- type: "boolean"
1047
- }
1048
- },
1049
- pdmPersistDefinition: {
1050
- description: "Check in a presentation query. It has version control logic which will add or update presentation query records and has settings for automatic version numbering.",
1051
- arguments: {
1052
- $ref: "#/components/schemas/PersistDefinitionArgs"
1053
- },
1054
- returnType: {
1055
- $ref: "#/components/schemas/PresentationDefinitionItem"
1056
1060
  }
1057
1061
  }
1058
1062
  }
1059
- }
1063
+ };
1060
1064
  }
1061
- };
1065
+ });
1066
+
1067
+ // src/index.ts
1068
+ var index_exports = {};
1069
+ __export(index_exports, {
1070
+ PDManager: () => PDManager,
1071
+ ReleaseType: () => import_semver.ReleaseType,
1072
+ pdManagerMethods: () => pdManagerMethods,
1073
+ schema: () => schema
1074
+ });
1075
+ module.exports = __toCommonJS(index_exports);
1062
1076
 
1063
1077
  // src/agent/PDManager.ts
1064
1078
  var import_ssi_sdk = require("@sphereon/ssi-sdk.data-store");
1065
- var import_preload = __toESM(require("semver/preload.js"), 1);
1079
+ var import_preload = __toESM(require("semver/preload"), 1);
1066
1080
  var pdManagerMethods = [
1067
1081
  "pdmHasDefinition",
1068
1082
  "pdmHasGetDefinitions",
@@ -1076,7 +1090,7 @@ var PDManager = class {
1076
1090
  static {
1077
1091
  __name(this, "PDManager");
1078
1092
  }
1079
- schema = plugin_schema_default.IPDManager;
1093
+ schema = schema.IPDManager;
1080
1094
  methods = {
1081
1095
  pdmPersistDefinition: this.pdmPersistDefinition.bind(this),
1082
1096
  pdmHasDefinition: this.pdmHasDefinition.bind(this),
@@ -1120,10 +1134,10 @@ var PDManager = class {
1120
1134
  let definitions = [];
1121
1135
  if (opts == void 0 || opts.showVersionHistory !== true) {
1122
1136
  const groupedByDefinitionId = allDefinitions.reduce((acc, entity) => {
1123
- if (!acc[entity.queryId]) {
1124
- acc[entity.queryId] = [];
1137
+ if (!acc[entity.definitionId]) {
1138
+ acc[entity.definitionId] = [];
1125
1139
  }
1126
- acc[entity.queryId].push(entity);
1140
+ acc[entity.definitionId].push(entity);
1127
1141
  return acc;
1128
1142
  }, {});
1129
1143
  definitions = Object.values(groupedByDefinitionId).map((entities) => entities.reduce((highestVersionItem, baseItem) => {
@@ -1146,99 +1160,89 @@ var PDManager = class {
1146
1160
  }
1147
1161
  /** {@inheritDoc IPDManager.pdmPersistDefinition} */
1148
1162
  async pdmPersistDefinition(args) {
1149
- try {
1150
- const { definitionItem, opts } = args;
1151
- const { versionControlMode, versionIncrementReleaseType } = opts ?? {
1152
- versionControlMode: "AutoIncrement"
1153
- };
1154
- const { version, tenantId } = definitionItem;
1155
- const definitionId = definitionItem.queryId;
1156
- let { id } = definitionItem;
1157
- if (id !== void 0 && versionControlMode !== "Overwrite") {
1158
- id = void 0;
1159
- }
1160
- const nonPersistedDefinitionItem = {
1161
- ...definitionItem,
1162
- version: version ?? "1"
1163
- };
1164
- const existing = await this.store.getDefinitions({
1165
- filter: [
1166
- {
1167
- id,
1168
- queryId: definitionId,
1169
- tenantId,
1170
- version
1171
- }
1172
- ]
1173
- });
1174
- const existingItem = existing[0];
1175
- const allDefinitions = await this.store.getDefinitions({
1176
- filter: [
1177
- {
1178
- queryId: definitionId,
1179
- tenantId
1180
- }
1181
- ]
1182
- });
1183
- allDefinitions.sort((a, b) => import_preload.default.compare(this.normalizeToSemverVersionFormat(a.version), this.normalizeToSemverVersionFormat(b.version)));
1184
- const trulyLatestVersionItem = allDefinitions[allDefinitions.length - 1];
1185
- let latestVersionItem = trulyLatestVersionItem;
1186
- if (existingItem && version) {
1187
- latestVersionItem = trulyLatestVersionItem ?? existingItem;
1188
- }
1189
- const isPayloadModified = !existingItem || !(0, import_ssi_sdk.isPresentationDefinitionEqual)(existingItem, definitionItem);
1190
- if (!isPayloadModified) return existingItem;
1191
- switch (versionControlMode) {
1192
- case "Overwrite":
1193
- return this.handleOverwriteMode(existingItem, nonPersistedDefinitionItem, version);
1194
- case "OverwriteLatest":
1195
- return this.handleOverwriteLatestMode(latestVersionItem, nonPersistedDefinitionItem);
1196
- case "Manual":
1197
- return this.handleManualMode(existingItem, nonPersistedDefinitionItem, tenantId, version);
1198
- case "AutoIncrement":
1199
- return this.handleAutoIncrementMode(latestVersionItem, nonPersistedDefinitionItem, versionIncrementReleaseType ?? "major");
1200
- default:
1201
- throw new Error(`Unknown version control mode: ${versionControlMode}`);
1202
- }
1203
- } catch (e) {
1204
- console.log("pdmPersistDefinition failed", e);
1205
- throw e;
1163
+ const { definitionItem, opts } = args;
1164
+ const { versionControlMode, versionIncrementReleaseType } = opts ?? {
1165
+ versionControlMode: "AutoIncrement"
1166
+ };
1167
+ const { version, tenantId } = definitionItem;
1168
+ const definitionId = definitionItem.definitionId ?? definitionItem.definitionPayload.id;
1169
+ let { id } = definitionItem;
1170
+ if (id !== void 0 && versionControlMode !== "Overwrite") {
1171
+ id = void 0;
1172
+ }
1173
+ const nonPersistedDefinitionItem = {
1174
+ ...definitionItem,
1175
+ definitionId,
1176
+ version: version ?? "1"
1177
+ };
1178
+ const existing = await this.store.getDefinitions({
1179
+ filter: [
1180
+ {
1181
+ id,
1182
+ definitionId,
1183
+ tenantId,
1184
+ version
1185
+ }
1186
+ ]
1187
+ });
1188
+ const existingItem = existing[0];
1189
+ const allDefinitions = await this.store.getDefinitions({
1190
+ filter: [
1191
+ {
1192
+ definitionId,
1193
+ tenantId
1194
+ }
1195
+ ]
1196
+ });
1197
+ allDefinitions.sort((a, b) => import_preload.default.compare(this.normalizeToSemverVersionFormat(a.version), this.normalizeToSemverVersionFormat(b.version)));
1198
+ const trulyLatestVersionItem = allDefinitions[allDefinitions.length - 1];
1199
+ let latestVersionItem = trulyLatestVersionItem;
1200
+ if (existingItem && version) {
1201
+ latestVersionItem = trulyLatestVersionItem ?? existingItem;
1202
+ }
1203
+ const isPayloadModified = !existingItem || !(0, import_ssi_sdk.isPresentationDefinitionEqual)(existingItem, definitionItem);
1204
+ if (!isPayloadModified) return existingItem;
1205
+ switch (versionControlMode) {
1206
+ case "Overwrite":
1207
+ return this.handleOverwriteMode(existingItem, nonPersistedDefinitionItem, version);
1208
+ case "OverwriteLatest":
1209
+ return this.handleOverwriteLatestMode(latestVersionItem, nonPersistedDefinitionItem);
1210
+ case "Manual":
1211
+ return this.handleManualMode(existingItem, nonPersistedDefinitionItem, tenantId, version);
1212
+ case "AutoIncrement":
1213
+ return this.handleAutoIncrementMode(latestVersionItem, nonPersistedDefinitionItem, versionIncrementReleaseType ?? "major");
1214
+ default:
1215
+ throw new Error(`Unknown version control mode: ${versionControlMode}`);
1206
1216
  }
1207
1217
  }
1208
1218
  async handleOverwriteMode(existingItem, definitionItem, version) {
1209
1219
  if (existingItem) {
1210
- existingItem.queryId = definitionItem.queryId;
1220
+ existingItem.definitionId = definitionItem.definitionId;
1211
1221
  existingItem.version = version ?? existingItem.version ?? "1";
1212
1222
  existingItem.tenantId = definitionItem.tenantId;
1213
- existingItem.name = definitionItem.name;
1214
- existingItem.purpose = definitionItem.purpose;
1215
- existingItem.query = definitionItem.query;
1223
+ existingItem.name = definitionItem.definitionPayload.name ?? definitionItem.name;
1224
+ existingItem.purpose = definitionItem.definitionPayload.purpose ?? definitionItem.purpose;
1225
+ existingItem.definitionPayload = definitionItem.definitionPayload;
1216
1226
  return await this.store.updateDefinition(existingItem);
1217
1227
  } else {
1218
- const newDefinitionItem = {
1219
- ...definitionItem
1220
- };
1221
- return await this.store.addDefinition(newDefinitionItem);
1228
+ return await this.store.addDefinition(definitionItem);
1222
1229
  }
1223
1230
  }
1224
1231
  async handleOverwriteLatestMode(latestVersionItem, definitionItem) {
1225
1232
  if (latestVersionItem) {
1226
- latestVersionItem.queryId = definitionItem.queryId;
1233
+ latestVersionItem.definitionId = definitionItem.definitionId;
1227
1234
  latestVersionItem.tenantId = definitionItem.tenantId;
1228
1235
  latestVersionItem.name = definitionItem.name;
1229
1236
  latestVersionItem.purpose = definitionItem.purpose;
1230
- latestVersionItem.query = definitionItem.query;
1237
+ latestVersionItem.definitionPayload = definitionItem.definitionPayload;
1231
1238
  return await this.store.updateDefinition(latestVersionItem);
1232
1239
  } else {
1233
- const newDefinitionItem = {
1234
- ...definitionItem
1235
- };
1236
- return await this.store.addDefinition(newDefinitionItem);
1240
+ return await this.store.addDefinition(definitionItem);
1237
1241
  }
1238
1242
  }
1239
1243
  async handleManualMode(existingItem, definitionItem, tenantId, version) {
1240
1244
  if (existingItem && !(0, import_ssi_sdk.isPresentationDefinitionEqual)(existingItem, definitionItem)) {
1241
- throw Error(`Cannot update definition ${definitionItem.queryId} for tenant ${tenantId} version ${version} because definition exists and manual version control is enabled.`);
1245
+ throw Error(`Cannot update definition ${definitionItem.definitionId} for tenant ${tenantId} version ${version} because definition exists and manual version control is enabled.`);
1242
1246
  } else {
1243
1247
  return await this.store.addDefinition(definitionItem);
1244
1248
  }
@@ -1254,7 +1258,7 @@ var PDManager = class {
1254
1258
  let normalizedBaseVersion = import_preload.default.coerce(baseVersion)?.version ?? `${defaultVersion}.0.0`;
1255
1259
  let preReleaseIdentifier = preReleaseSuffix ? preReleaseSuffix.match(/^[a-zA-Z]+/)?.[0] : void 0;
1256
1260
  let fullVersionToIncrement = preReleaseIdentifier ? `${normalizedBaseVersion}-${preReleaseSuffix}` : normalizedBaseVersion;
1257
- let incrementedVersion = import_preload.default.inc(fullVersionToIncrement, releaseType, void 0, preReleaseIdentifier);
1261
+ let incrementedVersion = import_preload.default.inc(fullVersionToIncrement, releaseType, preReleaseIdentifier);
1258
1262
  if (!incrementedVersion) {
1259
1263
  throw new Error(`Could not increment ${releaseType} version on ${currentVersion} ${preReleaseSuffix}`);
1260
1264
  }
@@ -1269,17 +1273,8 @@ var PDManager = class {
1269
1273
  resultVersion += `-${incrementedSuffix}`;
1270
1274
  }
1271
1275
  }
1272
- const newDefinitionItem = {
1273
- ...definitionItem,
1274
- version: resultVersion
1275
- };
1276
- try {
1277
- const dcqlQueryItem = await this.store.addDefinition(newDefinitionItem);
1278
- return dcqlQueryItem;
1279
- } catch (e) {
1280
- console.log(e);
1281
- throw e;
1282
- }
1276
+ definitionItem.version = resultVersion;
1277
+ return await this.store.addDefinition(definitionItem);
1283
1278
  }
1284
1279
  normalizeToSemverVersionFormat(version) {
1285
1280
  const defaultVersion = "1.0.0";
@@ -1291,4 +1286,8 @@ var PDManager = class {
1291
1286
  return normalizedBaseVersion;
1292
1287
  }
1293
1288
  };
1289
+
1290
+ // src/index.ts
1291
+ var import_semver = require("semver");
1292
+ var schema = require_plugin_schema();
1294
1293
  //# sourceMappingURL=index.cjs.map