docs: async def build_pool_upgrade_request(submitter_did: str,
                                       name: str,
                                       version: str,
                                       action: str,
                                       _sha256: str,
                                       _timeout: Optional[int],
                                       schedule: Optional[str],
                                       justification: Optional[str],
                                       reinstall: bool,
                                       force: bool,
                                       package: Optional[str]) -> str:
      """
      Builds a POOL_UPGRADE request. Request to upgrade the Pool (sent by Trustee).
      It upgrades the specified Nodes (either all nodes in the Pool, or some specific ones).
  
      :param submitter_did: DID of the submitter stored in secured Wallet.
      :param name: Human-readable name for the upgrade.
      :param version: The version of indy-node package we perform upgrade to.
                      Must be greater than existing one (or equal if reinstall flag is True).
      :param action: Either start or cancel.
      :param _sha256: sha256 hash of the package.
      :param _timeout: (Optional) Limits upgrade time on each Node.
      :param schedule: (Optional) Schedule of when to perform upgrade on each node. Map Node DIDs to upgrade time.
      :param justification: (Optional) justification string for this particular Upgrade.
      :param reinstall: Whether it's allowed to re-install the same version. False by default.
      :param force: Whether we should apply transaction (schedule Upgrade) without waiting
                    for consensus of this transaction.
      :param package: (Optional) Package to be upgraded.
      :return: Request result as json.
      """
  
      logger = logging.getLogger(__name__)
      logger.debug("build_pool_upgrade_request: >>> submitter_did: %r, name: %r, version: %r, action: %r, _sha256: %r, "
                   "timeout: %r, schedule: %r, justification: %r, reinstall: %r, force: %r, package: %r",
                   submitter_did, name, version, action, _sha256, _timeout, schedule, justification, reinstall, force,
                   package)
  
      if not hasattr(build_pool_upgrade_request, "cb"):
          logger.debug("build_pool_upgrade_request: Creating callback")
          build_pool_upgrade_request.cb = create_cb(CFUNCTYPE(None, c_int32, c_int32, c_char_p))
  
      c_submitter_did = c_char_p(submitter_did.encode('utf-8'))
      c_name = c_char_p(name.encode('utf-8'))
      c_version = c_char_p(version.encode('utf-8'))
      c_action = c_char_p(action.encode('utf-8'))
      c_sha256 = c_char_p(_sha256.encode('utf-8'))
      c_timeout = c_int32(_timeout) if _timeout else c_int32(-1)
      c_schedule = c_char_p(schedule.encode('utf-8')) if schedule is not None else None
      c_justification = c_char_p(justification.encode('utf-8')) if justification is not None else None
      c_reinstall = c_bool(reinstall)
      c_force = c_bool(force)
      c_package = c_char_p(package.encode('utf-8')) if package is not None else None
  
      request_json = await do_call('indy_build_pool_upgrade_request',
                                   c_submitter_did,
                                   c_name,
                                   c_version,
                                   c_action,
                                   c_sha256,
                                   c_timeout,
                                   c_schedule,
                                   c_justification,
                                   c_reinstall,
                                   c_force,
                                   c_package,
                                   build_pool_upgrade_request.cb)
  
      res = request_json.decode()
      logger.debug("build_pool_upgrade_request: <<< res: %r", res)
      return res