@sphereon/ssi-sdk.kms-rest-client 0.34.1-feature.IDK.11.48

package/dist/index.cjs

@@ -0,0 +1,2083 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// plugin.schema.json
+var require_plugin_schema = __commonJS({
+  "plugin.schema.json"(exports, module2) {
+    module2.exports = {
+      IKmsRestClient: {
+        components: {
+          schemas: {
+            KmsCreateRawSignatureArgs: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                keyInfo: {
+                  $ref: "#/components/schemas/KeyInfo"
+                },
+                input: {
+                  type: "string"
+                },
+                baseUrl: {
+                  type: "string"
+                }
+              },
+              required: [
+                "input",
+                "keyInfo"
+              ]
+            },
+            KeyInfo: {
+              type: "object",
+              properties: {
+                kid: {
+                  type: "string",
+                  description: "Unique identifier for the cryptographic key. Can be null if the key identifier is not provided."
+                },
+                key: {
+                  $ref: "#/components/schemas/Jwk"
+                },
+                signatureAlgorithm: {
+                  $ref: "#/components/schemas/SignatureAlgorithm"
+                },
+                keyVisibility: {
+                  $ref: "#/components/schemas/KeyVisibility"
+                },
+                x5c: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  },
+                  description: "X.509 certificate chain associated with the key."
+                },
+                alias: {
+                  type: "string",
+                  description: "A reference or alias to the key in the Key Management Service (KMS)."
+                },
+                providerId: {
+                  type: "string",
+                  description: "The Key Management System (KMS) identifier associated with the key."
+                },
+                keyType: {
+                  $ref: "#/components/schemas/KeyType"
+                },
+                keyEncoding: {
+                  $ref: "#/components/schemas/KeyEncoding"
+                },
+                opts: {
+                  type: "object",
+                  additionalProperties: {
+                    type: "string"
+                  },
+                  description: "Additional configuration options as key-value pairs."
+                }
+              },
+              additionalProperties: false,
+              description: "Information about a cryptographic key, providing metadata and configuration details necessary for cryptographic operations."
+            },
+            Jwk: {
+              type: "object",
+              properties: {
+                kty: {
+                  $ref: "#/components/schemas/JwkKeyType"
+                },
+                kid: {
+                  type: "string",
+                  description: "Key identifier used to uniquely identify the key."
+                },
+                alg: {
+                  type: "string",
+                  description: "The algorithm intended for use with the key (JWA algorithm name)."
+                },
+                use: {
+                  $ref: "#/components/schemas/JwkUse"
+                },
+                keyOps: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/KeyOperations"
+                  },
+                  description: "The allowed cryptographic operations for the key."
+                },
+                crv: {
+                  $ref: "#/components/schemas/Curve"
+                },
+                x: {
+                  type: "string",
+                  description: "The x coordinate for elliptic curve keys (base64url-encoded)."
+                },
+                y: {
+                  type: "string",
+                  description: "The y coordinate for elliptic curve keys (base64url-encoded)."
+                },
+                d: {
+                  type: "string",
+                  description: "The private key parameter (base64url-encoded)."
+                },
+                n: {
+                  type: "string",
+                  description: "The modulus value for RSA keys (base64url-encoded)."
+                },
+                e: {
+                  type: "string",
+                  description: "The public exponent for RSA keys (base64url-encoded)."
+                },
+                p: {
+                  type: "string",
+                  description: "The first prime factor for RSA private keys (base64url-encoded)."
+                },
+                q: {
+                  type: "string",
+                  description: "The second prime factor for RSA private keys (base64url-encoded)."
+                },
+                dp: {
+                  type: "string",
+                  description: "The first factor CRT exponent for RSA private keys (base64url-encoded)."
+                },
+                dq: {
+                  type: "string",
+                  description: "The second factor CRT exponent for RSA private keys (base64url-encoded)."
+                },
+                qi: {
+                  type: "string",
+                  description: "The first CRT coefficient for RSA private keys (base64url-encoded)."
+                },
+                k: {
+                  type: "string",
+                  description: "The symmetric key value (base64url-encoded)."
+                },
+                x5c: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  },
+                  description: "X.509 certificate chain as base64-encoded DER certificates."
+                },
+                x5t: {
+                  type: "string",
+                  description: "X.509 certificate SHA-1 thumbprint (base64url-encoded)."
+                },
+                x5u: {
+                  type: "string",
+                  description: "URL pointing to X.509 certificate or certificate chain."
+                },
+                x5tS256: {
+                  type: "string",
+                  description: "X.509 certificate SHA-256 thumbprint (base64url-encoded)."
+                }
+              },
+              required: [
+                "kty"
+              ],
+              additionalProperties: false,
+              description: "Represents a JSON Web Key (JWK) as defined by the JSON Web Key specification."
+            },
+            JwkKeyType: {
+              type: "string",
+              enum: [
+                "EC",
+                "RSA",
+                "OKP",
+                "oct"
+              ],
+              description: "JSON Web Key (JWK) key type parameter identifying the cryptographic algorithm family."
+            },
+            JwkUse: {
+              type: "string",
+              enum: [
+                "sig",
+                "enc"
+              ],
+              description: "Intended use of the key (signing or encryption)."
+            },
+            KeyOperations: {
+              type: "string",
+              enum: [
+                "sign",
+                "verify",
+                "encrypt",
+                "decrypt",
+                "wrapKey",
+                "unwrapKey",
+                "deriveKey",
+                "deriveBits"
+              ],
+              description: "Specific operations the key is intended for."
+            },
+            Curve: {
+              type: "string",
+              enum: [
+                "P-256",
+                "P-384",
+                "P-521",
+                "secp256k1",
+                "Ed25519",
+                "Ed448",
+                "X25519",
+                "X448"
+              ],
+              description: "Elliptic curve identifier."
+            },
+            SignatureAlgorithm: {
+              type: "string",
+              enum: [
+                "ED25519",
+                "ECDSA_SHA256",
+                "ECDSA_SHA384",
+                "ECDSA_SHA512",
+                "ES256K",
+                "ECKA_DH_SHA256",
+                "HMAC_SHA256",
+                "HMAC_SHA384",
+                "HMAC_SHA512",
+                "RSA_SSA_PSS_SHA256_MGF1",
+                "RSA_SSA_PSS_SHA384_MGF1",
+                "RSA_SSA_PSS_SHA512_MGF1"
+              ],
+              description: "Cryptographic signature algorithm identifier."
+            },
+            KeyVisibility: {
+              type: "string",
+              enum: [
+                "PUBLIC",
+                "PRIVATE"
+              ],
+              description: "Indicates the visibility status of a cryptographic key."
+            },
+            KeyType: {
+              type: "string",
+              enum: [
+                "OKP",
+                "EC",
+                "RSA"
+              ],
+              description: "Cryptographic key type identifier."
+            },
+            KeyEncoding: {
+              type: "string",
+              enum: [
+                "COSE",
+                "JOSE"
+              ],
+              description: "The encoding format of the cryptographic key."
+            },
+            CreateRawSignatureResponse: {
+              type: "object",
+              properties: {
+                signature: {
+                  type: "string",
+                  description: "The created signature encoded as a base64 string."
+                }
+              },
+              required: [
+                "signature"
+              ],
+              additionalProperties: false,
+              description: "Response body containing the created signature."
+            },
+            KmsDeleteKeyArgs: {
+              type: "object",
+              properties: {
+                baseUrl: {
+                  type: "string"
+                },
+                aliasOrKid: {
+                  type: "string"
+                }
+              },
+              additionalProperties: false
+            },
+            KmsGenerateKeyArgs: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                alias: {
+                  type: "string",
+                  description: "Alias for the generated key."
+                },
+                use: {
+                  $ref: "#/components/schemas/JwkUse"
+                },
+                keyOperations: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/KeyOperations"
+                  }
+                },
+                alg: {
+                  $ref: "#/components/schemas/SignatureAlgorithm"
+                },
+                providerId: {
+                  type: "string",
+                  description: "Optional provider ID. If not specified, the default provider will be used."
+                },
+                baseUrl: {
+                  type: "string"
+                }
+              }
+            },
+            ManagedKeyPair: {
+              type: "object",
+              properties: {
+                kid: {
+                  type: "string",
+                  description: "Key identifier, may be null."
+                },
+                providerId: {
+                  type: "string",
+                  description: "Key Management System identifier."
+                },
+                alias: {
+                  type: "string",
+                  description: "Reference to the key in the KMS."
+                },
+                cose: {
+                  $ref: "#/components/schemas/CoseKeyPair"
+                },
+                jose: {
+                  $ref: "#/components/schemas/JoseKeyPair"
+                }
+              },
+              required: [
+                "providerId",
+                "alias",
+                "cose",
+                "jose"
+              ],
+              additionalProperties: false,
+              description: "Represents a key pair used by a crypto provider, encapsulating both JOSE and COSE key pairs."
+            },
+            CoseKeyPair: {
+              type: "object",
+              properties: {
+                privateCoseKey: {
+                  $ref: "#/components/schemas/CoseKey"
+                },
+                publicCoseKey: {
+                  $ref: "#/components/schemas/CoseKey"
+                }
+              },
+              required: [
+                "publicCoseKey"
+              ],
+              additionalProperties: false,
+              description: "Represents a cryptographic key pair for COSE (CBOR Object Signing and Encryption) operations."
+            },
+            CoseKey: {
+              type: "object",
+              properties: {
+                kty: {
+                  $ref: "#/components/schemas/CoseKeyType"
+                },
+                kid: {
+                  type: "string",
+                  description: "Key identifier (base64url-encoded byte string)."
+                },
+                alg: {
+                  type: "number",
+                  description: "The COSE algorithm identifier (e.g., -7=ES256, -35=ES384, -36=ES512, -8=EdDSA)."
+                },
+                keyOps: {
+                  type: "array",
+                  items: {
+                    type: "number"
+                  },
+                  description: "The allowed COSE key operations (1=sign, 2=verify, 3=encrypt, 4=decrypt, etc.)."
+                },
+                baseIV: {
+                  type: "string",
+                  description: "Base initialization vector (base64url-encoded)."
+                },
+                crv: {
+                  type: "number",
+                  description: "The COSE curve identifier (1=P-256, 2=P-384, 3=P-521, 8=secp256k1, 6=Ed25519, etc.)."
+                },
+                x: {
+                  type: "string",
+                  description: "The x coordinate (base64url-encoded byte string)."
+                },
+                y: {
+                  type: "string",
+                  description: "The y coordinate (base64url-encoded byte string)."
+                },
+                d: {
+                  type: "string",
+                  description: "The private key parameter (base64url-encoded byte string)."
+                },
+                x5chain: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  },
+                  description: "X.509 certificate chain as base64-encoded certificates."
+                }
+              },
+              required: [
+                "kty"
+              ],
+              additionalProperties: false,
+              description: "Represents a COSE (CBOR Object Signing and Encryption) key in JSON format."
+            },
+            CoseKeyType: {
+              type: "number",
+              enum: [
+                1,
+                2,
+                3,
+                4
+              ],
+              description: "COSE key type parameter. 1=OKP (Octet Key Pair), 2=EC2 (Elliptic Curve), 3=RSA, 4=Symmetric."
+            },
+            JoseKeyPair: {
+              type: "object",
+              properties: {
+                privateJwk: {
+                  $ref: "#/components/schemas/Jwk"
+                },
+                publicJwk: {
+                  $ref: "#/components/schemas/Jwk"
+                }
+              },
+              required: [
+                "publicJwk"
+              ],
+              additionalProperties: false,
+              description: "Data class representing a cryptographic key pair used with JOSE (JSON Object Signing and Encryption)."
+            },
+            KmsGetKeyArgs: {
+              type: "object",
+              properties: {
+                baseUrl: {
+                  type: "string"
+                },
+                aliasOrKid: {
+                  type: "string"
+                }
+              },
+              required: [
+                "aliasOrKid"
+              ],
+              additionalProperties: false
+            },
+            ManagedKeyInfo: {
+              type: "object",
+              properties: {
+                kid: {
+                  type: "string",
+                  description: "Unique identifier for the cryptographic key. Can be null if the key identifier is not provided."
+                },
+                key: {
+                  $ref: "#/components/schemas/Jwk"
+                },
+                signatureAlgorithm: {
+                  $ref: "#/components/schemas/SignatureAlgorithm"
+                },
+                keyVisibility: {
+                  $ref: "#/components/schemas/KeyVisibility"
+                },
+                x5c: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  },
+                  description: "X.509 certificate chain associated with the key."
+                },
+                alias: {
+                  type: "string",
+                  description: "A reference or alias to the key in the Key Management Service (KMS)."
+                },
+                providerId: {
+                  type: "string",
+                  description: "The Key Management System (KMS) identifier associated with the key."
+                },
+                keyType: {
+                  $ref: "#/components/schemas/KeyType"
+                },
+                keyEncoding: {
+                  $ref: "#/components/schemas/KeyEncoding"
+                },
+                opts: {
+                  type: "object",
+                  additionalProperties: {
+                    type: "string"
+                  },
+                  description: "Additional configuration options as key-value pairs."
+                }
+              },
+              required: [
+                "key",
+                "alias",
+                "providerId"
+              ],
+              additionalProperties: false,
+              description: "Represents a managed cryptographic key information that is guaranteed to be present and resolved, part of a KMS providing concrete access to the key."
+            },
+            KmsGetKeyProviderArgs: {
+              type: "object",
+              properties: {
+                baseUrl: {
+                  type: "string"
+                },
+                providerId: {
+                  type: "string"
+                }
+              },
+              additionalProperties: false
+            },
+            KeyProviderResponse: {
+              type: "object",
+              properties: {
+                providerId: {
+                  type: "string",
+                  description: "The unique identifier assigned to the Key Provider instance upon creation."
+                },
+                type: {
+                  $ref: "#/components/schemas/KeyProviderType"
+                }
+              },
+              required: [
+                "providerId",
+                "type"
+              ],
+              additionalProperties: false,
+              description: "Response body containing the details of a Key Provider instance."
+            },
+            KeyProviderType: {
+              type: "string",
+              enum: [
+                "SOFTWARE",
+                "AZURE_KEYVAULT",
+                "AWS_KMS"
+              ],
+              description: "The type of Key Provider. Determines the required configuration settings. - AZURE_KEYVAULT: Microsoft Azure Key Vault or Managed HSM. - AWS_KMS: Amazon Web Services Key Management Service."
+            },
+            kmsGetResolverArgs: {
+              type: "object",
+              properties: {
+                baseUrl: {
+                  type: "string"
+                },
+                resolverId: {
+                  type: "string"
+                }
+              },
+              required: [
+                "resolverId"
+              ],
+              additionalProperties: false
+            },
+            Resolver: {
+              type: "object",
+              properties: {
+                resolverId: {
+                  type: "string",
+                  description: "Unique identifier for the resolver."
+                },
+                supportedIdentifierMethods: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/IdentifierMethod"
+                  },
+                  description: "List of identifier methods supported by this resolver."
+                },
+                supportedKeyTypes: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/KeyType"
+                  },
+                  description: "List of key types supported by this resolver."
+                }
+              },
+              required: [
+                "resolverId"
+              ],
+              additionalProperties: false,
+              description: "Represents a key resolver configuration."
+            },
+            IdentifierMethod: {
+              type: "string",
+              enum: [
+                "JWK",
+                "KID",
+                "COSE_KEY",
+                "X5C",
+                "DID"
+              ],
+              description: "Method used to identify cryptographic keys."
+            },
+            KmsIsValidRawSignatureArgs: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                keyInfo: {
+                  $ref: "#/components/schemas/KeyInfo"
+                },
+                input: {
+                  type: "string"
+                },
+                signature: {
+                  type: "string"
+                },
+                baseUrl: {
+                  type: "string"
+                }
+              },
+              required: [
+                "input",
+                "keyInfo",
+                "signature"
+              ]
+            },
+            VerifyRawSignatureResponse: {
+              type: "object",
+              properties: {
+                isValid: {
+                  type: "boolean",
+                  description: "Indicates whether the signature is valid or not."
+                }
+              },
+              required: [
+                "isValid"
+              ],
+              additionalProperties: false,
+              description: "Response body containing the details of the signature verification."
+            },
+            KmsListKeyProvidersArgs: {
+              type: "object",
+              properties: {
+                baseUrl: {
+                  type: "string"
+                }
+              },
+              additionalProperties: false
+            },
+            ListKeyProvidersResponse: {
+              type: "object",
+              properties: {
+                providers: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/KeyProvider"
+                  }
+                }
+              },
+              required: [
+                "providers"
+              ],
+              additionalProperties: false,
+              description: "Response body containing the details of a Key Provider instance."
+            },
+            KeyProvider: {
+              type: "object",
+              properties: {
+                providerId: {
+                  type: "string",
+                  description: "The unique identifier assigned to the Key Provider instance upon creation."
+                },
+                type: {
+                  $ref: "#/components/schemas/KeyProviderType"
+                }
+              },
+              required: [
+                "providerId",
+                "type"
+              ],
+              additionalProperties: false,
+              description: "Response body containing the details of a Key Provider instance."
+            },
+            KmsListKeysArgs: {
+              type: "object",
+              properties: {
+                baseUrl: {
+                  type: "string"
+                },
+                providerId: {
+                  type: "string"
+                }
+              },
+              additionalProperties: false
+            },
+            ListKeysResponse: {
+              type: "object",
+              properties: {
+                keyInfos: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/ManagedKeyInfo"
+                  }
+                }
+              },
+              required: [
+                "keyInfos"
+              ],
+              additionalProperties: false,
+              description: "Response body containing all the managed keys."
+            },
+            KmsListResolversArgs: {
+              type: "object",
+              properties: {
+                baseUrl: {
+                  type: "string"
+                }
+              },
+              additionalProperties: false
+            },
+            ListResolversResponse: {
+              type: "object",
+              properties: {
+                resolvers: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/Resolver"
+                  }
+                }
+              },
+              required: [
+                "resolvers"
+              ],
+              additionalProperties: false,
+              description: "Response body containing all the resolvers."
+            },
+            KmsProviderDeleteKeyArgs: {
+              type: "object",
+              properties: {
+                baseUrl: {
+                  type: "string"
+                },
+                providerId: {
+                  type: "string"
+                },
+                aliasOrKid: {
+                  type: "string"
+                }
+              },
+              required: [
+                "providerId",
+                "aliasOrKid"
+              ],
+              additionalProperties: false
+            },
+            KmsProviderGenerateKey: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                alias: {
+                  type: "string",
+                  description: "Alias for the generated key."
+                },
+                use: {
+                  $ref: "#/components/schemas/JwkUse"
+                },
+                keyOperations: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/KeyOperations"
+                  }
+                },
+                alg: {
+                  $ref: "#/components/schemas/SignatureAlgorithm"
+                },
+                baseUrl: {
+                  type: "string"
+                },
+                providerId: {
+                  type: "string"
+                }
+              },
+              required: [
+                "providerId"
+              ]
+            },
+            KmsProviderGetKeyArgs: {
+              type: "object",
+              properties: {
+                baseUrl: {
+                  type: "string"
+                },
+                providerId: {
+                  type: "string"
+                },
+                aliasOrKid: {
+                  type: "string"
+                }
+              },
+              required: [
+                "providerId",
+                "aliasOrKid"
+              ],
+              additionalProperties: false
+            },
+            KmsProviderListKeysArgs: {
+              type: "object",
+              properties: {
+                baseUrl: {
+                  type: "string"
+                },
+                providerId: {
+                  type: "string"
+                }
+              },
+              required: [
+                "providerId"
+              ],
+              additionalProperties: false
+            },
+            KmsProviderStoreKey: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                keyInfo: {
+                  $ref: "#/components/schemas/ResolvedKeyInfo"
+                },
+                certChain: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  },
+                  description: "X.509 certificate chain as base64-encoded DER certificates."
+                },
+                baseUrl: {
+                  type: "string"
+                },
+                providerId: {
+                  type: "string"
+                }
+              },
+              required: [
+                "keyInfo",
+                "providerId"
+              ]
+            },
+            ResolvedKeyInfo: {
+              type: "object",
+              properties: {
+                kid: {
+                  type: "string",
+                  description: "Unique identifier for the cryptographic key. Can be null if the key identifier is not provided."
+                },
+                key: {
+                  $ref: "#/components/schemas/Jwk"
+                },
+                signatureAlgorithm: {
+                  $ref: "#/components/schemas/SignatureAlgorithm"
+                },
+                keyVisibility: {
+                  $ref: "#/components/schemas/KeyVisibility"
+                },
+                x5c: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  },
+                  description: "X.509 certificate chain associated with the key."
+                },
+                alias: {
+                  type: "string",
+                  description: "A reference or alias to the key in the Key Management Service (KMS)."
+                },
+                providerId: {
+                  type: "string",
+                  description: "The Key Management System (KMS) identifier associated with the key."
+                },
+                keyType: {
+                  $ref: "#/components/schemas/KeyType"
+                },
+                keyEncoding: {
+                  $ref: "#/components/schemas/KeyEncoding"
+                },
+                opts: {
+                  type: "object",
+                  additionalProperties: {
+                    type: "string"
+                  },
+                  description: "Additional configuration options as key-value pairs."
+                }
+              },
+              required: [
+                "key"
+              ],
+              additionalProperties: false,
+              description: "Represents a resolved cryptographic key information where the key is guaranteed to be present and resolved, providing concrete access to the key."
+            },
+            KmsResolveKeyArgs: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                keyInfo: {
+                  $ref: "#/components/schemas/KeyInfo"
+                },
+                identifierMethod: {
+                  $ref: "#/components/schemas/IdentifierMethod"
+                },
+                trustedCerts: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  },
+                  description: "Optional array of trusted certificates (base64-encoded) that may be used in the resolution process."
+                },
+                verifyX509CertificateChain: {
+                  type: "boolean",
+                  description: "Optional boolean indicating whether the X.509 certificate chain should be verified."
+                },
+                baseUrl: {
+                  type: "string"
+                },
+                resolverId: {
+                  $ref: "#/components/schemas/String"
+                }
+              },
+              required: [
+                "keyInfo",
+                "resolverId"
+              ]
+            },
+            String: {
+              type: "object",
+              properties: {
+                length: {
+                  type: "number"
+                }
+              },
+              required: [
+                "length"
+              ],
+              additionalProperties: {
+                type: "string"
+              }
+            },
+            KmsStoreKeyArgs: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                keyInfo: {
+                  $ref: "#/components/schemas/ResolvedKeyInfo"
+                },
+                certChain: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  },
+                  description: "X.509 certificate chain as base64-encoded DER certificates."
+                },
+                baseUrl: {
+                  type: "string"
+                }
+              },
+              required: [
+                "keyInfo"
+              ]
+            }
+          },
+          methods: {
+            kmsCreateRawSignature: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsCreateRawSignatureArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/CreateRawSignatureResponse"
+              }
+            },
+            kmsDeleteKey: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsDeleteKeyArgs"
+              },
+              returnType: {
+                type: "boolean"
+              }
+            },
+            kmsGenerateKey: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsGenerateKeyArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/ManagedKeyPair"
+              }
+            },
+            kmsGetKey: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsGetKeyArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/ManagedKeyInfo"
+              }
+            },
+            kmsGetKeyProvider: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsGetKeyProviderArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/KeyProviderResponse"
+              }
+            },
+            kmsGetResolver: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/kmsGetResolverArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/Resolver"
+              }
+            },
+            kmsIsValidRawSignature: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsIsValidRawSignatureArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/VerifyRawSignatureResponse"
+              }
+            },
+            kmsListKeyProviders: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsListKeyProvidersArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/ListKeyProvidersResponse"
+              }
+            },
+            kmsListKeys: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsListKeysArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/ListKeysResponse"
+              }
+            },
+            kmsListResolvers: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsListResolversArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/ListResolversResponse"
+              }
+            },
+            kmsProviderDeleteKey: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsProviderDeleteKeyArgs"
+              },
+              returnType: {
+                type: "boolean"
+              }
+            },
+            kmsProviderGenerateKey: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsProviderGenerateKey"
+              },
+              returnType: {
+                $ref: "#/components/schemas/ManagedKeyPair"
+              }
+            },
+            kmsProviderGetKey: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsProviderGetKeyArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/ManagedKeyInfo"
+              }
+            },
+            kmsProviderListKeys: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsProviderListKeysArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/ListKeysResponse"
+              }
+            },
+            kmsProviderStoreKey: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsProviderStoreKey"
+              },
+              returnType: {
+                $ref: "#/components/schemas/ManagedKeyInfo"
+              }
+            },
+            kmsResolveKey: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsResolveKeyArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/ResolvedKeyInfo"
+              }
+            },
+            kmsStoreKey: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/KmsStoreKeyArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/ManagedKeyInfo"
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  KmsRestClient: () => KmsRestClient,
+  schema: () => schema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/agent/KmsRestClient.ts
+var import_ssi_types = require("@sphereon/ssi-types");
+var import_cross_fetch = require("cross-fetch");
+
+// src/models/CoseKeyType.ts
+function CoseKeyTypeFromJSON(json) {
+  return CoseKeyTypeFromJSONTyped(json, false);
+}
+__name(CoseKeyTypeFromJSON, "CoseKeyTypeFromJSON");
+function CoseKeyTypeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(CoseKeyTypeFromJSONTyped, "CoseKeyTypeFromJSONTyped");
+
+// src/models/CoseKey.ts
+function CoseKeyFromJSON(json) {
+  return CoseKeyFromJSONTyped(json, false);
+}
+__name(CoseKeyFromJSON, "CoseKeyFromJSON");
+function CoseKeyFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "kty": CoseKeyTypeFromJSON(json["kty"]),
+    "kid": json["kid"] == null ? void 0 : json["kid"],
+    "alg": json["alg"] == null ? void 0 : json["alg"],
+    "keyOps": json["key_ops"] == null ? void 0 : json["key_ops"],
+    "baseIV": json["baseIV"] == null ? void 0 : json["baseIV"],
+    "crv": json["crv"] == null ? void 0 : json["crv"],
+    "x": json["x"] == null ? void 0 : json["x"],
+    "y": json["y"] == null ? void 0 : json["y"],
+    "d": json["d"] == null ? void 0 : json["d"],
+    "x5chain": json["x5chain"] == null ? void 0 : json["x5chain"]
+  };
+}
+__name(CoseKeyFromJSONTyped, "CoseKeyFromJSONTyped");
+
+// src/models/CoseKeyPair.ts
+function CoseKeyPairFromJSON(json) {
+  return CoseKeyPairFromJSONTyped(json, false);
+}
+__name(CoseKeyPairFromJSON, "CoseKeyPairFromJSON");
+function CoseKeyPairFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "privateCoseKey": json["privateCoseKey"] == null ? void 0 : CoseKeyFromJSON(json["privateCoseKey"]),
+    "publicCoseKey": CoseKeyFromJSON(json["publicCoseKey"])
+  };
+}
+__name(CoseKeyPairFromJSONTyped, "CoseKeyPairFromJSONTyped");
+
+// src/models/KeyProviderType.ts
+function KeyProviderTypeFromJSON(json) {
+  return KeyProviderTypeFromJSONTyped(json, false);
+}
+__name(KeyProviderTypeFromJSON, "KeyProviderTypeFromJSON");
+function KeyProviderTypeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(KeyProviderTypeFromJSONTyped, "KeyProviderTypeFromJSONTyped");
+
+// src/models/KeyType.ts
+function KeyTypeFromJSON(json) {
+  return KeyTypeFromJSONTyped(json, false);
+}
+__name(KeyTypeFromJSON, "KeyTypeFromJSON");
+function KeyTypeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(KeyTypeFromJSONTyped, "KeyTypeFromJSONTyped");
+function KeyTypeToJSON(value) {
+  return value;
+}
+__name(KeyTypeToJSON, "KeyTypeToJSON");
+
+// src/models/KeyVisibility.ts
+function KeyVisibilityFromJSON(json) {
+  return KeyVisibilityFromJSONTyped(json, false);
+}
+__name(KeyVisibilityFromJSON, "KeyVisibilityFromJSON");
+function KeyVisibilityFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(KeyVisibilityFromJSONTyped, "KeyVisibilityFromJSONTyped");
+function KeyVisibilityToJSON(value) {
+  return value;
+}
+__name(KeyVisibilityToJSON, "KeyVisibilityToJSON");
+
+// src/models/SignatureAlgorithm.ts
+function SignatureAlgorithmFromJSON(json) {
+  return SignatureAlgorithmFromJSONTyped(json, false);
+}
+__name(SignatureAlgorithmFromJSON, "SignatureAlgorithmFromJSON");
+function SignatureAlgorithmFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(SignatureAlgorithmFromJSONTyped, "SignatureAlgorithmFromJSONTyped");
+function SignatureAlgorithmToJSON(value) {
+  return value;
+}
+__name(SignatureAlgorithmToJSON, "SignatureAlgorithmToJSON");
+
+// src/models/KeyEncoding.ts
+function KeyEncodingFromJSON(json) {
+  return KeyEncodingFromJSONTyped(json, false);
+}
+__name(KeyEncodingFromJSON, "KeyEncodingFromJSON");
+function KeyEncodingFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(KeyEncodingFromJSONTyped, "KeyEncodingFromJSONTyped");
+function KeyEncodingToJSON(value) {
+  return value;
+}
+__name(KeyEncodingToJSON, "KeyEncodingToJSON");
+
+// src/models/Curve.ts
+function CurveFromJSON(json) {
+  return CurveFromJSONTyped(json, false);
+}
+__name(CurveFromJSON, "CurveFromJSON");
+function CurveFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(CurveFromJSONTyped, "CurveFromJSONTyped");
+function CurveToJSON(value) {
+  return value;
+}
+__name(CurveToJSON, "CurveToJSON");
+
+// src/models/KeyOperations.ts
+function KeyOperationsFromJSON(json) {
+  return KeyOperationsFromJSONTyped(json, false);
+}
+__name(KeyOperationsFromJSON, "KeyOperationsFromJSON");
+function KeyOperationsFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(KeyOperationsFromJSONTyped, "KeyOperationsFromJSONTyped");
+function KeyOperationsToJSON(value) {
+  return value;
+}
+__name(KeyOperationsToJSON, "KeyOperationsToJSON");
+
+// src/models/JwkUse.ts
+function JwkUseFromJSON(json) {
+  return JwkUseFromJSONTyped(json, false);
+}
+__name(JwkUseFromJSON, "JwkUseFromJSON");
+function JwkUseFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(JwkUseFromJSONTyped, "JwkUseFromJSONTyped");
+function JwkUseToJSON(value) {
+  return value;
+}
+__name(JwkUseToJSON, "JwkUseToJSON");
+
+// src/models/JwkKeyType.ts
+function JwkKeyTypeFromJSON(json) {
+  return JwkKeyTypeFromJSONTyped(json, false);
+}
+__name(JwkKeyTypeFromJSON, "JwkKeyTypeFromJSON");
+function JwkKeyTypeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(JwkKeyTypeFromJSONTyped, "JwkKeyTypeFromJSONTyped");
+function JwkKeyTypeToJSON(value) {
+  return value;
+}
+__name(JwkKeyTypeToJSON, "JwkKeyTypeToJSON");
+
+// src/models/Jwk.ts
+function JwkFromJSON(json) {
+  return JwkFromJSONTyped(json, false);
+}
+__name(JwkFromJSON, "JwkFromJSON");
+function JwkFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "kty": JwkKeyTypeFromJSON(json["kty"]),
+    "kid": json["kid"] == null ? void 0 : json["kid"],
+    "alg": json["alg"] == null ? void 0 : json["alg"],
+    "use": json["use"] == null ? void 0 : JwkUseFromJSON(json["use"]),
+    "keyOps": json["key_ops"] == null ? void 0 : json["key_ops"].map(KeyOperationsFromJSON),
+    "crv": json["crv"] == null ? void 0 : CurveFromJSON(json["crv"]),
+    "x": json["x"] == null ? void 0 : json["x"],
+    "y": json["y"] == null ? void 0 : json["y"],
+    "d": json["d"] == null ? void 0 : json["d"],
+    "n": json["n"] == null ? void 0 : json["n"],
+    "e": json["e"] == null ? void 0 : json["e"],
+    "p": json["p"] == null ? void 0 : json["p"],
+    "q": json["q"] == null ? void 0 : json["q"],
+    "dp": json["dp"] == null ? void 0 : json["dp"],
+    "dq": json["dq"] == null ? void 0 : json["dq"],
+    "qi": json["qi"] == null ? void 0 : json["qi"],
+    "k": json["k"] == null ? void 0 : json["k"],
+    "x5c": json["x5c"] == null ? void 0 : json["x5c"],
+    "x5t": json["x5t"] == null ? void 0 : json["x5t"],
+    "x5u": json["x5u"] == null ? void 0 : json["x5u"],
+    "x5tS256": json["x5t#S256"] == null ? void 0 : json["x5t#S256"]
+  };
+}
+__name(JwkFromJSONTyped, "JwkFromJSONTyped");
+function JwkToJSON(json) {
+  return JwkToJSONTyped(json, false);
+}
+__name(JwkToJSON, "JwkToJSON");
+function JwkToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "kty": JwkKeyTypeToJSON(value["kty"]),
+    "kid": value["kid"],
+    "alg": value["alg"],
+    "use": JwkUseToJSON(value["use"]),
+    "key_ops": value["keyOps"] == null ? void 0 : value["keyOps"].map(KeyOperationsToJSON),
+    "crv": CurveToJSON(value["crv"]),
+    "x": value["x"],
+    "y": value["y"],
+    "d": value["d"],
+    "n": value["n"],
+    "e": value["e"],
+    "p": value["p"],
+    "q": value["q"],
+    "dp": value["dp"],
+    "dq": value["dq"],
+    "qi": value["qi"],
+    "k": value["k"],
+    "x5c": value["x5c"],
+    "x5t": value["x5t"],
+    "x5u": value["x5u"],
+    "x5t#S256": value["x5tS256"]
+  };
+}
+__name(JwkToJSONTyped, "JwkToJSONTyped");
+
+// src/models/KeyInfo.ts
+function KeyInfoToJSON(json) {
+  return KeyInfoToJSONTyped(json, false);
+}
+__name(KeyInfoToJSON, "KeyInfoToJSON");
+function KeyInfoToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "kid": value["kid"],
+    "key": JwkToJSON(value["key"]),
+    "signatureAlgorithm": SignatureAlgorithmToJSON(value["signatureAlgorithm"]),
+    "keyVisibility": KeyVisibilityToJSON(value["keyVisibility"]),
+    "x5c": value["x5c"],
+    "alias": value["alias"],
+    "providerId": value["providerId"],
+    "keyType": KeyTypeToJSON(value["keyType"]),
+    "keyEncoding": KeyEncodingToJSON(value["keyEncoding"]),
+    "opts": value["opts"]
+  };
+}
+__name(KeyInfoToJSONTyped, "KeyInfoToJSONTyped");
+
+// src/models/CreateRawSignature.ts
+function CreateRawSignatureToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "keyInfo": KeyInfoToJSON(value["keyInfo"]),
+    "input": value["input"]
+  };
+}
+__name(CreateRawSignatureToJSONTyped, "CreateRawSignatureToJSONTyped");
+
+// src/models/CreateRawSignatureResponse.ts
+function CreateRawSignatureResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "signature": json["signature"]
+  };
+}
+__name(CreateRawSignatureResponseFromJSONTyped, "CreateRawSignatureResponseFromJSONTyped");
+
+// src/models/GenerateKey.ts
+function GenerateKeyToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "alias": value["alias"],
+    "use": JwkUseToJSON(value["use"]),
+    "keyOperations": value["keyOperations"] == null ? void 0 : value["keyOperations"].map(KeyOperationsToJSON),
+    "alg": SignatureAlgorithmToJSON(value["alg"])
+  };
+}
+__name(GenerateKeyToJSONTyped, "GenerateKeyToJSONTyped");
+
+// src/models/GenerateKeyGlobal.ts
+function GenerateKeyGlobalToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "alias": value["alias"],
+    "use": JwkUseToJSON(value["use"]),
+    "keyOperations": value["keyOperations"] == null ? void 0 : value["keyOperations"].map(KeyOperationsToJSON),
+    "alg": SignatureAlgorithmToJSON(value["alg"]),
+    "providerId": value["providerId"]
+  };
+}
+__name(GenerateKeyGlobalToJSONTyped, "GenerateKeyGlobalToJSONTyped");
+
+// src/models/JoseKeyPair.ts
+function JoseKeyPairFromJSON(json) {
+  return JoseKeyPairFromJSONTyped(json, false);
+}
+__name(JoseKeyPairFromJSON, "JoseKeyPairFromJSON");
+function JoseKeyPairFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "privateJwk": json["privateJwk"] == null ? void 0 : JwkFromJSON(json["privateJwk"]),
+    "publicJwk": JwkFromJSON(json["publicJwk"])
+  };
+}
+__name(JoseKeyPairFromJSONTyped, "JoseKeyPairFromJSONTyped");
+
+// src/models/ManagedKeyPair.ts
+function ManagedKeyPairFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "kid": json["kid"] == null ? void 0 : json["kid"],
+    "providerId": json["providerId"],
+    "alias": json["alias"],
+    "cose": CoseKeyPairFromJSON(json["cose"]),
+    "jose": JoseKeyPairFromJSON(json["jose"])
+  };
+}
+__name(ManagedKeyPairFromJSONTyped, "ManagedKeyPairFromJSONTyped");
+
+// src/models/ManagedKeyInfo.ts
+function ManagedKeyInfoFromJSON(json) {
+  return ManagedKeyInfoFromJSONTyped(json, false);
+}
+__name(ManagedKeyInfoFromJSON, "ManagedKeyInfoFromJSON");
+function ManagedKeyInfoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "kid": json["kid"] == null ? void 0 : json["kid"],
+    "key": JwkFromJSON(json["key"]),
+    "signatureAlgorithm": json["signatureAlgorithm"] == null ? void 0 : SignatureAlgorithmFromJSON(json["signatureAlgorithm"]),
+    "keyVisibility": json["keyVisibility"] == null ? void 0 : KeyVisibilityFromJSON(json["keyVisibility"]),
+    "x5c": json["x5c"] == null ? void 0 : json["x5c"],
+    "alias": json["alias"],
+    "providerId": json["providerId"],
+    "keyType": json["keyType"] == null ? void 0 : KeyTypeFromJSON(json["keyType"]),
+    "keyEncoding": json["keyEncoding"] == null ? void 0 : KeyEncodingFromJSON(json["keyEncoding"]),
+    "opts": json["opts"] == null ? void 0 : json["opts"]
+  };
+}
+__name(ManagedKeyInfoFromJSONTyped, "ManagedKeyInfoFromJSONTyped");
+
+// src/models/IdentifierMethod.ts
+function IdentifierMethodFromJSON(json) {
+  return IdentifierMethodFromJSONTyped(json, false);
+}
+__name(IdentifierMethodFromJSON, "IdentifierMethodFromJSON");
+function IdentifierMethodFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(IdentifierMethodFromJSONTyped, "IdentifierMethodFromJSONTyped");
+function IdentifierMethodToJSON(value) {
+  return value;
+}
+__name(IdentifierMethodToJSON, "IdentifierMethodToJSON");
+
+// src/models/KeyProvider.ts
+function KeyProviderFromJSON(json) {
+  return KeyProviderFromJSONTyped(json, false);
+}
+__name(KeyProviderFromJSON, "KeyProviderFromJSON");
+function KeyProviderFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "providerId": json["providerId"],
+    "type": KeyProviderTypeFromJSON(json["type"])
+  };
+}
+__name(KeyProviderFromJSONTyped, "KeyProviderFromJSONTyped");
+
+// src/models/KeyProviderResponse.ts
+function KeyProviderResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "providerId": json["providerId"],
+    "type": KeyProviderTypeFromJSON(json["type"])
+  };
+}
+__name(KeyProviderResponseFromJSONTyped, "KeyProviderResponseFromJSONTyped");
+
+// src/models/ListKeyProvidersResponse.ts
+function ListKeyProvidersResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "providers": json["providers"].map(KeyProviderFromJSON)
+  };
+}
+__name(ListKeyProvidersResponseFromJSONTyped, "ListKeyProvidersResponseFromJSONTyped");
+
+// src/models/ListKeysResponse.ts
+function ListKeysResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "keyInfos": json["keyInfos"].map(ManagedKeyInfoFromJSON)
+  };
+}
+__name(ListKeysResponseFromJSONTyped, "ListKeysResponseFromJSONTyped");
+
+// src/models/Resolver.ts
+function ResolverFromJSON(json) {
+  return ResolverFromJSONTyped(json, false);
+}
+__name(ResolverFromJSON, "ResolverFromJSON");
+function ResolverFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "resolverId": json["resolverId"],
+    "supportedIdentifierMethods": json["supportedIdentifierMethods"] == null ? void 0 : json["supportedIdentifierMethods"].map(IdentifierMethodFromJSON),
+    "supportedKeyTypes": json["supportedKeyTypes"] == null ? void 0 : json["supportedKeyTypes"].map(KeyTypeFromJSON)
+  };
+}
+__name(ResolverFromJSONTyped, "ResolverFromJSONTyped");
+
+// src/models/ListResolversResponse.ts
+function ListResolversResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "resolvers": json["resolvers"].map(ResolverFromJSON)
+  };
+}
+__name(ListResolversResponseFromJSONTyped, "ListResolversResponseFromJSONTyped");
+
+// src/models/ResolvePublicKey.ts
+function ResolvePublicKeyToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "keyInfo": KeyInfoToJSON(value["keyInfo"]),
+    "identifierMethod": IdentifierMethodToJSON(value["identifierMethod"]),
+    "trustedCerts": value["trustedCerts"],
+    "verifyX509CertificateChain": value["verifyX509CertificateChain"]
+  };
+}
+__name(ResolvePublicKeyToJSONTyped, "ResolvePublicKeyToJSONTyped");
+
+// src/models/ResolvedKeyInfo.ts
+function ResolvedKeyInfoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "kid": json["kid"] == null ? void 0 : json["kid"],
+    "key": JwkFromJSON(json["key"]),
+    "signatureAlgorithm": json["signatureAlgorithm"] == null ? void 0 : SignatureAlgorithmFromJSON(json["signatureAlgorithm"]),
+    "keyVisibility": json["keyVisibility"] == null ? void 0 : KeyVisibilityFromJSON(json["keyVisibility"]),
+    "x5c": json["x5c"] == null ? void 0 : json["x5c"],
+    "alias": json["alias"] == null ? void 0 : json["alias"],
+    "providerId": json["providerId"] == null ? void 0 : json["providerId"],
+    "keyType": json["keyType"] == null ? void 0 : KeyTypeFromJSON(json["keyType"]),
+    "keyEncoding": json["keyEncoding"] == null ? void 0 : KeyEncodingFromJSON(json["keyEncoding"]),
+    "opts": json["opts"] == null ? void 0 : json["opts"]
+  };
+}
+__name(ResolvedKeyInfoFromJSONTyped, "ResolvedKeyInfoFromJSONTyped");
+function ResolvedKeyInfoToJSON(json) {
+  return ResolvedKeyInfoToJSONTyped(json, false);
+}
+__name(ResolvedKeyInfoToJSON, "ResolvedKeyInfoToJSON");
+function ResolvedKeyInfoToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "kid": value["kid"],
+    "key": JwkToJSON(value["key"]),
+    "signatureAlgorithm": SignatureAlgorithmToJSON(value["signatureAlgorithm"]),
+    "keyVisibility": KeyVisibilityToJSON(value["keyVisibility"]),
+    "x5c": value["x5c"],
+    "alias": value["alias"],
+    "providerId": value["providerId"],
+    "keyType": KeyTypeToJSON(value["keyType"]),
+    "keyEncoding": KeyEncodingToJSON(value["keyEncoding"]),
+    "opts": value["opts"]
+  };
+}
+__name(ResolvedKeyInfoToJSONTyped, "ResolvedKeyInfoToJSONTyped");
+
+// src/models/StoreKey.ts
+function StoreKeyToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "keyInfo": ResolvedKeyInfoToJSON(value["keyInfo"]),
+    "certChain": value["certChain"]
+  };
+}
+__name(StoreKeyToJSONTyped, "StoreKeyToJSONTyped");
+
+// src/models/VerifyRawSignature.ts
+function VerifyRawSignatureToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "keyInfo": KeyInfoToJSON(value["keyInfo"]),
+    "input": value["input"],
+    "signature": value["signature"]
+  };
+}
+__name(VerifyRawSignatureToJSONTyped, "VerifyRawSignatureToJSONTyped");
+
+// src/models/VerifyRawSignatureResponse.ts
+function VerifyRawSignatureResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "isValid": json["isValid"]
+  };
+}
+__name(VerifyRawSignatureResponseFromJSONTyped, "VerifyRawSignatureResponseFromJSONTyped");
+
+// src/agent/KmsRestClient.ts
+var logger = import_ssi_types.Loggers.DEFAULT.get("sphereon:ssi-sdk:kms:rest-client");
+var KmsRestClient = class _KmsRestClient {
+  static {
+    __name(this, "KmsRestClient");
+  }
+  methods = {
+    kmsGetKey: this.kmsGetKey.bind(this),
+    kmsListKeys: this.kmsListKeys.bind(this),
+    kmsStoreKey: this.kmsStoreKey.bind(this),
+    kmsGenerateKey: this.kmsGenerateKey.bind(this),
+    kmsDeleteKey: this.kmsDeleteKey.bind(this),
+    kmsGetKeyProvider: this.kmsGetKeyProvider.bind(this),
+    kmsListKeyProviders: this.kmsListKeyProviders.bind(this),
+    kmsProviderListKeys: this.kmsProviderListKeys.bind(this),
+    kmsProviderStoreKey: this.kmsProviderStoreKey.bind(this),
+    kmsProviderGenerateKey: this.kmsProviderGenerateKey.bind(this),
+    kmsProviderGetKey: this.kmsProviderGetKey.bind(this),
+    kmsProviderDeleteKey: this.kmsProviderDeleteKey.bind(this),
+    kmsGetResolver: this.kmsGetResolver.bind(this),
+    kmsListResolvers: this.kmsListResolvers.bind(this),
+    kmsResolveKey: this.kmsResolveKey.bind(this),
+    kmsCreateRawSignature: this.kmsCreateRawSignature.bind(this),
+    kmsIsValidRawSignature: this.kmsIsValidRawSignature.bind(this)
+  };
+  agentBaseUrl;
+  authOpts;
+  constructor(args) {
+    if (args?.baseUrl) {
+      this.agentBaseUrl = args.baseUrl;
+    }
+    this.authOpts = args?.authentication;
+  }
+  static urlWithBase(path, baseUrl) {
+    return `${baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+  }
+  /** {@inheritDoc IKmsRestClient.kmsGetResolver} */
+  async kmsGetResolver(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase(`/resolvers/${args.resolverId}`, baseUrl);
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "GET"
+    });
+    logger.debug(`get resolver response: ${response}`);
+    try {
+      return ResolverFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsListResolvers} */
+  async kmsListResolvers(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase("/resolvers", baseUrl);
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "GET"
+    });
+    logger.debug(`list resolvers response: ${response}`);
+    try {
+      return ListResolversResponseFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsResolveKey} */
+  async kmsResolveKey(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase(`/resolvers/${args.resolverId}/resolve`, baseUrl);
+    const body = {
+      keyInfo: args.keyInfo,
+      identifierMethod: args.identifierMethod,
+      trustedCerts: args.trustedCerts,
+      verifyX509CertificateChain: args.verifyX509CertificateChain
+    };
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "POST",
+      headers: await this.createHeaders({
+        "Content-Type": "application/json"
+      }),
+      body: JSON.stringify(ResolvePublicKeyToJSONTyped(body))
+    });
+    logger.debug(`resolve key response: ${response}`);
+    try {
+      return ResolvedKeyInfoFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsCreateRawSignature} */
+  async kmsCreateRawSignature(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase(`/signatures/raw`, baseUrl);
+    const body = {
+      keyInfo: args.keyInfo,
+      input: args.input
+    };
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "POST",
+      headers: await this.createHeaders({
+        "Content-Type": "application/json"
+      }),
+      body: JSON.stringify(CreateRawSignatureToJSONTyped(body))
+    });
+    logger.debug(`create raw signature response: ${response}`);
+    try {
+      return CreateRawSignatureResponseFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsIsValidRawSignature} */
+  async kmsIsValidRawSignature(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase(`/signatures/raw/verify`, baseUrl);
+    const body = {
+      keyInfo: args.keyInfo,
+      signature: args.signature,
+      input: args.input
+    };
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "POST",
+      headers: await this.createHeaders({
+        "Content-Type": "application/json"
+      }),
+      body: JSON.stringify(VerifyRawSignatureToJSONTyped(body))
+    });
+    logger.debug(`verify raw signature response: ${response}`);
+    try {
+      return VerifyRawSignatureResponseFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsGetKey} */
+  async kmsGetKey(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase(`/keys/${args.aliasOrKid}`, baseUrl);
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "GET"
+    });
+    logger.debug(`get key response: ${response}`);
+    try {
+      return ManagedKeyInfoFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsListKeys} */
+  async kmsListKeys(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = this.addSearchParams(_KmsRestClient.urlWithBase("/keys", baseUrl), {
+      ...args.providerId && {
+        providerId: args.providerId
+      }
+    });
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "GET"
+    });
+    logger.debug(`list keys response: ${response}`);
+    try {
+      const xx = await response.json();
+      return ListKeysResponseFromJSONTyped(xx, false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsStoreKey} */
+  async kmsStoreKey(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase(`/keys`, baseUrl);
+    const body = {
+      keyInfo: args.keyInfo,
+      certChain: args.certChain
+    };
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "POST",
+      headers: await this.createHeaders({
+        "Content-Type": "application/json"
+      }),
+      body: JSON.stringify(StoreKeyToJSONTyped(body))
+    });
+    logger.debug(`store key response: ${response}`);
+    try {
+      return ManagedKeyInfoFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsGenerateKey} */
+  async kmsGenerateKey(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase(`/keys/generate`, baseUrl);
+    const body = {
+      alg: args.alg,
+      keyOperations: args.keyOperations,
+      providerId: args.providerId,
+      use: args.use
+    };
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "POST",
+      headers: await this.createHeaders({
+        "Content-Type": "application/json"
+      }),
+      body: JSON.stringify(GenerateKeyGlobalToJSONTyped(body))
+    });
+    logger.debug(`generate key response: ${response}`);
+    try {
+      return ManagedKeyPairFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsDeleteKey} */
+  async kmsDeleteKey(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase(`/keys/${args.aliasOrKid}`, baseUrl);
+    await (0, import_cross_fetch.fetch)(url, {
+      method: "DELETE"
+    });
+    return true;
+  }
+  /** {@inheritDoc IKmsRestClient.kmsGetKeyProvider} */
+  async kmsGetKeyProvider(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase(`/providers/${args.providerId}`, baseUrl);
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "GET"
+    });
+    logger.debug(`get provider response: ${response}`);
+    try {
+      return KeyProviderResponseFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsListKeyProviders} */
+  async kmsListKeyProviders(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase("/providers", baseUrl);
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "GET"
+    });
+    logger.debug(`list providers response: ${response}`);
+    try {
+      return ListKeyProvidersResponseFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsProviderListKeys} */
+  async kmsProviderListKeys(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase(`/providers/${args.providerId}/keys`, baseUrl);
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "GET"
+    });
+    logger.debug(`list provider keys response: ${response}`);
+    try {
+      return ListKeysResponseFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsProviderStoreKey} */
+  async kmsProviderStoreKey(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase(`/providers/${args.providerId}/keys`, baseUrl);
+    const body = {
+      keyInfo: args.keyInfo,
+      certChain: args.certChain
+    };
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "POST",
+      headers: await this.createHeaders({
+        "Content-Type": "application/json"
+      }),
+      body: JSON.stringify(StoreKeyToJSONTyped(body))
+    });
+    logger.debug(`provider store key response: ${response}`);
+    try {
+      return ManagedKeyInfoFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsProviderGenerateKey} */
+  async kmsProviderGenerateKey(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase(`/providers/${args.providerId}/keys/generate`, baseUrl);
+    const body = {
+      alg: args.alg,
+      keyOperations: args.keyOperations,
+      use: args.use
+    };
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "POST",
+      headers: await this.createHeaders({
+        "Content-Type": "application/json"
+      }),
+      body: JSON.stringify(GenerateKeyToJSONTyped(body))
+    });
+    logger.debug(`provider generate key response: ${response}`);
+    try {
+      return ManagedKeyPairFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsProviderGetKey} */
+  async kmsProviderGetKey(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase(`/providers/${args.providerId}/keys/${args.aliasOrKid}`, baseUrl);
+    const response = await (0, import_cross_fetch.fetch)(url, {
+      method: "GET"
+    });
+    logger.debug(`get provider key response: ${response}`);
+    try {
+      return ManagedKeyInfoFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsProviderDeleteKey} */
+  async kmsProviderDeleteKey(args) {
+    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const url = _KmsRestClient.urlWithBase(`providers/${args.providerId}/keys/${args.aliasOrKid}`, baseUrl);
+    await (0, import_cross_fetch.fetch)(url, {
+      method: "DELETE"
+    });
+    return true;
+  }
+  assertedAgentBaseUrl(baseUrl) {
+    if (baseUrl) {
+      return baseUrl;
+    } else if (this.agentBaseUrl) {
+      return this.agentBaseUrl;
+    }
+    throw new Error("No base url has been provided");
+  }
+  async createHeaders(existing) {
+    const headers = {
+      ...existing,
+      Accept: "application/json"
+    };
+    if (this.authOpts?.enabled === true) {
+      if (!this.authOpts.bearerToken) {
+        throw Error(`Cannot have authentication enabled, whilst not enabling static bearer tokens at this point`);
+      }
+      headers.Authorization = `Bearer ${typeof this.authOpts.bearerToken === "string" ? this.authOpts.bearerToken : await this.authOpts.bearerToken()}`;
+    }
+    return headers;
+  }
+  addSearchParams(baseUrl, params) {
+    const url = new URL(baseUrl);
+    for (const [key, value] of Object.entries(params)) {
+      url.searchParams.set(key, String(value));
+    }
+    return url;
+  }
+};
+
+// src/index.ts
+var schema = require_plugin_schema();
+//# sourceMappingURL=index.cjs.map