docs: async def issuer_create_credential(wallet_handle: int,
                                     cred_offer_json: str,
                                     cred_req_json: str,
                                     cred_values_json: str,
                                     rev_reg_id: Optional[str],
                                     blob_storage_reader_handle: Optional[int]) -> (str, Optional[str], Optional[str]):
      """
      Check Cred Request for the given Cred Offer and issue Credential for the given Cred Request.
  
      Cred Request must match Cred Offer. The credential definition and revocation registry definition
      referenced in Cred Offer and Cred Request must be already created and stored into the wallet.
  
      Information for this credential revocation will be store in the wallet as part of revocation registry under
      generated cred_revoc_id local for this wallet.
  
      This call returns revoc registry delta as json file intended to be shared as REVOC_REG_ENTRY transaction.
      Note that it is possible to accumulate deltas to reduce ledger load.
  
      :param wallet_handle: wallet handle (created by open_wallet).
      :param cred_offer_json: a cred offer created by issuer_create_credential_offer
      :param cred_req_json: a credential request created by prover_create_credential_req
      :param cred_values_json: a credential containing attribute values for each of requested attribute names.
       Example:
       {
        "attr1" : {"raw": "value1", "encoded": "value1_as_int" },
        "attr2" : {"raw": "value1", "encoded": "value1_as_int" }
       }
      :param rev_reg_id: (Optional) id of revocation registry definition stored in the wallet
      :param blob_storage_reader_handle: pre-configured blob storage reader instance handle that
      will allow to read revocation tails
      :return: 
       cred_json: Credential json containing signed credential values
       {
           "schema_id": string,
           "cred_def_id": string,
           "rev_reg_def_id", Optional<string>,
           "values": <see cred_values_json above>,
           // Fields below can depend on Cred Def type
           "signature": <signature>,
           "signature_correctness_proof": <signature_correctness_proof>
       }
       cred_revoc_id: local id for revocation info (Can be used for revocation of this cred)
       revoc_reg_delta_json: Revocation registry delta json with a newly issued credential
      """
  
      logger = logging.getLogger(__name__)
      logger.debug("issuer_create_credential: >>> wallet_handle: %r, cred_offer_json: %r, cred_req_json: %r,"
                   " cred_values_json: %r, rev_reg_id: %r, blob_storage_reader_handle: %r",
                   wallet_handle,
                   cred_offer_json,
                   cred_req_json,
                   cred_values_json,
                   rev_reg_id,
                   blob_storage_reader_handle)
  
      if not hasattr(issuer_create_credential, "cb"):
          logger.debug("issuer_create_credential: Creating callback")
          issuer_create_credential.cb = create_cb(CFUNCTYPE(None, c_int32, c_int32, c_char_p, c_char_p, c_char_p))
  
      c_wallet_handle = c_int32(wallet_handle)
      c_cred_offer_json = c_char_p(cred_offer_json.encode('utf-8'))
      c_cred_req_json = c_char_p(cred_req_json.encode('utf-8'))
      c_cred_values_json = c_char_p(cred_values_json.encode('utf-8'))
      c_rev_reg_id = c_char_p(rev_reg_id.encode('utf-8')) if rev_reg_id is not None else None
      c_blob_storage_reader_handle = c_int32(blob_storage_reader_handle) if blob_storage_reader_handle else -1
  
      (cred_json, cred_revoc_id, revoc_reg_delta_json) = await do_call('indy_issuer_create_credential',
                                                                       c_wallet_handle,
                                                                       c_cred_offer_json,
                                                                       c_cred_req_json,
                                                                       c_cred_values_json,
                                                                       c_rev_reg_id,
                                                                       c_blob_storage_reader_handle,
                                                                       issuer_create_credential.cb)
      cred_json = cred_json.decode()
      cred_revoc_id = cred_revoc_id.decode() if cred_revoc_id else None
      revoc_reg_delta_json = revoc_reg_delta_json.decode() if revoc_reg_delta_json else None
      res = (cred_json, cred_revoc_id, revoc_reg_delta_json)
  
      logger.debug("issuer_create_credential: <<< res: %r", res)
      return res