pub fn new(

        tagname: TagName,

        filter: Option<Filter>,

        groups: Vec<GroupType>,

        window: Option<WindowRange>,

    ) -> Self {

        Self {

            tagname,

            filter,

            groups,

            window,

        }

    }

    fn serialize(&self) -> String {

        let mut cmd = match &self.filter {

            Some(f) => format!("{} {} {}", Self::COMMAND, self.tagname, f),

            None => format!("{} {}", Self::COMMAND, self.tagname),

        for group in &self.groups {

            cmd.push_str(&format!(" group {}", group));

        }

        if let Some(window) = &self.window {

            cmd.push_str(&format!(" window {}", window));

        }

        cmd.push('\n');

        cmd

    }

    fn parse(mut parts: RequestTokenizer<'_>) -> Result<Self, RequestParserError> {

        let tagname = parts.next().ok_or(Self::missing_arguments_error(0))?;

        let tagname = tagname

            .parse()

            .map_err(|_| RequestParserError::SubtypeParserError {

                raw_input: tagname.to_owned(),

            })?;

        let mut filter = None;

        let mut groups = Vec::new();

        let mut window = None;

        let mut next = parts.next();

        let mut argument_index_counter = 0;

        if let Some(f) = next

            && f != "group"

            && f != "window"

            argument_index_counter += 1;

            let parsed_filter =

                Filter::parse(f).map_err(|_| RequestParserError::SyntaxError(1, f.to_owned()))?;

            filter = Some(parsed_filter);

            next = parts.next();

        }

        while let Some(g) = next

            && g == "group"

            argument_index_counter += 1;

            let group = parts

                .next()

                .ok_or(RequestParserError::MissingKeywordValue {

                    keyword: "group",

                    argument_index: argument_index_counter,

                })?;

            let parsed_group =

                group

                    .parse()

                    .map_err(|_| RequestParserError::SubtypeParserError {

                        raw_input: group.to_owned(),

                    })?;

            groups.push(parsed_group);

            next = parts.next();

        if let Some(w) = next

            && w == "window"

            let window_str = parts

                .next()

                .ok_or(RequestParserError::MissingKeywordValue {

                    keyword: "window",

                    argument_index: argument_index_counter,

                })?;

            let parsed_window =

                window_str

                    .parse()

                    .map_err(|_| RequestParserError::SubtypeParserError {

                        raw_input: window_str.to_owned(),

                    })?;

            window = Some(parsed_window);

        }

        Self::throw_if_too_many_arguments(parts)?;

        Ok(ListRequest {

            tagname,

            filter,

            groups,

            window,

        })

    }

    pub fn new(items: Vec<String>) -> Self {

        ListResponse(items)

    }

    fn parse(parts: ResponseAttributes<'_>) -> Result<Self, ResponseParserError> {

        let parts_: Vec<_> = parts.into_vec()?;

        debug_assert!({

            let key = parts_.first().map(|(k, _)| k);

            parts_.iter().all(|(k, _)| k == key.unwrap())

        let list = parts_

            .into_iter()

            .map(|(k, v)| Ok(expect_property_type!(Some(v), k, Text).to_string()))

            .collect::<Result<Vec<_>, ResponseParserError>>()?;

        Ok(ListResponse(list))

    }

    fn serialize(&self) -> Vec<u8> {

        unimplemented!("response serialization is not yet implemented for ListResponse")