@sphereon/ssi-sdk.kms-rest-client 0.34.1-feature.IDK.11.52 → 0.34.1-feature.IDK.11.53

package/dist/index.js

@@ -1011,7 +1011,369 @@ var plugin_schema_default = {
 import { Loggers } from "@sphereon/ssi-types";
 import { fetch } from "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);
 }
@@ -1020,8 +1382,21 @@ 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);
 }
@@ -1044,8 +1419,35 @@ function CoseKeyFromJSONTyped(json, ignoreDiscriminator) {
   };
 }
 __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);
 }
@@ -1060,8 +1462,38 @@ function CoseKeyPairFromJSONTyped(json, ignoreDiscriminator) {
   };
 }
 __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);
 }
@@ -1070,8 +1502,73 @@ 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);
 }
@@ -1084,8 +1581,27 @@ 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);
 }
@@ -1098,8 +1614,37 @@ 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);
 }
@@ -1112,8 +1657,27 @@ 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);
 }
@@ -1126,8 +1690,33 @@ 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);
 }
@@ -1140,8 +1729,33 @@ 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);
 }
@@ -1154,8 +1768,27 @@ 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);
 }
@@ -1168,8 +1801,29 @@ 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);
 }
@@ -1182,8 +1836,17 @@ 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);
 }
@@ -1252,6 +1915,32 @@ function JwkToJSONTyped(value, ignoreDiscriminator = false) {
 __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);
 }
@@ -1276,6 +1965,30 @@ function KeyInfoToJSONTyped(value, ignoreDiscriminator = false) {
 __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;
@@ -1288,6 +2001,15 @@ function CreateRawSignatureToJSONTyped(value, ignoreDiscriminator = false) {
 __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;
@@ -1297,8 +2019,235 @@ function CreateRawSignatureResponseFromJSONTyped(json, ignoreDiscriminator) {
   };
 }
 __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;
@@ -1313,6 +2262,31 @@ function GenerateKeyToJSONTyped(value, ignoreDiscriminator = false) {
 __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;
@@ -1328,6 +2302,11 @@ function GenerateKeyGlobalToJSONTyped(value, ignoreDiscriminator = false) {
 __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);
 }
@@ -1342,47 +2321,203 @@ function JoseKeyPairFromJSONTyped(json, ignoreDiscriminator) {
   };
 }
 __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"])
+    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(ManagedKeyPairFromJSONTyped, "ManagedKeyPairFromJSONTyped");
-
-// src/models/ManagedKeyInfo.ts
-function ManagedKeyInfoFromJSON(json) {
-  return ManagedKeyInfoFromJSONTyped(json, false);
+__name(GetKeyResponseFromJSONTyped, "GetKeyResponseFromJSONTyped");
+function GetKeyResponseToJSON(json) {
+  return GetKeyResponseToJSONTyped(json, false);
 }
-__name(ManagedKeyInfoFromJSON, "ManagedKeyInfoFromJSON");
-function ManagedKeyInfoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
+__name(GetKeyResponseToJSON, "GetKeyResponseToJSON");
+function GetKeyResponseToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
   }
   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"]
+    keyInfo: ManagedKeyInfoToJSON(value["keyInfo"])
   };
 }
-__name(ManagedKeyInfoFromJSONTyped, "ManagedKeyInfoFromJSONTyped");
+__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);
 }
@@ -1395,8 +2530,18 @@ 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);
 }
@@ -1411,8 +2556,32 @@ function KeyProviderFromJSONTyped(json, ignoreDiscriminator) {
   };
 }
 __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;
@@ -1423,8 +2592,68 @@ function KeyProviderResponseFromJSONTyped(json, ignoreDiscriminator) {
   };
 }
 __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;
@@ -1434,8 +2663,30 @@ function ListKeyProvidersResponseFromJSONTyped(json, ignoreDiscriminator) {
   };
 }
 __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;
