greenbone / python-gvm

        cmd.set_attribute("role_id", role_id)

        return self._send_xml_command(cmd)

    def get_scanners(

        self,

        *,

        filter: Optional[str] = None,

        filter_id: Optional[str] = None,

        trash: Optional[bool] = None,

        details: Optional[bool] = None

    ) -> Any:

        """Request a list of scanners

        Arguments:

            filter: Filter term to use for the query

            filter_id: UUID of an existing filter to use for the query

            trash: Whether to get the trashcan scanners instead

            details:  Whether to include extra details like tasks using this

                scanner

        Returns:

            The response. See :py:meth:`send_command` for details.

        """

        cmd = XmlCommand("get_scanners")

        _add_filter(cmd, filter, filter_id)

        if not trash is None:

            cmd.set_attribute("trash", _to_bool(trash))

        if not details is None:

            cmd.set_attribute("details", _to_bool(details))

        return self._send_xml_command(cmd)

    def get_scanner(self, scanner_id: str) -> Any:

        """Request a single scanner

        cmd.set_attribute("tag_id", tag_id)

        return self._send_xml_command(cmd)

    def get_targets(

        self,

        *,

        filter: Optional[str] = None,

        filter_id: Optional[str] = None,

        trash: Optional[bool] = None,

        tasks: Optional[bool] = None

    ) -> Any:

        """Request a list of targets

        Arguments:

            filter: Filter term to use for the query

            filter_id: UUID of an existing filter to use for the query

            trash: Whether to get the trashcan targets instead

            tasks: Whether to include list of tasks that use the target

        Returns:

            The response. See :py:meth:`send_command` for details.

        """

        cmd = XmlCommand("get_targets")

        _add_filter(cmd, filter, filter_id)

        if not trash is None:

            cmd.set_attribute("trash", _to_bool(trash))

        if not tasks is None:

            cmd.set_attribute("tasks", _to_bool(tasks))

        return self._send_xml_command(cmd)

    def get_target(self, target_id: str) -> Any:

        """Request a single target

        return self._send_xml_command(cmd)

    def get_tags(

        self,

        *,

        filter: Optional[str] = None,

        filter_id: Optional[str] = None,

        trash: Optional[bool] = None,

        names_only: Optional[bool] = None

    ) -> Any:

        """Request a list of tags

        Arguments:

            filter: Filter term to use for the query

            filter_id: UUID of an existing filter to use for the query

            trash: Whether to get tags from the trashcan instead

            names_only: Whether to get only distinct tag names

        Returns:

            The response. See :py:meth:`send_command` for details.

        """

        cmd = XmlCommand("get_tags")

        _add_filter(cmd, filter, filter_id)

        if not trash is None:

            cmd.set_attribute("trash", _to_bool(trash))

        if not names_only is None:

            cmd.set_attribute("names_only", _to_bool(names_only))

        return self._send_xml_command(cmd)

    def get_tag(self, tag_id: str) -> Any:

        """Request a single tag

        cmd.set_attribute("details", "1")

        return self._send_xml_command(cmd)

    def get_schedules(

        self,

        *,

        filter: Optional[str] = None,

        filter_id: Optional[str] = None,

        trash: Optional[bool] = None,

        tasks: Optional[bool] = None

    ) -> Any:

        """Request a list of schedules

        Arguments:

            filter: Filter term to use for the query

            filter_id: UUID of an existing filter to use for the query

            trash: Whether to get the trashcan schedules instead

            tasks: Whether to include tasks using the schedules

        Returns:

            The response. See :py:meth:`send_command` for details.

        """

        cmd = XmlCommand("get_schedules")

        _add_filter(cmd, filter, filter_id)

        if not trash is None:

            cmd.set_attribute("trash", _to_bool(trash))

        if not tasks is None:

            cmd.set_attribute("tasks", _to_bool(tasks))

        return self._send_xml_command(cmd)

    def get_schedule(self, schedule_id: str) -> Any:

        """Request a single schedule

        return self._send_xml_command(cmd)

    def get_filters(

        self,

        *,

        filter: Optional[str] = None,

        filter_id: Optional[str] = None,

        trash: Optional[bool] = None,

        alerts: Optional[bool] = None

    ) -> Any:

        """Request a list of filters

        Arguments:

            filter: Filter term to use for the query

            filter_id: UUID of an existing filter to use for the query

            trash: Whether to get the trashcan filters instead

            alerts: Whether to include list of alerts that use the filter.

        Returns:

            The response. See :py:meth:`send_command` for details.

        """

        cmd = XmlCommand("get_filters")

        _add_filter(cmd, filter, filter_id)

        if not trash is None:

            cmd.set_attribute("trash", _to_bool(trash))

        if not alerts is None:

            cmd.set_attribute("alerts", _to_bool(alerts))

        return self._send_xml_command(cmd)

    def get_filter(self, filter_id: str) -> Any:

        """Request a single filter

        cmd.set_attributes(kwargs)

        return self._send_xml_command(cmd)

    def get_alerts(

        self,

        *,

        filter: Optional[str] = None,

        filter_id: Optional[str] = None,

        trash: Optional[bool] = None,

        tasks: Optional[bool] = None

    ) -> Any:

        """Request a list of alerts

        Arguments:

            filter: Filter term to use for the query

            filter_id: UUID of an existing filter to use for the query

            trash: True to request the alerts in the trashcan

            tasks: Whether to include the tasks using the alerts

        Returns:

            The response. See :py:meth:`send_command` for details.

        """

        cmd = XmlCommand("get_alerts")

        _add_filter(cmd, filter, filter_id)

        if not trash is None:

            cmd.set_attribute("trash", _to_bool(trash))

        if not tasks is None:

            cmd.set_attribute("tasks", _to_bool(tasks))

        return self._send_xml_command(cmd)

    def get_alert(self, alert_id: str) -> Any:

        """Request a single alert