diff --git a/gen/src/namespace_organizer.rs b/gen/src/namespace_organizer.rs
index aaf0722..b4c8a93 100644
--- a/gen/src/namespace_organizer.rs
+++ b/gen/src/namespace_organizer.rs
@@ -4,8 +4,8 @@
 use std::iter::FromIterator;
 
 pub struct NamespaceEntries<'a> {
-    entries: Vec<&'a Api>,
-    children: BTreeMap<&'a Ident, NamespaceEntries<'a>>,
+    direct: Vec<&'a Api>,
+    nested: BTreeMap<&'a Ident, NamespaceEntries<'a>>,
 }
 
 impl<'a> NamespaceEntries<'a> {
@@ -14,18 +14,18 @@
         Self::sort_by_inner_namespace(api_refs, 0)
     }
 
-    pub fn entries(&self) -> &[&'a Api] {
-        &self.entries
+    pub fn direct_content(&self) -> &[&'a Api] {
+        &self.direct
     }
 
-    pub fn children(&self) -> impl Iterator<Item = (&Ident, &NamespaceEntries)> {
-        self.children.iter().map(|(k, entries)| (*k, entries))
+    pub fn nested_content(&self) -> impl Iterator<Item = (&Ident, &NamespaceEntries)> {
+        self.nested.iter().map(|(k, entries)| (*k, entries))
     }
 
     fn sort_by_inner_namespace(apis: Vec<&'a Api>, depth: usize) -> Self {
         let mut root = NamespaceEntries {
-            entries: Vec::new(),
-            children: BTreeMap::new(),
+            direct: Vec::new(),
+            nested: BTreeMap::new(),
         };
 
         let mut kids_by_child_ns = BTreeMap::new();
@@ -38,11 +38,11 @@
                     continue;
                 }
             }
-            root.entries.push(api);
+            root.direct.push(api);
         }
 
         for (k, v) in kids_by_child_ns.into_iter() {
-            root.children
+            root.nested
                 .insert(k, Self::sort_by_inner_namespace(v, depth + 1));
         }
 
@@ -73,32 +73,32 @@
             make_api(Some("D"), "J"),
         ];
         let ns = NamespaceEntries::new(&entries);
-        let root_entries = ns.entries();
+        let root_entries = ns.direct_content();
         assert_eq!(root_entries.len(), 3);
         assert_ident(root_entries[0], "C");
         assert_ident(root_entries[1], "A");
         assert_ident(root_entries[2], "B");
-        let mut kids = ns.children();
+        let mut kids = ns.nested_content();
         let (d_id, d_nse) = kids.next().unwrap();
         assert_eq!(d_id.to_string(), "D");
         let (g_id, g_nse) = kids.next().unwrap();
         assert_eq!(g_id.to_string(), "G");
         assert!(kids.next().is_none());
-        let d_nse_entries = d_nse.entries();
+        let d_nse_entries = d_nse.direct_content();
         assert_eq!(d_nse_entries.len(), 3);
         assert_ident(d_nse_entries[0], "F");
         assert_ident(d_nse_entries[1], "I");
         assert_ident(d_nse_entries[2], "J");
-        let g_nse_entries = g_nse.entries();
+        let g_nse_entries = g_nse.direct_content();
         assert_eq!(g_nse_entries.len(), 2);
         assert_ident(g_nse_entries[0], "E");
         assert_ident(g_nse_entries[1], "H");
-        let mut g_kids = g_nse.children();
+        let mut g_kids = g_nse.nested_content();
         assert!(g_kids.next().is_none());
-        let mut d_kids = d_nse.children();
+        let mut d_kids = d_nse.nested_content();
         let (k_id, k_nse) = d_kids.next().unwrap();
         assert_eq!(k_id.to_string(), "K");
-        let k_nse_entries = k_nse.entries();
+        let k_nse_entries = k_nse.direct_content();
         assert_eq!(k_nse_entries.len(), 2);
         assert_ident(k_nse_entries[0], "L");
         assert_ident(k_nse_entries[1], "M");
diff --git a/gen/src/write.rs b/gen/src/write.rs
index 7c6d098..5ca3dc5 100644
--- a/gen/src/write.rs
+++ b/gen/src/write.rs
@@ -37,7 +37,7 @@
 }
 
 fn gen_namespace_forward_declarations(out: &mut OutFile, ns_entries: &NamespaceEntries) {
-    let apis = ns_entries.entries();
+    let apis = ns_entries.direct_content();
 
     for api in apis {
         match api {
@@ -49,7 +49,7 @@
         }
     }
 
-    for (child_ns, child_ns_entries) in ns_entries.children() {
+    for (child_ns, child_ns_entries) in ns_entries.nested_content() {
         writeln!(out, "namespace {} {{", child_ns);
         gen_namespace_forward_declarations(out, child_ns_entries);
         writeln!(out, "}} // namespace {}", child_ns);
@@ -57,7 +57,7 @@
 }
 
 fn gen_namespace_contents(out: &mut OutFile, ns_entries: &NamespaceEntries, opt: &Opt) {
-    let apis = ns_entries.entries();
+    let apis = ns_entries.direct_content();
 
     let mut methods_for_type = HashMap::new();
     for api in apis {
@@ -128,7 +128,7 @@
         }
     }
 
-    for (child_ns, child_ns_entries) in ns_entries.children() {
+    for (child_ns, child_ns_entries) in ns_entries.nested_content() {
         let block = format!("namespace {}", child_ns);
         out.begin_block(&block);
         gen_namespace_contents(out, child_ns_entries, opt);