diff --git a/src/materializer.rs b/src/materializer.rs
index eaeadd2..1828bb6 100644
--- a/src/materializer.rs
+++ b/src/materializer.rs
@@ -1,7 +1,6 @@
 use crate::parsing::traits::ParsableNode;
 use crate::tree::node::{DynamicNode, MaterializedNode};
-use crate::tree::node_repository::NodeRepository;
-use crate::tree::traits::LocatableNode;
+use crate::tree::traits::{LocatableNode, NodeRepository};
 use log::error;
 use phenopackets::schema::v2::core::{
     Diagnosis, Disease, OntologyClass, PhenotypicFeature, Resource, VitalStatus,
@@ -11,7 +10,7 @@ use phenopackets::schema::v2::{Cohort, Phenopacket};
 pub(crate) struct NodeMaterializer;
 
 impl NodeMaterializer {
-    pub fn materialize_nodes(&mut self, dyn_node: &DynamicNode, repo: &mut NodeRepository) {
+    pub fn materialize_nodes(&mut self, dyn_node: &DynamicNode, repo: &mut impl NodeRepository) {
         if let Some(cohort) = Cohort::parse(dyn_node) {
             Self::push_to_repo(cohort, dyn_node, repo);
         } else if let Some(oc) = OntologyClass::parse(dyn_node) {
@@ -33,12 +32,13 @@ impl NodeMaterializer {
         };
     }
 
-    fn push_to_repo<T: 'static>(
-        materialized: T,
+    fn push_to_repo<NodeType: 'static + Clone>(
+        materialized: NodeType,
         dyn_node: &DynamicNode,
-        board: &mut NodeRepository,
+        board: &mut impl NodeRepository,
     ) {
         let node = MaterializedNode::from_dynamic(materialized, dyn_node);
-        board.insert(node);
+        // TODO: Error throwing
+        board.insert(node).expect("Unable to insert node");
     }
 }
diff --git a/src/phenolint.rs b/src/phenolint.rs
index 1a374d3..cf1d1f2 100644
--- a/src/phenolint.rs
+++ b/src/phenolint.rs
@@ -14,13 +14,13 @@ use crate::schema_validation::validator::PhenopacketSchemaValidator;
 use crate::traits::Lint;
 use crate::tree::abstract_pheno_tree::AbstractTreeTraversal;
 use crate::tree::node::DynamicNode;
-use crate::tree::node_repository::NodeRepository;
 use crate::tree::pointer::Pointer;
 use log::{error, warn};
 use phenopackets::schema::v2::Phenopacket;
 use prost::Message;
 use serde_json::Value;
 
+use crate::tree::btree_node_repository::BTreeNodeRepository;
 use std::fs;
 use std::path::PathBuf;
 
@@ -71,7 +71,7 @@ impl Lint<str> for Phenolint {
         let root_node = DynamicNode::new(&values, &spans, Pointer::at_root());
 
         let apt = AbstractTreeTraversal::new(values, spans);
-        let mut node_repo: NodeRepository = NodeRepository::new();
+        let mut node_repo = BTreeNodeRepository::new();
 
         for node in apt.traverse() {
             self.node_materializer
diff --git a/src/rules/curies/curie_format_rule.rs b/src/rules/curies/curie_format_rule.rs
index a5e3a3c..41bd08d 100644
--- a/src/rules/curies/curie_format_rule.rs
+++ b/src/rules/curies/curie_format_rule.rs
@@ -10,7 +10,8 @@ use crate::report::traits::{CompileReport, RegisterableReport, ReportFromContext
 use crate::rules::rule_registration::RuleRegistration;
 use crate::rules::traits::RuleMetaData;
 use crate::rules::traits::{LintRule, RuleCheck, RuleFromContext};
-use crate::tree::node_repository::List;
+use crate::tree::querying::presentation::Flattened;
+use crate::tree::querying::queries::convenience::All;
 use crate::tree::traits::{LocatableNode, Node};
 use phenolint_macros::{register_report, register_rule};
 use phenopackets::schema::v2::core::OntologyClass;
@@ -38,9 +39,9 @@ impl RuleFromContext for CurieFormatRule {
 }
 
 impl RuleCheck for CurieFormatRule {
-    type Data<'a> = List<'a, OntologyClass>;
+    type Query = All<OntologyClass>;
 
-    fn check(&self, data: Self::Data<'_>) -> Vec<LintViolation> {
+    fn check(&self, data: Flattened<OntologyClass>) -> Vec<LintViolation> {
         let mut violations = vec![];
 
         for node in data.0.iter() {
diff --git a/src/rules/interpretation/disease_consistency_rule.rs b/src/rules/interpretation/disease_consistency_rule.rs
index cd2eafe..5a6a763 100644
--- a/src/rules/interpretation/disease_consistency_rule.rs
+++ b/src/rules/interpretation/disease_consistency_rule.rs
@@ -14,8 +14,9 @@ use crate::report::traits::{CompileReport, RegisterableReport, ReportFromContext
 use crate::rules::rule_registration::RuleRegistration;
 use crate::rules::traits::RuleMetaData;
 use crate::rules::traits::{LintRule, RuleCheck, RuleFromContext};
-use crate::tree::node_repository::List;
 use crate::tree::pointer::Pointer;
+use crate::tree::querying::presentation::Grouped;
+use crate::tree::querying::queries::convenience::GroupedIndividuals;
 use crate::tree::traits::{LocatableNode, Node};
 use phenolint_macros::{register_patch, register_report, register_rule};
 use phenopackets::schema::v2::core::{Diagnosis, Disease, OntologyClass};
@@ -38,34 +39,37 @@ impl RuleFromContext for DiseaseConsistencyRule {
 }
 
 impl RuleCheck for DiseaseConsistencyRule {
-    type Data<'a> = (List<'a, Diagnosis>, List<'a, Disease>);
+    type Query = (GroupedIndividuals<Diagnosis>, GroupedIndividuals<Disease>);
 
-    fn check(&self, data: Self::Data<'_>) -> Vec<LintViolation> {
+    fn check(&self, data: (Grouped<Diagnosis>, Grouped<Disease>)) -> Vec<LintViolation> {
         let mut violations = vec![];
 
-        let disease_terms: Vec<(&str, &str)> = data
-            .1
-            .iter()
-            .filter_map(|disease| {
-                disease
-                    .inner
-                    .term
-                    .as_ref()
-                    .map(|oc| (oc.id.as_str(), oc.label.as_str()))
-            })
-            .collect();
-
-        for diagnosis in data.0.iter() {
-            if let Some(oc) = &diagnosis.inner.disease
-                && !disease_terms.contains(&(oc.id.as_str(), oc.label.as_str()))
-            {
-                violations.push(LintViolation::new(
-                    ViolationSeverity::Warning,
-                    LintRule::rule_id(self),
-                    NonEmptyVec::with_single_entry(
-                        diagnosis.pointer().clone().down("disease").clone(),
-                    ),
-                ))
+        let (diagnosis_groups, diseases_group) = data;
+
+        for (diagnosis, diseases) in diagnosis_groups.0.iter().zip(diseases_group.0) {
+            let disease_terms: Vec<(&str, &str)> = diseases
+                .iter()
+                .filter_map(|disease| {
+                    disease
+                        .inner
+                        .term
+                        .as_ref()
+                        .map(|oc| (oc.id.as_str(), oc.label.as_str()))
+                })
+                .collect();
+
+            for diagnosis in diagnosis.iter() {
+                if let Some(oc) = &diagnosis.inner.disease
+                    && !disease_terms.contains(&(oc.id.as_str(), oc.label.as_str()))
+                {
+                    violations.push(LintViolation::new(
+                        ViolationSeverity::Warning,
+                        LintRule::rule_id(self),
+                        NonEmptyVec::with_single_entry(
+                            diagnosis.pointer().clone().down("disease").clone(),
+                        ),
+                    ))
+                }
             }
         }
 
diff --git a/src/rules/resources.rs b/src/rules/resources.rs
index 315498a..a7a3d46 100644
--- a/src/rules/resources.rs
+++ b/src/rules/resources.rs
@@ -8,8 +8,9 @@ use crate::report::traits::RuleReport;
 use crate::report::traits::{CompileReport, RegisterableReport, ReportFromContext};
 use crate::rules::rule_registration::RuleRegistration;
 use crate::rules::traits::{LintRule, RuleCheck, RuleFromContext, RuleMetaData};
-use crate::tree::node_repository::List;
 use crate::tree::pointer::Pointer;
+use crate::tree::querying::presentation::Grouped;
+use crate::tree::querying::queries::convenience::GroupedIndividuals;
 use crate::tree::traits::{LocatableNode, Node};
 use phenolint_macros::{register_report, register_rule};
 use phenopackets::schema::v2::core::{OntologyClass, Resource};
@@ -35,28 +36,34 @@ impl RuleFromContext for CuriesHaveResourcesRule {
 }
 
 impl RuleCheck for CuriesHaveResourcesRule {
-    type Data<'a> = (List<'a, OntologyClass>, List<'a, Resource>);
-
-    fn check(&self, data: Self::Data<'_>) -> Vec<LintViolation> {
-        let known_prefixes: HashSet<_> = data
-            .1
-            .iter()
-            .map(|r| r.inner.namespace_prefix.as_str())
-            .collect();
+    type Query = (
+        GroupedIndividuals<OntologyClass>,
+        GroupedIndividuals<Resource>,
+    );
 
+    fn check(&self, data: (Grouped<OntologyClass>, Grouped<Resource>)) -> Vec<LintViolation> {
+        let (ontology_classes, resources) = data;
         let mut violations = vec![];
 
-        for node in data.0.iter() {
-            if let Some(prefix) = find_prefix(node.inner.id.as_str())
-                && !known_prefixes.contains(prefix)
-            {
-                violations.push(LintViolation::new(
-                    ViolationSeverity::Error,
-                    LintRule::rule_id(self),
-                    node.pointer().clone().into(), // <- warns about the ontology class itself
-                ));
+        for (o, r) in ontology_classes.0.iter().zip(resources.0) {
+            let known_prefixes: HashSet<_> = r
+                .iter()
+                .map(|r| r.inner.namespace_prefix.as_str())
+                .collect();
+
+            for node in o.iter() {
+                if let Some(prefix) = find_prefix(node.inner.id.as_str())
+                    && !known_prefixes.contains(prefix)
+                {
+                    violations.push(LintViolation::new(
+                        ViolationSeverity::Error,
+                        LintRule::rule_id(self),
+                        node.pointer().clone().into(), // <- warns about the ontology class itself
+                    ));
+                }
             }
         }
+
         violations
     }
 }
@@ -66,8 +73,8 @@ mod test_curies_have_resources {
     use crate::rules::resources::CuriesHaveResourcesRule;
     use crate::rules::traits::{RuleCheck, RuleMetaData};
     use crate::tree::node::MaterializedNode;
-    use crate::tree::node_repository::List;
     use crate::tree::pointer::Pointer;
+    use crate::tree::querying::presentation::Grouped;
     use phenopackets::schema::v2::core::OntologyClass;
 
     #[test]
@@ -82,8 +89,8 @@ mod test_curies_have_resources {
             Default::default(),
             Pointer::new("/phenotypicFeatures/0/type"),
         )];
-        let resources = [];
-        let data = (List(&ocs), List(&resources));
+        let resources = vec![vec![]];
+        let data = (Grouped(vec![ocs.to_vec()]), Grouped(resources));
 
         let violations = rule.check(data);
 
diff --git a/src/rules/rule_registry.rs b/src/rules/rule_registry.rs
index 9bd3534..aa1296f 100644
--- a/src/rules/rule_registry.rs
+++ b/src/rules/rule_registry.rs
@@ -80,7 +80,8 @@ mod tests {
     use crate::rules::traits::RuleCheck;
     use crate::rules::traits::RuleFromContext;
     use crate::rules::traits::RuleMetaData;
-    use crate::tree::node_repository::List;
+    use crate::tree::querying::presentation::Flattened;
+    use crate::tree::querying::queries::convenience::All;
     use phenolint_macros::register_rule;
     use phenopackets::schema::v2::core::OntologyClass;
     use rstest::rstest;
@@ -100,9 +101,9 @@ mod tests {
         }
     }
     impl RuleCheck for TestRule {
-        type Data<'a> = List<'a, OntologyClass>;
+        type Query = All<OntologyClass>;
 
-        fn check(&self, _: Self::Data<'_>) -> Vec<LintViolation> {
+        fn check(&self, _: Flattened<OntologyClass>) -> Vec<LintViolation> {
             todo!()
         }
     }
diff --git a/src/rules/traits.rs b/src/rules/traits.rs
index 97173cb..656729b 100644
--- a/src/rules/traits.rs
+++ b/src/rules/traits.rs
@@ -1,15 +1,17 @@
 use crate::LinterContext;
 use crate::diagnostics::LintViolation;
 use crate::error::FromContextError;
-use crate::tree::node_repository::NodeRepository;
+use crate::tree::btree_node_repository::BTreeNodeRepository;
+use crate::tree::querying::traits::QueryStrategy;
 
-pub trait LintRule: RuleFromContext + Send + Sync {
+pub trait LintRule: Send + Sync {
     fn rule_id(&self) -> &str;
 
-    fn check_erased(&self, board: &NodeRepository) -> Vec<LintViolation>;
+    // Needs to be concrete type, because NodeRepository trait is not dyn compatible :(
+    fn check_erased(&self, board: &BTreeNodeRepository) -> Vec<LintViolation>;
 }
 
-pub trait RuleMetaData: Send + Sync {
+pub trait RuleMetaData {
     fn rule_id(&self) -> &str;
 }
 
@@ -20,28 +22,22 @@ pub trait RuleFromContext {
 }
 
 pub trait RuleCheck: Send + Sync + 'static {
-    type Data<'a>: LintData<'a> + ?Sized;
-    fn check(&self, data: Self::Data<'_>) -> Vec<LintViolation>;
+    type Query: QueryStrategy;
+    fn check(&self, data: <Self::Query as QueryStrategy>::Output) -> Vec<LintViolation>;
 }
 
 impl<T> LintRule for T
 where
     T: RuleCheck + RuleFromContext + RuleMetaData,
-    for<'a> <T as RuleCheck>::Data<'a>: Sized,
+    for<'a> <T as RuleCheck>::Query: Sized,
 {
     fn rule_id(&self) -> &str {
         self.rule_id()
     }
 
-    fn check_erased(&self, board: &NodeRepository) -> Vec<LintViolation> {
-        let data = <Self as RuleCheck>::Data::fetch(board);
+    fn check_erased(&self, board: &BTreeNodeRepository) -> Vec<LintViolation> {
+        let data = <Self as RuleCheck>::Query::query(board);
 
         self.check(data)
     }
 }
-
-pub trait LintData<'a> {
-    fn fetch(board: &'a NodeRepository) -> Self
-    where
-        Self: Sized;
-}
diff --git a/src/tree/btree_node_repository.rs b/src/tree/btree_node_repository.rs
index 566b6ef..dcf31a2 100644
--- a/src/tree/btree_node_repository.rs
+++ b/src/tree/btree_node_repository.rs
@@ -15,7 +15,7 @@ struct NodeEntry {
     inner: Box<dyn Any>,
 }
 
-pub(crate) struct BTreeNodeRepository {
+pub struct BTreeNodeRepository {
     node_store: BTreeMap<String, NodeEntry>,
     span_store: BTreeMap<String, Range<usize>>,
     scope_mappings: ScopeMappings,
@@ -38,18 +38,18 @@ impl BTreeNodeRepository {
             .collect()
     }
 
-    fn cast_entry<T>(
+    fn cast_entry<NodeType>(
         &self,
         path: &str,
         entry: &NodeEntry,
-    ) -> Result<MaterializedNode<T>, NodeRepositoryError>
+    ) -> Result<MaterializedNode<NodeType>, NodeRepositoryError>
     where
-        T: Clone + 'static,
+        NodeType: Clone + 'static,
     {
-        let content_ref = entry.inner.downcast_ref::<T>().ok_or_else(|| {
+        let content_ref = entry.inner.downcast_ref::<NodeType>().ok_or_else(|| {
             NodeRepositoryError::CantReinstantiateNode(
                 path.to_string(),
-                std::any::type_name::<T>().to_string(),
+                std::any::type_name::<NodeType>().to_string(),
             )
         })?;
 
@@ -61,8 +61,11 @@ impl BTreeNodeRepository {
 }
 
 impl NodeRepository for BTreeNodeRepository {
-    fn insert<T: 'static>(&mut self, node: MaterializedNode<T>) -> Result<(), NodeRepositoryError> {
-        let type_id = TypeId::of::<T>();
+    fn insert<NodeType: 'static>(
+        &mut self,
+        node: MaterializedNode<NodeType>,
+    ) -> Result<(), NodeRepositoryError> {
+        let type_id = TypeId::of::<NodeType>();
         let node_path = node.pointer().position().to_string();
 
         let scope = self
@@ -88,49 +91,49 @@ impl NodeRepository for BTreeNodeRepository {
         Ok(())
     }
 
-    fn get_all<T>(&self) -> Result<Vec<MaterializedNode<T>>, NodeRepositoryError>
+    fn get_all<NodeType>(&self) -> Result<Vec<MaterializedNode<NodeType>>, NodeRepositoryError>
     where
-        T: Clone + 'static,
+        NodeType: Clone + 'static,
     {
-        let target_type = TypeId::of::<T>();
+        let target_type = TypeId::of::<NodeType>();
 
         let nodes = self
             .node_store
             .iter()
             .filter(|(_, entry)| entry.type_id == target_type)
-            .map(|(path, entry)| self.cast_entry::<T>(path.as_str(), entry))
-            .collect::<Result<Vec<MaterializedNode<T>>, NodeRepositoryError>>()?;
+            .map(|(path, entry)| self.cast_entry::<NodeType>(path.as_str(), entry))
+            .collect::<Result<Vec<MaterializedNode<NodeType>>, NodeRepositoryError>>()?;
 
         Ok(nodes)
     }
 
-    fn get_nodes_in_scope<T>(
+    fn get_nodes_in_scope<NodeType>(
         &self,
         scope: ScopeLayer,
-    ) -> Result<Vec<MaterializedNode<T>>, NodeRepositoryError>
+    ) -> Result<Vec<MaterializedNode<NodeType>>, NodeRepositoryError>
     where
-        T: Clone + 'static,
+        NodeType: Clone + 'static,
     {
-        let target_type = TypeId::of::<T>();
+        let target_type = TypeId::of::<NodeType>();
 
         let nodes = self
             .node_store
             .iter()
             .filter(|(_, entry)| entry.type_id == target_type && entry.scope == scope)
-            .map(|(path, entry)| self.cast_entry::<T>(path, entry))
-            .collect::<Result<Vec<MaterializedNode<T>>, NodeRepositoryError>>()?;
+            .map(|(path, entry)| self.cast_entry::<NodeType>(path, entry))
+            .collect::<Result<Vec<MaterializedNode<NodeType>>, NodeRepositoryError>>()?;
 
         Ok(nodes)
     }
 
-    fn get_nodes_for_scope_per_top_level_element<T>(
+    fn get_nodes_for_scope_per_top_level_element<NodeType>(
         &self,
         scope: ScopeLayer,
-    ) -> Result<Vec<Vec<MaterializedNode<T>>>, NodeRepositoryError>
+    ) -> Result<Vec<Vec<MaterializedNode<NodeType>>>, NodeRepositoryError>
     where
-        T: Clone + 'static,
+        NodeType: Clone + 'static,
     {
-        let target_type = TypeId::of::<T>();
+        let target_type = TypeId::of::<NodeType>();
 
         let top_levels: Vec<&String> = self
             .node_store
@@ -147,12 +150,10 @@ impl NodeRepository for BTreeNodeRepository {
                 .range::<String, _>(tl_path.to_string()..)
                 .take_while(|(k, _)| k.starts_with(tl_path))
                 .filter(|(_, entry)| entry.type_id == target_type && entry.scope == scope)
-                .map(|(path, entry)| self.cast_entry::<T>(path, entry))
-                .collect::<Result<Vec<MaterializedNode<T>>, NodeRepositoryError>>()?;
+                .map(|(path, entry)| self.cast_entry::<NodeType>(path, entry))
+                .collect::<Result<Vec<MaterializedNode<NodeType>>, NodeRepositoryError>>()?;
 
-            if !children.is_empty() {
-                output.push(children);
-            }
+            output.push(children);
         }
 
         Ok(output)
diff --git a/src/tree/mod.rs b/src/tree/mod.rs
index 334f60d..7b8dd6f 100644
--- a/src/tree/mod.rs
+++ b/src/tree/mod.rs
@@ -2,8 +2,8 @@ pub(crate) mod abstract_pheno_tree;
 pub(crate) mod btree_node_repository;
 mod error;
 pub mod node;
-pub mod node_repository;
 pub mod pointer;
+pub mod querying;
 mod scopes;
 pub mod traits;
 pub(crate) mod utils;
diff --git a/src/tree/node.rs b/src/tree/node.rs
index 5bbcfc8..1f4e1ec 100644
--- a/src/tree/node.rs
+++ b/src/tree/node.rs
@@ -38,15 +38,16 @@ impl LocatableNode for DynamicNode {
     }
 }
 
-pub struct MaterializedNode<T> {
-    pub inner: T,
+#[derive(Clone, Debug)]
+pub struct MaterializedNode<NodeType> {
+    pub inner: NodeType,
     spans: HashMap<Pointer, Range<usize>>,
     pointer: Pointer,
 }
 
-impl<T> MaterializedNode<T> {
+impl<NodeType> MaterializedNode<NodeType> {
     pub fn new(
-        materialized_node: T,
+        materialized_node: NodeType,
         spans: HashMap<Pointer, Range<usize>>,
         pointer: Pointer,
     ) -> Self {
@@ -57,7 +58,7 @@ impl<T> MaterializedNode<T> {
         }
     }
 
-    pub(crate) fn from_dynamic(materialized: T, dyn_node: &DynamicNode) -> Self {
+    pub(crate) fn from_dynamic(materialized: NodeType, dyn_node: &DynamicNode) -> Self {
         Self::new(
             materialized,
             dyn_node.spans.clone(),
@@ -71,7 +72,7 @@ impl<T> MaterializedNode<T> {
     }
 }
 
-impl<T: Serialize> RetrievableNode for MaterializedNode<T> {
+impl<NodeType: Serialize> RetrievableNode for MaterializedNode<NodeType> {
     fn value_at(&self, ptr: &Pointer) -> Option<Cow<'_, Value>> {
         let node_opt = serde_json::to_value(&self.inner).ok()?;
         let value = node_opt.pointer(ptr.position())?.clone();
@@ -79,7 +80,7 @@ impl<T: Serialize> RetrievableNode for MaterializedNode<T> {
     }
 }
 
-impl<T> LocatableNode for MaterializedNode<T> {
+impl<NodeType> LocatableNode for MaterializedNode<NodeType> {
     fn span_at(&self, ptr: &Pointer) -> Option<&Range<usize>> {
         self.spans.get(ptr)
     }
diff --git a/src/tree/node_repository.rs b/src/tree/node_repository.rs
deleted file mode 100644
index d1eeac2..0000000
--- a/src/tree/node_repository.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-use crate::rules::traits::LintData;
-use crate::tree::node::MaterializedNode;
-use crate::tree::pointer::Pointer;
-use crate::tree::traits::LocatableNode;
-
-use std::any::{Any, TypeId};
-use std::collections::HashMap;
-use std::ops::Deref;
-
-#[derive(Default)]
-pub struct NodeRepository {
-    board: HashMap<TypeId, Box<dyn Any>>,
-}
-
-impl NodeRepository {
-    pub fn new() -> NodeRepository {
-        NodeRepository {
-            board: HashMap::new(),
-        }
-    }
-
-    fn get_raw<T: 'static>(&self) -> &[MaterializedNode<T>] {
-        self.board
-            .get(&TypeId::of::<T>())
-            .and_then(|b| b.downcast_ref::<Vec<MaterializedNode<T>>>())
-            .map(|v| v.as_slice())
-            .unwrap_or(&[])
-    }
-
-    pub fn insert<T: 'static>(&mut self, node: MaterializedNode<T>) {
-        self.board
-            .entry(TypeId::of::<T>())
-            .or_insert_with(|| Box::new(Vec::<MaterializedNode<T>>::new()))
-            .downcast_mut::<Vec<MaterializedNode<T>>>()
-            .unwrap()
-            .push(node);
-    }
-
-    pub fn node_by_pointer<T: 'static>(&self, ptr: &Pointer) -> Option<&MaterializedNode<T>> {
-        for nodes in self.board.values() {
-            let casted_node = nodes
-                .downcast_ref::<Vec<MaterializedNode<T>>>()
-                .expect("Should be downcastable");
-
-            for node in casted_node.iter() {
-                if node.pointer() == ptr {
-                    return Some(node);
-                }
-            }
-        }
-        None
-    }
-}
-
-pub struct Single<'a, T: 'static>(pub Option<&'a MaterializedNode<T>>);
-
-impl<'a, T> LintData<'a> for Single<'a, T> {
-    fn fetch(board: &'a NodeRepository) -> Self {
-        Single(board.get_raw::<T>().first())
-    }
-}
-
-pub struct List<'a, T: 'static>(pub &'a [MaterializedNode<T>]);
-
-impl<'a, T> Deref for List<'a, T> {
-    type Target = &'a [MaterializedNode<T>];
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl<'a, T> LintData<'a> for List<'a, T> {
-    fn fetch(board: &'a NodeRepository) -> Self {
-        List(board.get_raw())
-    }
-}
-
-impl<'a, A, B> LintData<'a> for (A, B)
-where
-    A: LintData<'a>,
-    B: LintData<'a>,
-{
-    fn fetch(board: &'a NodeRepository) -> Self {
-        (A::fetch(board), B::fetch(board))
-    }
-}
-
-impl<'a, A, B, C> LintData<'a> for (A, B, C)
-where
-    A: LintData<'a>,
-    B: LintData<'a>,
-    C: LintData<'a>,
-{
-    fn fetch(board: &'a NodeRepository) -> Self {
-        (A::fetch(board), B::fetch(board), C::fetch(board))
-    }
-}
diff --git a/src/tree/querying/mod.rs b/src/tree/querying/mod.rs
new file mode 100644
index 0000000..6bf3045
--- /dev/null
+++ b/src/tree/querying/mod.rs
@@ -0,0 +1,3 @@
+pub mod presentation;
+pub mod queries;
+pub mod traits;
diff --git a/src/tree/querying/presentation.rs b/src/tree/querying/presentation.rs
new file mode 100644
index 0000000..53f3528
--- /dev/null
+++ b/src/tree/querying/presentation.rs
@@ -0,0 +1,71 @@
+use crate::tree::node::MaterializedNode;
+use crate::tree::querying::traits::QueryPresentation;
+use std::ops::Deref;
+
+pub struct Flattened<NodeType>(pub Vec<MaterializedNode<NodeType>>);
+
+impl<NodeType> Deref for Flattened<NodeType> {
+    type Target = Vec<MaterializedNode<NodeType>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<NodeType> QueryPresentation<Vec<MaterializedNode<NodeType>>> for Flattened<NodeType> {
+    fn present(query_res: Vec<MaterializedNode<NodeType>>) -> Self {
+        Flattened(query_res)
+    }
+}
+
+impl<NodeType> QueryPresentation<Vec<Vec<MaterializedNode<NodeType>>>> for Flattened<NodeType> {
+    fn present(query_res: Vec<Vec<MaterializedNode<NodeType>>>) -> Self {
+        Flattened(query_res.into_iter().flatten().collect())
+    }
+}
+
+pub struct First<NodeType>(pub Option<MaterializedNode<NodeType>>);
+
+impl<NodeType> Deref for First<NodeType> {
+    type Target = Option<MaterializedNode<NodeType>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<NodeType: Clone> QueryPresentation<Vec<MaterializedNode<NodeType>>> for First<NodeType> {
+    fn present(query_res: Vec<MaterializedNode<NodeType>>) -> Self {
+        First(query_res.first().cloned())
+    }
+}
+
+impl<NodeType: Clone> QueryPresentation<Vec<Vec<MaterializedNode<NodeType>>>> for First<NodeType> {
+    fn present(query_res: Vec<Vec<MaterializedNode<NodeType>>>) -> Self {
+        for i in query_res {
+            if let Some(j) = i.into_iter().next() {
+                return First(Some(j));
+            }
+        }
+
+        First(None)
+    }
+}
+
+pub struct Grouped<NodeType>(pub Vec<Vec<MaterializedNode<NodeType>>>);
+
+impl<NodeType> Deref for Grouped<NodeType> {
+    type Target = Vec<Vec<MaterializedNode<NodeType>>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<NodeType: Clone> QueryPresentation<Vec<Vec<MaterializedNode<NodeType>>>>
+    for Grouped<NodeType>
+{
+    fn present(query_res: Vec<Vec<MaterializedNode<NodeType>>>) -> Self {
+        Grouped(query_res)
+    }
+}
diff --git a/src/tree/querying/queries.rs b/src/tree/querying/queries.rs
new file mode 100644
index 0000000..b7e91b0
--- /dev/null
+++ b/src/tree/querying/queries.rs
@@ -0,0 +1,128 @@
+use crate::tree::node::MaterializedNode;
+
+use crate::tree::traits::NodeRepository;
+
+use crate::tree::querying::traits::{QueryPresentation, QueryStrategy, ScopeDefinition};
+use std::marker::PhantomData;
+
+#[derive(Debug)]
+pub struct QueryAllNodes<NodeType, Presentation>(PhantomData<(Presentation, NodeType)>);
+
+impl<NodeType: Clone + 'static, Presentation: QueryPresentation<Vec<MaterializedNode<NodeType>>>>
+    QueryStrategy for QueryAllNodes<NodeType, Presentation>
+{
+    type Output = Presentation;
+    fn query(node_repo: &impl NodeRepository) -> Self::Output {
+        Presentation::present(node_repo.get_all::<NodeType>().unwrap_or_default())
+    }
+}
+#[derive(Debug)]
+pub struct QueryNodesInScope<Scope: ScopeDefinition, NodeType, Presentation>(
+    PhantomData<(Scope, Presentation, NodeType)>,
+);
+
+impl<
+    Scope: ScopeDefinition,
+    NodeType: Clone + 'static,
+    Presentation: QueryPresentation<Vec<MaterializedNode<NodeType>>>,
+> QueryStrategy for QueryNodesInScope<Scope, NodeType, Presentation>
+{
+    type Output = Presentation;
+    fn query(node_repo: &impl NodeRepository) -> Self::Output {
+        let query_result = node_repo
+            .get_nodes_in_scope::<NodeType>(Scope::layer())
+            .unwrap_or_default();
+
+        Presentation::present(query_result)
+    }
+}
+
+#[derive(Debug)]
+pub struct QueryGroupedNodes<Scope: ScopeDefinition, NodeType, Presentation>(
+    PhantomData<(Scope, Presentation, NodeType)>,
+);
+
+impl<
+    Scope: ScopeDefinition,
+    NodeType: Clone + 'static,
+    Presentation: QueryPresentation<Vec<Vec<MaterializedNode<NodeType>>>>,
+> QueryStrategy for QueryGroupedNodes<Scope, NodeType, Presentation>
+{
+    type Output = Presentation;
+    fn query(node_repo: &impl NodeRepository) -> Self::Output {
+        let query_result = node_repo
+            .get_nodes_for_scope_per_top_level_element::<NodeType>(Scope::layer())
+            .unwrap_or_default();
+
+        Presentation::present(query_result)
+    }
+}
+
+pub mod convenience {
+    use crate::tree::querying::presentation::{First, Flattened, Grouped};
+    use crate::tree::querying::queries::{QueryAllNodes, QueryGroupedNodes, QueryNodesInScope};
+    use phenopackets::schema::v2::Phenopacket;
+
+    // More to be added.
+    pub type All<NodeType> = QueryAllNodes<NodeType, Flattened<NodeType>>;
+    pub type GroupedIndividuals<NodeType> =
+        QueryGroupedNodes<Phenopacket, NodeType, Grouped<NodeType>>;
+    pub type SingleInScope<Scope, NodeType> = QueryNodesInScope<Scope, NodeType, First<NodeType>>;
+}
+
+mod temp_test {
+    #![allow(dead_code)]
+    #![allow(unused)]
+    // Testing and see how it would work from here:
+
+    use crate::tree::querying::presentation::{First, Flattened};
+    use crate::tree::querying::queries::convenience::{All, GroupedIndividuals, SingleInScope};
+    use crate::tree::querying::queries::{QueryAllNodes, QueryNodesInScope};
+    use crate::tree::querying::traits::QueryStrategy;
+    use phenopackets::schema::v2::Phenopacket;
+    use phenopackets::schema::v2::core::{OntologyClass, PhenotypicFeature};
+
+    trait TheRuleTrait {
+        type Query: QueryStrategy;
+
+        fn check_erased(&'_ self, board: <Self::Query as QueryStrategy>::Output) -> bool;
+    }
+
+    struct __RuleImplementation1;
+
+    impl TheRuleTrait for __RuleImplementation1 {
+        type Query = (
+            QueryNodesInScope<Phenopacket, OntologyClass, First<OntologyClass>>,
+            QueryAllNodes<OntologyClass, Flattened<OntologyClass>>,
+        );
+
+        fn check_erased(&'_ self, board: <Self::Query as QueryStrategy>::Output) -> bool {
+            todo!()
+        }
+    }
+
+    struct __RuleImplementation2;
+
+    impl TheRuleTrait for __RuleImplementation2 {
+        type Query = (
+            All<OntologyClass>,
+            SingleInScope<Phenopacket, OntologyClass>,
+            GroupedIndividuals<PhenotypicFeature>,
+        );
+
+        fn check_erased(&self, board: <Self::Query as QueryStrategy>::Output) -> bool {
+            let a = board;
+            todo!()
+        }
+    }
+
+    struct __RuleImplementation3;
+
+    impl TheRuleTrait for __RuleImplementation3 {
+        type Query = GroupedIndividuals<OntologyClass>;
+
+        fn check_erased(&self, board: <Self::Query as QueryStrategy>::Output) -> bool {
+            todo!()
+        }
+    }
+}
diff --git a/src/tree/querying/traits.rs b/src/tree/querying/traits.rs
new file mode 100644
index 0000000..3bfbc14
--- /dev/null
+++ b/src/tree/querying/traits.rs
@@ -0,0 +1,55 @@
+use crate::tree::scopes::ScopeLayer;
+use crate::tree::traits::NodeRepository;
+
+pub trait QueryStrategy {
+    type Output;
+    #[allow(unused)]
+    fn query(node_repo: &impl NodeRepository) -> Self::Output;
+}
+
+macro_rules! impl_query_strategy_tuple {
+    () => {
+        impl QueryStrategy for () {
+            type Output = ();
+            fn query(_node_repo: &impl NodeRepository) -> Self::Output {
+
+            }
+        }
+    };
+
+    ($head:ident $(, $tail:ident)*) => {
+        impl_query_strategy_tuple!($($tail),*);
+
+        impl<$head, $($tail),*> QueryStrategy for ($head, $($tail,)*)
+        where
+            $head: QueryStrategy,
+            $($tail: QueryStrategy),*
+        {
+            type Output = ($head::Output, $($tail::Output,)*);
+
+            fn query(node_repo: &impl NodeRepository) -> Self::Output {
+                (
+                    $head::query(node_repo),
+                    $($tail::query(node_repo),)*
+                )
+            }
+        }
+    };
+}
+
+impl_query_strategy_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12);
+
+#[allow(unused)]
+pub(crate) trait QueryPresentation<Input> {
+    fn present(query_res: Input) -> Self
+    where
+        Self: Sized;
+}
+
+pub trait ScopeDefinition {
+    fn layer() -> ScopeLayer;
+
+    fn partitioning_fields() -> &'static [&'static str] {
+        &[]
+    }
+}
diff --git a/src/tree/scopes.rs b/src/tree/scopes.rs
index bdf12f2..663215d 100644
--- a/src/tree/scopes.rs
+++ b/src/tree/scopes.rs
@@ -1,23 +1,16 @@
 use crate::tree::pointer::Pointer;
+use crate::tree::querying::traits::ScopeDefinition;
 use phenopackets::schema::v2::{Cohort, Family, Phenopacket};
 use std::any::TypeId;
 use std::cell::Cell;
 use std::collections::HashMap;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub(crate) enum ScopeLayer {
+pub enum ScopeLayer {
     Individual = 0,
     Aggregated = 1,
 }
 
-pub(crate) trait ScopeDefinition {
-    fn layer() -> ScopeLayer;
-
-    fn partitioning_fields() -> &'static [&'static str] {
-        &[]
-    }
-}
-
 impl ScopeDefinition for Phenopacket {
     fn layer() -> ScopeLayer {
         ScopeLayer::Individual
@@ -61,11 +54,11 @@ impl ScopeMappings {
         scope_map
     }
 
-    fn register<T: ScopeDefinition + 'static>(&mut self) {
-        let type_id = TypeId::of::<T>();
-        self.scope_by_type_id.insert(type_id, T::layer());
+    fn register<NodeType: ScopeDefinition + 'static>(&mut self) {
+        let type_id = TypeId::of::<NodeType>();
+        self.scope_by_type_id.insert(type_id, NodeType::layer());
 
-        for b_field in T::partitioning_fields() {
+        for b_field in NodeType::partitioning_fields() {
             self.boundaries.insert(b_field, type_id);
         }
     }
diff --git a/src/tree/traits.rs b/src/tree/traits.rs
index 1a3fc7e..8d9e203 100644
--- a/src/tree/traits.rs
+++ b/src/tree/traits.rs
@@ -20,7 +20,7 @@ pub trait RetrievableNode {
     fn value_at(&self, ptr: &Pointer) -> Option<Cow<'_, Value>>;
 }
 
-pub(crate) trait NodeRepository {
+pub trait NodeRepository {
     fn insert<T: 'static + Clone>(
         &mut self,
         node: MaterializedNode<T>,
diff --git a/tests/test_custom_rule.rs b/tests/test_custom_rule.rs
index 297f386..d7fc003 100644
--- a/tests/test_custom_rule.rs
+++ b/tests/test_custom_rule.rs
@@ -18,8 +18,9 @@ use phenolint::report::specs::{LabelSpecs, ReportSpecs};
 use phenolint::report::traits::{CompileReport, RegisterableReport, ReportFromContext, RuleReport};
 use phenolint::rules::traits::LintRule;
 use phenolint::rules::traits::{RuleCheck, RuleFromContext};
-use phenolint::tree::node_repository::List;
 use phenolint::tree::pointer::Pointer;
+use phenolint::tree::querying::presentation::Flattened;
+use phenolint::tree::querying::queries::convenience::All;
 use phenolint::tree::traits::Node;
 use phenolint_macros::{register_patch, register_report, register_rule};
 use phenopackets::schema::v2::Phenopacket;
@@ -43,9 +44,9 @@ impl RuleFromContext for CustomRule {
 }
 
 impl RuleCheck for CustomRule {
-    type Data<'a> = List<'a, OntologyClass>;
+    type Query = All<OntologyClass>;
 
-    fn check(&self, _: Self::Data<'_>) -> Vec<LintViolation> {
+    fn check(&self, _: Flattened<OntologyClass>) -> Vec<LintViolation> {
         vec![LintViolation::new(
             ViolationSeverity::Info,
             LintRule::rule_id(self),