@sphereon/idk-lib-data-link-http-client-impl 0.25.0-SNAPSHOT-build-8529934

package/idk-lib-crypto-core-impl.mjs

@@ -0,0 +1,2009 @@
+import {
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+  toString1pkumu07cwy4m as toString,
+  Unit_instancev9v8hjid95df as Unit_instance,
+  VOID3gxj6tk5isa35 as VOID,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  protoOf180f3jzyo7rfj as protoOf,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  isInterface3d6p8outrmvmk as isInterface,
+  promisify1z0ncraq1ipzh as promisify,
+  await2s6xyuld384ut as await_0,
+  defineProp3ur6h3slcvq4x as defineProp,
+  equals2au1ep9vhcato as equals,
+  FunctionAdapter3lcrrz3moet5b as FunctionAdapter,
+  Comparator2b3maoeh98xtg as Comparator,
+  hashCodeq5arwsb9dgti as hashCode,
+  compareValues1n2ayl87ihzfk as compareValues,
+  sortedWith2csnbbb21k0lg as sortedWith,
+  collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault,
+  mapCapacity1h45rc3eh9p2l as mapCapacity,
+  coerceAtLeast2bkz8m9ik7hep as coerceAtLeast,
+  LinkedHashMap1zhqxkxv3xnkl as LinkedHashMap,
+  toMutableMapr5f3w62lv8sk as toMutableMap,
+  first28gmhyvs4kf06 as first,
+  copyToArray2j022khrow2yi as copyToArray,
+  joinToStringxqcavsxcmh4q as joinToString,
+  contains1tccixv8iwdcq as contains,
+  toString30pk9tzaqopn as toString_0,
+  KProperty1ca4yb4wlo496 as KProperty1,
+  getPropertyCallableRef3hckxc0xueiaj as getPropertyCallableRef,
+  lazy2hsh8ze7j6ikd as lazy,
+  ArrayList3it5z8td81qkl as ArrayList,
+} from '../kotlin-kotlin-stdlib.mjs';
+import {
+  CoseJoseKeyMappingService_instance1u2hjnjtsd7r1 as CoseJoseKeyMappingService_instance,
+  JwaKeyType_EC_getInstancesy663o3quhf3 as JwaKeyType_EC_getInstance,
+  Companion_getInstance2j5z70v28sfbd as Companion_getInstance,
+  P_256_getInstance2c3yye4qdxi9a as P_256_getInstance,
+  EcdhUtils_instancem1f6p6z4er02 as EcdhUtils_instance,
+  getProviderById3cbs00g78z86z as getProviderById,
+  getProvider15nv6e6uoyvqk as getProvider,
+  registerProvidergldbgky7fryv as registerProvider,
+  getResolverById3o3u01y9o8j73 as getResolverById,
+  getResolverByKeyTypeOrIdentifieruxmy70pl5k7u as getResolverByKeyTypeOrIdentifier,
+  registerResolver26by0isjei20a as registerResolver,
+  QueryProviderArgs1qpobauc9f2xe as QueryProviderArgs,
+  QueryProvidersArgs2o8p6qm1z6ajs as QueryProvidersArgs,
+  GetAllCapabilitiesArgsvl5sannhkhj8 as GetAllCapabilitiesArgs,
+  getAllCapabilities$default2my8ewhe78lnc as getAllCapabilities$default,
+  ResolvePublicKeyArgs18wcr8ckibo4x as ResolvePublicKeyArgs,
+  PKIException2q8eyrx46yxje as PKIException,
+  ResolvedKeyInfoTypee7maap38fdff as ResolvedKeyInfoType,
+  resolvePublicKey$default1s9xtr3v06wzo as resolvePublicKey$default,
+  GenerateKeyArgs3exal8cx1h1iv as GenerateKeyArgs,
+  generateKeyAsync$virtualSuspendBridgea5kvtvcvqjgo as generateKeyAsync$virtualSuspendBridge,
+  generateKey$default1qhxgz7gl19w4 as generateKey$default,
+  generateKeyAsync$default2tvn0ng0q0x5u as generateKeyAsync$default,
+  CreateRawSignatureArgsj4ekfuix1k42 as CreateRawSignatureArgs,
+  IdentifierMethod_x5c_getInstance37h0jruk9ae35 as IdentifierMethod_x5c_getInstance,
+  VerifyRawSignatureArgs18ql14s7cjsl7 as VerifyRawSignatureArgs,
+  EncryptArgs3nscqgzjci3t0 as EncryptArgs,
+  EncryptionResult2kafqhrbwv0ks as EncryptionResult,
+  encrypt$virtualSuspendBridge2fzt5s4nxtydk as encrypt$virtualSuspendBridge,
+  encrypt$default5d1j5wmpk5ac as encrypt$default,
+  DecryptArgs2okdcyh5j1xm3 as DecryptArgs,
+  decrypt$virtualSuspendBridge26lx0sxvy72pq as decrypt$virtualSuspendBridge,
+  decrypt$default2tg5snelob84g as decrypt$default,
+  WrapKeyArgs1o2nu2n8hiij6 as WrapKeyArgs,
+  wrapKey$virtualSuspendBridgehuom2lnmrxig as wrapKey$virtualSuspendBridge,
+  UnwrapKeyArgs1l29bkkp4d04y as UnwrapKeyArgs,
+  unwrapKey$virtualSuspendBridge10diszgquw2jd as unwrapKey$virtualSuspendBridge,
+  PerformKeyAgreementArgs2cy1svd0b0maa as PerformKeyAgreementArgs,
+  performKeyAgreement$default3kjax4b11qhz1 as performKeyAgreement$default,
+  StoreKeyArgs2x4xpugiswbue as StoreKeyArgs,
+  storeKey$virtualSuspendBridge2ur76bvwv5849 as storeKey$virtualSuspendBridge,
+  storeKey$default3hyedu7uwb2q as storeKey$default,
+  ListKeysArgsx5y8zk7xx666 as ListKeysArgs,
+  listKeys$virtualSuspendBridgeogq2mk63x0vn as listKeys$virtualSuspendBridge,
+  listKeys$virtualSuspendBridge3om318qdf1ayn as listKeys$virtualSuspendBridge_0,
+  GetKeyArgs3d3w36dy5oz41 as GetKeyArgs,
+  getKey$virtualSuspendBridge38ippv9eib6zv as getKey$virtualSuspendBridge,
+  DeleteKeyArgskxnuaox68awq as DeleteKeyArgs,
+  deleteKey$virtualSuspendBridge2clie97ix3t7p as deleteKey$virtualSuspendBridge,
+  createRawSignatureResult$defaultd77zhembl951 as createRawSignatureResult$default,
+  encryptResult$default1hbyrnrb2tnze as encryptResult$default,
+  decryptResult$default2xvx5e6kgoqpi as decryptResult$default,
+  performKeyAgreementResult$default1zk3om63b7aeh as performKeyAgreementResult$default,
+  generateKeyResult$default3jhigo88uholy as generateKeyResult$default,
+  listKeysResult$default3rniwb27pmy11 as listKeysResult$default,
+  storeKeyResult$default3cq4wzefnn46l as storeKeyResult$default,
+  resolvePublicKeyResult$default1xzdkdrhpdxr1 as resolvePublicKeyResult$default,
+  exposesPrivateKeysForSigning2dtrk591mvf2q as exposesPrivateKeysForSigning,
+  KeyManagerService1jy2oalnbllzs as KeyManagerService,
+  KeyResolverRegistry6pjvs5ngvu1l as KeyResolverRegistry,
+  KmsProviderRegistry37cfrhx8iscz8 as KmsProviderRegistry,
+  Companion_instanceg7awlm0z4331 as Companion_instance,
+  Companion_instance32pwcnmcyatxm as Companion_instance_0,
+  PredefinedKeyStoreTypes_MEMORY_getInstance23f58aplzn8ww as PredefinedKeyStoreTypes_MEMORY_getInstance,
+  Companion_getInstance12wp5sqa9plkt as Companion_getInstance_0,
+  toKeyReference1hbuu4zgrnbfp as toKeyReference,
+  KeyVisibility_PUBLIC_getInstancexko9xei8c785 as KeyVisibility_PUBLIC_getInstance,
+  KeyVisibility_PRIVATE_getInstance3vqkhhiu4wt1g as KeyVisibility_PRIVATE_getInstance,
+  ManagedKeyInfo2yqhf0w110ugh as ManagedKeyInfo,
+  storeCertificateChain$default11apxigx30bm7 as storeCertificateChain$default,
+  get_order2qb9qo6aibruu as get_order,
+  get_enabled1p6jc410a0fyv as get_enabled,
+  listKeys19wgim0aszum0 as listKeys,
+  listKeysFiltered2tyqsqt30ik0b as listKeysFiltered,
+  KeyStore3o40bf3gbe8w9 as KeyStore,
+  X509VerifyPlatformCallback3rbl32vhepoz7 as X509VerifyPlatformCallback,
+  X509VerifyService1ji3rocew3bty as X509VerifyService,
+  HasPlatformCallback1ytgk8bbzqatz as HasPlatformCallback,
+} from './idk-lib-crypto-core-public.mjs';
+import {
+  Companion_instance27w1uk4n2zibh as Companion_instance_1,
+  asErrorResult2t61x2oy4870d as asErrorResult,
+  NotFoundException1nc2pz9vpeyq7 as NotFoundException,
+} from './idk-lib-core-api-public.mjs';
+import {
+  _Result___get_error__impl__ihqhun2yewd2st3zd9i as _Result___get_error__impl__ihqhun,
+  _Result___get_value__impl__bjfvqg3pdjhj1ntjbaj as _Result___get_value__impl__bjfvqg,
+  _Result___get_isOk__impl__qbhaup1tqxnca0qn7sa as _Result___get_isOk__impl__qbhaup,
+} from '../kotlin-result-kotlin-result.mjs';
+import { Companion_getInstance1cart96rrvhbk as Companion_getInstance_1 } from '../metro-runtime-js.mjs';
+import { awaitd1m8y0em728c as await_1 } from '../kotlinx-coroutines-core.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+class DefaultCallbacks {
+  constructor() {
+    this.e5l_1 = null;
+    this.f5l_1 = null;
+  }
+  x509() {
+    var callback = this.e5l_1;
+    $l$block: {
+      // Inline function 'kotlin.checkNotNull' call
+      if (callback == null) {
+        var message = 'No default X509 Platform Callback implementation was registered';
+        throw IllegalStateException.o(toString(message));
+      } else {
+        break $l$block;
+      }
+    }
+    return callback;
+  }
+  g5l(x509Callback) {
+    this.e5l_1 = x509Callback;
+  }
+  setX509Default(x509Callback, $super) {
+    x509Callback = x509Callback === VOID ? null : x509Callback;
+    var tmp;
+    if ($super === VOID) {
+      this.g5l(x509Callback);
+      tmp = Unit_instance;
+    } else {
+      tmp = $super.g5l.call(this, x509Callback);
+    }
+    return tmp;
+  }
+  hasX509Default() {
+    return !(this.e5l_1 == null);
+  }
+  coseCrypto() {
+    var callback = this.f5l_1;
+    $l$block: {
+      // Inline function 'kotlin.checkNotNull' call
+      if (callback == null) {
+        var message = 'No default Cose Crypto Platform Callback implementation was registered';
+        throw IllegalStateException.o(toString(message));
+      } else {
+        break $l$block;
+      }
+    }
+    return callback;
+  }
+  hasCoseCryptoDefault() {
+    return !(this.f5l_1 == null);
+  }
+  h5l(coseCryptoCallback) {
+    this.f5l_1 = coseCryptoCallback;
+  }
+  setCoseCryptoDefault(coseCryptoCallback, $super) {
+    coseCryptoCallback = coseCryptoCallback === VOID ? null : coseCryptoCallback;
+    var tmp;
+    if ($super === VOID) {
+      this.h5l(coseCryptoCallback);
+      tmp = Unit_instance;
+    } else {
+      tmp = $super.h5l.call(this, coseCryptoCallback);
+    }
+    return tmp;
+  }
+}
+class Companion {
+  create(providerRegistry, resolverRegistry, keyStoreService, execution, queryProviderCommand, queryProvidersCommand, getAllCapabilitiesCommand, createRawSignatureCommand, verifyRawSignatureCommand, encryptCommand, decryptCommand, wrapKeyCommand, unwrapKeyCommand, performKeyAgreementCommand, generateKeyCommand, listKeysCommand, getKeyCommand, storeKeyCommand, deleteKeyCommand, resolvePublicKeyCommand) {
+    return new MetroFactory(providerRegistry, resolverRegistry, keyStoreService, execution, queryProviderCommand, queryProvidersCommand, getAllCapabilitiesCommand, createRawSignatureCommand, verifyRawSignatureCommand, encryptCommand, decryptCommand, wrapKeyCommand, unwrapKeyCommand, performKeyAgreementCommand, generateKeyCommand, listKeysCommand, getKeyCommand, storeKeyCommand, deleteKeyCommand, resolvePublicKeyCommand);
+  }
+  newInstance(providerRegistry, resolverRegistry, keyStoreService, execution, queryProviderCommand, queryProvidersCommand, getAllCapabilitiesCommand, createRawSignatureCommand, verifyRawSignatureCommand, encryptCommand, decryptCommand, wrapKeyCommand, unwrapKeyCommand, performKeyAgreementCommand, generateKeyCommand, listKeysCommand, getKeyCommand, storeKeyCommand, deleteKeyCommand, resolvePublicKeyCommand) {
+    return new KeyManagerServiceImpl(providerRegistry, resolverRegistry, keyStoreService, execution, queryProviderCommand, queryProvidersCommand, getAllCapabilitiesCommand, createRawSignatureCommand, verifyRawSignatureCommand, encryptCommand, decryptCommand, wrapKeyCommand, unwrapKeyCommand, performKeyAgreementCommand, generateKeyCommand, listKeysCommand, getKeyCommand, storeKeyCommand, deleteKeyCommand, resolvePublicKeyCommand);
+  }
+}
+class BindsMirror {}
+class MetroFactory {
+  constructor(providerRegistry, resolverRegistry, keyStoreService, execution, queryProviderCommand, queryProvidersCommand, getAllCapabilitiesCommand, createRawSignatureCommand, verifyRawSignatureCommand, encryptCommand, decryptCommand, wrapKeyCommand, unwrapKeyCommand, performKeyAgreementCommand, generateKeyCommand, listKeysCommand, getKeyCommand, storeKeyCommand, deleteKeyCommand, resolvePublicKeyCommand) {
+    this.i5l_1 = providerRegistry;
+    this.j5l_1 = resolverRegistry;
+    this.k5l_1 = keyStoreService;
+    this.l5l_1 = execution;
+    this.m5l_1 = queryProviderCommand;
+    this.n5l_1 = queryProvidersCommand;
+    this.o5l_1 = getAllCapabilitiesCommand;
+    this.p5l_1 = createRawSignatureCommand;
+    this.q5l_1 = verifyRawSignatureCommand;
+    this.r5l_1 = encryptCommand;
+    this.s5l_1 = decryptCommand;
+    this.t5l_1 = wrapKeyCommand;
+    this.u5l_1 = unwrapKeyCommand;
+    this.v5l_1 = performKeyAgreementCommand;
+    this.w5l_1 = generateKeyCommand;
+    this.x5l_1 = listKeysCommand;
+    this.y5l_1 = getKeyCommand;
+    this.z5l_1 = storeKeyCommand;
+    this.a5m_1 = deleteKeyCommand;
+    this.b5m_1 = resolvePublicKeyCommand;
+  }
+  s1i() {
+    return Companion_instance_2.newInstance(this.i5l_1.s1i(), this.j5l_1.s1i(), this.k5l_1.s1i(), this.l5l_1.s1i(), this.m5l_1.s1i(), this.n5l_1.s1i(), this.o5l_1.s1i(), this.p5l_1.s1i(), this.q5l_1.s1i(), this.r5l_1.s1i(), this.s5l_1.s1i(), this.t5l_1.s1i(), this.u5l_1.s1i(), this.v5l_1.s1i(), this.w5l_1.s1i(), this.x5l_1.s1i(), this.y5l_1.s1i(), this.z5l_1.s1i(), this.a5m_1.s1i(), this.b5m_1.s1i());
+  }
+  mirrorFunction(providerRegistry, resolverRegistry, keyStoreService, execution, queryProviderCommand, queryProvidersCommand, getAllCapabilitiesCommand, createRawSignatureCommand, verifyRawSignatureCommand, encryptCommand, decryptCommand, wrapKeyCommand, unwrapKeyCommand, performKeyAgreementCommand, generateKeyCommand, listKeysCommand, getKeyCommand, storeKeyCommand, deleteKeyCommand, resolvePublicKeyCommand) {
+    // Inline function 'kotlin.error' call
+    var message = 'Never called';
+    throw IllegalStateException.o(toString(message));
+  }
+}
+class MetroContributionToSessionScope {}
+function bindsAsKeyManagerService(instance) {
+  // Inline function 'kotlin.error' call
+  var message = 'Never called';
+  throw IllegalStateException.o(toString(message));
+}
+function bindsAsSimpleSignatureService(instance) {
+  // Inline function 'kotlin.error' call
+  var message = 'Never called';
+  throw IllegalStateException.o(toString(message));
+}
+class KeyManagerServiceImpl {
+  constructor(providerRegistry, resolverRegistry, keyStoreService, execution, queryProviderCommand, queryProvidersCommand, getAllCapabilitiesCommand, createRawSignatureCommand, verifyRawSignatureCommand, encryptCommand, decryptCommand, wrapKeyCommand, unwrapKeyCommand, performKeyAgreementCommand, generateKeyCommand, listKeysCommand, getKeyCommand, storeKeyCommand, deleteKeyCommand, resolvePublicKeyCommand) {
+    this.c5m_1 = providerRegistry;
+    this.d5m_1 = resolverRegistry;
+    this.e5m_1 = keyStoreService;
+    this.f5m_1 = execution;
+    this.g5m_1 = queryProviderCommand;
+    this.h5m_1 = queryProvidersCommand;
+    this.i5m_1 = getAllCapabilitiesCommand;
+    this.j5m_1 = createRawSignatureCommand;
+    this.k5m_1 = verifyRawSignatureCommand;
+    this.l5m_1 = encryptCommand;
+    this.m5m_1 = decryptCommand;
+    this.n5m_1 = wrapKeyCommand;
+    this.o5m_1 = unwrapKeyCommand;
+    this.p5m_1 = performKeyAgreementCommand;
+    this.q5m_1 = generateKeyCommand;
+    this.r5m_1 = listKeysCommand;
+    this.s5m_1 = getKeyCommand;
+    this.t5m_1 = storeKeyCommand;
+    this.u5m_1 = deleteKeyCommand;
+    this.v5m_1 = resolvePublicKeyCommand;
+  }
+  w5m() {
+    return this.e5m_1;
+  }
+  defaultProviderId() {
+    return this.c5m_1.defaultProviderId();
+  }
+  getProviderIds() {
+    return this.c5m_1.getProviderIds();
+  }
+  s4x(id) {
+    return this.c5m_1.getProviderById(id);
+  }
+  t4x(providerId, alg) {
+    return this.c5m_1.getProvider(providerId, alg);
+  }
+  getKmsBySignatureAlgorithm(signatureAlgorithm) {
+    return this.c5m_1.getKmsBySignatureAlgorithm(signatureAlgorithm);
+  }
+  u4x(provider, makeDefaultKms) {
+    return this.c5m_1.registerProvider(provider, makeDefaultKms);
+  }
+  defaultResolverId() {
+    return this.d5m_1.defaultResolverId();
+  }
+  getResolverIds() {
+    return this.d5m_1.getResolverIds();
+  }
+  d4t(id) {
+    return this.d5m_1.getResolverById(id);
+  }
+  e4t(identifierMethod, keyType, resolverId) {
+    return this.d5m_1.getResolverByKeyTypeOrIdentifier(identifierMethod, keyType, resolverId);
+  }
+  f4t(resolver, makeDefaultResolver) {
+    return this.d5m_1.registerResolver(resolver, makeDefaultResolver);
+  }
+  *x5m(query, $completion) {
+    var tmp0_elvis_lhs = this.g5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'QueryProviderCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new QueryProviderArgs(query);
+    return yield* command.f2s(args, $completion);
+  }
+  *y5m(query, $completion) {
+    var tmp0_elvis_lhs = this.h5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'QueryProvidersCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new QueryProvidersArgs(query);
+    return yield* command.f2s(args, $completion);
+  }
+  *f4s(includeDisabled, $completion) {
+    var tmp0_elvis_lhs = this.i5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'GetAllCapabilitiesCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new GetAllCapabilitiesArgs(includeDisabled);
+    return yield* command.f2s(args, $completion);
+  }
+  *g4t(keyInfo, identifierMethod, trustedCerts, verifyX509CertificateChain, $completion) {
+    var command = this.v5m_1;
+    var exec = this.f5m_1;
+    if (!(command == null) && !(exec == null)) {
+      var args = new ResolvePublicKeyArgs(keyInfo, identifierMethod, trustedCerts, verifyX509CertificateChain);
+      var result = yield* command.f2s(args, $completion);
+      // Inline function 'com.sphereon.core.api.IdkResult.getOrElse' call
+      // Inline function 'com.github.michaelbull.result.getOrElse' call
+      var this_0 = result.o2n_1;
+      var tmp;
+      if (_Result___get_isOk__impl__qbhaup(this_0)) {
+        tmp = _Result___get_value__impl__bjfvqg(this_0);
+      } else {
+        var tmp0_elvis_lhs = _Result___get_error__impl__ihqhun(this_0).message.defaultMessage;
+        throw PKIException.s44(tmp0_elvis_lhs == null ? 'Resolve public key failed' : tmp0_elvis_lhs);
+      }
+      var tmp0_elvis_lhs_0 = tmp.resolvedKeyInfo;
+      var tmp_0;
+      if (tmp0_elvis_lhs_0 == null) {
+        throw PKIException.s44('Resolved key info is null');
+      } else {
+        tmp_0 = tmp0_elvis_lhs_0;
+      }
+      var resolvedKeyInfo = tmp_0;
+      return isInterface(resolvedKeyInfo, ResolvedKeyInfoType) ? resolvedKeyInfo : THROW_CCE();
+    }
+    return yield* this.getResolverByKeyTypeOrIdentifier(identifierMethod, keyInfo.keyType, keyInfo.i43()).g4t(keyInfo, identifierMethod, trustedCerts, verifyX509CertificateChain, $completion);
+  }
+  *j4s(providerId, alias, use, keyOperations, alg, keyVisibility, $completion) {
+    var command = this.q5m_1;
+    var exec = this.f5m_1;
+    if (!(command == null) && !(exec == null)) {
+      var args = new GenerateKeyArgs(providerId, alias, use, keyOperations, alg, keyVisibility);
+      var result = yield* command.f2s(args, $completion);
+      // Inline function 'com.sphereon.core.api.IdkResult.getOrElse' call
+      // Inline function 'com.github.michaelbull.result.getOrElse' call
+      var this_0 = result.o2n_1;
+      var tmp;
+      if (_Result___get_isOk__impl__qbhaup(this_0)) {
+        tmp = _Result___get_value__impl__bjfvqg(this_0);
+      } else {
+        var tmp0_elvis_lhs = _Result___get_error__impl__ihqhun(this_0).message.defaultMessage;
+        throw PKIException.s44(tmp0_elvis_lhs == null ? 'Key generation failed' : tmp0_elvis_lhs);
+      }
+      var tmp0_elvis_lhs_0 = tmp.keyPair;
+      var tmp_0;
+      if (tmp0_elvis_lhs_0 == null) {
+        throw PKIException.s44('Generated key pair is null');
+      } else {
+        tmp_0 = tmp0_elvis_lhs_0;
+      }
+      return tmp_0;
+    }
+    var kmsProvider = this.getProvider(providerId, alg);
+    var keyPair = yield* generateKeyAsync$virtualSuspendBridge(kmsProvider, alias, use, keyOperations, alg, VOID, $completion);
+    return keyPair;
+  }
+  *h4s(providerId, alias, use, keyOperations, alg, keyVisibility, $completion) {
+    return yield* this.j4s(providerId, alias, use, keyOperations, alg, keyVisibility, $completion);
+  }
+  *a4z(keyInfo, input, requireX5Chain, $completion) {
+    var command = this.j5m_1;
+    var exec = this.f5m_1;
+    if (!(command == null) && !(exec == null)) {
+      var args = new CreateRawSignatureArgs(keyInfo, input, requireX5Chain);
+      var result = yield* command.f2s(args, $completion);
+      // Inline function 'com.sphereon.core.api.IdkResult.getOrElse' call
+      // Inline function 'com.github.michaelbull.result.getOrElse' call
+      var this_0 = result.o2n_1;
+      var tmp;
+      if (_Result___get_isOk__impl__qbhaup(this_0)) {
+        tmp = _Result___get_value__impl__bjfvqg(this_0);
+      } else {
+        var tmp0_elvis_lhs = _Result___get_error__impl__ihqhun(this_0).message.defaultMessage;
+        throw PKIException.s44(tmp0_elvis_lhs == null ? 'Signature creation failed' : tmp0_elvis_lhs);
+      }
+      return tmp.signature;
+    }
+    return yield* this.getProvider(keyInfo.i43(), keyInfo.signatureAlgorithm).a4z(keyInfo, input, requireX5Chain, $completion);
+  }
+  *b4z(keyInfo, input, signature, $completion) {
+    var tmp;
+    var tmp_0;
+    if (keyInfo.key == null && keyInfo.g43() == null && keyInfo.j43() == null) {
+      // Inline function 'kotlin.collections.isNullOrEmpty' call
+      var this_0 = keyInfo.x5c;
+      var tmp_1;
+      if (this_0 == null) {
+        tmp_1 = true;
+      } else {
+        // Inline function 'kotlin.collections.isEmpty' call
+        tmp_1 = this_0.length === 0;
+      }
+      tmp_0 = !tmp_1;
+    } else {
+      tmp_0 = false;
+    }
+    if (tmp_0) {
+      tmp = yield* this.b4t(keyInfo, IdentifierMethod_x5c_getInstance(), VOID, VOID, $completion);
+    } else {
+      tmp = keyInfo;
+    }
+    var resolvedKeyInfo = tmp;
+    var command = this.k5m_1;
+    var exec = this.f5m_1;
+    if (!(command == null) && !(exec == null)) {
+      var args = new VerifyRawSignatureArgs(resolvedKeyInfo, input, signature);
+      var result = yield* command.f2s(args, $completion);
+      // Inline function 'com.sphereon.core.api.IdkResult.getOrElse' call
+      // Inline function 'com.github.michaelbull.result.getOrElse' call
+      var this_1 = result.o2n_1;
+      var tmp_2;
+      if (_Result___get_isOk__impl__qbhaup(this_1)) {
+        tmp_2 = _Result___get_value__impl__bjfvqg(this_1);
+      } else {
+        var tmp0_elvis_lhs = _Result___get_error__impl__ihqhun(this_1).message.defaultMessage;
+        throw PKIException.s44(tmp0_elvis_lhs == null ? 'Signature verification failed' : tmp0_elvis_lhs);
+      }
+      return tmp_2.isValid;
+    }
+    var kms = resolvedKeyInfo.i43();
+    var alg = resolvedKeyInfo.signatureAlgorithm;
+    if (!(kms === null) || !(alg === null)) {
+      return yield* this.getProvider(kms, alg).b4z(resolvedKeyInfo, input, signature, $completion);
+    }
+    return yield* this.getProviderById(this.defaultProviderId()).b4z(resolvedKeyInfo, input, signature, $completion);
+  }
+  *l4r(keyInfo, plaintext, algorithm, additionalAuthenticatedData, $completion) {
+    var command = this.l5m_1;
+    var exec = this.f5m_1;
+    if (!(command == null) && !(exec == null)) {
+      var args = new EncryptArgs(keyInfo, plaintext, algorithm, additionalAuthenticatedData);
+      var result = yield* command.f2s(args, $completion);
+      // Inline function 'com.sphereon.core.api.IdkResult.getOrElse' call
+      // Inline function 'com.github.michaelbull.result.getOrElse' call
+      var this_0 = result.o2n_1;
+      var tmp;
+      if (_Result___get_isOk__impl__qbhaup(this_0)) {
+        tmp = _Result___get_value__impl__bjfvqg(this_0);
+      } else {
+        var tmp0_elvis_lhs = _Result___get_error__impl__ihqhun(this_0).message.defaultMessage;
+        throw PKIException.s44(tmp0_elvis_lhs == null ? 'Encryption failed' : tmp0_elvis_lhs);
+      }
+      var encResult = tmp;
+      return new EncryptionResult(encResult.ciphertext, encResult.iv, encResult.authTag);
+    }
+    return yield* encrypt$virtualSuspendBridge(this.getProvider(keyInfo.i43(), keyInfo.signatureAlgorithm), keyInfo, plaintext, algorithm, additionalAuthenticatedData, $completion);
+  }
+  encrypt(keyInfo, plaintext, algorithm, additionalAuthenticatedData) {
+    return promisify(($completion) => this.m4r(keyInfo, plaintext, algorithm, additionalAuthenticatedData, $completion));
+  }
+  *h4r(keyInfo, plaintext, algorithm, additionalAuthenticatedData, $completion) {
+    return this.encrypt === protoOf(KeyManagerServiceImpl).encrypt ? (yield* this.m4r(keyInfo, plaintext, algorithm, additionalAuthenticatedData, $completion)) : (yield* await_0(this.encrypt(keyInfo, plaintext, algorithm, additionalAuthenticatedData), $completion));
+  }
+  *n4r(keyInfo, ciphertext, algorithm, iv, authTag, additionalAuthenticatedData, $completion) {
+    var command = this.m5m_1;
+    var exec = this.f5m_1;
+    if (!(command == null) && !(exec == null)) {
+      var args = new DecryptArgs(keyInfo, ciphertext, algorithm, iv, authTag, additionalAuthenticatedData);
+      var result = yield* command.f2s(args, $completion);
+      // Inline function 'com.sphereon.core.api.IdkResult.getOrElse' call
+      // Inline function 'com.github.michaelbull.result.getOrElse' call
+      var this_0 = result.o2n_1;
+      var tmp;
+      if (_Result___get_isOk__impl__qbhaup(this_0)) {
+        tmp = _Result___get_value__impl__bjfvqg(this_0);
+      } else {
+        var tmp0_elvis_lhs = _Result___get_error__impl__ihqhun(this_0).message.defaultMessage;
+        throw PKIException.s44(tmp0_elvis_lhs == null ? 'Decryption failed' : tmp0_elvis_lhs);
+      }
+      return tmp.plaintext;
+    }
+    return yield* decrypt$virtualSuspendBridge(this.getProvider(keyInfo.i43(), keyInfo.signatureAlgorithm), keyInfo, ciphertext, algorithm, iv, authTag, additionalAuthenticatedData, $completion);
+  }
+  decrypt(keyInfo, ciphertext, algorithm, iv, authTag, additionalAuthenticatedData) {
+    return promisify(($completion) => this.o4r(keyInfo, ciphertext, algorithm, iv, authTag, additionalAuthenticatedData, $completion));
+  }
+  *i4r(keyInfo, ciphertext, algorithm, iv, authTag, additionalAuthenticatedData, $completion) {
+    return this.decrypt === protoOf(KeyManagerServiceImpl).decrypt ? (yield* this.o4r(keyInfo, ciphertext, algorithm, iv, authTag, additionalAuthenticatedData, $completion)) : (yield* await_0(this.decrypt(keyInfo, ciphertext, algorithm, iv, authTag, additionalAuthenticatedData), $completion));
+  }
+  *p4r(wrappingKeyInfo, keyToWrap, algorithm, $completion) {
+    var command = this.n5m_1;
+    var exec = this.f5m_1;
+    if (!(command == null) && !(exec == null)) {
+      var args = new WrapKeyArgs(wrappingKeyInfo, keyToWrap, algorithm);
+      var result = yield* command.f2s(args, $completion);
+      // Inline function 'com.sphereon.core.api.IdkResult.getOrElse' call
+      // Inline function 'com.github.michaelbull.result.getOrElse' call
+      var this_0 = result.o2n_1;
+      var tmp;
+      if (_Result___get_isOk__impl__qbhaup(this_0)) {
+        tmp = _Result___get_value__impl__bjfvqg(this_0);
+      } else {
+        var tmp0_elvis_lhs = _Result___get_error__impl__ihqhun(this_0).message.defaultMessage;
+        throw PKIException.s44(tmp0_elvis_lhs == null ? 'Key wrap failed' : tmp0_elvis_lhs);
+      }
+      return tmp.wrappedKey;
+    }
+    return yield* wrapKey$virtualSuspendBridge(this.getProvider(wrappingKeyInfo.i43(), wrappingKeyInfo.signatureAlgorithm), wrappingKeyInfo, keyToWrap, algorithm, $completion);
+  }
+  wrapKey(wrappingKeyInfo, keyToWrap, algorithm) {
+    return promisify(($completion) => this.p4r(wrappingKeyInfo, keyToWrap, algorithm, $completion));
+  }
+  *j4r(wrappingKeyInfo, keyToWrap, algorithm, $completion) {
+    return this.wrapKey === protoOf(KeyManagerServiceImpl).wrapKey ? (yield* this.p4r(wrappingKeyInfo, keyToWrap, algorithm, $completion)) : (yield* await_0(this.wrapKey(wrappingKeyInfo, keyToWrap, algorithm), $completion));
+  }
+  *q4r(unwrappingKeyInfo, wrappedKey, algorithm, $completion) {
+    var command = this.o5m_1;
+    var exec = this.f5m_1;
+    if (!(command == null) && !(exec == null)) {
+      var args = new UnwrapKeyArgs(unwrappingKeyInfo, wrappedKey, algorithm);
+      var result = yield* command.f2s(args, $completion);
+      // Inline function 'com.sphereon.core.api.IdkResult.getOrElse' call
+      // Inline function 'com.github.michaelbull.result.getOrElse' call
+      var this_0 = result.o2n_1;
+      var tmp;
+      if (_Result___get_isOk__impl__qbhaup(this_0)) {
+        tmp = _Result___get_value__impl__bjfvqg(this_0);
+      } else {
+        var tmp0_elvis_lhs = _Result___get_error__impl__ihqhun(this_0).message.defaultMessage;
+        throw PKIException.s44(tmp0_elvis_lhs == null ? 'Key unwrap failed' : tmp0_elvis_lhs);
+      }
+      return tmp.unwrappedKey;
+    }
+    return yield* unwrapKey$virtualSuspendBridge(this.getProvider(unwrappingKeyInfo.i43(), unwrappingKeyInfo.signatureAlgorithm), unwrappingKeyInfo, wrappedKey, algorithm, $completion);
+  }
+  unwrapKey(unwrappingKeyInfo, wrappedKey, algorithm) {
+    return promisify(($completion) => this.q4r(unwrappingKeyInfo, wrappedKey, algorithm, $completion));
+  }
+  *k4r(unwrappingKeyInfo, wrappedKey, algorithm, $completion) {
+    return this.unwrapKey === protoOf(KeyManagerServiceImpl).unwrapKey ? (yield* this.q4r(unwrappingKeyInfo, wrappedKey, algorithm, $completion)) : (yield* await_0(this.unwrapKey(unwrappingKeyInfo, wrappedKey, algorithm), $completion));
+  }
+  *r4r(privateKeyInfo, publicKeyInfo, algorithm, keyDataLen, $completion) {
+    var command = this.p5m_1;
+    var exec = this.f5m_1;
+    if (!(command == null) && !(exec == null)) {
+      var args = new PerformKeyAgreementArgs(privateKeyInfo, publicKeyInfo, algorithm, keyDataLen);
+      var result = yield* command.f2s(args, $completion);
+      // Inline function 'com.sphereon.core.api.IdkResult.getOrElse' call
+      // Inline function 'com.github.michaelbull.result.getOrElse' call
+      var this_0 = result.o2n_1;
+      var tmp;
+      if (_Result___get_isOk__impl__qbhaup(this_0)) {
+        tmp = _Result___get_value__impl__bjfvqg(this_0);
+      } else {
+        var tmp0_elvis_lhs = _Result___get_error__impl__ihqhun(this_0).message.defaultMessage;
+        throw PKIException.s44(tmp0_elvis_lhs == null ? 'Key agreement failed' : tmp0_elvis_lhs);
+      }
+      return tmp.sharedSecret;
+    }
+    return yield* /*#__NOINLINE__*/performKeyAgreementDirect(this, privateKeyInfo, publicKeyInfo, algorithm, keyDataLen, $completion);
+  }
+  performKeyAgreement(privateKeyInfo, publicKeyInfo, algorithm, keyDataLen) {
+    return promisify(($completion) => this.s4r(privateKeyInfo, publicKeyInfo, algorithm, keyDataLen, $completion));
+  }
+  *t4r(privateKeyInfo, publicKeyInfo, algorithm, keyDataLen, $completion) {
+    return this.performKeyAgreement === protoOf(KeyManagerServiceImpl).performKeyAgreement ? (yield* this.s4r(privateKeyInfo, publicKeyInfo, algorithm, keyDataLen, $completion)) : (yield* await_0(this.performKeyAgreement(privateKeyInfo, publicKeyInfo, algorithm, keyDataLen), $completion));
+  }
+  *v4t(keyInfo, providerId, alias, certChain, $completion) {
+    var command = this.t5m_1;
+    var exec = this.f5m_1;
+    if (!(command == null) && !(exec == null)) {
+      var args = new StoreKeyArgs(keyInfo, providerId, alias, certChain);
+      var result = yield* command.f2s(args, $completion);
+      // Inline function 'com.sphereon.core.api.IdkResult.getOrElse' call
+      // Inline function 'com.github.michaelbull.result.getOrElse' call
+      var this_0 = result.o2n_1;
+      var tmp;
+      if (_Result___get_isOk__impl__qbhaup(this_0)) {
+        tmp = _Result___get_value__impl__bjfvqg(this_0);
+      } else {
+        var tmp0_elvis_lhs = _Result___get_error__impl__ihqhun(this_0).message.defaultMessage;
+        throw PKIException.s44(tmp0_elvis_lhs == null ? 'Store key failed' : tmp0_elvis_lhs);
+      }
+      var tmp0_elvis_lhs_0 = tmp.key;
+      var tmp_0;
+      if (tmp0_elvis_lhs_0 == null) {
+        throw PKIException.s44('Store key result is null');
+      } else {
+        tmp_0 = tmp0_elvis_lhs_0;
+      }
+      return tmp_0;
+    }
+    return yield* storeKey$virtualSuspendBridge(this.w5m(), keyInfo, providerId, alias, certChain, $completion);
+  }
+  storeKey(keyInfo, providerId, alias, certChain) {
+    return promisify(($completion) => this.c4t(keyInfo, providerId, alias, certChain, $completion));
+  }
+  *k4t(keyInfo, providerId, alias, certChain, $completion) {
+    return this.storeKey === protoOf(KeyManagerServiceImpl).storeKey ? (yield* this.c4t(keyInfo, providerId, alias, certChain, $completion)) : (yield* await_0(this.storeKey(keyInfo, providerId, alias, certChain), $completion));
+  }
+  m4t() {
+    return this.w5m().settings;
+  }
+  *n4t($completion) {
+    var command = this.r5m_1;
+    var exec = this.f5m_1;
+    if (!(command == null) && !(exec == null)) {
+      var args = new ListKeysArgs();
+      var result = yield* command.f2s(args, $completion);
+      // Inline function 'com.sphereon.core.api.IdkResult.getOrElse' call
+      // Inline function 'com.github.michaelbull.result.getOrElse' call
+      var this_0 = result.o2n_1;
+      var tmp;
+      if (_Result___get_isOk__impl__qbhaup(this_0)) {
+        tmp = _Result___get_value__impl__bjfvqg(this_0);
+      } else {
+        var tmp0_elvis_lhs = _Result___get_error__impl__ihqhun(this_0).message.defaultMessage;
+        throw PKIException.s44(tmp0_elvis_lhs == null ? 'List keys failed' : tmp0_elvis_lhs);
+      }
+      return tmp.keys;
+    }
+    return yield* listKeys$virtualSuspendBridge(this.w5m(), $completion);
+  }
+  listKeys() {
+    return promisify(($completion) => this.n4t($completion));
+  }
+  *h4t($completion) {
+    return this.listKeys === protoOf(KeyManagerServiceImpl).listKeys ? (yield* this.n4t($completion)) : (yield* await_0(this.listKeys(), $completion));
+  }
+  *o4t(filter, $completion) {
+    return yield* listKeys$virtualSuspendBridge_0(this.w5m(), filter, $completion);
+  }
+  listKeysFiltered(filter) {
+    return promisify(($completion) => this.o4t(filter, $completion));
+  }
+  *i4t(filter, $completion) {
+    return this.listKeysFiltered === protoOf(KeyManagerServiceImpl).listKeysFiltered ? (yield* this.o4t(filter, $completion)) : (yield* await_0(this.listKeysFiltered(filter), $completion));
+  }
+  *u4t(keyInfo, $completion) {
+    var command = this.s5m_1;
+    var exec = this.f5m_1;
+    if (!(command == null) && !(exec == null)) {
+      var args = new GetKeyArgs(keyInfo);
+      var result = yield* command.f2s(args, $completion);
+      // Inline function 'com.sphereon.core.api.IdkResult.getOrElse' call
+      // Inline function 'com.github.michaelbull.result.getOrElse' call
+      var this_0 = result.o2n_1;
+      var tmp;
+      if (_Result___get_isOk__impl__qbhaup(this_0)) {
+        tmp = _Result___get_value__impl__bjfvqg(this_0);
+      } else {
+        var tmp0_elvis_lhs = _Result___get_error__impl__ihqhun(this_0).message.defaultMessage;
+        throw PKIException.s44(tmp0_elvis_lhs == null ? 'Get key failed' : tmp0_elvis_lhs);
+      }
+      var tmp0_elvis_lhs_0 = tmp.key;
+      var tmp_0;
+      if (tmp0_elvis_lhs_0 == null) {
+        throw PKIException.s44('Get key result is null');
+      } else {
+        tmp_0 = tmp0_elvis_lhs_0;
+      }
+      return tmp_0;
+    }
+    return yield* getKey$virtualSuspendBridge(this.w5m(), keyInfo, $completion);
+  }
+  getKey(keyInfo) {
+    return promisify(($completion) => this.u4t(keyInfo, $completion));
+  }
+  *j4t(keyInfo, $completion) {
+    return this.getKey === protoOf(KeyManagerServiceImpl).getKey ? (yield* this.u4t(keyInfo, $completion)) : (yield* await_0(this.getKey(keyInfo), $completion));
+  }
+  *w4t(keyInfo, $completion) {
+    var command = this.u5m_1;
+    var exec = this.f5m_1;
+    if (!(command == null) && !(exec == null)) {
+      var args = new DeleteKeyArgs(keyInfo);
+      var result = yield* command.f2s(args, $completion);
+      // Inline function 'com.sphereon.core.api.IdkResult.getOrElse' call
+      // Inline function 'com.github.michaelbull.result.getOrElse' call
+      var this_0 = result.o2n_1;
+      var tmp;
+      if (_Result___get_isOk__impl__qbhaup(this_0)) {
+        tmp = _Result___get_value__impl__bjfvqg(this_0);
+      } else {
+        var tmp0_elvis_lhs = _Result___get_error__impl__ihqhun(this_0).message.defaultMessage;
+        throw PKIException.s44(tmp0_elvis_lhs == null ? 'Delete key failed' : tmp0_elvis_lhs);
+      }
+      return tmp.deleted;
+    }
+    return yield* deleteKey$virtualSuspendBridge(this.w5m(), keyInfo, $completion);
+  }
+  deleteKey(keyInfo) {
+    return promisify(($completion) => this.w4t(keyInfo, $completion));
+  }
+  *l4t(keyInfo, $completion) {
+    return this.deleteKey === protoOf(KeyManagerServiceImpl).deleteKey ? (yield* this.w4t(keyInfo, $completion)) : (yield* await_0(this.deleteKey(keyInfo), $completion));
+  }
+  keyVisibility() {
+    return this.w5m().keyVisibility();
+  }
+  *l4s(keyInfo, input, requireX5Chain, $completion) {
+    var tmp0_elvis_lhs = this.j5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'CreateRawSignatureCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new CreateRawSignatureArgs(keyInfo, input, requireX5Chain);
+    return yield* command.f2s(args, $completion);
+  }
+  *z5m(keyInfo, input, signature, $completion) {
+    var tmp0_elvis_lhs = this.k5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'VerifyRawSignatureCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new VerifyRawSignatureArgs(keyInfo, input, signature);
+    return yield* command.f2s(args, $completion);
+  }
+  *n4s(keyInfo, plaintext, algorithm, additionalAuthenticatedData, $completion) {
+    var tmp0_elvis_lhs = this.l5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'EncryptCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new EncryptArgs(keyInfo, plaintext, algorithm, additionalAuthenticatedData);
+    return yield* command.f2s(args, $completion);
+  }
+  *p4s(keyInfo, ciphertext, algorithm, iv, authTag, additionalAuthenticatedData, $completion) {
+    var tmp0_elvis_lhs = this.m5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'DecryptCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new DecryptArgs(keyInfo, ciphertext, algorithm, iv, authTag, additionalAuthenticatedData);
+    return yield* command.f2s(args, $completion);
+  }
+  *a5n(wrappingKeyInfo, keyToWrap, algorithm, $completion) {
+    var tmp0_elvis_lhs = this.n5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'WrapKeyCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new WrapKeyArgs(wrappingKeyInfo, keyToWrap, algorithm);
+    return yield* command.f2s(args, $completion);
+  }
+  *b5n(unwrappingKeyInfo, wrappedKey, algorithm, $completion) {
+    var tmp0_elvis_lhs = this.o5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'UnwrapKeyCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new UnwrapKeyArgs(unwrappingKeyInfo, wrappedKey, algorithm);
+    return yield* command.f2s(args, $completion);
+  }
+  *r4s(privateKeyInfo, publicKeyInfo, algorithm, keyDataLen, $completion) {
+    var tmp0_elvis_lhs = this.p5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'PerformKeyAgreementCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new PerformKeyAgreementArgs(privateKeyInfo, publicKeyInfo, algorithm, keyDataLen);
+    return yield* command.f2s(args, $completion);
+  }
+  *t4s(providerId, alias, use, keyOperations, alg, keyVisibility, $completion) {
+    var tmp0_elvis_lhs = this.q5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'GenerateKeyCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new GenerateKeyArgs(providerId, alias, use, keyOperations, alg, keyVisibility);
+    return yield* command.f2s(args, $completion);
+  }
+  *v4s(providerId, $completion) {
+    var tmp0_elvis_lhs = this.r5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'ListKeysCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new ListKeysArgs(providerId);
+    return yield* command.f2s(args, $completion);
+  }
+  *c5n(keyInfo, $completion) {
+    var tmp0_elvis_lhs = this.s5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'GetKeyCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new GetKeyArgs(keyInfo);
+    return yield* command.f2s(args, $completion);
+  }
+  *x4s(keyInfo, providerId, alias, certChain, $completion) {
+    var tmp0_elvis_lhs = this.t5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'StoreKeyCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new StoreKeyArgs(keyInfo, providerId, alias, certChain);
+    return yield* command.f2s(args, $completion);
+  }
+  *d5n(keyInfo, $completion) {
+    var tmp0_elvis_lhs = this.u5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'DeleteKeyCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new DeleteKeyArgs(keyInfo);
+    return yield* command.f2s(args, $completion);
+  }
+  *z4s(keyInfo, identifierMethod, trustedCerts, verifyX509CertificateChain, $completion) {
+    var tmp0_elvis_lhs = this.v5m_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.v2o(VOID, VOID, 'ResolvePublicKeyCommand', 'Command not available'));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var command = tmp;
+    var tmp1_elvis_lhs = this.f5m_1;
+    var tmp_0;
+    if (tmp1_elvis_lhs == null) {
+      return asErrorResult(Companion_instance_1.p2o(VOID, VOID, 'SessionExecution not available'));
+    } else {
+      tmp_0 = tmp1_elvis_lhs;
+    }
+    var exec = tmp_0;
+    var args = new ResolvePublicKeyArgs(keyInfo, identifierMethod, trustedCerts, verifyX509CertificateChain);
+    return yield* command.f2s(args, $completion);
+  }
+  get settings() {
+    return this.m4t();
+  }
+}
+class Companion_0 {
+  create(keyResolvers) {
+    return new MetroFactory_0(keyResolvers);
+  }
+  newInstance(keyResolvers) {
+    return new KeyResolverRegistryImpl(keyResolvers);
+  }
+}
+class BindsMirror_0 {}
+class MetroFactory_0 {
+  constructor(keyResolvers) {
+    this.e5n_1 = keyResolvers;
+  }
+  s1i() {
+    return Companion_instance_3.newInstance(this.e5n_1.s1i());
+  }
+  mirrorFunction(keyResolvers) {
+    // Inline function 'kotlin.error' call
+    var message = 'Never called';
+    throw IllegalStateException.o(toString(message));
+  }
+}
+class MetroContributionToSessionScope_0 {}
+function bindsAsKeyResolverRegistry(instance) {
+  // Inline function 'kotlin.error' call
+  var message = 'Never called';
+  throw IllegalStateException.o(toString(message));
+}
+class sam$kotlin_Comparator$0 {
+  constructor(function_0) {
+    this.f5n_1 = function_0;
+  }
+  ji(a, b) {
+    return this.f5n_1(a, b);
+  }
+  compare(a, b) {
+    return this.ji(a, b);
+  }
+  g5() {
+    return this.f5n_1;
+  }
+  equals(other) {
+    var tmp;
+    if (!(other == null) ? isInterface(other, Comparator) : false) {
+      var tmp_0;
+      if (!(other == null) ? isInterface(other, FunctionAdapter) : false) {
+        tmp_0 = equals(this.g5(), other.g5());
+      } else {
+        tmp_0 = false;
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  }
+  hashCode() {
+    return hashCode(this.g5());
+  }
+}
+class KeyResolverRegistryImpl {
+  constructor(keyResolvers) {
+    var tmp = this;
+    // Inline function 'kotlin.collections.sortedBy' call
+    // Inline function 'kotlin.comparisons.compareBy' call
+    var tmp_0 = KeyResolverRegistryImpl$keyResolversById$lambda;
+    var tmp$ret$1 = new sam$kotlin_Comparator$0(tmp_0);
+    // Inline function 'kotlin.collections.associateBy' call
+    var this_0 = sortedWith(keyResolvers, tmp$ret$1);
+    var capacity = coerceAtLeast(mapCapacity(collectionSizeOrDefault(this_0, 10)), 16);
+    // Inline function 'kotlin.collections.associateByTo' call
+    var destination = LinkedHashMap.hc(capacity);
+    var _iterator__ex2g4s = this_0.j1();
+    while (_iterator__ex2g4s.k1()) {
+      var element = _iterator__ex2g4s.l1();
+      var tmp$ret$4 = element.getId();
+      destination.p4(tmp$ret$4, element);
+    }
+    tmp.g5n_1 = toMutableMap(destination);
+    this.h5n_1 = null;
+  }
+  defaultResolverId() {
+    // Inline function 'kotlin.collections.isNotEmpty' call
+    // Inline function 'kotlin.require' call
+    if (!!this.g5n_1.h1()) {
+      var message = 'At least one key resolver is required';
+      throw IllegalArgumentException.y1(toString(message));
+    }
+    var tmp0_elvis_lhs = this.h5n_1;
+    return tmp0_elvis_lhs == null ? first(this.g5n_1.n4()).getId() : tmp0_elvis_lhs;
+  }
+  getResolverIds() {
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var this_0 = this.g5n_1.m4();
+    return copyToArray(this_0);
+  }
+  d4t(id) {
+    var tmp0_elvis_lhs = this.g5n_1.l4(id);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      throw PKIException.s44('Invalid Resolver id ' + id + '. Valid ids are: ' + joinToString(this.getResolverIds(), ','));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    return tmp;
+  }
+  e4t(identifierMethod, keyType, resolverId) {
+    // Inline function 'kotlin.collections.isNotEmpty' call
+    // Inline function 'kotlin.require' call
+    if (!!this.g5n_1.h1()) {
+      var message = 'At least one resolver is required';
+      throw IllegalArgumentException.y1(toString(message));
+    }
+    var tmp0 = this.g5n_1.n4();
+    var tmp$ret$3;
+    $l$block_4: {
+      // Inline function 'kotlin.collections.firstOrNull' call
+      var _iterator__ex2g4s = tmp0.j1();
+      while (_iterator__ex2g4s.k1()) {
+        var element = _iterator__ex2g4s.l1();
+        var tmp$ret$4;
+        $l$block_3: {
+          if (!(resolverId == null) && element.getId() === resolverId) {
+            tmp$ret$4 = true;
+            break $l$block_3;
+          }
+          if (!(keyType == null)) {
+            if (!(identifierMethod == null)) {
+              tmp$ret$4 = contains(element.getSupportedKeyTypes(identifierMethod), keyType);
+              break $l$block_3;
+            } else if (contains(element.allSupportedKeyTypes(), keyType)) {
+              tmp$ret$4 = true;
+              break $l$block_3;
+            }
+          }
+          if (!(identifierMethod == null) && contains(element.allSupportedIdentifierMethods(), identifierMethod)) {
+            tmp$ret$4 = true;
+            break $l$block_3;
+          }
+          if (identifierMethod == null && keyType == null && resolverId == null) {
+            tmp$ret$4 = element.getId() === this.defaultResolverId();
+            break $l$block_3;
+          }
+          tmp$ret$4 = false;
+        }
+        if (tmp$ret$4) {
+          tmp$ret$3 = element;
+          break $l$block_4;
+        }
+      }
+      tmp$ret$3 = null;
+    }
+    var resolver = tmp$ret$3;
+    var tmp;
+    if (resolver == null) {
+      throw IllegalArgumentException.y1('Could not find resolver for identifier method ' + toString_0(identifierMethod) + ' and key type ' + toString_0(keyType));
+    } else {
+      tmp = resolver;
+    }
+    return tmp;
+  }
+  f4t(resolver, makeDefaultResolver) {
+    var tmp0 = this.g5n_1;
+    // Inline function 'kotlin.collections.set' call
+    var key = resolver.getId();
+    tmp0.p4(key, resolver);
+    if (makeDefaultResolver === true) {
+      this.h5n_1 = resolver.getId();
+    }
+  }
+}
+class Companion_1 {
+  create(contextConfig, kmsProviderManager, execution) {
+    return new MetroFactory_1(contextConfig, kmsProviderManager, execution);
+  }
+  newInstance(contextConfig, kmsProviderManager, execution) {
+    return new KmsProviderRegistryImpl(contextConfig, kmsProviderManager, execution);
+  }
+}
+class BindsMirror_1 {}
+class MetroFactory_1 {
+  constructor(contextConfig, kmsProviderManager, execution) {
+    this.n5n_1 = contextConfig;
+    this.o5n_1 = kmsProviderManager;
+    this.p5n_1 = execution;
+  }
+  s1i() {
+    return Companion_instance_4.newInstance(this.n5n_1.s1i(), this.o5n_1.s1i(), this.p5n_1.s1i());
+  }
+  mirrorFunction(contextConfig, kmsProviderManager, execution) {
+    // Inline function 'kotlin.error' call
+    var message = 'Never called';
+    throw IllegalStateException.o(toString(message));
+  }
+}
+class MetroContributionToSessionScope_1 {}
+function bindsAsKmsProviderRegistry(instance) {
+  // Inline function 'kotlin.error' call
+  var message = 'Never called';
+  throw IllegalStateException.o(toString(message));
+}
+class sam$kotlin_Comparator$0_0 {
+  constructor(function_0) {
+    this.q5n_1 = function_0;
+  }
+  ji(a, b) {
+    return this.q5n_1(a, b);
+  }
+  compare(a, b) {
+    return this.ji(a, b);
+  }
+  g5() {
+    return this.q5n_1;
+  }
+  equals(other) {
+    var tmp;
+    if (!(other == null) ? isInterface(other, Comparator) : false) {
+      var tmp_0;
+      if (!(other == null) ? isInterface(other, FunctionAdapter) : false) {
+        tmp_0 = equals(this.g5(), other.g5());
+      } else {
+        tmp_0 = false;
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  }
+  hashCode() {
+    return hashCode(this.g5());
+  }
+}
+class KmsProviderRegistryImpl {
+  constructor(contextConfig, kmsProviderManager, execution) {
+    this.i5n_1 = contextConfig;
+    this.j5n_1 = kmsProviderManager;
+    this.k5n_1 = execution;
+    var tmp = this;
+    tmp.l5n_1 = lazy(KmsProviderRegistryImpl$kmsProvidersById$delegate$lambda(this));
+    this.m5n_1 = null;
+  }
+  defaultProviderId() {
+    // Inline function 'kotlin.collections.isNotEmpty' call
+    // Inline function 'kotlin.require' call
+    if (!!_get_kmsProvidersById__3ih65k(this).h1()) {
+      var message = 'At least one KMS provider is required';
+      throw IllegalArgumentException.y1(toString(message));
+    }
+    var tmp0_elvis_lhs = this.m5n_1;
+    return tmp0_elvis_lhs == null ? first(_get_kmsProvidersById__3ih65k(this).n4()).id : tmp0_elvis_lhs;
+  }
+  getProviderIds() {
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var this_0 = _get_kmsProvidersById__3ih65k(this).m4();
+    return copyToArray(this_0);
+  }
+  s4x(id) {
+    var tmp0_elvis_lhs = _get_kmsProvidersById__3ih65k(this).l4(id);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      throw PKIException.s44('Invalid KMS id ' + id + ' provider. Valid ids are: ' + joinToString(this.getProviderIds(), ','));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    return tmp;
+  }
+  t4x(providerId, alg) {
+    if (providerId == null && !(alg == null)) {
+      return this.getKmsBySignatureAlgorithm(alg);
+    }
+    return this.getProviderById(providerId == null ? this.defaultProviderId() : providerId);
+  }
+  getKmsBySignatureAlgorithm(signatureAlgorithm) {
+    var tmp0 = _get_kmsProvidersById__3ih65k(this).n4();
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.collections.firstOrNull' call
+      var _iterator__ex2g4s = tmp0.j1();
+      while (_iterator__ex2g4s.k1()) {
+        var element = _iterator__ex2g4s.l1();
+        if (contains(element.supportedSignatureAlgorithms(), signatureAlgorithm)) {
+          tmp$ret$0 = element;
+          break $l$block;
+        }
+      }
+      tmp$ret$0 = null;
+    }
+    var tmp0_elvis_lhs = tmp$ret$0;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      throw PKIException.s44('No KMS found for signature algorithm ' + toString(signatureAlgorithm));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    return tmp;
+  }
+  u4x(provider, makeDefaultKms) {
+    var tmp0 = _get_kmsProvidersById__3ih65k(this);
+    // Inline function 'kotlin.collections.set' call
+    var key = provider.id;
+    tmp0.p4(key, provider);
+    if (makeDefaultKms === true) {
+      this.m5n_1 = provider.id;
+    }
+  }
+}
+class Companion_2 {
+  create(delegateFactory) {
+    return Companion_getInstance_1().q1i(new Impl(delegateFactory));
+  }
+}
+class MemoryKeyStoreServiceFactory {}
+class Impl {
+  constructor(delegateFactory) {
+    this.u5n_1 = delegateFactory;
+  }
+  create(config, backingStorage, partitionKey) {
+    return this.u5n_1.v5n(config, backingStorage, partitionKey);
+  }
+}
+class Companion_3 {
+  w5n(config, backingStorage, partitionKey) {
+    return new MemoryKeyStoreService(config, backingStorage, partitionKey);
+  }
+}
+class MemoryKeyStoreService {
+  constructor(config, backingStorage, partitionKey) {
+    backingStorage = backingStorage === VOID ? null : backingStorage;
+    partitionKey = partitionKey === VOID ? null : partitionKey;
+    this.x5n_1 = config;
+    this.y5n_1 = backingStorage;
+    this.z5n_1 = partitionKey;
+    this.a5o_1 = this.x5n_1.id;
+    this.b5o_1 = this.x5n_1.keyStoreType;
+    var tmp = this;
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var this_0 = Companion_instance.v2z();
+    tmp.c5o_1 = copyToArray(this_0);
+    var tmp_0 = this;
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var this_1 = Companion_instance_0.v2z();
+    tmp_0.d5o_1 = copyToArray(this_1);
+    var tmp_1 = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp_1.e5o_1 = LinkedHashMap.v5();
+    var tmp_2 = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp_2.f5o_1 = LinkedHashMap.v5();
+    var tmp_3 = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp_3.g5o_1 = LinkedHashMap.v5();
+    // Inline function 'kotlin.require' call
+    if (!(this.x5n_1.keyStoreType === PredefinedKeyStoreTypes_MEMORY_getInstance().c56_1)) {
+      var message = 'A memory keystore needs to be of config type MEMORY';
+      throw IllegalArgumentException.y1(toString(message));
+    }
+  }
+  n2c() {
+    return this.a5o_1;
+  }
+  i4u() {
+    return this.b5o_1;
+  }
+  o4u() {
+    return this.c5o_1;
+  }
+  p4u() {
+    return this.d5o_1;
+  }
+  m4t() {
+    return null;
+  }
+  exposesPrivateKeysForSigning() {
+    return true;
+  }
+  keyVisibility() {
+    return Companion_getInstance_0().v48(this.x5n_1.keyVisibility);
+  }
+  *n4t($completion) {
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = _get_keys__d97k5z(this);
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList.j2(this_0.m2());
+    // Inline function 'kotlin.collections.iterator' call
+    var _iterator__ex2g4s = this_0.x2().j1();
+    while (_iterator__ex2g4s.k1()) {
+      var item = _iterator__ex2g4s.l1();
+      var tmp$ret$3 = toKeyReference(item.h4());
+      destination.k2(tmp$ret$3);
+    }
+    // Inline function 'kotlin.collections.toTypedArray' call
+    return copyToArray(destination);
+  }
+  listKeys() {
+    return promisify(($completion) => this.n4t($completion));
+  }
+  *h4t($completion) {
+    return this.listKeys === protoOf(MemoryKeyStoreService).listKeys ? (yield* this.n4t($completion)) : (yield* await_0(this.listKeys(), $completion));
+  }
+  *u4t(keyInfo, $completion) {
+    var managedKeyInfo = keyInfo;
+    if (managedKeyInfo.j43() === null) {
+      // Inline function 'kotlin.collections.find' call
+      var tmp0 = _get_keys__d97k5z(this).n4();
+      var tmp$ret$1;
+      $l$block: {
+        // Inline function 'kotlin.collections.firstOrNull' call
+        var _iterator__ex2g4s = tmp0.j1();
+        while (_iterator__ex2g4s.k1()) {
+          var element = _iterator__ex2g4s.l1();
+          var tmp;
+          if (!(keyInfo.g43() === null) && element.g43() == keyInfo.g43()) {
+            tmp = true;
+          } else {
+            var tmp_0;
+            var tmp0_safe_receiver = keyInfo.key;
+            if ((tmp0_safe_receiver == null ? null : tmp0_safe_receiver.getXAsString()) == element.key.getXAsString()) {
+              var tmp1_safe_receiver = keyInfo.key;
+              tmp_0 = (tmp1_safe_receiver == null ? null : tmp1_safe_receiver.getYAsString()) == element.key.getYAsString();
+            } else {
+              tmp_0 = false;
+            }
+            tmp = tmp_0;
+          }
+          if (tmp) {
+            tmp$ret$1 = element;
+            break $l$block;
+          }
+        }
+        tmp$ret$1 = null;
+      }
+      var matchingKey = tmp$ret$1;
+      if (!(matchingKey == null)) {
+        managedKeyInfo = matchingKey;
+      }
+    }
+    // Inline function 'kotlin.require' call
+    if (!(!(managedKeyInfo.key === null) || !(managedKeyInfo.g43() === null) || !(managedKeyInfo.j43() === null))) {
+      var message = 'Either a kid needs to be provided or a key needs to be passed in';
+      throw IllegalArgumentException.y1(toString(message));
+    }
+    var tmp0_elvis_lhs = managedKeyInfo.keyVisibility;
+    var visibility = tmp0_elvis_lhs == null ? this.x5n_1.keyVisibility : tmp0_elvis_lhs;
+    if (this.x5n_1.keyVisibility === KeyVisibility_PUBLIC_getInstance().y48_1 && visibility === KeyVisibility_PRIVATE_getInstance()) {
+      throw PKIException.s44('Cannot get private key info for a public key store');
+    }
+    var tmp1_elvis_lhs = managedKeyInfo.g43();
+    var tmp_1;
+    if (tmp1_elvis_lhs == null) {
+      var tmp2_safe_receiver = managedKeyInfo.key;
+      tmp_1 = tmp2_safe_receiver == null ? null : tmp2_safe_receiver.kid;
+    } else {
+      tmp_1 = tmp1_elvis_lhs;
+    }
+    var kid = tmp_1;
+    var alias = managedKeyInfo.j43();
+    // Inline function 'kotlin.require' call
+    if (!!(alias === null)) {
+      var message_0 = 'Need to provide a alias';
+      throw IllegalArgumentException.y1(toString(message_0));
+    }
+    var keyInfoResult = _get_keys__d97k5z(this).l4(alias);
+    // Inline function 'kotlin.require' call
+    if (!!(keyInfoResult === null)) {
+      var message_1 = 'Could not find key for alias ' + alias + ', kid ' + toString_0(kid);
+      throw IllegalArgumentException.y1(toString(message_1));
+    }
+    var tmp_2;
+    if (visibility === KeyVisibility_PUBLIC_getInstance()) {
+      tmp_2 = new ManagedKeyInfo(alias, keyInfoResult.i43(), keyInfoResult.toResolvedPublicKeyInfo());
+    } else {
+      if (!(keyInfoResult.keyVisibility === KeyVisibility_PRIVATE_getInstance())) {
+        throw IllegalArgumentException.y1('Key with alias ' + alias + ' is not a private key, whilst a private key is requested');
+      }
+      tmp_2 = keyInfoResult;
+    }
+    return tmp_2;
+  }
+  getKey(keyInfo) {
+    return promisify(($completion) => this.u4t(keyInfo, $completion));
+  }
+  *j4t(keyInfo, $completion) {
+    return this.getKey === protoOf(MemoryKeyStoreService).getKey ? (yield* this.u4t(keyInfo, $completion)) : (yield* await_0(this.getKey(keyInfo), $completion));
+  }
+  *w4t(keyInfo, $completion) {
+    var tmp;
+    try {
+      var storedKeyInfo = yield* this.j4t(keyInfo, $completion);
+      tmp = !(_get_keys__d97k5z(this).q4(storedKeyInfo.j43()) == null);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof NotFoundException) {
+        var e = $p;
+        tmp_0 = false;
+      } else {
+        if ($p instanceof IllegalArgumentException) {
+          var e_0 = $p;
+          tmp_0 = false;
+        } else {
+          throw $p;
+        }
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  }
+  deleteKey(keyInfo) {
+    return promisify(($completion) => this.w4t(keyInfo, $completion));
+  }
+  *l4t(keyInfo, $completion) {
+    return this.deleteKey === protoOf(MemoryKeyStoreService).deleteKey ? (yield* this.w4t(keyInfo, $completion)) : (yield* await_0(this.deleteKey(keyInfo), $completion));
+  }
+  *v4t(keyInfo, providerId, alias, certChain, $completion) {
+    var tmp0_elvis_lhs = keyInfo.keyVisibility;
+    var visibility = tmp0_elvis_lhs == null ? this.x5n_1.keyVisibility : tmp0_elvis_lhs;
+    if (this.x5n_1.keyVisibility === KeyVisibility_PUBLIC_getInstance().y48_1 && visibility === KeyVisibility_PRIVATE_getInstance()) {
+      throw PKIException.s44('Cannot get private key info for a public key store');
+    }
+    var managedKeyInfo = new ManagedKeyInfo(alias, providerId, keyInfo);
+    if (!this.x5n_1.overwriteAlias) {
+      // Inline function 'kotlin.check' call
+      if (!!_get_keys__d97k5z(this).j4(alias)) {
+        var message = 'Cannot overwrite key alias ' + alias + ', as alias already exists in keystore and overwriting is not enabled';
+        throw IllegalStateException.o(toString(message));
+      }
+    }
+    // Inline function 'kotlin.collections.set' call
+    _get_keys__d97k5z(this).p4(alias, managedKeyInfo);
+    return managedKeyInfo;
+  }
+  storeKey(keyInfo, providerId, alias, certChain) {
+    return promisify(($completion) => this.c4t(keyInfo, providerId, alias, certChain, $completion));
+  }
+  *k4t(keyInfo, providerId, alias, certChain, $completion) {
+    return this.storeKey === protoOf(MemoryKeyStoreService).storeKey ? (yield* this.c4t(keyInfo, providerId, alias, certChain, $completion)) : (yield* await_0(this.storeKey(keyInfo, providerId, alias, certChain), $completion));
+  }
+  *n4q(alias, certificates, keyInfo, $completion) {
+    if (!this.x5n_1.overwriteAlias) {
+      // Inline function 'kotlin.check' call
+      if (!!_get_certificateChains__l5yeco(this).j4(alias)) {
+        var message = 'Cannot overwrite certificate chain alias ' + alias + ', as alias already exists in keystore and overwriting is not enabled';
+        throw IllegalStateException.o(toString(message));
+      }
+    }
+    if (certificates.length === 1) {
+      var tmp0 = _get_certificates__eymdpt(this);
+      // Inline function 'kotlin.collections.set' call
+      var value = certificates[0];
+      tmp0.p4(alias, value);
+    }
+    // Inline function 'kotlin.collections.set' call
+    _get_certificateChains__l5yeco(this).p4(alias, certificates);
+    return Unit_instance;
+  }
+  storeCertificateChain(alias, certificates, keyInfo) {
+    return promisify(($completion) => this.o4q(alias, certificates, keyInfo, $completion));
+  }
+  *p4q(alias, certificates, keyInfo, $completion) {
+    if (this.storeCertificateChain === protoOf(MemoryKeyStoreService).storeCertificateChain)
+      yield* this.o4q(alias, certificates, keyInfo, $completion);
+    else
+      yield* await_0(this.storeCertificateChain(alias, certificates, keyInfo), $completion);
+    return Unit_instance;
+  }
+  *q4q($completion) {
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var this_0 = _get_certificateChains__l5yeco(this).m4();
+    return copyToArray(this_0);
+  }
+  listCertificateChainAliases() {
+    return promisify(($completion) => this.q4q($completion));
+  }
+  *r4q($completion) {
+    return this.listCertificateChainAliases === protoOf(MemoryKeyStoreService).listCertificateChainAliases ? (yield* this.q4q($completion)) : (yield* await_0(this.listCertificateChainAliases(), $completion));
+  }
+  *s4q(alias, $completion) {
+    var tmp0_elvis_lhs = _get_certificateChains__l5yeco(this).l4(alias);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      var tmp1_safe_receiver = _get_certificates__eymdpt(this).l4(alias);
+      var tmp_0;
+      if (tmp1_safe_receiver == null) {
+        tmp_0 = null;
+      } else {
+        // Inline function 'kotlin.let' call
+        // Inline function 'kotlin.arrayOf' call
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        tmp_0 = [tmp1_safe_receiver];
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var tmp2_elvis_lhs = tmp;
+    var tmp_1;
+    if (tmp2_elvis_lhs == null) {
+      throw NotFoundException.c2q('Could not find certificate chain for alias ' + alias);
+    } else {
+      tmp_1 = tmp2_elvis_lhs;
+    }
+    return tmp_1;
+  }
+  getCertificateChain(alias) {
+    return promisify(($completion) => this.s4q(alias, $completion));
+  }
+  *t4q(alias, $completion) {
+    return this.getCertificateChain === protoOf(MemoryKeyStoreService).getCertificateChain ? (yield* this.s4q(alias, $completion)) : (yield* await_0(this.getCertificateChain(alias), $completion));
+  }
+  *u4q(alias, $completion) {
+    return !(_get_certificateChains__l5yeco(this).q4(alias) == null);
+  }
+  deleteCertificateChain(alias) {
+    return promisify(($completion) => this.u4q(alias, $completion));
+  }
+  *v4q(alias, $completion) {
+    return this.deleteCertificateChain === protoOf(MemoryKeyStoreService).deleteCertificateChain ? (yield* this.u4q(alias, $completion)) : (yield* await_0(this.deleteCertificateChain(alias), $completion));
+  }
+  *w4q(alias, certificate, $completion) {
+    if (!this.x5n_1.overwriteAlias) {
+      // Inline function 'kotlin.check' call
+      if (!!_get_certificates__eymdpt(this).j4(alias)) {
+        var message = 'Cannot overwrite certificate alias ' + alias + ', as alias already exists in keystore and overwriting is not enabled';
+        throw IllegalStateException.o(toString(message));
+      }
+    }
+    // Inline function 'kotlin.collections.set' call
+    _get_certificates__eymdpt(this).p4(alias, certificate);
+    return Unit_instance;
+  }
+  storeTrustedCertificate(alias, certificate) {
+    return promisify(($completion) => this.w4q(alias, certificate, $completion));
+  }
+  *x4q(alias, certificate, $completion) {
+    if (this.storeTrustedCertificate === protoOf(MemoryKeyStoreService).storeTrustedCertificate)
+      yield* this.w4q(alias, certificate, $completion);
+    else
+      yield* await_0(this.storeTrustedCertificate(alias, certificate), $completion);
+    return Unit_instance;
+  }
+  *y4q($completion) {
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var this_0 = _get_certificates__eymdpt(this).m4();
+    return copyToArray(this_0);
+  }
+  listCertificateAliases() {
+    return promisify(($completion) => this.y4q($completion));
+  }
+  *z4q($completion) {
+    return this.listCertificateAliases === protoOf(MemoryKeyStoreService).listCertificateAliases ? (yield* this.y4q($completion)) : (yield* await_0(this.listCertificateAliases(), $completion));
+  }
+  *a4r(alias, $completion) {
+    var tmp0_elvis_lhs = _get_certificates__eymdpt(this).l4(alias);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      var tmp1_safe_receiver = _get_certificateChains__l5yeco(this).l4(alias);
+      tmp = tmp1_safe_receiver == null ? null : tmp1_safe_receiver[0];
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var tmp2_elvis_lhs = tmp;
+    var tmp_0;
+    if (tmp2_elvis_lhs == null) {
+      throw NotFoundException.c2q('Could not find certificate for alias ' + alias);
+    } else {
+      tmp_0 = tmp2_elvis_lhs;
+    }
+    return tmp_0;
+  }
+  getCertificate(alias) {
+    return promisify(($completion) => this.a4r(alias, $completion));
+  }
+  *b4r(alias, $completion) {
+    return this.getCertificate === protoOf(MemoryKeyStoreService).getCertificate ? (yield* this.a4r(alias, $completion)) : (yield* await_0(this.getCertificate(alias), $completion));
+  }
+  *c4r(alias, $completion) {
+    return !(_get_certificates__eymdpt(this).q4(alias) == null);
+  }
+  deleteCertificate(alias) {
+    return promisify(($completion) => this.c4r(alias, $completion));
+  }
+  *d4r(alias, $completion) {
+    return this.deleteCertificate === protoOf(MemoryKeyStoreService).deleteCertificate ? (yield* this.c4r(alias, $completion)) : (yield* await_0(this.deleteCertificate(alias), $completion));
+  }
+  l5o(filter, $completion) {
+    return this.o4t(filter, $completion);
+  }
+  get id() {
+    return this.n2c();
+  }
+  get keyStoreType() {
+    return this.i4u();
+  }
+  get keyTypesSupported() {
+    return this.o4u();
+  }
+  get signatureAlgorithmsSupported() {
+    return this.p4u();
+  }
+  get settings() {
+    return this.m4t();
+  }
+  get order() {
+    return this.v2v();
+  }
+  get enabled() {
+    return this.j4u();
+  }
+}
+class IX509JSCallback {}
+class X509VerifyVerifyPlatformCallbackJSPromises {}
+function *verifyCertificateChain(req, $completion) {
+  var context = req.validateToContext();
+  if (context.isErr) {
+    return context.error;
+  }
+  return yield* await_1(this.verifyCertificateChainUsingPlatformCallback(context.value), $completion);
+}
+//endregion
+var DefaultCallbacks_instance;
+function DefaultCallbacks_getInstance() {
+  return DefaultCallbacks_instance;
+}
+var Companion_instance_2;
+function Companion_getInstance_2() {
+  return Companion_instance_2;
+}
+function *performKeyAgreementDirect($this, privateKeyInfo, publicKeyInfo, algorithm, keyDataLen, $completion) {
+  var tmp0_elvis_lhs = CoseJoseKeyMappingService_instance.toJwkKeyInfo(privateKeyInfo).key;
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    throw IllegalArgumentException.y1('Private key info must contain a key');
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var privateKeyJwk = tmp;
+  var tmp1_elvis_lhs = CoseJoseKeyMappingService_instance.toJwkKeyInfo(publicKeyInfo).key;
+  var tmp_0;
+  if (tmp1_elvis_lhs == null) {
+    throw IllegalArgumentException.y1('Public key info must contain a key');
+  } else {
+    tmp_0 = tmp1_elvis_lhs;
+  }
+  var publicKeyJwk = tmp_0;
+  // Inline function 'kotlin.require' call
+  if (!privateKeyJwk.s4m_1.equals(JwaKeyType_EC_getInstance())) {
+    var message = 'Private key must be an EC key for ECDH key agreement, got: ' + privateKeyJwk.s4m_1.toString();
+    throw IllegalArgumentException.y1(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  if (!publicKeyJwk.s4m_1.equals(JwaKeyType_EC_getInstance())) {
+    var message_0 = 'Public key must be an EC key for ECDH key agreement, got: ' + publicKeyJwk.s4m_1.toString();
+    throw IllegalArgumentException.y1(toString(message_0));
+  }
+  // Inline function 'kotlin.require' call
+  if (!!(privateKeyJwk.i4m_1 == null)) {
+    var message_1 = "Private key must have 'd' parameter for key agreement";
+    throw IllegalArgumentException.y1(toString(message_1));
+  }
+  // Inline function 'kotlin.require' call
+  if (!(!(publicKeyJwk.v4m_1 == null) && !(publicKeyJwk.a4n_1 == null))) {
+    var message_2 = "Public key must have 'x' and 'y' coordinates for key agreement";
+    throw IllegalArgumentException.y1(toString(message_2));
+  }
+  var tmp2_safe_receiver = privateKeyJwk.h4m_1;
+  var tmp_1;
+  if (tmp2_safe_receiver == null) {
+    tmp_1 = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    tmp_1 = Companion_getInstance().p4i(tmp2_safe_receiver);
+  }
+  var tmp3_elvis_lhs = tmp_1;
+  var tmp_2;
+  if (tmp3_elvis_lhs == null) {
+    var tmp4_safe_receiver = publicKeyJwk.h4m_1;
+    var tmp_3;
+    if (tmp4_safe_receiver == null) {
+      tmp_3 = null;
+    } else {
+      // Inline function 'kotlin.let' call
+      tmp_3 = Companion_getInstance().p4i(tmp4_safe_receiver);
+    }
+    tmp_2 = tmp_3;
+  } else {
+    tmp_2 = tmp3_elvis_lhs;
+  }
+  var tmp5_elvis_lhs = tmp_2;
+  var curve = tmp5_elvis_lhs == null ? P_256_getInstance() : tmp5_elvis_lhs;
+  return yield* EcdhUtils_instance.e4r(privateKeyJwk, publicKeyJwk, curve, $completion);
+}
+var Companion_instance_3;
+function Companion_getInstance_3() {
+  return Companion_instance_3;
+}
+function KeyResolverRegistryImpl$keyResolversById$lambda(a, b) {
+  // Inline function 'kotlin.comparisons.compareValuesBy' call
+  var tmp = a.getId();
+  var tmp$ret$2 = b.getId();
+  return compareValues(tmp, tmp$ret$2);
+}
+var Companion_instance_4;
+function Companion_getInstance_4() {
+  return Companion_instance_4;
+}
+function _get_kmsProvidersById__3ih65k($this) {
+  var tmp0 = $this.l5n_1;
+  var tmp = KProperty1;
+  // Inline function 'kotlin.getValue' call
+  getPropertyCallableRef('kmsProvidersById', 1, tmp, KmsProviderRegistryImpl$_get_kmsProvidersById_$ref_i56lok(), null);
+  return tmp0.h4();
+}
+function KmsProviderRegistryImpl$kmsProvidersById$delegate$lambda$lambda(a, b) {
+  // Inline function 'kotlin.comparisons.compareValuesBy' call
+  var tmp = a.id;
+  var tmp$ret$2 = b.id;
+  return compareValues(tmp, tmp$ret$2);
+}
+function KmsProviderRegistryImpl$kmsProvidersById$delegate$lambda(this$0) {
+  return () => {
+    // Inline function 'kotlin.collections.sortedBy' call
+    var this_0 = this$0.j5n_1.t5n(this$0.i5n_1, this$0.k5n_1);
+    // Inline function 'kotlin.comparisons.compareBy' call
+    var tmp = KmsProviderRegistryImpl$kmsProvidersById$delegate$lambda$lambda;
+    var tmp$ret$1 = new sam$kotlin_Comparator$0_0(tmp);
+    // Inline function 'kotlin.collections.associateBy' call
+    var this_1 = sortedWith(this_0, tmp$ret$1);
+    var capacity = coerceAtLeast(mapCapacity(collectionSizeOrDefault(this_1, 10)), 16);
+    // Inline function 'kotlin.collections.associateByTo' call
+    var destination = LinkedHashMap.hc(capacity);
+    var _iterator__ex2g4s = this_1.j1();
+    while (_iterator__ex2g4s.k1()) {
+      var element = _iterator__ex2g4s.l1();
+      var tmp$ret$4 = element.id;
+      destination.p4(tmp$ret$4, element);
+    }
+    return toMutableMap(destination);
+  };
+}
+function KmsProviderRegistryImpl$_get_kmsProvidersById_$ref_i56lok() {
+  return (p0) => _get_kmsProvidersById__3ih65k(p0);
+}
+var Companion_instance_5;
+function Companion_getInstance_5() {
+  return Companion_instance_5;
+}
+var Companion_instance_6;
+function Companion_getInstance_6() {
+  return Companion_instance_6;
+}
+function _get_partition__kyj23d($this) {
+  var tmp0_safe_receiver = $this.y5n_1;
+  var tmp;
+  if (tmp0_safe_receiver == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    var tmp0_safe_receiver_0 = $this.z5n_1;
+    var tmp_0;
+    if (tmp0_safe_receiver_0 == null) {
+      tmp_0 = null;
+    } else {
+      // Inline function 'kotlin.let' call
+      tmp_0 = tmp0_safe_receiver.h5o(tmp0_safe_receiver_0);
+    }
+    tmp = tmp_0;
+  }
+  return tmp;
+}
+function _get_keys__d97k5z($this) {
+  var tmp0_safe_receiver = _get_partition__kyj23d($this);
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.i5o_1;
+  return tmp1_elvis_lhs == null ? $this.e5o_1 : tmp1_elvis_lhs;
+}
+function _get_certificateChains__l5yeco($this) {
+  var tmp0_safe_receiver = _get_partition__kyj23d($this);
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.j5o_1;
+  return tmp1_elvis_lhs == null ? $this.f5o_1 : tmp1_elvis_lhs;
+}
+function _get_certificates__eymdpt($this) {
+  var tmp0_safe_receiver = _get_partition__kyj23d($this);
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.k5o_1;
+  return tmp1_elvis_lhs == null ? $this.g5o_1 : tmp1_elvis_lhs;
+}
+//region block: post-declaration
+initMetadataForObject(DefaultCallbacks, 'DefaultCallbacks');
+initMetadataForCompanion(Companion);
+initMetadataForClass(BindsMirror, 'BindsMirror');
+initMetadataForClass(MetroFactory, 'MetroFactory');
+initMetadataForInterface(MetroContributionToSessionScope, 'MetroContributionToSessionScope');
+protoOf(KeyManagerServiceImpl).getProviderById = getProviderById;
+protoOf(KeyManagerServiceImpl).getProvider = getProvider;
+protoOf(KeyManagerServiceImpl).registerProvider = registerProvider;
+protoOf(KeyManagerServiceImpl).getResolverById = getResolverById;
+protoOf(KeyManagerServiceImpl).getResolverByKeyTypeOrIdentifier = getResolverByKeyTypeOrIdentifier;
+protoOf(KeyManagerServiceImpl).registerResolver = registerResolver;
+protoOf(KeyManagerServiceImpl).g4s = getAllCapabilities$default;
+protoOf(KeyManagerServiceImpl).b4t = resolvePublicKey$default;
+protoOf(KeyManagerServiceImpl).k4s = generateKey$default;
+protoOf(KeyManagerServiceImpl).i4s = generateKeyAsync$default;
+protoOf(KeyManagerServiceImpl).m4r = encrypt$default;
+protoOf(KeyManagerServiceImpl).o4r = decrypt$default;
+protoOf(KeyManagerServiceImpl).s4r = performKeyAgreement$default;
+protoOf(KeyManagerServiceImpl).c4t = storeKey$default;
+protoOf(KeyManagerServiceImpl).m4s = createRawSignatureResult$default;
+protoOf(KeyManagerServiceImpl).o4s = encryptResult$default;
+protoOf(KeyManagerServiceImpl).q4s = decryptResult$default;
+protoOf(KeyManagerServiceImpl).s4s = performKeyAgreementResult$default;
+protoOf(KeyManagerServiceImpl).u4s = generateKeyResult$default;
+protoOf(KeyManagerServiceImpl).w4s = listKeysResult$default;
+protoOf(KeyManagerServiceImpl).y4s = storeKeyResult$default;
+protoOf(KeyManagerServiceImpl).a4t = resolvePublicKeyResult$default;
+protoOf(KeyManagerServiceImpl).exposesPrivateKeysForSigning = exposesPrivateKeysForSigning;
+initMetadataForClass(KeyManagerServiceImpl, 'KeyManagerServiceImpl', VOID, VOID, [KeyManagerService], [1, 4, 6, 3, 0]);
+initMetadataForCompanion(Companion_0);
+initMetadataForClass(BindsMirror_0, 'BindsMirror');
+initMetadataForClass(MetroFactory_0, 'MetroFactory');
+initMetadataForInterface(MetroContributionToSessionScope_0, 'MetroContributionToSessionScope');
+initMetadataForClass(sam$kotlin_Comparator$0, 'sam$kotlin_Comparator$0', VOID, VOID, [Comparator, FunctionAdapter]);
+protoOf(KeyResolverRegistryImpl).getResolverById = getResolverById;
+protoOf(KeyResolverRegistryImpl).getResolverByKeyTypeOrIdentifier = getResolverByKeyTypeOrIdentifier;
+protoOf(KeyResolverRegistryImpl).registerResolver = registerResolver;
+initMetadataForClass(KeyResolverRegistryImpl, 'KeyResolverRegistryImpl', VOID, VOID, [KeyResolverRegistry]);
+initMetadataForCompanion(Companion_1);
+initMetadataForClass(BindsMirror_1, 'BindsMirror');
+initMetadataForClass(MetroFactory_1, 'MetroFactory');
+initMetadataForInterface(MetroContributionToSessionScope_1, 'MetroContributionToSessionScope');
+initMetadataForClass(sam$kotlin_Comparator$0_0, 'sam$kotlin_Comparator$0', VOID, VOID, [Comparator, FunctionAdapter]);
+protoOf(KmsProviderRegistryImpl).getProviderById = getProviderById;
+protoOf(KmsProviderRegistryImpl).getProvider = getProvider;
+protoOf(KmsProviderRegistryImpl).registerProvider = registerProvider;
+initMetadataForClass(KmsProviderRegistryImpl, 'KmsProviderRegistryImpl', VOID, VOID, [KmsProviderRegistry]);
+initMetadataForCompanion(Companion_2);
+initMetadataForInterface(MemoryKeyStoreServiceFactory, 'MemoryKeyStoreServiceFactory');
+initMetadataForClass(Impl, 'Impl', VOID, VOID, [MemoryKeyStoreServiceFactory]);
+initMetadataForCompanion(Companion_3);
+protoOf(MemoryKeyStoreService).c4t = storeKey$default;
+protoOf(MemoryKeyStoreService).o4q = storeCertificateChain$default;
+protoOf(MemoryKeyStoreService).v2v = get_order;
+protoOf(MemoryKeyStoreService).j4u = get_enabled;
+protoOf(MemoryKeyStoreService).o4t = listKeys;
+protoOf(MemoryKeyStoreService).listKeysFiltered = listKeysFiltered;
+initMetadataForClass(MemoryKeyStoreService, 'MemoryKeyStoreService', VOID, VOID, [KeyStore], [0, 1, 4, 3, 2]);
+initMetadataForInterface(IX509JSCallback, 'IX509JSCallback', VOID, VOID, [X509VerifyPlatformCallback]);
+initMetadataForInterface(X509VerifyVerifyPlatformCallbackJSPromises, 'X509VerifyVerifyPlatformCallbackJSPromises', VOID, VOID, [X509VerifyService, IX509JSCallback, HasPlatformCallback], [1]);
+//endregion
+//region block: init
+DefaultCallbacks_instance = new DefaultCallbacks();
+Companion_instance_2 = new Companion();
+Companion_instance_3 = new Companion_0();
+Companion_instance_4 = new Companion_1();
+Companion_instance_5 = new Companion_2();
+Companion_instance_6 = new Companion_3();
+//endregion
+//region block: exports
+var DefaultCallbacks_0 = {getInstance: DefaultCallbacks_getInstance};
+KeyManagerServiceImpl.MetroFactory = MetroFactory;
+defineProp(KeyManagerServiceImpl.MetroFactory, 'Companion', Companion_getInstance_2, VOID, true);
+var MetroContributionToSessionScope_2 = {};
+KeyManagerServiceImpl.MetroContributionToSessionScope = MetroContributionToSessionScope_2;
+KeyManagerServiceImpl.MetroContributionToSessionScope.BindsMirror = BindsMirror;
+KeyResolverRegistryImpl.MetroFactory = MetroFactory_0;
+defineProp(KeyResolverRegistryImpl.MetroFactory, 'Companion', Companion_getInstance_3, VOID, true);
+var MetroContributionToSessionScope_3 = {};
+KeyResolverRegistryImpl.MetroContributionToSessionScope = MetroContributionToSessionScope_3;
+KeyResolverRegistryImpl.MetroContributionToSessionScope.BindsMirror = BindsMirror_0;
+KmsProviderRegistryImpl.MetroFactory = MetroFactory_1;
+defineProp(KmsProviderRegistryImpl.MetroFactory, 'Companion', Companion_getInstance_4, VOID, true);
+var MetroContributionToSessionScope_4 = {};
+KmsProviderRegistryImpl.MetroContributionToSessionScope = MetroContributionToSessionScope_4;
+KmsProviderRegistryImpl.MetroContributionToSessionScope.BindsMirror = BindsMirror_1;
+var MemoryKeyStoreServiceFactory_0 = {};
+MemoryKeyStoreServiceFactory_0.Impl = Impl;
+defineProp(MemoryKeyStoreServiceFactory_0.Impl, 'Companion', Companion_getInstance_5, VOID, true);
+export {
+  DefaultCallbacks_0 as DefaultCallbacks,
+  KeyManagerServiceImpl as KeyManagerServiceImpl,
+  KeyResolverRegistryImpl as KeyResolverRegistryImpl,
+  KmsProviderRegistryImpl as KmsProviderRegistryImpl,
+  MemoryKeyStoreServiceFactory_0 as MemoryKeyStoreServiceFactory,
+};
+//endregion
+
+//# sourceMappingURL=idk-lib-crypto-core-impl.mjs.map