@sphereon/ssi-sdk.pd-manager 0.33.1-next.3 → 0.33.1-next.68

package/dist/index.cjs

@@ -0,0 +1,1293 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// plugin.schema.json
+var require_plugin_schema = __commonJS({
+  "plugin.schema.json"(exports, module2) {
+    module2.exports = {
+      IPDManager: {
+        components: {
+          schemas: {
+            DeleteDefinitionItemArgs: {
+              type: "object",
+              properties: {
+                itemId: {
+                  type: "string"
+                }
+              },
+              required: ["itemId"],
+              additionalProperties: false
+            },
+            DeleteDefinitionItemsArgs: {
+              $ref: "#/components/schemas/GetDefinitionItemsArgs"
+            },
+            GetDefinitionItemsArgs: {
+              type: "object",
+              properties: {
+                filter: {
+                  $ref: "#/components/schemas/FindDefinitionArgs"
+                },
+                opts: {
+                  $ref: "#/components/schemas/FetchOptions"
+                }
+              },
+              additionalProperties: false
+            },
+            FindDefinitionArgs: {
+              type: "array",
+              items: {
+                $ref: "#/components/schemas/PresentationDefinitionItemFilter"
+              }
+            },
+            PresentationDefinitionItemFilter: {
+              $ref: '#/components/schemas/Partial<Omit<PresentationDefinitionItem,("definitionPayload"|"dcqlPayload")>>'
+            },
+            'Partial<Omit<PresentationDefinitionItem,("definitionPayload"|"dcqlPayload")>>': {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                definitionId: {
+                  type: "string"
+                },
+                tenantId: {
+                  type: "string"
+                },
+                version: {
+                  type: "string"
+                },
+                name: {
+                  type: "string"
+                },
+                purpose: {
+                  type: "string"
+                },
+                createdAt: {
+                  type: "string",
+                  format: "date-time"
+                },
+                lastUpdatedAt: {
+                  type: "string",
+                  format: "date-time"
+                }
+              },
+              additionalProperties: false
+            },
+            FetchOptions: {
+              type: "object",
+              properties: {
+                showVersionHistory: {
+                  type: "boolean"
+                }
+              },
+              additionalProperties: false
+            },
+            GetDefinitionItemArgs: {
+              type: "object",
+              properties: {
+                itemId: {
+                  type: "string"
+                }
+              },
+              required: ["itemId"],
+              additionalProperties: false
+            },
+            PresentationDefinitionItem: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                definitionId: {
+                  type: "string"
+                },
+                tenantId: {
+                  type: "string"
+                },
+                version: {
+                  type: "string"
+                },
+                name: {
+                  type: "string"
+                },
+                purpose: {
+                  type: "string"
+                },
+                definitionPayload: {
+                  $ref: "#/components/schemas/IPresentationDefinition"
+                },
+                dcqlPayload: {
+                  $ref: "#/components/schemas/DcqlQueryREST"
+                },
+                createdAt: {
+                  type: "string",
+                  format: "date-time"
+                },
+                lastUpdatedAt: {
+                  type: "string",
+                  format: "date-time"
+                }
+              },
+              required: ["id", "definitionId", "version", "definitionPayload", "createdAt", "lastUpdatedAt"],
+              additionalProperties: false
+            },
+            IPresentationDefinition: {
+              anyOf: [
+                {
+                  $ref: "#/components/schemas/PresentationDefinitionV1"
+                },
+                {
+                  $ref: "#/components/schemas/PresentationDefinitionV2"
+                }
+              ]
+            },
+            PresentationDefinitionV1: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                name: {
+                  type: "string"
+                },
+                purpose: {
+                  type: "string"
+                },
+                format: {
+                  $ref: "#/components/schemas/Format"
+                },
+                submission_requirements: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/SubmissionRequirement"
+                  }
+                },
+                input_descriptors: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/InputDescriptorV1"
+                  }
+                }
+              },
+              required: ["id", "input_descriptors"],
+              additionalProperties: false
+            },
+            Format: {
+              type: "object",
+              properties: {
+                jwt: {
+                  $ref: "#/components/schemas/JwtObject"
+                },
+                jwt_vc: {
+                  $ref: "#/components/schemas/JwtObject"
+                },
+                jwt_vc_json: {
+                  $ref: "#/components/schemas/JwtObject"
+                },
+                jwt_vp: {
+                  $ref: "#/components/schemas/JwtObject"
+                },
+                jwt_vp_json: {
+                  $ref: "#/components/schemas/JwtObject"
+                },
+                ldp: {
+                  $ref: "#/components/schemas/LdpObject"
+                },
+                ldp_vc: {
+                  $ref: "#/components/schemas/LdpObject"
+                },
+                ldp_vp: {
+                  $ref: "#/components/schemas/LdpObject"
+                },
+                di: {
+                  $ref: "#/components/schemas/DiObject"
+                },
+                di_vc: {
+                  $ref: "#/components/schemas/DiObject"
+                },
+                di_vp: {
+                  $ref: "#/components/schemas/DiObject"
+                },
+                "vc+sd-jwt": {
+                  $ref: "#/components/schemas/SdJwtObject"
+                },
+                mso_mdoc: {
+                  $ref: "#/components/schemas/MsoMdocObject"
+                }
+              },
+              additionalProperties: false
+            },
+            JwtObject: {
+              type: "object",
+              properties: {
+                alg: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                }
+              },
+              required: ["alg"],
+              additionalProperties: false
+            },
+            LdpObject: {
+              type: "object",
+              properties: {
+                proof_type: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                }
+              },
+              required: ["proof_type"],
+              additionalProperties: false
+            },
+            DiObject: {
+              type: "object",
+              properties: {
+                proof_type: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                cryptosuite: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                }
+              },
+              required: ["proof_type", "cryptosuite"],
+              additionalProperties: false
+            },
+            SdJwtObject: {
+              type: "object",
+              properties: {
+                "sd-jwt_alg_values": {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                "kb-jwt_alg_values": {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                }
+              },
+              additionalProperties: false
+            },
+            MsoMdocObject: {
+              type: "object",
+              properties: {
+                alg: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                }
+              },
+              required: ["alg"],
+              additionalProperties: false
+            },
+            SubmissionRequirement: {
+              type: "object",
+              properties: {
+                name: {
+                  type: "string"
+                },
+                purpose: {
+                  type: "string"
+                },
+                rule: {
+                  $ref: "#/components/schemas/Rules"
+                },
+                count: {
+                  type: "number"
+                },
+                min: {
+                  type: "number"
+                },
+                max: {
+                  type: "number"
+                },
+                from: {
+                  type: "string"
+                },
+                from_nested: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/SubmissionRequirement"
+                  }
+                }
+              },
+              required: ["rule"],
+              additionalProperties: false
+            },
+            Rules: {
+              type: "string",
+              enum: ["all", "pick"]
+            },
+            InputDescriptorV1: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                name: {
+                  type: "string"
+                },
+                purpose: {
+                  type: "string"
+                },
+                group: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                schema: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/Schema"
+                  }
+                },
+                issuance: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/Issuance"
+                  }
+                },
+                constraints: {
+                  $ref: "#/components/schemas/ConstraintsV1"
+                }
+              },
+              required: ["id", "schema"],
+              additionalProperties: false
+            },
+            Schema: {
+              type: "object",
+              properties: {
+                uri: {
+                  type: "string"
+                },
+                required: {
+                  type: "boolean"
+                }
+              },
+              required: ["uri"],
+              additionalProperties: false
+            },
+            Issuance: {
+              type: "object",
+              properties: {
+                manifest: {
+                  type: "string"
+                }
+              },
+              additionalProperties: {}
+            },
+            ConstraintsV1: {
+              type: "object",
+              properties: {
+                limit_disclosure: {
+                  $ref: "#/components/schemas/Optionality"
+                },
+                statuses: {
+                  $ref: "#/components/schemas/Statuses"
+                },
+                fields: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/FieldV1"
+                  }
+                },
+                subject_is_issuer: {
+                  $ref: "#/components/schemas/Optionality"
+                },
+                is_holder: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/HolderSubject"
+                  }
+                },
+                same_subject: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/HolderSubject"
+                  }
+                }
+              },
+              additionalProperties: false
+            },
+            Optionality: {
+              type: "string",
+              enum: ["required", "preferred"]
+            },
+            Statuses: {
+              type: "object",
+              properties: {
+                active: {
+                  $ref: "#/components/schemas/PdStatus"
+                },
+                suspended: {
+                  $ref: "#/components/schemas/PdStatus"
+                },
+                revoked: {
+                  $ref: "#/components/schemas/PdStatus"
+                }
+              },
+              additionalProperties: false
+            },
+            PdStatus: {
+              type: "object",
+              properties: {
+                directive: {
+                  $ref: "#/components/schemas/Directives"
+                }
+              },
+              additionalProperties: false
+            },
+            Directives: {
+              type: "string",
+              enum: ["required", "allowed", "disallowed"]
+            },
+            FieldV1: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                path: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                purpose: {
+                  type: "string"
+                },
+                filter: {
+                  $ref: "#/components/schemas/FilterV1"
+                },
+                predicate: {
+                  $ref: "#/components/schemas/Optionality"
+                }
+              },
+              required: ["path"],
+              additionalProperties: false
+            },
+            FilterV1: {
+              type: "object",
+              properties: {
+                const: {
+                  $ref: "#/components/schemas/OneOfNumberStringBoolean"
+                },
+                enum: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/OneOfNumberStringBoolean"
+                  }
+                },
+                exclusiveMinimum: {
+                  $ref: "#/components/schemas/OneOfNumberString"
+                },
+                exclusiveMaximum: {
+                  $ref: "#/components/schemas/OneOfNumberString"
+                },
+                format: {
+                  type: "string"
+                },
+                minLength: {
+                  type: "number"
+                },
+                maxLength: {
+                  type: "number"
+                },
+                minimum: {
+                  $ref: "#/components/schemas/OneOfNumberString"
+                },
+                maximum: {
+                  $ref: "#/components/schemas/OneOfNumberString"
+                },
+                not: {
+                  type: "object"
+                },
+                pattern: {
+                  type: "string"
+                },
+                type: {
+                  type: "string"
+                }
+              },
+              additionalProperties: false
+            },
+            OneOfNumberStringBoolean: {
+              type: ["boolean", "number", "string"]
+            },
+            OneOfNumberString: {
+              type: ["number", "string"]
+            },
+            HolderSubject: {
+              type: "object",
+              properties: {
+                field_id: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                directive: {
+                  $ref: "#/components/schemas/Optionality"
+                }
+              },
+              required: ["field_id", "directive"],
+              additionalProperties: false
+            },
+            PresentationDefinitionV2: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                name: {
+                  type: "string"
+                },
+                purpose: {
+                  type: "string"
+                },
+                format: {
+                  $ref: "#/components/schemas/Format"
+                },
+                submission_requirements: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/SubmissionRequirement"
+                  }
+                },
+                input_descriptors: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/InputDescriptorV2"
+                  }
+                },
+                frame: {
+                  type: "object"
+                }
+              },
+              required: ["id", "input_descriptors"],
+              additionalProperties: false
+            },
+            InputDescriptorV2: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                name: {
+                  type: "string"
+                },
+                purpose: {
+                  type: "string"
+                },
+                format: {
+                  $ref: "#/components/schemas/Format"
+                },
+                group: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                issuance: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/Issuance"
+                  }
+                },
+                constraints: {
+                  $ref: "#/components/schemas/ConstraintsV2"
+                }
+              },
+              required: ["id", "constraints"],
+              additionalProperties: false
+            },
+            ConstraintsV2: {
+              type: "object",
+              properties: {
+                limit_disclosure: {
+                  $ref: "#/components/schemas/Optionality"
+                },
+                statuses: {
+                  $ref: "#/components/schemas/Statuses"
+                },
+                fields: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/FieldV2"
+                  }
+                },
+                subject_is_issuer: {
+                  $ref: "#/components/schemas/Optionality"
+                },
+                is_holder: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/HolderSubject"
+                  }
+                },
+                same_subject: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/HolderSubject"
+                  }
+                }
+              },
+              additionalProperties: false
+            },
+            FieldV2: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                path: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                purpose: {
+                  type: "string"
+                },
+                filter: {
+                  $ref: "#/components/schemas/FilterV2"
+                },
+                predicate: {
+                  $ref: "#/components/schemas/Optionality"
+                },
+                intent_to_retain: {
+                  type: "boolean"
+                },
+                name: {
+                  type: "string"
+                },
+                optional: {
+                  type: "boolean"
+                }
+              },
+              required: ["path"],
+              additionalProperties: false
+            },
+            FilterV2: {
+              type: "object",
+              properties: {
+                const: {
+                  $ref: "#/components/schemas/OneOfNumberStringBoolean"
+                },
+                enum: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/OneOfNumberStringBoolean"
+                  }
+                },
+                exclusiveMinimum: {
+                  $ref: "#/components/schemas/OneOfNumberString"
+                },
+                exclusiveMaximum: {
+                  $ref: "#/components/schemas/OneOfNumberString"
+                },
+                format: {
+                  type: "string"
+                },
+                formatMaximum: {
+                  type: "string"
+                },
+                formatMinimum: {
+                  type: "string"
+                },
+                formatExclusiveMaximum: {
+                  type: "string"
+                },
+                formatExclusiveMinimum: {
+                  type: "string"
+                },
+                minLength: {
+                  type: "number"
+                },
+                maxLength: {
+                  type: "number"
+                },
+                minimum: {
+                  $ref: "#/components/schemas/OneOfNumberString"
+                },
+                maximum: {
+                  $ref: "#/components/schemas/OneOfNumberString"
+                },
+                not: {
+                  type: "object"
+                },
+                pattern: {
+                  type: "string"
+                },
+                type: {
+                  type: "string"
+                },
+                contains: {
+                  $ref: "#/components/schemas/FilterV2"
+                },
+                items: {
+                  $ref: "#/components/schemas/FilterV2Items"
+                }
+              },
+              additionalProperties: false
+            },
+            FilterV2Items: {
+              type: "object",
+              properties: {
+                const: {
+                  $ref: "#/components/schemas/OneOfNumberStringBoolean"
+                },
+                enum: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/OneOfNumberStringBoolean"
+                  }
+                },
+                exclusiveMinimum: {
+                  $ref: "#/components/schemas/OneOfNumberString"
+                },
+                exclusiveMaximum: {
+                  $ref: "#/components/schemas/OneOfNumberString"
+                },
+                format: {
+                  type: "string"
+                },
+                formatMaximum: {
+                  type: "string"
+                },
+                formatMinimum: {
+                  type: "string"
+                },
+                formatExclusiveMaximum: {
+                  type: "string"
+                },
+                formatExclusiveMinimum: {
+                  type: "string"
+                },
+                minLength: {
+                  type: "number"
+                },
+                maxLength: {
+                  type: "number"
+                },
+                minimum: {
+                  $ref: "#/components/schemas/OneOfNumberString"
+                },
+                maximum: {
+                  $ref: "#/components/schemas/OneOfNumberString"
+                },
+                not: {
+                  type: "object"
+                },
+                pattern: {
+                  type: "string"
+                },
+                type: {
+                  type: "string"
+                },
+                contains: {
+                  $ref: "#/components/schemas/FilterV2"
+                },
+                items: {
+                  $ref: "#/components/schemas/FilterV2Items"
+                }
+              },
+              additionalProperties: false
+            },
+            DcqlQueryREST: {
+              type: "object",
+              properties: {
+                credentials: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/DcqlCredentialQuery"
+                  }
+                }
+              },
+              required: ["credentials"],
+              additionalProperties: false
+            },
+            DcqlCredentialQuery: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                format: {
+                  type: "string"
+                },
+                alg: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                claims: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/DcqlClaim"
+                  }
+                },
+                meta: {
+                  $ref: "#/components/schemas/Record<string,any>"
+                }
+              },
+              required: ["id", "format", "claims"],
+              additionalProperties: false
+            },
+            DcqlClaim: {
+              type: "object",
+              properties: {
+                namespace: {
+                  type: "string"
+                },
+                claim_name: {
+                  type: "string"
+                },
+                filter: {
+                  $ref: "#/components/schemas/DcqlFilter"
+                }
+              },
+              required: ["namespace", "claim_name"],
+              additionalProperties: false
+            },
+            DcqlFilter: {
+              type: "object",
+              properties: {
+                type: {
+                  type: "string",
+                  enum: ["string", "number", "boolean"]
+                },
+                pattern: {
+                  type: "string"
+                },
+                minimum: {
+                  type: "number"
+                },
+                maximum: {
+                  type: "number"
+                }
+              },
+              required: ["type"],
+              additionalProperties: false
+            },
+            "Record<string,any>": {
+              type: "object"
+            },
+            HasDefinitionItemArgs: {
+              $ref: "#/components/schemas/GetDefinitionItemArgs"
+            },
+            HasDefinitionItemsArgs: {
+              $ref: "#/components/schemas/GetDefinitionItemsArgs"
+            },
+            PersistDefinitionArgs: {
+              type: "object",
+              properties: {
+                definitionItem: {
+                  $ref: "#/components/schemas/PersistPresentationDefinitionItem"
+                },
+                opts: {
+                  $ref: "#/components/schemas/PersistOptions"
+                }
+              },
+              required: ["definitionItem"],
+              additionalProperties: false
+            },
+            PersistPresentationDefinitionItem: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                id: {
+                  type: "string"
+                },
+                definitionId: {
+                  type: "string"
+                },
+                version: {
+                  type: "string"
+                },
+                tenantId: {
+                  type: "string"
+                },
+                name: {
+                  type: "string"
+                },
+                purpose: {
+                  type: "string"
+                },
+                definitionPayload: {
+                  $ref: "#/components/schemas/IPresentationDefinition"
+                },
+                dcqlPayload: {
+                  $ref: "#/components/schemas/DcqlQueryREST"
+                }
+              },
+              required: ["definitionPayload"]
+            },
+            PersistOptions: {
+              type: "object",
+              properties: {
+                versionControlMode: {
+                  $ref: "#/components/schemas/VersionControlMode"
+                },
+                versionIncrementReleaseType: {
+                  $ref: "#/components/schemas/ReleaseType"
+                }
+              },
+              additionalProperties: false
+            },
+            VersionControlMode: {
+              type: "string",
+              enum: ["AutoIncrement", "Manual", "Overwrite", "OverwriteLatest"]
+            },
+            ReleaseType: {
+              type: "string",
+              enum: ["major", "premajor", "minor", "preminor", "patch", "prepatch", "prerelease", "release"]
+            }
+          },
+          methods: {
+            pdmDeleteDefinition: {
+              description: "Delete a single presentation definition records by primary key",
+              arguments: {
+                $ref: "#/components/schemas/DeleteDefinitionItemArgs"
+              },
+              returnType: {
+                type: "boolean"
+              }
+            },
+            pdmDeleteDefinitions: {
+              description: "Delete multiple presentation definitions records using filters",
+              arguments: {
+                $ref: "#/components/schemas/DeleteDefinitionItemsArgs"
+              },
+              returnType: {
+                type: "number"
+              }
+            },
+            pdmGetDefinition: {
+              description: "Get a single presentation definition records by primary key",
+              arguments: {
+                $ref: "#/components/schemas/GetDefinitionItemArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/PresentationDefinitionItem"
+              }
+            },
+            pdmGetDefinitions: {
+              description: "Find one or more presentation definition records using filters",
+              arguments: {
+                $ref: "#/components/schemas/GetDefinitionItemsArgs"
+              },
+              returnType: {
+                type: "array",
+                items: {
+                  $ref: "#/components/schemas/PresentationDefinitionItem"
+                }
+              }
+            },
+            pdmHasDefinition: {
+              description: "Checks whether a presentation definition record exists by primary key",
+              arguments: {
+                $ref: "#/components/schemas/HasDefinitionItemArgs"
+              },
+              returnType: {
+                type: "boolean"
+              }
+            },
+            pdmHasDefinitions: {
+              description: "Checks whether one or more presentation definition records exist using filters",
+              arguments: {
+                $ref: "#/components/schemas/HasDefinitionItemsArgs"
+              },
+              returnType: {
+                type: "boolean"
+              }
+            },
+            pdmPersistDefinition: {
+              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.",
+              arguments: {
+                $ref: "#/components/schemas/PersistDefinitionArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/PresentationDefinitionItem"
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PDManager: () => PDManager,
+  ReleaseType: () => import_semver.ReleaseType,
+  pdManagerMethods: () => pdManagerMethods,
+  schema: () => schema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/agent/PDManager.ts
+var import_ssi_sdk = require("@sphereon/ssi-sdk.data-store");
+var import_preload = __toESM(require("semver/preload"), 1);
+var pdManagerMethods = [
+  "pdmHasDefinition",
+  "pdmHasGetDefinitions",
+  "pdmGetDefinition",
+  "pdmGetDefinitions",
+  "pdmPersistDefinition",
+  "pdmDeleteDefinition",
+  "pdmDeleteDefinitions"
+];
+var PDManager = class {
+  static {
+    __name(this, "PDManager");
+  }
+  schema = schema.IPDManager;
+  methods = {
+    pdmPersistDefinition: this.pdmPersistDefinition.bind(this),
+    pdmHasDefinition: this.pdmHasDefinition.bind(this),
+    pdmHasDefinitions: this.pdmHasDefinitions.bind(this),
+    pdmGetDefinition: this.pdmGetDefinition.bind(this),
+    pdmGetDefinitions: this.pdmGetDefinitions.bind(this),
+    pdmDeleteDefinition: this.pdmDeleteDefinition.bind(this),
+    pdmDeleteDefinitions: this.pdmDeleteDefinitions.bind(this)
+  };
+  store;
+  constructor(options) {
+    this.store = options.store;
+  }
+  /** {@inheritDoc IPDManager.pdmHasDefinition} */
+  async pdmHasDefinition(args) {
+    const { itemId } = args;
+    return this.store.hasDefinition({
+      itemId
+    });
+  }
+  /** {@inheritDoc IPDManager.pdmHasDefinitions} */
+  async pdmHasDefinitions(args) {
+    const { filter } = args;
+    return this.store.hasDefinitions({
+      filter
+    });
+  }
+  /** {@inheritDoc IPDManager.pdmGetDefinition} */
+  async pdmGetDefinition(args) {
+    const { itemId } = args;
+    return this.store.getDefinition({
+      itemId
+    });
+  }
+  /** {@inheritDoc IPDManager.pdmGetDefinitions} */
+  async pdmGetDefinitions(args) {
+    const { filter, opts } = args;
+    const allDefinitions = await this.store.getDefinitions({
+      filter
+    });
+    let definitions = [];
+    if (opts == void 0 || opts.showVersionHistory !== true) {
+      const groupedByDefinitionId = allDefinitions.reduce((acc, entity) => {
+        if (!acc[entity.definitionId]) {
+          acc[entity.definitionId] = [];
+        }
+        acc[entity.definitionId].push(entity);
+        return acc;
+      }, {});
+      definitions = Object.values(groupedByDefinitionId).map((entities) => entities.reduce((highestVersionItem, baseItem) => {
+        const baseVersion = this.normalizeToSemverVersionFormat(baseItem.version);
+        const highestVersion = this.normalizeToSemverVersionFormat(highestVersionItem.version);
+        return import_preload.default.gt(baseVersion, highestVersion) ? baseItem : highestVersionItem;
+      }));
+    } else {
+      definitions = allDefinitions;
+    }
+    return definitions;
+  }
+  /** {@inheritDoc IPDManager.pdmDeleteDefinition} */
+  async pdmDeleteDefinition(args) {
+    return this.store.deleteDefinition(args).then((value) => true);
+  }
+  /** {@inheritDoc IPDManager.pdmDeleteDefinitions} */
+  async pdmDeleteDefinitions(args) {
+    return this.store.deleteDefinitions(args);
+  }
+  /** {@inheritDoc IPDManager.pdmPersistDefinition} */
+  async pdmPersistDefinition(args) {
+    const { definitionItem, opts } = args;
+    const { versionControlMode, versionIncrementReleaseType } = opts ?? {
+      versionControlMode: "AutoIncrement"
+    };
+    const { version, tenantId } = definitionItem;
+    const definitionId = definitionItem.definitionId ?? definitionItem.definitionPayload.id;
+    let { id } = definitionItem;
+    if (id !== void 0 && versionControlMode !== "Overwrite") {
+      id = void 0;
+    }
+    const nonPersistedDefinitionItem = {
+      ...definitionItem,
+      definitionId,
+      version: version ?? "1"
+    };
+    const existing = await this.store.getDefinitions({
+      filter: [
+        {
+          id,
+          definitionId,
+          tenantId,
+          version
+        }
+      ]
+    });
+    const existingItem = existing[0];
+    const allDefinitions = await this.store.getDefinitions({
+      filter: [
+        {
+          definitionId,
+          tenantId
+        }
+      ]
+    });
+    allDefinitions.sort((a, b) => import_preload.default.compare(this.normalizeToSemverVersionFormat(a.version), this.normalizeToSemverVersionFormat(b.version)));
+    const trulyLatestVersionItem = allDefinitions[allDefinitions.length - 1];
+    let latestVersionItem = trulyLatestVersionItem;
+    if (existingItem && version) {
+      latestVersionItem = trulyLatestVersionItem ?? existingItem;
+    }
+    const isPayloadModified = !existingItem || !(0, import_ssi_sdk.isPresentationDefinitionEqual)(existingItem, definitionItem);
+    if (!isPayloadModified) return existingItem;
+    switch (versionControlMode) {
+      case "Overwrite":
+        return this.handleOverwriteMode(existingItem, nonPersistedDefinitionItem, version);
+      case "OverwriteLatest":
+        return this.handleOverwriteLatestMode(latestVersionItem, nonPersistedDefinitionItem);
+      case "Manual":
+        return this.handleManualMode(existingItem, nonPersistedDefinitionItem, tenantId, version);
+      case "AutoIncrement":
+        return this.handleAutoIncrementMode(latestVersionItem, nonPersistedDefinitionItem, versionIncrementReleaseType ?? "major");
+      default:
+        throw new Error(`Unknown version control mode: ${versionControlMode}`);
+    }
+  }
+  async handleOverwriteMode(existingItem, definitionItem, version) {
+    if (existingItem) {
+      existingItem.definitionId = definitionItem.definitionId;
+      existingItem.version = version ?? existingItem.version ?? "1";
+      existingItem.tenantId = definitionItem.tenantId;
+      existingItem.name = definitionItem.definitionPayload.name ?? definitionItem.name;
+      existingItem.purpose = definitionItem.definitionPayload.purpose ?? definitionItem.purpose;
+      existingItem.definitionPayload = definitionItem.definitionPayload;
+      return await this.store.updateDefinition(existingItem);
+    } else {
+      return await this.store.addDefinition(definitionItem);
+    }
+  }
+  async handleOverwriteLatestMode(latestVersionItem, definitionItem) {
+    if (latestVersionItem) {
+      latestVersionItem.definitionId = definitionItem.definitionId;
+      latestVersionItem.tenantId = definitionItem.tenantId;
+      latestVersionItem.name = definitionItem.name;
+      latestVersionItem.purpose = definitionItem.purpose;
+      latestVersionItem.definitionPayload = definitionItem.definitionPayload;
+      return await this.store.updateDefinition(latestVersionItem);
+    } else {
+      return await this.store.addDefinition(definitionItem);
+    }
+  }
+  async handleManualMode(existingItem, definitionItem, tenantId, version) {
+    if (existingItem && !(0, import_ssi_sdk.isPresentationDefinitionEqual)(existingItem, definitionItem)) {
+      throw Error(`Cannot update definition ${definitionItem.definitionId} for tenant ${tenantId} version ${version} because definition exists and manual version control is enabled.`);
+    } else {
+      return await this.store.addDefinition(definitionItem);
+    }
+  }
+  async handleAutoIncrementMode(latestVersionItem, definitionItem, releaseType) {
+    const defaultVersion = "1";
+    let currentVersion = latestVersionItem?.version ?? definitionItem.version ?? defaultVersion;
+    let resultVersion;
+    if (!latestVersionItem) {
+      resultVersion = currentVersion;
+    } else {
+      let [baseVersion, preReleaseSuffix] = currentVersion.split(/-(.+)/);
+      let normalizedBaseVersion = import_preload.default.coerce(baseVersion)?.version ?? `${defaultVersion}.0.0`;
+      let preReleaseIdentifier = preReleaseSuffix ? preReleaseSuffix.match(/^[a-zA-Z]+/)?.[0] : void 0;
+      let fullVersionToIncrement = preReleaseIdentifier ? `${normalizedBaseVersion}-${preReleaseSuffix}` : normalizedBaseVersion;
+      let incrementedVersion = import_preload.default.inc(fullVersionToIncrement, releaseType, preReleaseIdentifier);
+      if (!incrementedVersion) {
+        throw new Error(`Could not increment ${releaseType} version on ${currentVersion} ${preReleaseSuffix}`);
+      }
+      let [incrementedBaseVersion, incrementedSuffix] = incrementedVersion.split(/-(.+)/);
+      let originalParts = baseVersion.split(".");
+      let newParts = incrementedBaseVersion.split(".");
+      while (newParts.length > originalParts.length) {
+        newParts.pop();
+      }
+      resultVersion = newParts.join(".");
+      if (incrementedSuffix) {
+        resultVersion += `-${incrementedSuffix}`;
+      }
+    }
+    definitionItem.version = resultVersion;
+    return await this.store.addDefinition(definitionItem);
+  }
+  normalizeToSemverVersionFormat(version) {
+    const defaultVersion = "1.0.0";
+    let [baseVersion, preReleaseSuffix] = version.split(/-(.+)/);
+    let normalizedBaseVersion = import_preload.default.coerce(baseVersion)?.version ?? defaultVersion;
+    if (preReleaseSuffix) {
+      normalizedBaseVersion += `-${preReleaseSuffix}`;
+    }
+    return normalizedBaseVersion;
+  }
+};
+
+// src/index.ts
+var import_semver = require("semver");
+var schema = require_plugin_schema();
+//# sourceMappingURL=index.cjs.map