def cover(self, minAcc, maxAcc, groupBy=None, new_reg_fields=None, cover_type="normal"):
        """
        *Wrapper of* ``COVER``

        COVER is a GMQL operator that takes as input a dataset (of usually, 
        but not necessarily, multiple samples) and returns another dataset 
        (with a single sample, if no groupby option is specified) by “collapsing”
        the input samples and their regions according to certain rules 
        specified by the COVER parameters. The attributes of the output regions 
        are only the region coordinates, plus in case, when aggregate functions 
        are specified, new attributes with aggregate values over attribute values 
        of the contributing input regions; output metadata are the union of the 
        input ones, plus the metadata attributes JaccardIntersect and 
        JaccardResult, representing global Jaccard Indexes for the considered 
        dataset, computed as the correspondent region Jaccard Indexes but on 
        the whole sample regions.

        :param cover_type: the kind of cover variant you want ['normal', 'flat', 'summit', 'histogram']
        :param minAcc: minimum accumulation value, i.e. the minimum number
         of overlapping regions to be considered during COVER execution. It can be any positive
         number or the strings {'ALL', 'ANY'}.
        :param maxAcc: maximum accumulation value, i.e. the maximum number
         of overlapping regions to be considered during COVER execution. It can be any positive
         number or the strings {'ALL', 'ANY'}.
        :param groupBy: optional list of metadata attributes 
        :param new_reg_fields: dictionary of the type
            {'new_region_attribute' : AGGREGATE_FUNCTION('field'), ...}
        :return: a new GMQLDataset
        
        An example of usage::
        
            cell_tf = narrow_peak.cover("normal", minAcc=1, maxAcc="Any", 
                                            groupBy=['cell', 'antibody_target'])    
        """
        if isinstance(cover_type, str):
            coverFlag = self.opmng.getCoverTypes(cover_type)
        else:
            raise TypeError("type must be a string. "
                            "{} was provided".format(type(cover_type)))
        if isinstance(minAcc, str):
            minAccParam = self.opmng.getCoverParam(minAcc.lower())
        elif isinstance(minAcc, int):
            minAccParam = self.opmng.getCoverParam(str(minAcc).lower())
        else:
            raise TypeError("minAcc must be a string or an integer. "
                            "{} was provided".format(type(minAcc)))
        if isinstance(maxAcc, str):
            maxAccParam = self.opmng.getCoverParam(maxAcc.lower())
        elif isinstance(maxAcc, int):
            maxAccParam = self.opmng.getCoverParam(str(maxAcc).lower())
        else:
            raise TypeError("maxAcc must be a string or an integer. "
                            "{} was provided".format(type(minAcc)))

        if isinstance(groupBy, list) and \
            all([isinstance(x, str) for x in groupBy]):
            groupBy_result = Some(groupBy)
        elif groupBy is None:
            groupBy_result = none()
        else:
            raise TypeError("groupBy must be a list of string. "
                            "{} was provided".format(type(groupBy)))

        aggregates = []
        if isinstance(new_reg_fields, dict):
            expBuild = self.pmg.getNewExpressionBuilder(self.__index)
            for k in new_reg_fields.keys():
                if isinstance(k, str):
                    item = new_reg_fields[k]
                    if isinstance(item, (SUM, MIN, MAX, AVG, BAG, BAGD,
                                         MEDIAN, COUNT)):
                        op_name = item.get_aggregate_name()
                        op_argument = item.get_argument()
                        if op_argument is None:
                            op_argument = none()
                        else:
                            op_argument = Some(op_argument)
                        regsToReg = expBuild.getRegionsToRegion(op_name, k, op_argument)
                        aggregates.append(regsToReg)
                    else:
                        raise TypeError("The items in new_reg_fields must be Aggregates (SUM, MIN, MAX, AVG, BAG, "
                                        "BAGD, MEDIAN, COUNT)"
                                        " {} was provided".format(type(item)))
                else:
                    raise TypeError("The key of new_reg_fields must be a string. "
                                    "{} was provided".format(type(k)))
        elif new_reg_fields is None:
            pass
        else:
            raise TypeError("new_reg_fields must be a list of dictionary. "
                            "{} was provided".format(type(new_reg_fields)))

        new_index = self.opmng.cover(self.__index, coverFlag, minAccParam, maxAccParam,
                                     groupBy_result, aggregates)
        return GMQLDataset(index=new_index, location=self.location,
                           local_sources=self._local_sources,
                           remote_sources=self._remote_sources, meta_profile=self.meta_profile)