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

package/dist/index.cjs

@@ -0,0 +1,3924 @@
+"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 __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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AwsAssumeRoleCredentialsFromJSON: () => AwsAssumeRoleCredentialsFromJSON,
+  AwsAssumeRoleCredentialsFromJSONTyped: () => AwsAssumeRoleCredentialsFromJSONTyped,
+  AwsAssumeRoleCredentialsToJSON: () => AwsAssumeRoleCredentialsToJSON,
+  AwsAssumeRoleCredentialsToJSONTyped: () => AwsAssumeRoleCredentialsToJSONTyped,
+  AwsClientConfigurationFromJSON: () => AwsClientConfigurationFromJSON,
+  AwsClientConfigurationFromJSONTyped: () => AwsClientConfigurationFromJSONTyped,
+  AwsClientConfigurationToJSON: () => AwsClientConfigurationToJSON,
+  AwsClientConfigurationToJSONTyped: () => AwsClientConfigurationToJSONTyped,
+  AwsKmsSettingFromJSON: () => AwsKmsSettingFromJSON,
+  AwsKmsSettingFromJSONTyped: () => AwsKmsSettingFromJSONTyped,
+  AwsKmsSettingToJSON: () => AwsKmsSettingToJSON,
+  AwsKmsSettingToJSONTyped: () => AwsKmsSettingToJSONTyped,
+  AwsStaticCredentialsFromJSON: () => AwsStaticCredentialsFromJSON,
+  AwsStaticCredentialsFromJSONTyped: () => AwsStaticCredentialsFromJSONTyped,
+  AwsStaticCredentialsToJSON: () => AwsStaticCredentialsToJSON,
+  AwsStaticCredentialsToJSONTyped: () => AwsStaticCredentialsToJSONTyped,
+  AwsWebIdentityTokenCredentialsFromJSON: () => AwsWebIdentityTokenCredentialsFromJSON,
+  AwsWebIdentityTokenCredentialsFromJSONTyped: () => AwsWebIdentityTokenCredentialsFromJSONTyped,
+  AwsWebIdentityTokenCredentialsToJSON: () => AwsWebIdentityTokenCredentialsToJSON,
+  AwsWebIdentityTokenCredentialsToJSONTyped: () => AwsWebIdentityTokenCredentialsToJSONTyped,
+  AzureClientSecretCredentialOptsFromJSON: () => AzureClientSecretCredentialOptsFromJSON,
+  AzureClientSecretCredentialOptsFromJSONTyped: () => AzureClientSecretCredentialOptsFromJSONTyped,
+  AzureClientSecretCredentialOptsToJSON: () => AzureClientSecretCredentialOptsToJSON,
+  AzureClientSecretCredentialOptsToJSONTyped: () => AzureClientSecretCredentialOptsToJSONTyped,
+  AzureCredentialOptsFromJSON: () => AzureCredentialOptsFromJSON,
+  AzureCredentialOptsFromJSONTyped: () => AzureCredentialOptsFromJSONTyped,
+  AzureCredentialOptsToJSON: () => AzureCredentialOptsToJSON,
+  AzureCredentialOptsToJSONTyped: () => AzureCredentialOptsToJSONTyped,
+  AzureKeyVaultSettingFromJSON: () => AzureKeyVaultSettingFromJSON,
+  AzureKeyVaultSettingFromJSONTyped: () => AzureKeyVaultSettingFromJSONTyped,
+  AzureKeyVaultSettingToJSON: () => AzureKeyVaultSettingToJSON,
+  AzureKeyVaultSettingToJSONTyped: () => AzureKeyVaultSettingToJSONTyped,
+  CoseKeyFromJSON: () => CoseKeyFromJSON,
+  CoseKeyFromJSONTyped: () => CoseKeyFromJSONTyped,
+  CoseKeyPairFromJSON: () => CoseKeyPairFromJSON,
+  CoseKeyPairFromJSONTyped: () => CoseKeyPairFromJSONTyped,
+  CoseKeyPairToJSON: () => CoseKeyPairToJSON,
+  CoseKeyPairToJSONTyped: () => CoseKeyPairToJSONTyped,
+  CoseKeyToJSON: () => CoseKeyToJSON,
+  CoseKeyToJSONTyped: () => CoseKeyToJSONTyped,
+  CoseKeyType: () => CoseKeyType,
+  CoseKeyTypeFromJSON: () => CoseKeyTypeFromJSON,
+  CoseKeyTypeFromJSONTyped: () => CoseKeyTypeFromJSONTyped,
+  CoseKeyTypeToJSON: () => CoseKeyTypeToJSON,
+  CoseKeyTypeToJSONTyped: () => CoseKeyTypeToJSONTyped,
+  CreateKeyProviderFromJSON: () => CreateKeyProviderFromJSON,
+  CreateKeyProviderFromJSONTyped: () => CreateKeyProviderFromJSONTyped,
+  CreateKeyProviderToJSON: () => CreateKeyProviderToJSON,
+  CreateKeyProviderToJSONTyped: () => CreateKeyProviderToJSONTyped,
+  CreateRawSignatureFromJSON: () => CreateRawSignatureFromJSON,
+  CreateRawSignatureFromJSONTyped: () => CreateRawSignatureFromJSONTyped,
+  CreateRawSignatureResponseFromJSON: () => CreateRawSignatureResponseFromJSON,
+  CreateRawSignatureResponseFromJSONTyped: () => CreateRawSignatureResponseFromJSONTyped,
+  CreateRawSignatureResponseToJSON: () => CreateRawSignatureResponseToJSON,
+  CreateRawSignatureResponseToJSONTyped: () => CreateRawSignatureResponseToJSONTyped,
+  CreateRawSignatureToJSON: () => CreateRawSignatureToJSON,
+  CreateRawSignatureToJSONTyped: () => CreateRawSignatureToJSONTyped,
+  CreateSimpleSignatureFromJSON: () => CreateSimpleSignatureFromJSON,
+  CreateSimpleSignatureFromJSONTyped: () => CreateSimpleSignatureFromJSONTyped,
+  CreateSimpleSignatureToJSON: () => CreateSimpleSignatureToJSON,
+  CreateSimpleSignatureToJSONTyped: () => CreateSimpleSignatureToJSONTyped,
+  CryptoAlg: () => CryptoAlg,
+  CryptoAlgFromJSON: () => CryptoAlgFromJSON,
+  CryptoAlgFromJSONTyped: () => CryptoAlgFromJSONTyped,
+  CryptoAlgToJSON: () => CryptoAlgToJSON,
+  CryptoAlgToJSONTyped: () => CryptoAlgToJSONTyped,
+  Curve: () => Curve,
+  CurveFromJSON: () => CurveFromJSON,
+  CurveFromJSONTyped: () => CurveFromJSONTyped,
+  CurveToJSON: () => CurveToJSON,
+  CurveToJSONTyped: () => CurveToJSONTyped,
+  DigestAlg: () => DigestAlg,
+  DigestAlgFromJSON: () => DigestAlgFromJSON,
+  DigestAlgFromJSONTyped: () => DigestAlgFromJSONTyped,
+  DigestAlgToJSON: () => DigestAlgToJSON,
+  DigestAlgToJSONTyped: () => DigestAlgToJSONTyped,
+  ErrorResponseFromJSON: () => ErrorResponseFromJSON,
+  ErrorResponseFromJSONTyped: () => ErrorResponseFromJSONTyped,
+  ErrorResponseToJSON: () => ErrorResponseToJSON,
+  ErrorResponseToJSONTyped: () => ErrorResponseToJSONTyped,
+  GenerateKeyFromJSON: () => GenerateKeyFromJSON,
+  GenerateKeyFromJSONTyped: () => GenerateKeyFromJSONTyped,
+  GenerateKeyGlobalFromJSON: () => GenerateKeyGlobalFromJSON,
+  GenerateKeyGlobalFromJSONTyped: () => GenerateKeyGlobalFromJSONTyped,
+  GenerateKeyGlobalToJSON: () => GenerateKeyGlobalToJSON,
+  GenerateKeyGlobalToJSONTyped: () => GenerateKeyGlobalToJSONTyped,
+  GenerateKeyResponseFromJSON: () => GenerateKeyResponseFromJSON,
+  GenerateKeyResponseFromJSONTyped: () => GenerateKeyResponseFromJSONTyped,
+  GenerateKeyResponseToJSON: () => GenerateKeyResponseToJSON,
+  GenerateKeyResponseToJSONTyped: () => GenerateKeyResponseToJSONTyped,
+  GenerateKeyToJSON: () => GenerateKeyToJSON,
+  GenerateKeyToJSONTyped: () => GenerateKeyToJSONTyped,
+  GetKeyResponseFromJSON: () => GetKeyResponseFromJSON,
+  GetKeyResponseFromJSONTyped: () => GetKeyResponseFromJSONTyped,
+  GetKeyResponseToJSON: () => GetKeyResponseToJSON,
+  GetKeyResponseToJSONTyped: () => GetKeyResponseToJSONTyped,
+  IdentifierMethod: () => IdentifierMethod,
+  IdentifierMethodFromJSON: () => IdentifierMethodFromJSON,
+  IdentifierMethodFromJSONTyped: () => IdentifierMethodFromJSONTyped,
+  IdentifierMethodToJSON: () => IdentifierMethodToJSON,
+  IdentifierMethodToJSONTyped: () => IdentifierMethodToJSONTyped,
+  JoseKeyPairFromJSON: () => JoseKeyPairFromJSON,
+  JoseKeyPairFromJSONTyped: () => JoseKeyPairFromJSONTyped,
+  JoseKeyPairToJSON: () => JoseKeyPairToJSON,
+  JoseKeyPairToJSONTyped: () => JoseKeyPairToJSONTyped,
+  JwkFromJSON: () => JwkFromJSON,
+  JwkFromJSONTyped: () => JwkFromJSONTyped,
+  JwkKeyType: () => JwkKeyType,
+  JwkKeyTypeFromJSON: () => JwkKeyTypeFromJSON,
+  JwkKeyTypeFromJSONTyped: () => JwkKeyTypeFromJSONTyped,
+  JwkKeyTypeToJSON: () => JwkKeyTypeToJSON,
+  JwkKeyTypeToJSONTyped: () => JwkKeyTypeToJSONTyped,
+  JwkToJSON: () => JwkToJSON,
+  JwkToJSONTyped: () => JwkToJSONTyped,
+  JwkUse: () => JwkUse,
+  JwkUseFromJSON: () => JwkUseFromJSON,
+  JwkUseFromJSONTyped: () => JwkUseFromJSONTyped,
+  JwkUseToJSON: () => JwkUseToJSON,
+  JwkUseToJSONTyped: () => JwkUseToJSONTyped,
+  KeyEncoding: () => KeyEncoding,
+  KeyEncodingFromJSON: () => KeyEncodingFromJSON,
+  KeyEncodingFromJSONTyped: () => KeyEncodingFromJSONTyped,
+  KeyEncodingToJSON: () => KeyEncodingToJSON,
+  KeyEncodingToJSONTyped: () => KeyEncodingToJSONTyped,
+  KeyInfoFromJSON: () => KeyInfoFromJSON,
+  KeyInfoFromJSONTyped: () => KeyInfoFromJSONTyped,
+  KeyInfoToJSON: () => KeyInfoToJSON,
+  KeyInfoToJSONTyped: () => KeyInfoToJSONTyped,
+  KeyOperations: () => KeyOperations,
+  KeyOperationsFromJSON: () => KeyOperationsFromJSON,
+  KeyOperationsFromJSONTyped: () => KeyOperationsFromJSONTyped,
+  KeyOperationsToJSON: () => KeyOperationsToJSON,
+  KeyOperationsToJSONTyped: () => KeyOperationsToJSONTyped,
+  KeyProviderFromJSON: () => KeyProviderFromJSON,
+  KeyProviderFromJSONTyped: () => KeyProviderFromJSONTyped,
+  KeyProviderResponseFromJSON: () => KeyProviderResponseFromJSON,
+  KeyProviderResponseFromJSONTyped: () => KeyProviderResponseFromJSONTyped,
+  KeyProviderResponseToJSON: () => KeyProviderResponseToJSON,
+  KeyProviderResponseToJSONTyped: () => KeyProviderResponseToJSONTyped,
+  KeyProviderToJSON: () => KeyProviderToJSON,
+  KeyProviderToJSONTyped: () => KeyProviderToJSONTyped,
+  KeyProviderType: () => KeyProviderType,
+  KeyProviderTypeFromJSON: () => KeyProviderTypeFromJSON,
+  KeyProviderTypeFromJSONTyped: () => KeyProviderTypeFromJSONTyped,
+  KeyProviderTypeToJSON: () => KeyProviderTypeToJSON,
+  KeyProviderTypeToJSONTyped: () => KeyProviderTypeToJSONTyped,
+  KeyResolverFromJSON: () => KeyResolverFromJSON,
+  KeyResolverFromJSONTyped: () => KeyResolverFromJSONTyped,
+  KeyResolverToJSON: () => KeyResolverToJSON,
+  KeyResolverToJSONTyped: () => KeyResolverToJSONTyped,
+  KeyType: () => KeyType,
+  KeyTypeFromJSON: () => KeyTypeFromJSON,
+  KeyTypeFromJSONTyped: () => KeyTypeFromJSONTyped,
+  KeyTypeToJSON: () => KeyTypeToJSON,
+  KeyTypeToJSONTyped: () => KeyTypeToJSONTyped,
+  KeyVisibility: () => KeyVisibility,
+  KeyVisibilityFromJSON: () => KeyVisibilityFromJSON,
+  KeyVisibilityFromJSONTyped: () => KeyVisibilityFromJSONTyped,
+  KeyVisibilityToJSON: () => KeyVisibilityToJSON,
+  KeyVisibilityToJSONTyped: () => KeyVisibilityToJSONTyped,
+  KmsRestClient: () => KmsRestClient,
+  ListKeyProvidersResponseFromJSON: () => ListKeyProvidersResponseFromJSON,
+  ListKeyProvidersResponseFromJSONTyped: () => ListKeyProvidersResponseFromJSONTyped,
+  ListKeyProvidersResponseToJSON: () => ListKeyProvidersResponseToJSON,
+  ListKeyProvidersResponseToJSONTyped: () => ListKeyProvidersResponseToJSONTyped,
+  ListKeysResponseFromJSON: () => ListKeysResponseFromJSON,
+  ListKeysResponseFromJSONTyped: () => ListKeysResponseFromJSONTyped,
+  ListKeysResponseToJSON: () => ListKeysResponseToJSON,
+  ListKeysResponseToJSONTyped: () => ListKeysResponseToJSONTyped,
+  ListResolversResponseFromJSON: () => ListResolversResponseFromJSON,
+  ListResolversResponseFromJSONTyped: () => ListResolversResponseFromJSONTyped,
+  ListResolversResponseToJSON: () => ListResolversResponseToJSON,
+  ListResolversResponseToJSONTyped: () => ListResolversResponseToJSONTyped,
+  LookupMode: () => LookupMode,
+  LookupModeFromJSON: () => LookupModeFromJSON,
+  LookupModeFromJSONTyped: () => LookupModeFromJSONTyped,
+  LookupModeToJSON: () => LookupModeToJSON,
+  LookupModeToJSONTyped: () => LookupModeToJSONTyped,
+  ManagedKeyInfoFromJSON: () => ManagedKeyInfoFromJSON,
+  ManagedKeyInfoFromJSONTyped: () => ManagedKeyInfoFromJSONTyped,
+  ManagedKeyInfoToJSON: () => ManagedKeyInfoToJSON,
+  ManagedKeyInfoToJSONTyped: () => ManagedKeyInfoToJSONTyped,
+  ManagedKeyPairFromJSON: () => ManagedKeyPairFromJSON,
+  ManagedKeyPairFromJSONTyped: () => ManagedKeyPairFromJSONTyped,
+  ManagedKeyPairToJSON: () => ManagedKeyPairToJSON,
+  ManagedKeyPairToJSONTyped: () => ManagedKeyPairToJSONTyped,
+  MaskGenFunction: () => MaskGenFunction,
+  MaskGenFunctionFromJSON: () => MaskGenFunctionFromJSON,
+  MaskGenFunctionFromJSONTyped: () => MaskGenFunctionFromJSONTyped,
+  MaskGenFunctionToJSON: () => MaskGenFunctionToJSON,
+  MaskGenFunctionToJSONTyped: () => MaskGenFunctionToJSONTyped,
+  ProviderCapabilitiesFromJSON: () => ProviderCapabilitiesFromJSON,
+  ProviderCapabilitiesFromJSONTyped: () => ProviderCapabilitiesFromJSONTyped,
+  ProviderCapabilitiesToJSON: () => ProviderCapabilitiesToJSON,
+  ProviderCapabilitiesToJSONTyped: () => ProviderCapabilitiesToJSONTyped,
+  ResolvePublicKeyFromJSON: () => ResolvePublicKeyFromJSON,
+  ResolvePublicKeyFromJSONTyped: () => ResolvePublicKeyFromJSONTyped,
+  ResolvePublicKeyToJSON: () => ResolvePublicKeyToJSON,
+  ResolvePublicKeyToJSONTyped: () => ResolvePublicKeyToJSONTyped,
+  ResolvedKeyInfoFromJSON: () => ResolvedKeyInfoFromJSON,
+  ResolvedKeyInfoFromJSONTyped: () => ResolvedKeyInfoFromJSONTyped,
+  ResolvedKeyInfoToJSON: () => ResolvedKeyInfoToJSON,
+  ResolvedKeyInfoToJSONTyped: () => ResolvedKeyInfoToJSONTyped,
+  ResolverFromJSON: () => ResolverFromJSON,
+  ResolverFromJSONTyped: () => ResolverFromJSONTyped,
+  ResolverToJSON: () => ResolverToJSON,
+  ResolverToJSONTyped: () => ResolverToJSONTyped,
+  SignInputFromJSON: () => SignInputFromJSON,
+  SignInputFromJSONTyped: () => SignInputFromJSONTyped,
+  SignInputModeEnum: () => SignInputModeEnum,
+  SignInputToJSON: () => SignInputToJSON,
+  SignInputToJSONTyped: () => SignInputToJSONTyped,
+  SignOutputFromJSON: () => SignOutputFromJSON,
+  SignOutputFromJSONTyped: () => SignOutputFromJSONTyped,
+  SignOutputToJSON: () => SignOutputToJSON,
+  SignOutputToJSONTyped: () => SignOutputToJSONTyped,
+  SignatureAlgorithm: () => SignatureAlgorithm,
+  SignatureAlgorithmFromJSON: () => SignatureAlgorithmFromJSON,
+  SignatureAlgorithmFromJSONTyped: () => SignatureAlgorithmFromJSONTyped,
+  SignatureAlgorithmToJSON: () => SignatureAlgorithmToJSON,
+  SignatureAlgorithmToJSONTyped: () => SignatureAlgorithmToJSONTyped,
+  SignatureFromJSON: () => SignatureFromJSON,
+  SignatureFromJSONTyped: () => SignatureFromJSONTyped,
+  SignatureToJSON: () => SignatureToJSON,
+  SignatureToJSONTyped: () => SignatureToJSONTyped,
+  StoreKeyFromJSON: () => StoreKeyFromJSON,
+  StoreKeyFromJSONTyped: () => StoreKeyFromJSONTyped,
+  StoreKeyResponseFromJSON: () => StoreKeyResponseFromJSON,
+  StoreKeyResponseFromJSONTyped: () => StoreKeyResponseFromJSONTyped,
+  StoreKeyResponseToJSON: () => StoreKeyResponseToJSON,
+  StoreKeyResponseToJSONTyped: () => StoreKeyResponseToJSONTyped,
+  StoreKeyToJSON: () => StoreKeyToJSON,
+  StoreKeyToJSONTyped: () => StoreKeyToJSONTyped,
+  UpdateKeyProviderFromJSON: () => UpdateKeyProviderFromJSON,
+  UpdateKeyProviderFromJSONTyped: () => UpdateKeyProviderFromJSONTyped,
+  UpdateKeyProviderToJSON: () => UpdateKeyProviderToJSON,
+  UpdateKeyProviderToJSONTyped: () => UpdateKeyProviderToJSONTyped,
+  VerifyRawSignatureFromJSON: () => VerifyRawSignatureFromJSON,
+  VerifyRawSignatureFromJSONTyped: () => VerifyRawSignatureFromJSONTyped,
+  VerifyRawSignatureResponseFromJSON: () => VerifyRawSignatureResponseFromJSON,
+  VerifyRawSignatureResponseFromJSONTyped: () => VerifyRawSignatureResponseFromJSONTyped,
+  VerifyRawSignatureResponseToJSON: () => VerifyRawSignatureResponseToJSON,
+  VerifyRawSignatureResponseToJSONTyped: () => VerifyRawSignatureResponseToJSONTyped,
+  VerifyRawSignatureToJSON: () => VerifyRawSignatureToJSON,
+  VerifyRawSignatureToJSONTyped: () => VerifyRawSignatureToJSONTyped,
+  VerifySimpleSignatureFromJSON: () => VerifySimpleSignatureFromJSON,
+  VerifySimpleSignatureFromJSONTyped: () => VerifySimpleSignatureFromJSONTyped,
+  VerifySimpleSignatureToJSON: () => VerifySimpleSignatureToJSON,
+  VerifySimpleSignatureToJSONTyped: () => VerifySimpleSignatureToJSONTyped,
+  instanceOfAwsAssumeRoleCredentials: () => instanceOfAwsAssumeRoleCredentials,
+  instanceOfAwsClientConfiguration: () => instanceOfAwsClientConfiguration,
+  instanceOfAwsKmsSetting: () => instanceOfAwsKmsSetting,
+  instanceOfAwsStaticCredentials: () => instanceOfAwsStaticCredentials,
+  instanceOfAwsWebIdentityTokenCredentials: () => instanceOfAwsWebIdentityTokenCredentials,
+  instanceOfAzureClientSecretCredentialOpts: () => instanceOfAzureClientSecretCredentialOpts,
+  instanceOfAzureCredentialOpts: () => instanceOfAzureCredentialOpts,
+  instanceOfAzureKeyVaultSetting: () => instanceOfAzureKeyVaultSetting,
+  instanceOfCoseKey: () => instanceOfCoseKey,
+  instanceOfCoseKeyPair: () => instanceOfCoseKeyPair,
+  instanceOfCoseKeyType: () => instanceOfCoseKeyType,
+  instanceOfCreateKeyProvider: () => instanceOfCreateKeyProvider,
+  instanceOfCreateRawSignature: () => instanceOfCreateRawSignature,
+  instanceOfCreateRawSignatureResponse: () => instanceOfCreateRawSignatureResponse,
+  instanceOfCreateSimpleSignature: () => instanceOfCreateSimpleSignature,
+  instanceOfCryptoAlg: () => instanceOfCryptoAlg,
+  instanceOfCurve: () => instanceOfCurve,
+  instanceOfDigestAlg: () => instanceOfDigestAlg,
+  instanceOfErrorResponse: () => instanceOfErrorResponse,
+  instanceOfGenerateKey: () => instanceOfGenerateKey,
+  instanceOfGenerateKeyGlobal: () => instanceOfGenerateKeyGlobal,
+  instanceOfGenerateKeyResponse: () => instanceOfGenerateKeyResponse,
+  instanceOfGetKeyResponse: () => instanceOfGetKeyResponse,
+  instanceOfIdentifierMethod: () => instanceOfIdentifierMethod,
+  instanceOfJoseKeyPair: () => instanceOfJoseKeyPair,
+  instanceOfJwk: () => instanceOfJwk,
+  instanceOfJwkKeyType: () => instanceOfJwkKeyType,
+  instanceOfJwkUse: () => instanceOfJwkUse,
+  instanceOfKeyEncoding: () => instanceOfKeyEncoding,
+  instanceOfKeyInfo: () => instanceOfKeyInfo,
+  instanceOfKeyOperations: () => instanceOfKeyOperations,
+  instanceOfKeyProvider: () => instanceOfKeyProvider,
+  instanceOfKeyProviderResponse: () => instanceOfKeyProviderResponse,
+  instanceOfKeyProviderType: () => instanceOfKeyProviderType,
+  instanceOfKeyResolver: () => instanceOfKeyResolver,
+  instanceOfKeyType: () => instanceOfKeyType,
+  instanceOfKeyVisibility: () => instanceOfKeyVisibility,
+  instanceOfListKeyProvidersResponse: () => instanceOfListKeyProvidersResponse,
+  instanceOfListKeysResponse: () => instanceOfListKeysResponse,
+  instanceOfListResolversResponse: () => instanceOfListResolversResponse,
+  instanceOfLookupMode: () => instanceOfLookupMode,
+  instanceOfManagedKeyInfo: () => instanceOfManagedKeyInfo,
+  instanceOfManagedKeyPair: () => instanceOfManagedKeyPair,
+  instanceOfMaskGenFunction: () => instanceOfMaskGenFunction,
+  instanceOfProviderCapabilities: () => instanceOfProviderCapabilities,
+  instanceOfResolvePublicKey: () => instanceOfResolvePublicKey,
+  instanceOfResolvedKeyInfo: () => instanceOfResolvedKeyInfo,
+  instanceOfResolver: () => instanceOfResolver,
+  instanceOfSignInput: () => instanceOfSignInput,
+  instanceOfSignOutput: () => instanceOfSignOutput,
+  instanceOfSignature: () => instanceOfSignature,
+  instanceOfSignatureAlgorithm: () => instanceOfSignatureAlgorithm,
+  instanceOfStoreKey: () => instanceOfStoreKey,
+  instanceOfStoreKeyResponse: () => instanceOfStoreKeyResponse,
+  instanceOfUpdateKeyProvider: () => instanceOfUpdateKeyProvider,
+  instanceOfVerifyRawSignature: () => instanceOfVerifyRawSignature,
+  instanceOfVerifyRawSignatureResponse: () => instanceOfVerifyRawSignatureResponse,
+  instanceOfVerifySimpleSignature: () => instanceOfVerifySimpleSignature,
+  schema: () => plugin_schema_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// plugin.schema.json
+var plugin_schema_default = {
+  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/agent/KmsRestClient.ts
+var import_ssi_types = require("@sphereon/ssi-types");
+var import_cross_fetch = require("cross-fetch");
+
+// src/models/LookupMode.ts
+var LookupMode = {
+  Value: "VALUE",
+  ConfigService: "CONFIG_SERVICE",
+  SecretService: "SECRET_SERVICE"
+};
+function instanceOfLookupMode(value) {
+  for (const key in LookupMode) {
+    if (Object.prototype.hasOwnProperty.call(LookupMode, key)) {
+      if (LookupMode[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfLookupMode, "instanceOfLookupMode");
+function LookupModeFromJSON(json) {
+  return LookupModeFromJSONTyped(json, false);
+}
+__name(LookupModeFromJSON, "LookupModeFromJSON");
+function LookupModeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(LookupModeFromJSONTyped, "LookupModeFromJSONTyped");
+function LookupModeToJSON(value) {
+  return value;
+}
+__name(LookupModeToJSON, "LookupModeToJSON");
+function LookupModeToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(LookupModeToJSONTyped, "LookupModeToJSONTyped");
+
+// src/models/AwsAssumeRoleCredentials.ts
+function instanceOfAwsAssumeRoleCredentials(value) {
+  if (!("roleArn" in value) || value["roleArn"] === void 0) return false;
+  if (!("roleSessionName" in value) || value["roleSessionName"] === void 0) return false;
+  return true;
+}
+__name(instanceOfAwsAssumeRoleCredentials, "instanceOfAwsAssumeRoleCredentials");
+function AwsAssumeRoleCredentialsFromJSON(json) {
+  return AwsAssumeRoleCredentialsFromJSONTyped(json, false);
+}
+__name(AwsAssumeRoleCredentialsFromJSON, "AwsAssumeRoleCredentialsFromJSON");
+function AwsAssumeRoleCredentialsFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    roleArn: json["roleArn"],
+    roleSessionName: json["roleSessionName"],
+    externalId: json["externalId"] == null ? void 0 : json["externalId"],
+    lookupMode: json["lookupMode"] == null ? void 0 : LookupModeFromJSON(json["lookupMode"])
+  };
+}
+__name(AwsAssumeRoleCredentialsFromJSONTyped, "AwsAssumeRoleCredentialsFromJSONTyped");
+function AwsAssumeRoleCredentialsToJSON(json) {
+  return AwsAssumeRoleCredentialsToJSONTyped(json, false);
+}
+__name(AwsAssumeRoleCredentialsToJSON, "AwsAssumeRoleCredentialsToJSON");
+function AwsAssumeRoleCredentialsToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    roleArn: value["roleArn"],
+    roleSessionName: value["roleSessionName"],
+    externalId: value["externalId"],
+    lookupMode: LookupModeToJSON(value["lookupMode"])
+  };
+}
+__name(AwsAssumeRoleCredentialsToJSONTyped, "AwsAssumeRoleCredentialsToJSONTyped");
+
+// src/models/AwsClientConfiguration.ts
+function instanceOfAwsClientConfiguration(value) {
+  return true;
+}
+__name(instanceOfAwsClientConfiguration, "instanceOfAwsClientConfiguration");
+function AwsClientConfigurationFromJSON(json) {
+  return AwsClientConfigurationFromJSONTyped(json, false);
+}
+__name(AwsClientConfigurationFromJSON, "AwsClientConfigurationFromJSON");
+function AwsClientConfigurationFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    connectionTimeoutInMillis: json["connectionTimeoutInMillis"] == null ? void 0 : json["connectionTimeoutInMillis"],
+    socketTimeoutInMillis: json["socketTimeoutInMillis"] == null ? void 0 : json["socketTimeoutInMillis"]
+  };
+}
+__name(AwsClientConfigurationFromJSONTyped, "AwsClientConfigurationFromJSONTyped");
+function AwsClientConfigurationToJSON(json) {
+  return AwsClientConfigurationToJSONTyped(json, false);
+}
+__name(AwsClientConfigurationToJSON, "AwsClientConfigurationToJSON");
+function AwsClientConfigurationToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    connectionTimeoutInMillis: value["connectionTimeoutInMillis"],
+    socketTimeoutInMillis: value["socketTimeoutInMillis"]
+  };
+}
+__name(AwsClientConfigurationToJSONTyped, "AwsClientConfigurationToJSONTyped");
+
+// src/models/AwsStaticCredentials.ts
+function instanceOfAwsStaticCredentials(value) {
+  if (!("accesskid" in value) || value["accesskid"] === void 0) return false;
+  if (!("secretAccessKey" in value) || value["secretAccessKey"] === void 0) return false;
+  return true;
+}
+__name(instanceOfAwsStaticCredentials, "instanceOfAwsStaticCredentials");
+function AwsStaticCredentialsFromJSON(json) {
+  return AwsStaticCredentialsFromJSONTyped(json, false);
+}
+__name(AwsStaticCredentialsFromJSON, "AwsStaticCredentialsFromJSON");
+function AwsStaticCredentialsFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    accesskid: json["accesskid"],
+    secretAccessKey: json["secretAccessKey"],
+    sessionToken: json["sessionToken"] == null ? void 0 : json["sessionToken"],
+    lookupMode: json["lookupMode"] == null ? void 0 : LookupModeFromJSON(json["lookupMode"])
+  };
+}
+__name(AwsStaticCredentialsFromJSONTyped, "AwsStaticCredentialsFromJSONTyped");
+function AwsStaticCredentialsToJSON(json) {
+  return AwsStaticCredentialsToJSONTyped(json, false);
+}
+__name(AwsStaticCredentialsToJSON, "AwsStaticCredentialsToJSON");
+function AwsStaticCredentialsToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    accesskid: value["accesskid"],
+    secretAccessKey: value["secretAccessKey"],
+    sessionToken: value["sessionToken"],
+    lookupMode: LookupModeToJSON(value["lookupMode"])
+  };
+}
+__name(AwsStaticCredentialsToJSONTyped, "AwsStaticCredentialsToJSONTyped");
+
+// src/models/AwsWebIdentityTokenCredentials.ts
+function instanceOfAwsWebIdentityTokenCredentials(value) {
+  if (!("roleArn" in value) || value["roleArn"] === void 0) return false;
+  if (!("roleSessionName" in value) || value["roleSessionName"] === void 0) return false;
+  if (!("webIdentityToken" in value) || value["webIdentityToken"] === void 0) return false;
+  return true;
+}
+__name(instanceOfAwsWebIdentityTokenCredentials, "instanceOfAwsWebIdentityTokenCredentials");
+function AwsWebIdentityTokenCredentialsFromJSON(json) {
+  return AwsWebIdentityTokenCredentialsFromJSONTyped(json, false);
+}
+__name(AwsWebIdentityTokenCredentialsFromJSON, "AwsWebIdentityTokenCredentialsFromJSON");
+function AwsWebIdentityTokenCredentialsFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    roleArn: json["roleArn"],
+    roleSessionName: json["roleSessionName"],
+    webIdentityToken: json["webIdentityToken"],
+    lookupMode: json["lookupMode"] == null ? void 0 : LookupModeFromJSON(json["lookupMode"])
+  };
+}
+__name(AwsWebIdentityTokenCredentialsFromJSONTyped, "AwsWebIdentityTokenCredentialsFromJSONTyped");
+function AwsWebIdentityTokenCredentialsToJSON(json) {
+  return AwsWebIdentityTokenCredentialsToJSONTyped(json, false);
+}
+__name(AwsWebIdentityTokenCredentialsToJSON, "AwsWebIdentityTokenCredentialsToJSON");
+function AwsWebIdentityTokenCredentialsToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    roleArn: value["roleArn"],
+    roleSessionName: value["roleSessionName"],
+    webIdentityToken: value["webIdentityToken"],
+    lookupMode: LookupModeToJSON(value["lookupMode"])
+  };
+}
+__name(AwsWebIdentityTokenCredentialsToJSONTyped, "AwsWebIdentityTokenCredentialsToJSONTyped");
+
+// src/models/AwsKmsSetting.ts
+function instanceOfAwsKmsSetting(value) {
+  if (!("region" in value) || value["region"] === void 0) return false;
+  return true;
+}
+__name(instanceOfAwsKmsSetting, "instanceOfAwsKmsSetting");
+function AwsKmsSettingFromJSON(json) {
+  return AwsKmsSettingFromJSONTyped(json, false);
+}
+__name(AwsKmsSettingFromJSON, "AwsKmsSettingFromJSON");
+function AwsKmsSettingFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    region: json["region"],
+    staticCredentials: json["staticCredentials"] == null ? void 0 : AwsStaticCredentialsFromJSON(json["staticCredentials"]),
+    assumeRoleCredentials: json["assumeRoleCredentials"] == null ? void 0 : AwsAssumeRoleCredentialsFromJSON(json["assumeRoleCredentials"]),
+    webIdentityTokenCredentials: json["webIdentityTokenCredentials"] == null ? void 0 : AwsWebIdentityTokenCredentialsFromJSON(json["webIdentityTokenCredentials"]),
+    endpointUrl: json["endpointUrl"] == null ? void 0 : json["endpointUrl"],
+    clientConfiguration: json["clientConfiguration"] == null ? void 0 : AwsClientConfigurationFromJSON(json["clientConfiguration"])
+  };
+}
+__name(AwsKmsSettingFromJSONTyped, "AwsKmsSettingFromJSONTyped");
+function AwsKmsSettingToJSON(json) {
+  return AwsKmsSettingToJSONTyped(json, false);
+}
+__name(AwsKmsSettingToJSON, "AwsKmsSettingToJSON");
+function AwsKmsSettingToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    region: value["region"],
+    staticCredentials: AwsStaticCredentialsToJSON(value["staticCredentials"]),
+    assumeRoleCredentials: AwsAssumeRoleCredentialsToJSON(value["assumeRoleCredentials"]),
+    webIdentityTokenCredentials: AwsWebIdentityTokenCredentialsToJSON(value["webIdentityTokenCredentials"]),
+    endpointUrl: value["endpointUrl"],
+    clientConfiguration: AwsClientConfigurationToJSON(value["clientConfiguration"])
+  };
+}
+__name(AwsKmsSettingToJSONTyped, "AwsKmsSettingToJSONTyped");
+
+// src/models/AzureClientSecretCredentialOpts.ts
+function instanceOfAzureClientSecretCredentialOpts(value) {
+  if (!("clientId" in value) || value["clientId"] === void 0) return false;
+  if (!("clientSecret" in value) || value["clientSecret"] === void 0) return false;
+  return true;
+}
+__name(instanceOfAzureClientSecretCredentialOpts, "instanceOfAzureClientSecretCredentialOpts");
+function AzureClientSecretCredentialOptsFromJSON(json) {
+  return AzureClientSecretCredentialOptsFromJSONTyped(json, false);
+}
+__name(AzureClientSecretCredentialOptsFromJSON, "AzureClientSecretCredentialOptsFromJSON");
+function AzureClientSecretCredentialOptsFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    clientId: json["clientId"],
+    clientSecret: json["clientSecret"],
+    lookupMode: json["lookupMode"] == null ? void 0 : LookupModeFromJSON(json["lookupMode"])
+  };
+}
+__name(AzureClientSecretCredentialOptsFromJSONTyped, "AzureClientSecretCredentialOptsFromJSONTyped");
+function AzureClientSecretCredentialOptsToJSON(json) {
+  return AzureClientSecretCredentialOptsToJSONTyped(json, false);
+}
+__name(AzureClientSecretCredentialOptsToJSON, "AzureClientSecretCredentialOptsToJSON");
+function AzureClientSecretCredentialOptsToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    clientId: value["clientId"],
+    clientSecret: value["clientSecret"],
+    lookupMode: LookupModeToJSON(value["lookupMode"])
+  };
+}
+__name(AzureClientSecretCredentialOptsToJSONTyped, "AzureClientSecretCredentialOptsToJSONTyped");
+
+// src/models/AzureCredentialOpts.ts
+function instanceOfAzureCredentialOpts(value) {
+  return true;
+}
+__name(instanceOfAzureCredentialOpts, "instanceOfAzureCredentialOpts");
+function AzureCredentialOptsFromJSON(json) {
+  return AzureCredentialOptsFromJSONTyped(json, false);
+}
+__name(AzureCredentialOptsFromJSON, "AzureCredentialOptsFromJSON");
+function AzureCredentialOptsFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    clientSecretCredentialOpts: json["clientSecretCredentialOpts"] == null ? void 0 : AzureClientSecretCredentialOptsFromJSON(json["clientSecretCredentialOpts"])
+  };
+}
+__name(AzureCredentialOptsFromJSONTyped, "AzureCredentialOptsFromJSONTyped");
+function AzureCredentialOptsToJSON(json) {
+  return AzureCredentialOptsToJSONTyped(json, false);
+}
+__name(AzureCredentialOptsToJSON, "AzureCredentialOptsToJSON");
+function AzureCredentialOptsToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    clientSecretCredentialOpts: AzureClientSecretCredentialOptsToJSON(value["clientSecretCredentialOpts"])
+  };
+}
+__name(AzureCredentialOptsToJSONTyped, "AzureCredentialOptsToJSONTyped");
+
+// src/models/AzureKeyVaultSetting.ts
+function instanceOfAzureKeyVaultSetting(value) {
+  if (!("keyvaultUrl" in value) || value["keyvaultUrl"] === void 0) return false;
+  if (!("tenantId" in value) || value["tenantId"] === void 0) return false;
+  if (!("credentialOpts" in value) || value["credentialOpts"] === void 0) return false;
+  return true;
+}
+__name(instanceOfAzureKeyVaultSetting, "instanceOfAzureKeyVaultSetting");
+function AzureKeyVaultSettingFromJSON(json) {
+  return AzureKeyVaultSettingFromJSONTyped(json, false);
+}
+__name(AzureKeyVaultSettingFromJSON, "AzureKeyVaultSettingFromJSON");
+function AzureKeyVaultSettingFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    keyvaultUrl: json["keyvaultUrl"],
+    tenantId: json["tenantId"],
+    credentialOpts: AzureCredentialOptsFromJSON(json["credentialOpts"]),
+    applicationId: json["applicationId"] == null ? void 0 : json["applicationId"],
+    lookupMode: json["lookupMode"] == null ? void 0 : LookupModeFromJSON(json["lookupMode"])
+  };
+}
+__name(AzureKeyVaultSettingFromJSONTyped, "AzureKeyVaultSettingFromJSONTyped");
+function AzureKeyVaultSettingToJSON(json) {
+  return AzureKeyVaultSettingToJSONTyped(json, false);
+}
+__name(AzureKeyVaultSettingToJSON, "AzureKeyVaultSettingToJSON");
+function AzureKeyVaultSettingToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    keyvaultUrl: value["keyvaultUrl"],
+    tenantId: value["tenantId"],
+    credentialOpts: AzureCredentialOptsToJSON(value["credentialOpts"]),
+    applicationId: value["applicationId"],
+    lookupMode: LookupModeToJSON(value["lookupMode"])
+  };
+}
+__name(AzureKeyVaultSettingToJSONTyped, "AzureKeyVaultSettingToJSONTyped");
+
+// src/models/CoseKeyType.ts
+var CoseKeyType = {
+  NUMBER_1: 1,
+  NUMBER_2: 2,
+  NUMBER_3: 3,
+  NUMBER_4: 4
+};
+function instanceOfCoseKeyType(value) {
+  for (const key in CoseKeyType) {
+    if (Object.prototype.hasOwnProperty.call(CoseKeyType, key)) {
+      if (CoseKeyType[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfCoseKeyType, "instanceOfCoseKeyType");
+function CoseKeyTypeFromJSON(json) {
+  return CoseKeyTypeFromJSONTyped(json, false);
+}
+__name(CoseKeyTypeFromJSON, "CoseKeyTypeFromJSON");
+function CoseKeyTypeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(CoseKeyTypeFromJSONTyped, "CoseKeyTypeFromJSONTyped");
+function CoseKeyTypeToJSON(value) {
+  return value;
+}
+__name(CoseKeyTypeToJSON, "CoseKeyTypeToJSON");
+function CoseKeyTypeToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(CoseKeyTypeToJSONTyped, "CoseKeyTypeToJSONTyped");
+
+// src/models/CoseKey.ts
+function instanceOfCoseKey(value) {
+  if (!("kty" in value) || value["kty"] === void 0) return false;
+  return true;
+}
+__name(instanceOfCoseKey, "instanceOfCoseKey");
+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");
+function CoseKeyToJSON(json) {
+  return CoseKeyToJSONTyped(json, false);
+}
+__name(CoseKeyToJSON, "CoseKeyToJSON");
+function CoseKeyToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    kty: CoseKeyTypeToJSON(value["kty"]),
+    kid: value["kid"],
+    alg: value["alg"],
+    key_ops: value["keyOps"],
+    baseIV: value["baseIV"],
+    crv: value["crv"],
+    x: value["x"],
+    y: value["y"],
+    d: value["d"],
+    x5chain: value["x5chain"]
+  };
+}
+__name(CoseKeyToJSONTyped, "CoseKeyToJSONTyped");
+
+// src/models/CoseKeyPair.ts
+function instanceOfCoseKeyPair(value) {
+  if (!("publicCoseKey" in value) || value["publicCoseKey"] === void 0) return false;
+  return true;
+}
+__name(instanceOfCoseKeyPair, "instanceOfCoseKeyPair");
+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");
+function CoseKeyPairToJSON(json) {
+  return CoseKeyPairToJSONTyped(json, false);
+}
+__name(CoseKeyPairToJSON, "CoseKeyPairToJSON");
+function CoseKeyPairToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    privateCoseKey: CoseKeyToJSON(value["privateCoseKey"]),
+    publicCoseKey: CoseKeyToJSON(value["publicCoseKey"])
+  };
+}
+__name(CoseKeyPairToJSONTyped, "CoseKeyPairToJSONTyped");
+
+// src/models/KeyProviderType.ts
+var KeyProviderType = {
+  Software: "SOFTWARE",
+  AzureKeyvault: "AZURE_KEYVAULT",
+  AwsKms: "AWS_KMS"
+};
+function instanceOfKeyProviderType(value) {
+  for (const key in KeyProviderType) {
+    if (Object.prototype.hasOwnProperty.call(KeyProviderType, key)) {
+      if (KeyProviderType[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfKeyProviderType, "instanceOfKeyProviderType");
+function KeyProviderTypeFromJSON(json) {
+  return KeyProviderTypeFromJSONTyped(json, false);
+}
+__name(KeyProviderTypeFromJSON, "KeyProviderTypeFromJSON");
+function KeyProviderTypeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(KeyProviderTypeFromJSONTyped, "KeyProviderTypeFromJSONTyped");
+function KeyProviderTypeToJSON(value) {
+  return value;
+}
+__name(KeyProviderTypeToJSON, "KeyProviderTypeToJSON");
+function KeyProviderTypeToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(KeyProviderTypeToJSONTyped, "KeyProviderTypeToJSONTyped");
+
+// src/models/CreateKeyProvider.ts
+function instanceOfCreateKeyProvider(value) {
+  if (!("type" in value) || value["type"] === void 0) return false;
+  return true;
+}
+__name(instanceOfCreateKeyProvider, "instanceOfCreateKeyProvider");
+function CreateKeyProviderFromJSON(json) {
+  return CreateKeyProviderFromJSONTyped(json, false);
+}
+__name(CreateKeyProviderFromJSON, "CreateKeyProviderFromJSON");
+function CreateKeyProviderFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    type: KeyProviderTypeFromJSON(json["type"]),
+    azureKeyvaultSettings: json["azureKeyvaultSettings"] == null ? void 0 : AzureKeyVaultSettingFromJSON(json["azureKeyvaultSettings"]),
+    awsKmsSettings: json["awsKmsSettings"] == null ? void 0 : AwsKmsSettingFromJSON(json["awsKmsSettings"]),
+    cacheEnabled: json["cacheEnabled"] == null ? void 0 : json["cacheEnabled"],
+    cacheTTLInSeconds: json["cacheTTLInSeconds"] == null ? void 0 : json["cacheTTLInSeconds"]
+  };
+}
+__name(CreateKeyProviderFromJSONTyped, "CreateKeyProviderFromJSONTyped");
+function CreateKeyProviderToJSON(json) {
+  return CreateKeyProviderToJSONTyped(json, false);
+}
+__name(CreateKeyProviderToJSON, "CreateKeyProviderToJSON");
+function CreateKeyProviderToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    type: KeyProviderTypeToJSON(value["type"]),
+    azureKeyvaultSettings: AzureKeyVaultSettingToJSON(value["azureKeyvaultSettings"]),
+    awsKmsSettings: AwsKmsSettingToJSON(value["awsKmsSettings"]),
+    cacheEnabled: value["cacheEnabled"],
+    cacheTTLInSeconds: value["cacheTTLInSeconds"]
+  };
+}
+__name(CreateKeyProviderToJSONTyped, "CreateKeyProviderToJSONTyped");
+
+// src/models/KeyType.ts
+var KeyType = {
+  Okp: "OKP",
+  Ec: "EC",
+  Rsa: "RSA"
+};
+function instanceOfKeyType(value) {
+  for (const key in KeyType) {
+    if (Object.prototype.hasOwnProperty.call(KeyType, key)) {
+      if (KeyType[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfKeyType, "instanceOfKeyType");
+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");
+function KeyTypeToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(KeyTypeToJSONTyped, "KeyTypeToJSONTyped");
+
+// src/models/KeyVisibility.ts
+var KeyVisibility = {
+  Public: "PUBLIC",
+  Private: "PRIVATE"
+};
+function instanceOfKeyVisibility(value) {
+  for (const key in KeyVisibility) {
+    if (Object.prototype.hasOwnProperty.call(KeyVisibility, key)) {
+      if (KeyVisibility[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfKeyVisibility, "instanceOfKeyVisibility");
+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");
+function KeyVisibilityToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(KeyVisibilityToJSONTyped, "KeyVisibilityToJSONTyped");
+
+// src/models/SignatureAlgorithm.ts
+var SignatureAlgorithm = {
+  Ed25519: "ED25519",
+  EcdsaSha256: "ECDSA_SHA256",
+  EcdsaSha384: "ECDSA_SHA384",
+  EcdsaSha512: "ECDSA_SHA512",
+  Es256K: "ES256K",
+  EckaDhSha256: "ECKA_DH_SHA256",
+  HmacSha256: "HMAC_SHA256",
+  HmacSha384: "HMAC_SHA384",
+  HmacSha512: "HMAC_SHA512",
+  RsaSsaPssSha256Mgf1: "RSA_SSA_PSS_SHA256_MGF1",
+  RsaSsaPssSha384Mgf1: "RSA_SSA_PSS_SHA384_MGF1",
+  RsaSsaPssSha512Mgf1: "RSA_SSA_PSS_SHA512_MGF1"
+};
+function instanceOfSignatureAlgorithm(value) {
+  for (const key in SignatureAlgorithm) {
+    if (Object.prototype.hasOwnProperty.call(SignatureAlgorithm, key)) {
+      if (SignatureAlgorithm[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfSignatureAlgorithm, "instanceOfSignatureAlgorithm");
+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");
+function SignatureAlgorithmToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(SignatureAlgorithmToJSONTyped, "SignatureAlgorithmToJSONTyped");
+
+// src/models/KeyEncoding.ts
+var KeyEncoding = {
+  Cose: "COSE",
+  Jose: "JOSE"
+};
+function instanceOfKeyEncoding(value) {
+  for (const key in KeyEncoding) {
+    if (Object.prototype.hasOwnProperty.call(KeyEncoding, key)) {
+      if (KeyEncoding[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfKeyEncoding, "instanceOfKeyEncoding");
+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");
+function KeyEncodingToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(KeyEncodingToJSONTyped, "KeyEncodingToJSONTyped");
+
+// src/models/Curve.ts
+var Curve = {
+  P256: "P-256",
+  P384: "P-384",
+  P521: "P-521",
+  Secp256k1: "secp256k1",
+  Ed25519: "Ed25519",
+  Ed448: "Ed448",
+  X25519: "X25519",
+  X448: "X448"
+};
+function instanceOfCurve(value) {
+  for (const key in Curve) {
+    if (Object.prototype.hasOwnProperty.call(Curve, key)) {
+      if (Curve[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfCurve, "instanceOfCurve");
+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");
+function CurveToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(CurveToJSONTyped, "CurveToJSONTyped");
+
+// src/models/KeyOperations.ts
+var KeyOperations = {
+  Sign: "sign",
+  Verify: "verify",
+  Encrypt: "encrypt",
+  Decrypt: "decrypt",
+  WrapKey: "wrapKey",
+  UnwrapKey: "unwrapKey",
+  DeriveKey: "deriveKey",
+  DeriveBits: "deriveBits"
+};
+function instanceOfKeyOperations(value) {
+  for (const key in KeyOperations) {
+    if (Object.prototype.hasOwnProperty.call(KeyOperations, key)) {
+      if (KeyOperations[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfKeyOperations, "instanceOfKeyOperations");
+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");
+function KeyOperationsToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(KeyOperationsToJSONTyped, "KeyOperationsToJSONTyped");
+
+// src/models/JwkUse.ts
+var JwkUse = {
+  Sig: "sig",
+  Enc: "enc"
+};
+function instanceOfJwkUse(value) {
+  for (const key in JwkUse) {
+    if (Object.prototype.hasOwnProperty.call(JwkUse, key)) {
+      if (JwkUse[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfJwkUse, "instanceOfJwkUse");
+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");
+function JwkUseToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(JwkUseToJSONTyped, "JwkUseToJSONTyped");
+
+// src/models/JwkKeyType.ts
+var JwkKeyType = {
+  Ec: "EC",
+  Rsa: "RSA",
+  Okp: "OKP",
+  Oct: "oct"
+};
+function instanceOfJwkKeyType(value) {
+  for (const key in JwkKeyType) {
+    if (Object.prototype.hasOwnProperty.call(JwkKeyType, key)) {
+      if (JwkKeyType[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfJwkKeyType, "instanceOfJwkKeyType");
+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");
+function JwkKeyTypeToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(JwkKeyTypeToJSONTyped, "JwkKeyTypeToJSONTyped");
+
+// src/models/Jwk.ts
+function instanceOfJwk(value) {
+  if (!("kty" in value) || value["kty"] === void 0) return false;
+  return true;
+}
+__name(instanceOfJwk, "instanceOfJwk");
+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 instanceOfKeyInfo(value) {
+  return true;
+}
+__name(instanceOfKeyInfo, "instanceOfKeyInfo");
+function KeyInfoFromJSON(json) {
+  return KeyInfoFromJSONTyped(json, false);
+}
+__name(KeyInfoFromJSON, "KeyInfoFromJSON");
+function KeyInfoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    kid: json["kid"] == null ? void 0 : json["kid"],
+    key: json["key"] == null ? void 0 : 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(KeyInfoFromJSONTyped, "KeyInfoFromJSONTyped");
+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 instanceOfCreateRawSignature(value) {
+  if (!("keyInfo" in value) || value["keyInfo"] === void 0) return false;
+  if (!("input" in value) || value["input"] === void 0) return false;
+  return true;
+}
+__name(instanceOfCreateRawSignature, "instanceOfCreateRawSignature");
+function CreateRawSignatureFromJSON(json) {
+  return CreateRawSignatureFromJSONTyped(json, false);
+}
+__name(CreateRawSignatureFromJSON, "CreateRawSignatureFromJSON");
+function CreateRawSignatureFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    keyInfo: KeyInfoFromJSON(json["keyInfo"]),
+    input: json["input"]
+  };
+}
+__name(CreateRawSignatureFromJSONTyped, "CreateRawSignatureFromJSONTyped");
+function CreateRawSignatureToJSON(json) {
+  return CreateRawSignatureToJSONTyped(json, false);
+}
+__name(CreateRawSignatureToJSON, "CreateRawSignatureToJSON");
+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 instanceOfCreateRawSignatureResponse(value) {
+  if (!("signature" in value) || value["signature"] === void 0) return false;
+  return true;
+}
+__name(instanceOfCreateRawSignatureResponse, "instanceOfCreateRawSignatureResponse");
+function CreateRawSignatureResponseFromJSON(json) {
+  return CreateRawSignatureResponseFromJSONTyped(json, false);
+}
+__name(CreateRawSignatureResponseFromJSON, "CreateRawSignatureResponseFromJSON");
+function CreateRawSignatureResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    signature: json["signature"]
+  };
+}
+__name(CreateRawSignatureResponseFromJSONTyped, "CreateRawSignatureResponseFromJSONTyped");
+function CreateRawSignatureResponseToJSON(json) {
+  return CreateRawSignatureResponseToJSONTyped(json, false);
+}
+__name(CreateRawSignatureResponseToJSON, "CreateRawSignatureResponseToJSON");
+function CreateRawSignatureResponseToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    signature: value["signature"]
+  };
+}
+__name(CreateRawSignatureResponseToJSONTyped, "CreateRawSignatureResponseToJSONTyped");
+
+// src/models/SignInput.ts
+var SignInputModeEnum = {
+  Detached: "DETACHED",
+  Attached: "ATTACHED"
+};
+function instanceOfSignInput(value) {
+  if (!("data" in value) || value["data"] === void 0) return false;
+  return true;
+}
+__name(instanceOfSignInput, "instanceOfSignInput");
+function SignInputFromJSON(json) {
+  return SignInputFromJSONTyped(json, false);
+}
+__name(SignInputFromJSON, "SignInputFromJSON");
+function SignInputFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    data: json["data"],
+    mode: json["mode"] == null ? void 0 : json["mode"],
+    metadata: json["metadata"] == null ? void 0 : json["metadata"]
+  };
+}
+__name(SignInputFromJSONTyped, "SignInputFromJSONTyped");
+function SignInputToJSON(json) {
+  return SignInputToJSONTyped(json, false);
+}
+__name(SignInputToJSON, "SignInputToJSON");
+function SignInputToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    data: value["data"],
+    mode: value["mode"],
+    metadata: value["metadata"]
+  };
+}
+__name(SignInputToJSONTyped, "SignInputToJSONTyped");
+
+// src/models/CreateSimpleSignature.ts
+function instanceOfCreateSimpleSignature(value) {
+  if (!("signInput" in value) || value["signInput"] === void 0) return false;
+  if (!("keyInfo" in value) || value["keyInfo"] === void 0) return false;
+  return true;
+}
+__name(instanceOfCreateSimpleSignature, "instanceOfCreateSimpleSignature");
+function CreateSimpleSignatureFromJSON(json) {
+  return CreateSimpleSignatureFromJSONTyped(json, false);
+}
+__name(CreateSimpleSignatureFromJSON, "CreateSimpleSignatureFromJSON");
+function CreateSimpleSignatureFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    signInput: SignInputFromJSON(json["signInput"]),
+    keyInfo: KeyInfoFromJSON(json["keyInfo"]),
+    signatureAlgorithm: json["signatureAlgorithm"] == null ? void 0 : SignatureAlgorithmFromJSON(json["signatureAlgorithm"])
+  };
+}
+__name(CreateSimpleSignatureFromJSONTyped, "CreateSimpleSignatureFromJSONTyped");
+function CreateSimpleSignatureToJSON(json) {
+  return CreateSimpleSignatureToJSONTyped(json, false);
+}
+__name(CreateSimpleSignatureToJSON, "CreateSimpleSignatureToJSON");
+function CreateSimpleSignatureToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    signInput: SignInputToJSON(value["signInput"]),
+    keyInfo: KeyInfoToJSON(value["keyInfo"]),
+    signatureAlgorithm: SignatureAlgorithmToJSON(value["signatureAlgorithm"])
+  };
+}
+__name(CreateSimpleSignatureToJSONTyped, "CreateSimpleSignatureToJSONTyped");
+
+// src/models/CryptoAlg.ts
+var CryptoAlg = {
+  Ed25519: "ED25519",
+  Ecdsa: "ECDSA",
+  Hmac: "HMAC",
+  Rsa: "RSA"
+};
+function instanceOfCryptoAlg(value) {
+  for (const key in CryptoAlg) {
+    if (Object.prototype.hasOwnProperty.call(CryptoAlg, key)) {
+      if (CryptoAlg[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfCryptoAlg, "instanceOfCryptoAlg");
+function CryptoAlgFromJSON(json) {
+  return CryptoAlgFromJSONTyped(json, false);
+}
+__name(CryptoAlgFromJSON, "CryptoAlgFromJSON");
+function CryptoAlgFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(CryptoAlgFromJSONTyped, "CryptoAlgFromJSONTyped");
+function CryptoAlgToJSON(value) {
+  return value;
+}
+__name(CryptoAlgToJSON, "CryptoAlgToJSON");
+function CryptoAlgToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(CryptoAlgToJSONTyped, "CryptoAlgToJSONTyped");
+
+// src/models/DigestAlg.ts
+var DigestAlg = {
+  None: "NONE",
+  Sha256: "SHA256",
+  Sha384: "SHA384",
+  Sha512: "SHA512",
+  Sha3256: "SHA3_256",
+  Sha3384: "SHA3_384",
+  Sha3512: "SHA3_512"
+};
+function instanceOfDigestAlg(value) {
+  for (const key in DigestAlg) {
+    if (Object.prototype.hasOwnProperty.call(DigestAlg, key)) {
+      if (DigestAlg[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfDigestAlg, "instanceOfDigestAlg");
+function DigestAlgFromJSON(json) {
+  return DigestAlgFromJSONTyped(json, false);
+}
+__name(DigestAlgFromJSON, "DigestAlgFromJSON");
+function DigestAlgFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(DigestAlgFromJSONTyped, "DigestAlgFromJSONTyped");
+function DigestAlgToJSON(value) {
+  return value;
+}
+__name(DigestAlgToJSON, "DigestAlgToJSON");
+function DigestAlgToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(DigestAlgToJSONTyped, "DigestAlgToJSONTyped");
+
+// src/models/ErrorResponse.ts
+function instanceOfErrorResponse(value) {
+  if (!("code" in value) || value["code"] === void 0) return false;
+  if (!("message" in value) || value["message"] === void 0) return false;
+  return true;
+}
+__name(instanceOfErrorResponse, "instanceOfErrorResponse");
+function ErrorResponseFromJSON(json) {
+  return ErrorResponseFromJSONTyped(json, false);
+}
+__name(ErrorResponseFromJSON, "ErrorResponseFromJSON");
+function ErrorResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    code: json["code"],
+    message: json["message"],
+    details: json["details"] == null ? void 0 : json["details"]
+  };
+}
+__name(ErrorResponseFromJSONTyped, "ErrorResponseFromJSONTyped");
+function ErrorResponseToJSON(json) {
+  return ErrorResponseToJSONTyped(json, false);
+}
+__name(ErrorResponseToJSON, "ErrorResponseToJSON");
+function ErrorResponseToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    code: value["code"],
+    message: value["message"],
+    details: value["details"]
+  };
+}
+__name(ErrorResponseToJSONTyped, "ErrorResponseToJSONTyped");
+
+// src/models/GenerateKey.ts
+function instanceOfGenerateKey(value) {
+  return true;
+}
+__name(instanceOfGenerateKey, "instanceOfGenerateKey");
+function GenerateKeyFromJSON(json) {
+  return GenerateKeyFromJSONTyped(json, false);
+}
+__name(GenerateKeyFromJSON, "GenerateKeyFromJSON");
+function GenerateKeyFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    alias: json["alias"] == null ? void 0 : json["alias"],
+    use: json["use"] == null ? void 0 : JwkUseFromJSON(json["use"]),
+    keyOperations: json["keyOperations"] == null ? void 0 : json["keyOperations"].map(KeyOperationsFromJSON),
+    alg: json["alg"] == null ? void 0 : SignatureAlgorithmFromJSON(json["alg"])
+  };
+}
+__name(GenerateKeyFromJSONTyped, "GenerateKeyFromJSONTyped");
+function GenerateKeyToJSON(json) {
+  return GenerateKeyToJSONTyped(json, false);
+}
+__name(GenerateKeyToJSON, "GenerateKeyToJSON");
+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 instanceOfGenerateKeyGlobal(value) {
+  return true;
+}
+__name(instanceOfGenerateKeyGlobal, "instanceOfGenerateKeyGlobal");
+function GenerateKeyGlobalFromJSON(json) {
+  return GenerateKeyGlobalFromJSONTyped(json, false);
+}
+__name(GenerateKeyGlobalFromJSON, "GenerateKeyGlobalFromJSON");
+function GenerateKeyGlobalFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    alias: json["alias"] == null ? void 0 : json["alias"],
+    use: json["use"] == null ? void 0 : JwkUseFromJSON(json["use"]),
+    keyOperations: json["keyOperations"] == null ? void 0 : json["keyOperations"].map(KeyOperationsFromJSON),
+    alg: json["alg"] == null ? void 0 : SignatureAlgorithmFromJSON(json["alg"]),
+    providerId: json["providerId"] == null ? void 0 : json["providerId"]
+  };
+}
+__name(GenerateKeyGlobalFromJSONTyped, "GenerateKeyGlobalFromJSONTyped");
+function GenerateKeyGlobalToJSON(json) {
+  return GenerateKeyGlobalToJSONTyped(json, false);
+}
+__name(GenerateKeyGlobalToJSON, "GenerateKeyGlobalToJSON");
+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 instanceOfJoseKeyPair(value) {
+  if (!("publicJwk" in value) || value["publicJwk"] === void 0) return false;
+  return true;
+}
+__name(instanceOfJoseKeyPair, "instanceOfJoseKeyPair");
+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");
+function JoseKeyPairToJSON(json) {
+  return JoseKeyPairToJSONTyped(json, false);
+}
+__name(JoseKeyPairToJSON, "JoseKeyPairToJSON");
+function JoseKeyPairToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    privateJwk: JwkToJSON(value["privateJwk"]),
+    publicJwk: JwkToJSON(value["publicJwk"])
+  };
+}
+__name(JoseKeyPairToJSONTyped, "JoseKeyPairToJSONTyped");
+
+// src/models/ManagedKeyPair.ts
+function instanceOfManagedKeyPair(value) {
+  if (!("providerId" in value) || value["providerId"] === void 0) return false;
+  if (!("alias" in value) || value["alias"] === void 0) return false;
+  if (!("cose" in value) || value["cose"] === void 0) return false;
+  if (!("jose" in value) || value["jose"] === void 0) return false;
+  return true;
+}
+__name(instanceOfManagedKeyPair, "instanceOfManagedKeyPair");
+function ManagedKeyPairFromJSON(json) {
+  return ManagedKeyPairFromJSONTyped(json, false);
+}
+__name(ManagedKeyPairFromJSON, "ManagedKeyPairFromJSON");
+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");
+function ManagedKeyPairToJSON(json) {
+  return ManagedKeyPairToJSONTyped(json, false);
+}
+__name(ManagedKeyPairToJSON, "ManagedKeyPairToJSON");
+function ManagedKeyPairToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    kid: value["kid"],
+    providerId: value["providerId"],
+    alias: value["alias"],
+    cose: CoseKeyPairToJSON(value["cose"]),
+    jose: JoseKeyPairToJSON(value["jose"])
+  };
+}
+__name(ManagedKeyPairToJSONTyped, "ManagedKeyPairToJSONTyped");
+
+// src/models/GenerateKeyResponse.ts
+function instanceOfGenerateKeyResponse(value) {
+  if (!("keyPair" in value) || value["keyPair"] === void 0) return false;
+  return true;
+}
+__name(instanceOfGenerateKeyResponse, "instanceOfGenerateKeyResponse");
+function GenerateKeyResponseFromJSON(json) {
+  return GenerateKeyResponseFromJSONTyped(json, false);
+}
+__name(GenerateKeyResponseFromJSON, "GenerateKeyResponseFromJSON");
+function GenerateKeyResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    keyPair: ManagedKeyPairFromJSON(json["keyPair"])
+  };
+}
+__name(GenerateKeyResponseFromJSONTyped, "GenerateKeyResponseFromJSONTyped");
+function GenerateKeyResponseToJSON(json) {
+  return GenerateKeyResponseToJSONTyped(json, false);
+}
+__name(GenerateKeyResponseToJSON, "GenerateKeyResponseToJSON");
+function GenerateKeyResponseToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    keyPair: ManagedKeyPairToJSON(value["keyPair"])
+  };
+}
+__name(GenerateKeyResponseToJSONTyped, "GenerateKeyResponseToJSONTyped");
+
+// src/models/ManagedKeyInfo.ts
+function instanceOfManagedKeyInfo(value) {
+  if (!("key" in value) || value["key"] === void 0) return false;
+  if (!("alias" in value) || value["alias"] === void 0) return false;
+  if (!("providerId" in value) || value["providerId"] === void 0) return false;
+  return true;
+}
+__name(instanceOfManagedKeyInfo, "instanceOfManagedKeyInfo");
+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");
+function ManagedKeyInfoToJSON(json) {
+  return ManagedKeyInfoToJSONTyped(json, false);
+}
+__name(ManagedKeyInfoToJSON, "ManagedKeyInfoToJSON");
+function ManagedKeyInfoToJSONTyped(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(ManagedKeyInfoToJSONTyped, "ManagedKeyInfoToJSONTyped");
+
+// src/models/GetKeyResponse.ts
+function instanceOfGetKeyResponse(value) {
+  if (!("keyInfo" in value) || value["keyInfo"] === void 0) return false;
+  return true;
+}
+__name(instanceOfGetKeyResponse, "instanceOfGetKeyResponse");
+function GetKeyResponseFromJSON(json) {
+  return GetKeyResponseFromJSONTyped(json, false);
+}
+__name(GetKeyResponseFromJSON, "GetKeyResponseFromJSON");
+function GetKeyResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    keyInfo: ManagedKeyInfoFromJSON(json["keyInfo"])
+  };
+}
+__name(GetKeyResponseFromJSONTyped, "GetKeyResponseFromJSONTyped");
+function GetKeyResponseToJSON(json) {
+  return GetKeyResponseToJSONTyped(json, false);
+}
+__name(GetKeyResponseToJSON, "GetKeyResponseToJSON");
+function GetKeyResponseToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    keyInfo: ManagedKeyInfoToJSON(value["keyInfo"])
+  };
+}
+__name(GetKeyResponseToJSONTyped, "GetKeyResponseToJSONTyped");
+
+// src/models/IdentifierMethod.ts
+var IdentifierMethod = {
+  Jwk: "JWK",
+  Kid: "KID",
+  CoseKey: "COSE_KEY",
+  X5C: "X5C",
+  Did: "DID"
+};
+function instanceOfIdentifierMethod(value) {
+  for (const key in IdentifierMethod) {
+    if (Object.prototype.hasOwnProperty.call(IdentifierMethod, key)) {
+      if (IdentifierMethod[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfIdentifierMethod, "instanceOfIdentifierMethod");
+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");
+function IdentifierMethodToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(IdentifierMethodToJSONTyped, "IdentifierMethodToJSONTyped");
+
+// src/models/KeyProvider.ts
+function instanceOfKeyProvider(value) {
+  if (!("providerId" in value) || value["providerId"] === void 0) return false;
+  if (!("type" in value) || value["type"] === void 0) return false;
+  return true;
+}
+__name(instanceOfKeyProvider, "instanceOfKeyProvider");
+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");
+function KeyProviderToJSON(json) {
+  return KeyProviderToJSONTyped(json, false);
+}
+__name(KeyProviderToJSON, "KeyProviderToJSON");
+function KeyProviderToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    providerId: value["providerId"],
+    type: KeyProviderTypeToJSON(value["type"])
+  };
+}
+__name(KeyProviderToJSONTyped, "KeyProviderToJSONTyped");
+
+// src/models/KeyProviderResponse.ts
+function instanceOfKeyProviderResponse(value) {
+  if (!("providerId" in value) || value["providerId"] === void 0) return false;
+  if (!("type" in value) || value["type"] === void 0) return false;
+  return true;
+}
+__name(instanceOfKeyProviderResponse, "instanceOfKeyProviderResponse");
+function KeyProviderResponseFromJSON(json) {
+  return KeyProviderResponseFromJSONTyped(json, false);
+}
+__name(KeyProviderResponseFromJSON, "KeyProviderResponseFromJSON");
+function KeyProviderResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    providerId: json["providerId"],
+    type: KeyProviderTypeFromJSON(json["type"])
+  };
+}
+__name(KeyProviderResponseFromJSONTyped, "KeyProviderResponseFromJSONTyped");
+function KeyProviderResponseToJSON(json) {
+  return KeyProviderResponseToJSONTyped(json, false);
+}
+__name(KeyProviderResponseToJSON, "KeyProviderResponseToJSON");
+function KeyProviderResponseToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    providerId: value["providerId"],
+    type: KeyProviderTypeToJSON(value["type"])
+  };
+}
+__name(KeyProviderResponseToJSONTyped, "KeyProviderResponseToJSONTyped");
+
+// src/models/KeyResolver.ts
+function instanceOfKeyResolver(value) {
+  if (!("resolverId" in value) || value["resolverId"] === void 0) return false;
+  return true;
+}
+__name(instanceOfKeyResolver, "instanceOfKeyResolver");
+function KeyResolverFromJSON(json) {
+  return KeyResolverFromJSONTyped(json, false);
+}
+__name(KeyResolverFromJSON, "KeyResolverFromJSON");
+function KeyResolverFromJSONTyped(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(KeyResolverFromJSONTyped, "KeyResolverFromJSONTyped");
+function KeyResolverToJSON(json) {
+  return KeyResolverToJSONTyped(json, false);
+}
+__name(KeyResolverToJSON, "KeyResolverToJSON");
+function KeyResolverToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    resolverId: value["resolverId"],
+    supportedIdentifierMethods: value["supportedIdentifierMethods"] == null ? void 0 : value["supportedIdentifierMethods"].map(IdentifierMethodToJSON),
+    supportedKeyTypes: value["supportedKeyTypes"] == null ? void 0 : value["supportedKeyTypes"].map(KeyTypeToJSON)
+  };
+}
+__name(KeyResolverToJSONTyped, "KeyResolverToJSONTyped");
+
+// src/models/ListKeyProvidersResponse.ts
+function instanceOfListKeyProvidersResponse(value) {
+  if (!("providers" in value) || value["providers"] === void 0) return false;
+  return true;
+}
+__name(instanceOfListKeyProvidersResponse, "instanceOfListKeyProvidersResponse");
+function ListKeyProvidersResponseFromJSON(json) {
+  return ListKeyProvidersResponseFromJSONTyped(json, false);
+}
+__name(ListKeyProvidersResponseFromJSON, "ListKeyProvidersResponseFromJSON");
+function ListKeyProvidersResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    providers: json["providers"].map(KeyProviderFromJSON)
+  };
+}
+__name(ListKeyProvidersResponseFromJSONTyped, "ListKeyProvidersResponseFromJSONTyped");
+function ListKeyProvidersResponseToJSON(json) {
+  return ListKeyProvidersResponseToJSONTyped(json, false);
+}
+__name(ListKeyProvidersResponseToJSON, "ListKeyProvidersResponseToJSON");
+function ListKeyProvidersResponseToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    providers: value["providers"].map(KeyProviderToJSON)
+  };
+}
+__name(ListKeyProvidersResponseToJSONTyped, "ListKeyProvidersResponseToJSONTyped");
+
+// src/models/ListKeysResponse.ts
+function instanceOfListKeysResponse(value) {
+  if (!("keyInfos" in value) || value["keyInfos"] === void 0) return false;
+  return true;
+}
+__name(instanceOfListKeysResponse, "instanceOfListKeysResponse");
+function ListKeysResponseFromJSON(json) {
+  return ListKeysResponseFromJSONTyped(json, false);
+}
+__name(ListKeysResponseFromJSON, "ListKeysResponseFromJSON");
+function ListKeysResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    keyInfos: json["keyInfos"].map(ManagedKeyInfoFromJSON)
+  };
+}
+__name(ListKeysResponseFromJSONTyped, "ListKeysResponseFromJSONTyped");
+function ListKeysResponseToJSON(json) {
+  return ListKeysResponseToJSONTyped(json, false);
+}
+__name(ListKeysResponseToJSON, "ListKeysResponseToJSON");
+function ListKeysResponseToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    keyInfos: value["keyInfos"].map(ManagedKeyInfoToJSON)
+  };
+}
+__name(ListKeysResponseToJSONTyped, "ListKeysResponseToJSONTyped");
+
+// src/models/Resolver.ts
+function instanceOfResolver(value) {
+  if (!("resolverId" in value) || value["resolverId"] === void 0) return false;
+  return true;
+}
+__name(instanceOfResolver, "instanceOfResolver");
+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");
+function ResolverToJSON(json) {
+  return ResolverToJSONTyped(json, false);
+}
+__name(ResolverToJSON, "ResolverToJSON");
+function ResolverToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    resolverId: value["resolverId"],
+    supportedIdentifierMethods: value["supportedIdentifierMethods"] == null ? void 0 : value["supportedIdentifierMethods"].map(IdentifierMethodToJSON),
+    supportedKeyTypes: value["supportedKeyTypes"] == null ? void 0 : value["supportedKeyTypes"].map(KeyTypeToJSON)
+  };
+}
+__name(ResolverToJSONTyped, "ResolverToJSONTyped");
+
+// src/models/ListResolversResponse.ts
+function instanceOfListResolversResponse(value) {
+  if (!("resolvers" in value) || value["resolvers"] === void 0) return false;
+  return true;
+}
+__name(instanceOfListResolversResponse, "instanceOfListResolversResponse");
+function ListResolversResponseFromJSON(json) {
+  return ListResolversResponseFromJSONTyped(json, false);
+}
+__name(ListResolversResponseFromJSON, "ListResolversResponseFromJSON");
+function ListResolversResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    resolvers: json["resolvers"].map(ResolverFromJSON)
+  };
+}
+__name(ListResolversResponseFromJSONTyped, "ListResolversResponseFromJSONTyped");
+function ListResolversResponseToJSON(json) {
+  return ListResolversResponseToJSONTyped(json, false);
+}
+__name(ListResolversResponseToJSON, "ListResolversResponseToJSON");
+function ListResolversResponseToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    resolvers: value["resolvers"].map(ResolverToJSON)
+  };
+}
+__name(ListResolversResponseToJSONTyped, "ListResolversResponseToJSONTyped");
+
+// src/models/MaskGenFunction.ts
+var MaskGenFunction = {
+  Mgf1: "MGF1"
+};
+function instanceOfMaskGenFunction(value) {
+  for (const key in MaskGenFunction) {
+    if (Object.prototype.hasOwnProperty.call(MaskGenFunction, key)) {
+      if (MaskGenFunction[key] === value) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(instanceOfMaskGenFunction, "instanceOfMaskGenFunction");
+function MaskGenFunctionFromJSON(json) {
+  return MaskGenFunctionFromJSONTyped(json, false);
+}
+__name(MaskGenFunctionFromJSON, "MaskGenFunctionFromJSON");
+function MaskGenFunctionFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+__name(MaskGenFunctionFromJSONTyped, "MaskGenFunctionFromJSONTyped");
+function MaskGenFunctionToJSON(value) {
+  return value;
+}
+__name(MaskGenFunctionToJSON, "MaskGenFunctionToJSON");
+function MaskGenFunctionToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+__name(MaskGenFunctionToJSONTyped, "MaskGenFunctionToJSONTyped");
+
+// src/models/ProviderCapabilities.ts
+function instanceOfProviderCapabilities(value) {
+  return true;
+}
+__name(instanceOfProviderCapabilities, "instanceOfProviderCapabilities");
+function ProviderCapabilitiesFromJSON(json) {
+  return ProviderCapabilitiesFromJSONTyped(json, false);
+}
+__name(ProviderCapabilitiesFromJSON, "ProviderCapabilitiesFromJSON");
+function ProviderCapabilitiesFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    keyTypes: json["keyTypes"] == null ? void 0 : json["keyTypes"].map(KeyTypeFromJSON),
+    signatureAlgorithms: json["signatureAlgorithms"] == null ? void 0 : json["signatureAlgorithms"].map(SignatureAlgorithmFromJSON),
+    digests: json["digests"] == null ? void 0 : json["digests"].map(DigestAlgFromJSON),
+    curves: json["curves"] == null ? void 0 : json["curves"].map(CurveFromJSON),
+    keyOperations: json["keyOperations"] == null ? void 0 : json["keyOperations"].map(KeyOperationsFromJSON)
+  };
+}
+__name(ProviderCapabilitiesFromJSONTyped, "ProviderCapabilitiesFromJSONTyped");
+function ProviderCapabilitiesToJSON(json) {
+  return ProviderCapabilitiesToJSONTyped(json, false);
+}
+__name(ProviderCapabilitiesToJSON, "ProviderCapabilitiesToJSON");
+function ProviderCapabilitiesToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    keyTypes: value["keyTypes"] == null ? void 0 : value["keyTypes"].map(KeyTypeToJSON),
+    signatureAlgorithms: value["signatureAlgorithms"] == null ? void 0 : value["signatureAlgorithms"].map(SignatureAlgorithmToJSON),
+    digests: value["digests"] == null ? void 0 : value["digests"].map(DigestAlgToJSON),
+    curves: value["curves"] == null ? void 0 : value["curves"].map(CurveToJSON),
+    keyOperations: value["keyOperations"] == null ? void 0 : value["keyOperations"].map(KeyOperationsToJSON)
+  };
+}
+__name(ProviderCapabilitiesToJSONTyped, "ProviderCapabilitiesToJSONTyped");
+
+// src/models/ResolvePublicKey.ts
+function instanceOfResolvePublicKey(value) {
+  if (!("keyInfo" in value) || value["keyInfo"] === void 0) return false;
+  return true;
+}
+__name(instanceOfResolvePublicKey, "instanceOfResolvePublicKey");
+function ResolvePublicKeyFromJSON(json) {
+  return ResolvePublicKeyFromJSONTyped(json, false);
+}
+__name(ResolvePublicKeyFromJSON, "ResolvePublicKeyFromJSON");
+function ResolvePublicKeyFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    keyInfo: KeyInfoFromJSON(json["keyInfo"]),
+    identifierMethod: json["identifierMethod"] == null ? void 0 : IdentifierMethodFromJSON(json["identifierMethod"]),
+    trustedCerts: json["trustedCerts"] == null ? void 0 : json["trustedCerts"],
+    verifyX509CertificateChain: json["verifyX509CertificateChain"] == null ? void 0 : json["verifyX509CertificateChain"]
+  };
+}
+__name(ResolvePublicKeyFromJSONTyped, "ResolvePublicKeyFromJSONTyped");
+function ResolvePublicKeyToJSON(json) {
+  return ResolvePublicKeyToJSONTyped(json, false);
+}
+__name(ResolvePublicKeyToJSON, "ResolvePublicKeyToJSON");
+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 instanceOfResolvedKeyInfo(value) {
+  if (!("key" in value) || value["key"] === void 0) return false;
+  return true;
+}
+__name(instanceOfResolvedKeyInfo, "instanceOfResolvedKeyInfo");
+function ResolvedKeyInfoFromJSON(json) {
+  return ResolvedKeyInfoFromJSONTyped(json, false);
+}
+__name(ResolvedKeyInfoFromJSON, "ResolvedKeyInfoFromJSON");
+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/Signature.ts
+function instanceOfSignature(value) {
+  if (!("value" in value) || value["value"] === void 0) return false;
+  if (!("algorithm" in value) || value["algorithm"] === void 0) return false;
+  return true;
+}
+__name(instanceOfSignature, "instanceOfSignature");
+function SignatureFromJSON(json) {
+  return SignatureFromJSONTyped(json, false);
+}
+__name(SignatureFromJSON, "SignatureFromJSON");
+function SignatureFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    value: json["value"],
+    algorithm: SignatureAlgorithmFromJSON(json["algorithm"]),
+    keyInfo: json["keyInfo"] == null ? void 0 : KeyInfoFromJSON(json["keyInfo"]),
+    metadata: json["metadata"] == null ? void 0 : json["metadata"]
+  };
+}
+__name(SignatureFromJSONTyped, "SignatureFromJSONTyped");
+function SignatureToJSON(json) {
+  return SignatureToJSONTyped(json, false);
+}
+__name(SignatureToJSON, "SignatureToJSON");
+function SignatureToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    value: value["value"],
+    algorithm: SignatureAlgorithmToJSON(value["algorithm"]),
+    keyInfo: KeyInfoToJSON(value["keyInfo"]),
+    metadata: value["metadata"]
+  };
+}
+__name(SignatureToJSONTyped, "SignatureToJSONTyped");
+
+// src/models/SignOutput.ts
+function instanceOfSignOutput(value) {
+  if (!("signature" in value) || value["signature"] === void 0) return false;
+  return true;
+}
+__name(instanceOfSignOutput, "instanceOfSignOutput");
+function SignOutputFromJSON(json) {
+  return SignOutputFromJSONTyped(json, false);
+}
+__name(SignOutputFromJSON, "SignOutputFromJSON");
+function SignOutputFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    signature: SignatureFromJSON(json["signature"]),
+    metadata: json["metadata"] == null ? void 0 : json["metadata"]
+  };
+}
+__name(SignOutputFromJSONTyped, "SignOutputFromJSONTyped");
+function SignOutputToJSON(json) {
+  return SignOutputToJSONTyped(json, false);
+}
+__name(SignOutputToJSON, "SignOutputToJSON");
+function SignOutputToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    signature: SignatureToJSON(value["signature"]),
+    metadata: value["metadata"]
+  };
+}
+__name(SignOutputToJSONTyped, "SignOutputToJSONTyped");
+
+// src/models/StoreKey.ts
+function instanceOfStoreKey(value) {
+  if (!("keyInfo" in value) || value["keyInfo"] === void 0) return false;
+  return true;
+}
+__name(instanceOfStoreKey, "instanceOfStoreKey");
+function StoreKeyFromJSON(json) {
+  return StoreKeyFromJSONTyped(json, false);
+}
+__name(StoreKeyFromJSON, "StoreKeyFromJSON");
+function StoreKeyFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    keyInfo: ResolvedKeyInfoFromJSON(json["keyInfo"]),
+    certChain: json["certChain"] == null ? void 0 : json["certChain"]
+  };
+}
+__name(StoreKeyFromJSONTyped, "StoreKeyFromJSONTyped");
+function StoreKeyToJSON(json) {
+  return StoreKeyToJSONTyped(json, false);
+}
+__name(StoreKeyToJSON, "StoreKeyToJSON");
+function StoreKeyToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    keyInfo: ResolvedKeyInfoToJSON(value["keyInfo"]),
+    certChain: value["certChain"]
+  };
+}
+__name(StoreKeyToJSONTyped, "StoreKeyToJSONTyped");
+
+// src/models/StoreKeyResponse.ts
+function instanceOfStoreKeyResponse(value) {
+  if (!("keyInfo" in value) || value["keyInfo"] === void 0) return false;
+  return true;
+}
+__name(instanceOfStoreKeyResponse, "instanceOfStoreKeyResponse");
+function StoreKeyResponseFromJSON(json) {
+  return StoreKeyResponseFromJSONTyped(json, false);
+}
+__name(StoreKeyResponseFromJSON, "StoreKeyResponseFromJSON");
+function StoreKeyResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    keyInfo: ManagedKeyInfoFromJSON(json["keyInfo"])
+  };
+}
+__name(StoreKeyResponseFromJSONTyped, "StoreKeyResponseFromJSONTyped");
+function StoreKeyResponseToJSON(json) {
+  return StoreKeyResponseToJSONTyped(json, false);
+}
+__name(StoreKeyResponseToJSON, "StoreKeyResponseToJSON");
+function StoreKeyResponseToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    keyInfo: ManagedKeyInfoToJSON(value["keyInfo"])
+  };
+}
+__name(StoreKeyResponseToJSONTyped, "StoreKeyResponseToJSONTyped");
+
+// src/models/UpdateKeyProvider.ts
+function instanceOfUpdateKeyProvider(value) {
+  return true;
+}
+__name(instanceOfUpdateKeyProvider, "instanceOfUpdateKeyProvider");
+function UpdateKeyProviderFromJSON(json) {
+  return UpdateKeyProviderFromJSONTyped(json, false);
+}
+__name(UpdateKeyProviderFromJSON, "UpdateKeyProviderFromJSON");
+function UpdateKeyProviderFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    azureKeyvaultSettings: json["azureKeyvaultSettings"] == null ? void 0 : AzureKeyVaultSettingFromJSON(json["azureKeyvaultSettings"]),
+    awsKmsSettings: json["awsKmsSettings"] == null ? void 0 : AwsKmsSettingFromJSON(json["awsKmsSettings"]),
+    cacheEnabled: json["cacheEnabled"] == null ? void 0 : json["cacheEnabled"],
+    cacheTTLInSeconds: json["cacheTTLInSeconds"] == null ? void 0 : json["cacheTTLInSeconds"]
+  };
+}
+__name(UpdateKeyProviderFromJSONTyped, "UpdateKeyProviderFromJSONTyped");
+function UpdateKeyProviderToJSON(json) {
+  return UpdateKeyProviderToJSONTyped(json, false);
+}
+__name(UpdateKeyProviderToJSON, "UpdateKeyProviderToJSON");
+function UpdateKeyProviderToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    azureKeyvaultSettings: AzureKeyVaultSettingToJSON(value["azureKeyvaultSettings"]),
+    awsKmsSettings: AwsKmsSettingToJSON(value["awsKmsSettings"]),
+    cacheEnabled: value["cacheEnabled"],
+    cacheTTLInSeconds: value["cacheTTLInSeconds"]
+  };
+}
+__name(UpdateKeyProviderToJSONTyped, "UpdateKeyProviderToJSONTyped");
+
+// src/models/VerifyRawSignature.ts
+function instanceOfVerifyRawSignature(value) {
+  if (!("keyInfo" in value) || value["keyInfo"] === void 0) return false;
+  if (!("input" in value) || value["input"] === void 0) return false;
+  if (!("signature" in value) || value["signature"] === void 0) return false;
+  return true;
+}
+__name(instanceOfVerifyRawSignature, "instanceOfVerifyRawSignature");
+function VerifyRawSignatureFromJSON(json) {
+  return VerifyRawSignatureFromJSONTyped(json, false);
+}
+__name(VerifyRawSignatureFromJSON, "VerifyRawSignatureFromJSON");
+function VerifyRawSignatureFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    keyInfo: KeyInfoFromJSON(json["keyInfo"]),
+    input: json["input"],
+    signature: json["signature"]
+  };
+}
+__name(VerifyRawSignatureFromJSONTyped, "VerifyRawSignatureFromJSONTyped");
+function VerifyRawSignatureToJSON(json) {
+  return VerifyRawSignatureToJSONTyped(json, false);
+}
+__name(VerifyRawSignatureToJSON, "VerifyRawSignatureToJSON");
+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 instanceOfVerifyRawSignatureResponse(value) {
+  if (!("isValid" in value) || value["isValid"] === void 0) return false;
+  return true;
+}
+__name(instanceOfVerifyRawSignatureResponse, "instanceOfVerifyRawSignatureResponse");
+function VerifyRawSignatureResponseFromJSON(json) {
+  return VerifyRawSignatureResponseFromJSONTyped(json, false);
+}
+__name(VerifyRawSignatureResponseFromJSON, "VerifyRawSignatureResponseFromJSON");
+function VerifyRawSignatureResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    isValid: json["isValid"]
+  };
+}
+__name(VerifyRawSignatureResponseFromJSONTyped, "VerifyRawSignatureResponseFromJSONTyped");
+function VerifyRawSignatureResponseToJSON(json) {
+  return VerifyRawSignatureResponseToJSONTyped(json, false);
+}
+__name(VerifyRawSignatureResponseToJSON, "VerifyRawSignatureResponseToJSON");
+function VerifyRawSignatureResponseToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    isValid: value["isValid"]
+  };
+}
+__name(VerifyRawSignatureResponseToJSONTyped, "VerifyRawSignatureResponseToJSONTyped");
+
+// src/models/VerifySimpleSignature.ts
+function instanceOfVerifySimpleSignature(value) {
+  if (!("signInput" in value) || value["signInput"] === void 0) return false;
+  if (!("signature" in value) || value["signature"] === void 0) return false;
+  return true;
+}
+__name(instanceOfVerifySimpleSignature, "instanceOfVerifySimpleSignature");
+function VerifySimpleSignatureFromJSON(json) {
+  return VerifySimpleSignatureFromJSONTyped(json, false);
+}
+__name(VerifySimpleSignatureFromJSON, "VerifySimpleSignatureFromJSON");
+function VerifySimpleSignatureFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    signInput: SignInputFromJSON(json["signInput"]),
+    signature: SignatureFromJSON(json["signature"])
+  };
+}
+__name(VerifySimpleSignatureFromJSONTyped, "VerifySimpleSignatureFromJSONTyped");
+function VerifySimpleSignatureToJSON(json) {
+  return VerifySimpleSignatureToJSONTyped(json, false);
+}
+__name(VerifySimpleSignatureToJSON, "VerifySimpleSignatureToJSON");
+function VerifySimpleSignatureToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    signInput: SignInputToJSON(value["signInput"]),
+    signature: SignatureToJSON(value["signature"])
+  };
+}
+__name(VerifySimpleSignatureToJSONTyped, "VerifySimpleSignatureToJSONTyped");
+
+// 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 = {
+    kmsClientGetKey: this.kmsClientGetKey.bind(this),
+    kmsClientListKeys: this.kmsClientListKeys.bind(this),
+    kmsClientStoreKey: this.kmsClientStoreKey.bind(this),
+    kmsClientGenerateKey: this.kmsClientGenerateKey.bind(this),
+    kmsClientDeleteKey: this.kmsClientDeleteKey.bind(this),
+    kmsClientGetKeyProvider: this.kmsClientGetKeyProvider.bind(this),
+    kmsClientListKeyProviders: this.kmsClientListKeyProviders.bind(this),
+    kmsClientProviderListKeys: this.kmsClientProviderListKeys.bind(this),
+    kmsClientProviderStoreKey: this.kmsClientProviderStoreKey.bind(this),
+    kmsClientProviderGenerateKey: this.kmsClientProviderGenerateKey.bind(this),
+    kmsClientProviderGetKey: this.kmsClientProviderGetKey.bind(this),
+    kmsClientProviderDeleteKey: this.kmsClientProviderDeleteKey.bind(this),
+    kmsClientGetResolver: this.kmsClientGetResolver.bind(this),
+    kmsClientListResolvers: this.kmsClientListResolvers.bind(this),
+    kmsClientResolveKey: this.kmsClientResolveKey.bind(this),
+    kmsClientCreateRawSignature: this.kmsClientCreateRawSignature.bind(this),
+    kmsClientIsValidRawSignature: this.kmsClientIsValidRawSignature.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 kmsClientGetResolver(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 kmsClientListResolvers(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 kmsClientResolveKey(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 kmsClientCreateRawSignature(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 kmsClientIsValidRawSignature(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 kmsClientGetKey(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 GetKeyResponseFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsListKeys} */
+  async kmsClientListKeys(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 {
+      return ListKeysResponseFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsStoreKey} */
+  async kmsClientStoreKey(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 StoreKeyResponseFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsGenerateKey} */
+  async kmsClientGenerateKey(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 GenerateKeyResponseFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsDeleteKey} */
+  async kmsClientDeleteKey(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 kmsClientGetKeyProvider(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 kmsClientListKeyProviders(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 kmsClientProviderListKeys(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 kmsClientProviderStoreKey(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 StoreKeyResponseFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsProviderGenerateKey} */
+  async kmsClientProviderGenerateKey(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 GenerateKeyResponseFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsProviderGetKey} */
+  async kmsClientProviderGetKey(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 GetKeyResponseFromJSONTyped(await response.json(), false);
+    } catch (error) {
+      return Promise.reject(Error(`request to ${url} returned ${error}`));
+    }
+  }
+  /** {@inheritDoc IKmsRestClient.kmsProviderDeleteKey} */
+  async kmsClientProviderDeleteKey(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;
+  }
+};
+//# sourceMappingURL=index.cjs.map