docs: async def issuer_create_and_store_credential_def(wallet_handle: int,
                                                   issuer_did: str,
                                                   schema_json: str,
                                                   tag: str,
                                                   signature_type: Optional[str],
                                                   config_json: Optional[str]) -> (str, str):
      """
      Create credential definition entity that encapsulates credentials issuer DID, credential schema, secrets used for
      signing credentials and secrets used for credentials revocation.
  
      Credential definition entity contains private and public parts. Private part will be stored in the wallet.
      Public part will be returned as json intended to be shared with all anoncreds workflow actors usually by
      publishing CRED_DEF transaction to Indy distributed ledger.
  
      It is IMPORTANT for current version GET Schema from Ledger with correct seq_no to save compatibility with Ledger.
  
      :param wallet_handle: wallet handler (created by open_wallet).
      :param issuer_did: a DID of the issuer signing cred_def transaction to the Ledger
      :param schema_json: credential schema as a json
      :param tag: allows to distinct between credential definitions for the same issuer and schema
      :param signature_type: credential definition type (optional, 'CL' by default) that defines credentials signature and revocation math.
      Supported types are:
          - 'CL': Camenisch-Lysyanskaya credential signature type
      :param  config_json: (optional) type-specific configuration of credential definition as json:
          - 'CL':
            - support_revocation: whether to request non-revocation credential (optional, default false)
      :return: 
          cred_def_id: identifier of created credential definition
          cred_def_json: public part of created credential definition
      """
  
      logger = logging.getLogger(__name__)
      logger.debug("issuer_create_and_store_credential_def: >>> wallet_handle: %r, issuer_did: %r, schema_json: %r,"
                   " tag: %r, signature_type: %r, config_json: %r",
                   wallet_handle,
                   issuer_did,
                   schema_json,
                   tag,
                   signature_type,
                   config_json)
  
      if not hasattr(issuer_create_and_store_credential_def, "cb"):
          logger.debug("issuer_create_and_store_credential_def: Creating callback")
          issuer_create_and_store_credential_def.cb = create_cb(CFUNCTYPE(None, c_int32, c_int32, c_char_p, c_char_p))
  
      c_wallet_handle = c_int32(wallet_handle)
      c_issuer_did = c_char_p(issuer_did.encode('utf-8'))
      c_schema_json = c_char_p(schema_json.encode('utf-8'))
      c_tag = c_char_p(tag.encode('utf-8'))
      c_signature_type = c_char_p(signature_type.encode('utf-8')) if signature_type is not None else None
      c_config_json = c_char_p(config_json.encode('utf-8')) if config_json is not None else None
  
      (credential_def_id, credential_def_json) = await do_call('indy_issuer_create_and_store_credential_def',
                                                               c_wallet_handle,
                                                               c_issuer_did,
                                                               c_schema_json,
                                                               c_tag,
                                                               c_signature_type,
                                                               c_config_json,
                                                               issuer_create_and_store_credential_def.cb)
  
      res = (credential_def_id.decode(), credential_def_json.decode())
      logger.debug("issuer_create_and_store_credential_def: <<< res: %r", res)
      return res