@@ -1445,8 +2696,26 @@ function ListKeysResponseFromJSONTyped(json, ignoreDiscriminator) {
   };
 }
 __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);
 }
@@ -1462,8 +2731,32 @@ function ResolverFromJSONTyped(json, ignoreDiscriminator) {
   };
 }
 __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;
@@ -1473,8 +2766,118 @@ function ListResolversResponseFromJSONTyped(json, ignoreDiscriminator) {
   };
 }
 __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;
@@ -1489,6 +2892,15 @@ function ResolvePublicKeyToJSONTyped(value, ignoreDiscriminator = false) {
 __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;
@@ -1530,7 +2942,105 @@ function ResolvedKeyInfoToJSONTyped(value, ignoreDiscriminator = false) {
 }
 __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;
@@ -1542,7 +3052,104 @@ function StoreKeyToJSONTyped(value, ignoreDiscriminator = false) {
 }
 __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;
@@ -1556,6 +3163,15 @@ function VerifyRawSignatureToJSONTyped(value, ignoreDiscriminator = false) {
 __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;
@@ -1565,6 +3181,55 @@ function VerifyRawSignatureResponseFromJSONTyped(json, ignoreDiscriminator) {
   };
 }
 __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 = Loggers.DEFAULT.get("sphereon:ssi-sdk:kms:rest-client");
@@ -1618,7 +3283,7 @@ var KmsRestClient = class _KmsRestClient {
   }
   /** {@inheritDoc IKmsRestClient.kmsListResolvers} */
   async kmsClientListResolvers(args) {
-    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const baseUrl = this.assertedAgentBaseUrl(args?.baseUrl);
     const url = _KmsRestClient.urlWithBase("/resolvers", baseUrl);
     const response = await fetch(url, {
       method: "GET"
@@ -1708,16 +3373,16 @@ var KmsRestClient = class _KmsRestClient {
     });
     logger.debug(`get key response: ${response}`);
     try {
-      return ManagedKeyInfoFromJSONTyped(await response.json(), false);
+      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 baseUrl = this.assertedAgentBaseUrl(args?.baseUrl);
     const url = this.addSearchParams(_KmsRestClient.urlWithBase("/keys", baseUrl), {
-      ...args.providerId && {
+      ...args?.providerId && {
         providerId: args.providerId
       }
     });
@@ -1726,8 +3391,7 @@ var KmsRestClient = class _KmsRestClient {
     });
     logger.debug(`list keys response: ${response}`);
     try {
-      const xx = await response.json();
-      return ListKeysResponseFromJSONTyped(xx, false);
+      return ListKeysResponseFromJSONTyped(await response.json(), false);
     } catch (error) {
       return Promise.reject(Error(`request to ${url} returned ${error}`));
     }
@@ -1749,7 +3413,7 @@ var KmsRestClient = class _KmsRestClient {
     });
     logger.debug(`store key response: ${response}`);
     try {
-      return ManagedKeyInfoFromJSONTyped(await response.json(), false);
+      return StoreKeyResponseFromJSONTyped(await response.json(), false);
     } catch (error) {
       return Promise.reject(Error(`request to ${url} returned ${error}`));
     }
@@ -1773,7 +3437,7 @@ var KmsRestClient = class _KmsRestClient {
     });
     logger.debug(`generate key response: ${response}`);
     try {
-      return ManagedKeyPairFromJSONTyped(await response.json(), false);
+      return GenerateKeyResponseFromJSONTyped(await response.json(), false);
     } catch (error) {
       return Promise.reject(Error(`request to ${url} returned ${error}`));
     }
@@ -1803,7 +3467,7 @@ var KmsRestClient = class _KmsRestClient {
   }
   /** {@inheritDoc IKmsRestClient.kmsListKeyProviders} */
   async kmsClientListKeyProviders(args) {
-    const baseUrl = this.assertedAgentBaseUrl(args.baseUrl);
+    const baseUrl = this.assertedAgentBaseUrl(args?.baseUrl);
     const url = _KmsRestClient.urlWithBase("/providers", baseUrl);
     const response = await fetch(url, {
       method: "GET"
@@ -1846,7 +3510,7 @@ var KmsRestClient = class _KmsRestClient {
     });
     logger.debug(`provider store key response: ${response}`);
     try {
-      return ManagedKeyInfoFromJSONTyped(await response.json(), false);
+      return StoreKeyResponseFromJSONTyped(await response.json(), false);
     } catch (error) {
       return Promise.reject(Error(`request to ${url} returned ${error}`));
     }
@@ -1869,7 +3533,7 @@ var KmsRestClient = class _KmsRestClient {
     });
     logger.debug(`provider generate key response: ${response}`);
     try {
-      return ManagedKeyPairFromJSONTyped(await response.json(), false);
+      return GenerateKeyResponseFromJSONTyped(await response.json(), false);
     } catch (error) {
       return Promise.reject(Error(`request to ${url} returned ${error}`));
     }
@@ -1883,7 +3547,7 @@ var KmsRestClient = class _KmsRestClient {
     });
     logger.debug(`get provider key response: ${response}`);
     try {
-      return ManagedKeyInfoFromJSONTyped(await response.json(), false);
+      return GetKeyResponseFromJSONTyped(await response.json(), false);
     } catch (error) {
       return Promise.reject(Error(`request to ${url} returned ${error}`));
     }
@@ -1927,7 +3591,313 @@ var KmsRestClient = class _KmsRestClient {
   }
 };
 export {
+  AwsAssumeRoleCredentialsFromJSON,
+  AwsAssumeRoleCredentialsFromJSONTyped,
+  AwsAssumeRoleCredentialsToJSON,
+  AwsAssumeRoleCredentialsToJSONTyped,
+  AwsClientConfigurationFromJSON,
+  AwsClientConfigurationFromJSONTyped,
+  AwsClientConfigurationToJSON,
+  AwsClientConfigurationToJSONTyped,
+  AwsKmsSettingFromJSON,
+  AwsKmsSettingFromJSONTyped,
+  AwsKmsSettingToJSON,
+  AwsKmsSettingToJSONTyped,
+  AwsStaticCredentialsFromJSON,
+  AwsStaticCredentialsFromJSONTyped,
+  AwsStaticCredentialsToJSON,
+  AwsStaticCredentialsToJSONTyped,
+  AwsWebIdentityTokenCredentialsFromJSON,
+  AwsWebIdentityTokenCredentialsFromJSONTyped,
+  AwsWebIdentityTokenCredentialsToJSON,
+  AwsWebIdentityTokenCredentialsToJSONTyped,
+  AzureClientSecretCredentialOptsFromJSON,
+  AzureClientSecretCredentialOptsFromJSONTyped,
+  AzureClientSecretCredentialOptsToJSON,
+  AzureClientSecretCredentialOptsToJSONTyped,
+  AzureCredentialOptsFromJSON,
+  AzureCredentialOptsFromJSONTyped,
+  AzureCredentialOptsToJSON,
+  AzureCredentialOptsToJSONTyped,
+  AzureKeyVaultSettingFromJSON,
+  AzureKeyVaultSettingFromJSONTyped,
+  AzureKeyVaultSettingToJSON,
+  AzureKeyVaultSettingToJSONTyped,
+  CoseKeyFromJSON,
+  CoseKeyFromJSONTyped,
+  CoseKeyPairFromJSON,
+  CoseKeyPairFromJSONTyped,
+  CoseKeyPairToJSON,
+  CoseKeyPairToJSONTyped,
+  CoseKeyToJSON,
+  CoseKeyToJSONTyped,
+  CoseKeyType,
+  CoseKeyTypeFromJSON,
+  CoseKeyTypeFromJSONTyped,
+  CoseKeyTypeToJSON,
+  CoseKeyTypeToJSONTyped,
+  CreateKeyProviderFromJSON,
+  CreateKeyProviderFromJSONTyped,
+  CreateKeyProviderToJSON,
+  CreateKeyProviderToJSONTyped,
+  CreateRawSignatureFromJSON,
+  CreateRawSignatureFromJSONTyped,
+  CreateRawSignatureResponseFromJSON,
+  CreateRawSignatureResponseFromJSONTyped,
+  CreateRawSignatureResponseToJSON,
+  CreateRawSignatureResponseToJSONTyped,
+  CreateRawSignatureToJSON,
+  CreateRawSignatureToJSONTyped,
+  CreateSimpleSignatureFromJSON,
+  CreateSimpleSignatureFromJSONTyped,
+  CreateSimpleSignatureToJSON,
+  CreateSimpleSignatureToJSONTyped,
+  CryptoAlg,
+  CryptoAlgFromJSON,
+  CryptoAlgFromJSONTyped,
+  CryptoAlgToJSON,
+  CryptoAlgToJSONTyped,
+  Curve,
+  CurveFromJSON,
+  CurveFromJSONTyped,
+  CurveToJSON,
+  CurveToJSONTyped,
+  DigestAlg,
+  DigestAlgFromJSON,
+  DigestAlgFromJSONTyped,
+  DigestAlgToJSON,
+  DigestAlgToJSONTyped,
+  ErrorResponseFromJSON,
+  ErrorResponseFromJSONTyped,
+  ErrorResponseToJSON,
+  ErrorResponseToJSONTyped,
+  GenerateKeyFromJSON,
+  GenerateKeyFromJSONTyped,
+  GenerateKeyGlobalFromJSON,
+  GenerateKeyGlobalFromJSONTyped,
+  GenerateKeyGlobalToJSON,
+  GenerateKeyGlobalToJSONTyped,
+  GenerateKeyResponseFromJSON,
+  GenerateKeyResponseFromJSONTyped,
+  GenerateKeyResponseToJSON,
+  GenerateKeyResponseToJSONTyped,
+  GenerateKeyToJSON,
+  GenerateKeyToJSONTyped,
+  GetKeyResponseFromJSON,
+  GetKeyResponseFromJSONTyped,
+  GetKeyResponseToJSON,
+  GetKeyResponseToJSONTyped,
+  IdentifierMethod,
+  IdentifierMethodFromJSON,
+  IdentifierMethodFromJSONTyped,
+  IdentifierMethodToJSON,
+  IdentifierMethodToJSONTyped,
+  JoseKeyPairFromJSON,
+  JoseKeyPairFromJSONTyped,
+  JoseKeyPairToJSON,
+  JoseKeyPairToJSONTyped,
+  JwkFromJSON,
+  JwkFromJSONTyped,
+  JwkKeyType,
+  JwkKeyTypeFromJSON,
+  JwkKeyTypeFromJSONTyped,
+  JwkKeyTypeToJSON,
+  JwkKeyTypeToJSONTyped,
+  JwkToJSON,
+  JwkToJSONTyped,
+  JwkUse,
+  JwkUseFromJSON,
+  JwkUseFromJSONTyped,
+  JwkUseToJSON,
+  JwkUseToJSONTyped,
+  KeyEncoding,
+  KeyEncodingFromJSON,
+  KeyEncodingFromJSONTyped,
+  KeyEncodingToJSON,
+  KeyEncodingToJSONTyped,
+  KeyInfoFromJSON,
+  KeyInfoFromJSONTyped,
+  KeyInfoToJSON,
+  KeyInfoToJSONTyped,
+  KeyOperations,
+  KeyOperationsFromJSON,
+  KeyOperationsFromJSONTyped,
+  KeyOperationsToJSON,
+  KeyOperationsToJSONTyped,
+  KeyProviderFromJSON,
+  KeyProviderFromJSONTyped,
+  KeyProviderResponseFromJSON,
+  KeyProviderResponseFromJSONTyped,
+  KeyProviderResponseToJSON,
+  KeyProviderResponseToJSONTyped,
+  KeyProviderToJSON,
+  KeyProviderToJSONTyped,
+  KeyProviderType,
+  KeyProviderTypeFromJSON,
+  KeyProviderTypeFromJSONTyped,
+  KeyProviderTypeToJSON,
+  KeyProviderTypeToJSONTyped,
+  KeyResolverFromJSON,
+  KeyResolverFromJSONTyped,
+  KeyResolverToJSON,
+  KeyResolverToJSONTyped,
+  KeyType,
+  KeyTypeFromJSON,
+  KeyTypeFromJSONTyped,
+  KeyTypeToJSON,
+  KeyTypeToJSONTyped,
+  KeyVisibility,
+  KeyVisibilityFromJSON,
+  KeyVisibilityFromJSONTyped,
+  KeyVisibilityToJSON,
+  KeyVisibilityToJSONTyped,
   KmsRestClient,
+  ListKeyProvidersResponseFromJSON,
+  ListKeyProvidersResponseFromJSONTyped,
+  ListKeyProvidersResponseToJSON,
+  ListKeyProvidersResponseToJSONTyped,
+  ListKeysResponseFromJSON,
+  ListKeysResponseFromJSONTyped,
+  ListKeysResponseToJSON,
+  ListKeysResponseToJSONTyped,
+  ListResolversResponseFromJSON,
+  ListResolversResponseFromJSONTyped,
+  ListResolversResponseToJSON,
+  ListResolversResponseToJSONTyped,
+  LookupMode,
+  LookupModeFromJSON,
+  LookupModeFromJSONTyped,
+  LookupModeToJSON,
+  LookupModeToJSONTyped,
+  ManagedKeyInfoFromJSON,
+  ManagedKeyInfoFromJSONTyped,
+  ManagedKeyInfoToJSON,
+  ManagedKeyInfoToJSONTyped,
+  ManagedKeyPairFromJSON,
+  ManagedKeyPairFromJSONTyped,
+  ManagedKeyPairToJSON,
+  ManagedKeyPairToJSONTyped,
+  MaskGenFunction,
+  MaskGenFunctionFromJSON,
+  MaskGenFunctionFromJSONTyped,
+  MaskGenFunctionToJSON,
+  MaskGenFunctionToJSONTyped,
+  ProviderCapabilitiesFromJSON,
+  ProviderCapabilitiesFromJSONTyped,
+  ProviderCapabilitiesToJSON,
+  ProviderCapabilitiesToJSONTyped,
+  ResolvePublicKeyFromJSON,
+  ResolvePublicKeyFromJSONTyped,
+  ResolvePublicKeyToJSON,
+  ResolvePublicKeyToJSONTyped,
+  ResolvedKeyInfoFromJSON,
+  ResolvedKeyInfoFromJSONTyped,
+  ResolvedKeyInfoToJSON,
+  ResolvedKeyInfoToJSONTyped,
+  ResolverFromJSON,
+  ResolverFromJSONTyped,
+  ResolverToJSON,
+  ResolverToJSONTyped,
+  SignInputFromJSON,
+  SignInputFromJSONTyped,
+  SignInputModeEnum,
+  SignInputToJSON,
+  SignInputToJSONTyped,
+  SignOutputFromJSON,
+  SignOutputFromJSONTyped,
+  SignOutputToJSON,
+  SignOutputToJSONTyped,
+  SignatureAlgorithm,
+  SignatureAlgorithmFromJSON,
+  SignatureAlgorithmFromJSONTyped,
+  SignatureAlgorithmToJSON,
+  SignatureAlgorithmToJSONTyped,
+  SignatureFromJSON,
+  SignatureFromJSONTyped,
+  SignatureToJSON,
+  SignatureToJSONTyped,
+  StoreKeyFromJSON,
+  StoreKeyFromJSONTyped,
+  StoreKeyResponseFromJSON,
+  StoreKeyResponseFromJSONTyped,
+  StoreKeyResponseToJSON,
+  StoreKeyResponseToJSONTyped,
+  StoreKeyToJSON,
+  StoreKeyToJSONTyped,
+  UpdateKeyProviderFromJSON,
+  UpdateKeyProviderFromJSONTyped,
+  UpdateKeyProviderToJSON,
+  UpdateKeyProviderToJSONTyped,
+  VerifyRawSignatureFromJSON,
+  VerifyRawSignatureFromJSONTyped,
+  VerifyRawSignatureResponseFromJSON,
+  VerifyRawSignatureResponseFromJSONTyped,
+  VerifyRawSignatureResponseToJSON,
+  VerifyRawSignatureResponseToJSONTyped,
+  VerifyRawSignatureToJSON,
+  VerifyRawSignatureToJSONTyped,
+  VerifySimpleSignatureFromJSON,
+  VerifySimpleSignatureFromJSONTyped,
+  VerifySimpleSignatureToJSON,
+  VerifySimpleSignatureToJSONTyped,
+  instanceOfAwsAssumeRoleCredentials,
+  instanceOfAwsClientConfiguration,
+  instanceOfAwsKmsSetting,
+  instanceOfAwsStaticCredentials,
+  instanceOfAwsWebIdentityTokenCredentials,
+  instanceOfAzureClientSecretCredentialOpts,
+  instanceOfAzureCredentialOpts,
+  instanceOfAzureKeyVaultSetting,
+  instanceOfCoseKey,
+  instanceOfCoseKeyPair,
+  instanceOfCoseKeyType,
+  instanceOfCreateKeyProvider,
+  instanceOfCreateRawSignature,
+  instanceOfCreateRawSignatureResponse,
+  instanceOfCreateSimpleSignature,
+  instanceOfCryptoAlg,
+  instanceOfCurve,
+  instanceOfDigestAlg,
+  instanceOfErrorResponse,
+  instanceOfGenerateKey,
+  instanceOfGenerateKeyGlobal,
+  instanceOfGenerateKeyResponse,
+  instanceOfGetKeyResponse,
+  instanceOfIdentifierMethod,
+  instanceOfJoseKeyPair,
+  instanceOfJwk,
+  instanceOfJwkKeyType,
+  instanceOfJwkUse,
+  instanceOfKeyEncoding,
+  instanceOfKeyInfo,
+  instanceOfKeyOperations,
+  instanceOfKeyProvider,
+  instanceOfKeyProviderResponse,
+  instanceOfKeyProviderType,
+  instanceOfKeyResolver,
+  instanceOfKeyType,
+  instanceOfKeyVisibility,
+  instanceOfListKeyProvidersResponse,
+  instanceOfListKeysResponse,
+  instanceOfListResolversResponse,
+  instanceOfLookupMode,
+  instanceOfManagedKeyInfo,
+  instanceOfManagedKeyPair,
+  instanceOfMaskGenFunction,
+  instanceOfProviderCapabilities,
+  instanceOfResolvePublicKey,
+  instanceOfResolvedKeyInfo,
+  instanceOfResolver,
+  instanceOfSignInput,
+  instanceOfSignOutput,
+  instanceOfSignature,
+  instanceOfSignatureAlgorithm,
+  instanceOfStoreKey,
+  instanceOfStoreKeyResponse,
+  instanceOfUpdateKeyProvider,
+  instanceOfVerifyRawSignature,
+  instanceOfVerifyRawSignatureResponse,
+  instanceOfVerifySimpleSignature,
   plugin_schema_default as schema
 };
 //# sourceMappingURL=index.js.map