diff --git a/README.md b/README.md
index e88ecf0..3107a83 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # cs2-dumper
 
-An external offset/interface dumper for Counter-Strike 2, with support for both Windows & Linux.
+An external offset/interface dumper for Counter-Strike 2, with support for both Windows & Linux (soon).
 
 Powered by [memflow](https://github.com/memflow/memflow).
 
@@ -21,11 +21,12 @@ E.g. `./cs2-dumper -c pcileech -a device=fpga -vvv`
 
 ### Available Arguments
 
-- `-v...`: Increase logging verbosity. Can be specified multiple times.
 - `-c, --connector <connector>`: The name of the memflow connector to use.
-- `-a, --connector-args <connector-args>`: Additional arguments to supply to the connector.
+- `-a, --connector-args <connector-args>`: Additional arguments to pass to the connector.
+- `-f, --file-types <file-types>`: The types of files to generate. Default: `cs`, `hpp`,  `json`, `rs`.
 - `-o, --output <output>`: The output directory to write the generated files to. Default: `output`.
 - `-i, --indent-size <indent-size>`: The number of spaces to use per indentation level. Default: `4`.
+- `-v...`: Increase logging verbosity. Can be specified multiple times.
 - `-h, --help`: Print help.
 - `-V, --version`: Print version.
 
diff --git a/src/analysis/buttons.rs b/src/analysis/buttons.rs
index 2eb6689..5fc577b 100644
--- a/src/analysis/buttons.rs
+++ b/src/analysis/buttons.rs
@@ -10,7 +10,6 @@ use serde::{Deserialize, Serialize};
 use crate::error::{Error, Result};
 use crate::source2::KeyButton;
 
-/// Represents a keyboard button.
 #[derive(Debug, Deserialize, Serialize)]
 pub struct Button {
     pub name: String,
diff --git a/src/analysis/interfaces.rs b/src/analysis/interfaces.rs
index 6e12b8f..bbe5ccf 100644
--- a/src/analysis/interfaces.rs
+++ b/src/analysis/interfaces.rs
@@ -14,7 +14,6 @@ use crate::source2::InterfaceReg;
 
 pub type InterfaceMap = BTreeMap<String, Vec<Interface>>;
 
-/// Represents an exposed interface.
 #[derive(Debug, Deserialize, Serialize)]
 pub struct Interface {
     pub name: String,
diff --git a/src/analysis/mod.rs b/src/analysis/mod.rs
index 56793a9..619bef9 100644
--- a/src/analysis/mod.rs
+++ b/src/analysis/mod.rs
@@ -3,7 +3,33 @@ pub use interfaces::*;
 pub use offsets::*;
 pub use schemas::*;
 
-pub mod buttons;
-pub mod interfaces;
-pub mod offsets;
-pub mod schemas;
+use memflow::prelude::v1::*;
+
+use crate::error::Result;
+
+mod buttons;
+mod interfaces;
+mod offsets;
+mod schemas;
+
+#[derive(Debug)]
+pub struct AnalysisResult {
+    pub buttons: Vec<Button>,
+    pub interfaces: InterfaceMap,
+    pub offsets: OffsetMap,
+    pub schemas: SchemaMap,
+}
+
+pub fn analyze_all(process: &mut IntoProcessInstanceArcBox<'_>) -> Result<AnalysisResult> {
+    let buttons = buttons(process)?;
+    let interfaces = interfaces(process)?;
+    let offsets = offsets(process)?;
+    let schemas = schemas(process)?;
+
+    Ok(AnalysisResult {
+        buttons,
+        interfaces,
+        offsets,
+        schemas,
+    })
+}
diff --git a/src/analysis/offsets.rs b/src/analysis/offsets.rs
index 6c5bbe4..7599743 100644
--- a/src/analysis/offsets.rs
+++ b/src/analysis/offsets.rs
@@ -98,9 +98,9 @@ pattern_map! {
         "dwNetworkGameClient" => pattern!("48893d${'} 488d15") => None,
         "dwNetworkGameClient_deltaTick" => pattern!("8983u4 40b7") => None,
         "dwNetworkGameClient_getLocalPlayer" => pattern!("4883c0u1 488d0440 458b04c7") => Some(|_view, map, rva| {
-            // .text 48 83 C0 0A   add rax, 0Ah
-            // .text 48 8D 04 40   lea rax, [rax+rax*2]
-            // .text 45 8B 04 C7   mov r8d, [r15+rax*8]
+            // .text 48 83 C0 0A | add rax, 0Ah
+            // .text 48 8D 04 40 | lea rax, [rax + rax * 2]
+            // .text 45 8B 04 C7 | mov r8d, [r15 + rax * 8]
             map.insert("dwNetworkGameClient_getLocalPlayer".to_string(), (rva + (rva * 2)) * 8);
         }),
         "dwNetworkGameClient_getMaxClients" => pattern!("8b81u2?? c3cccccccccccccccccc 8b81${} ffc0") => None,
diff --git a/src/analysis/schemas.rs b/src/analysis/schemas.rs
index 33a2ef2..a2d2433 100644
--- a/src/analysis/schemas.rs
+++ b/src/analysis/schemas.rs
@@ -15,14 +15,14 @@ use crate::source2::*;
 
 pub type SchemaMap = BTreeMap<String, (Vec<Class>, Vec<Enum>)>;
 
-#[derive(Clone, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub enum ClassMetadata {
     Unknown { name: String },
     NetworkChangeCallback { name: String },
     NetworkVarNames { name: String, type_name: String },
 }
 
-#[derive(Clone, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Class {
     pub name: String,
     pub module_name: String,
@@ -31,14 +31,14 @@ pub struct Class {
     pub fields: Vec<ClassField>,
 }
 
-#[derive(Clone, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct ClassField {
     pub name: String,
     pub type_name: String,
     pub offset: i32,
 }
 
-#[derive(Clone, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Enum {
     pub name: String,
     pub alignment: u8,
@@ -46,13 +46,13 @@ pub struct Enum {
     pub members: Vec<EnumMember>,
 }
 
-#[derive(Clone, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct EnumMember {
     pub name: String,
     pub value: i64,
 }
 
-#[derive(Clone, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct TypeScope {
     pub module_name: String,
     pub classes: Vec<Class>,
@@ -63,7 +63,7 @@ pub fn schemas(process: &mut IntoProcessInstanceArcBox<'_>) -> Result<SchemaMap>
     let schema_system = read_schema_system(process)?;
     let type_scopes = read_type_scopes(process, &schema_system)?;
 
-    let map: BTreeMap<_, _> = type_scopes
+    let map = type_scopes
         .into_iter()
         .map(|type_scope| {
             (
@@ -134,10 +134,10 @@ fn read_class_binding_fields(
         }
 
         let name = field.name.read_string(process)?.to_string();
-        let type_ = field.schema_type.read(process)?;
+        let schema_type = field.schema_type.read(process)?;
 
         // TODO: Parse this properly.
-        let type_name = type_.name.read_string(process)?.replace(" ", "");
+        let type_name = schema_type.name.read_string(process)?.replace(" ", "");
 
         acc.push(ClassField {
             name,
diff --git a/src/main.rs b/src/main.rs
index ebbaf36..68d4bc8 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,3 @@
-use std::env;
 use std::path::PathBuf;
 use std::time::Instant;
 
@@ -11,7 +10,7 @@ use memflow::prelude::v1::*;
 use simplelog::{ColorChoice, TermLogger};
 
 use error::Result;
-use output::Results;
+use output::Output;
 
 mod analysis;
 mod error;
@@ -22,10 +21,10 @@ mod source2;
 const PROCESS_NAME: &str = "cs2.exe";
 
 fn main() -> Result<()> {
-    let start_time = Instant::now();
+    let now = Instant::now();
 
     let matches = parse_args();
-    let (conn_name, conn_args, indent_size, out_dir) = extract_args(&matches)?;
+    let (conn_name, conn_args, file_types, indent_size, out_dir) = extract_args(&matches)?;
 
     let os = if let Some(conn_name) = conn_name {
         let inventory = Inventory::scan();
@@ -37,22 +36,18 @@ fn main() -> Result<()> {
             .os("win32")
             .build()?
     } else {
-        // Fallback to the native OS layer if no connector name was provided.
+        // Fallback to the native OS layer if no connector name was specified.
         memflow_native::create_os(&Default::default(), Default::default())?
     };
 
     let mut process = os.into_process_by_name(PROCESS_NAME)?;
 
-    let buttons = analysis::buttons(&mut process)?;
-    let interfaces = analysis::interfaces(&mut process)?;
-    let offsets = analysis::offsets(&mut process)?;
-    let schemas = analysis::schemas(&mut process)?;
+    let result = analysis::analyze_all(&mut process)?;
+    let output = Output::new(&file_types, indent_size, &out_dir, &result)?;
 
-    let results = Results::new(buttons, interfaces, offsets, schemas);
+    output.dump_all(&mut process)?;
 
-    results.dump_all(&mut process, &out_dir, indent_size)?;
-
-    info!("finished in {:?}", start_time.elapsed());
+    info!("finished in {:?}", now.elapsed());
 
     Ok(())
 }
@@ -61,12 +56,6 @@ fn parse_args() -> ArgMatches {
     Command::new("cs2-dumper")
         .version(crate_version!())
         .author(crate_authors!())
-        .arg(
-            Arg::new("verbose")
-                .help("Increase logging verbosity. Can be specified multiple times.")
-                .short('v')
-                .action(ArgAction::Count),
-        )
         .arg(
             Arg::new("connector")
                 .help("The name of the memflow connector to use.")
@@ -76,11 +65,31 @@ fn parse_args() -> ArgMatches {
         )
         .arg(
             Arg::new("connector-args")
-                .help("Additional arguments to supply to the connector.")
+                .help("Additional arguments to pass to the connector.")
                 .long("connector-args")
                 .short('a')
                 .required(false),
         )
+        .arg(
+            Arg::new("file-types")
+                .help("The types of files to generate.")
+                .long("file-types")
+                .short('f')
+                .action(ArgAction::Append)
+                .default_values(["cs", "hpp", "json", "rs"])
+                .value_parser(["cs", "hpp", "json", "rs"])
+                .value_delimiter(',')
+                .required(false),
+        )
+        .arg(
+            Arg::new("indent-size")
+                .help("The number of spaces to use per indentation level.")
+                .long("indent-size")
+                .short('i')
+                .default_value("4")
+                .value_parser(value_parser!(usize))
+                .required(false),
+        )
         .arg(
             Arg::new("output")
                 .help("The output directory to write the generated files to.")
@@ -91,18 +100,17 @@ fn parse_args() -> ArgMatches {
                 .required(false),
         )
         .arg(
-            Arg::new("indent-size")
-                .help("The number of spaces to use per indentation level.")
-                .long("indent-size")
-                .short('i')
-                .default_value("4")
-                .value_parser(value_parser!(usize))
-                .required(false),
+            Arg::new("verbose")
+                .help("Increase logging verbosity. Can be specified multiple times.")
+                .short('v')
+                .action(ArgAction::Count),
         )
         .get_matches()
 }
 
-fn extract_args(matches: &ArgMatches) -> Result<(Option<String>, ConnectorArgs, usize, &PathBuf)> {
+fn extract_args(
+    matches: &ArgMatches,
+) -> Result<(Option<String>, ConnectorArgs, Vec<String>, usize, &PathBuf)> {
     use std::str::FromStr;
 
     let log_level = match matches.get_count("verbose") {
@@ -131,8 +139,14 @@ fn extract_args(matches: &ArgMatches) -> Result<(Option<String>, ConnectorArgs,
         .map(|s| ConnectorArgs::from_str(&s).expect("unable to parse connector arguments"))
         .unwrap_or_default();
 
+    let file_types = matches
+        .get_many::<String>("file-types")
+        .unwrap()
+        .map(|s| s.to_string())
+        .collect();
+
     let indent_size = *matches.get_one::<usize>("indent-size").unwrap();
     let out_dir = matches.get_one::<PathBuf>("output").unwrap();
 
-    Ok((conn_name, conn_args, indent_size, out_dir))
+    Ok((conn_name, conn_args, file_types, indent_size, out_dir))
 }
diff --git a/src/output/buttons.rs b/src/output/buttons.rs
index d9f5bc4..f37953e 100644
--- a/src/output/buttons.rs
+++ b/src/output/buttons.rs
@@ -1,59 +1,49 @@
 use std::collections::BTreeMap;
-use std::fmt::Write;
+use std::fmt::{self, Write};
 
-use super::{Button, CodeGen, Results};
+use super::{Button, CodeWriter, Formatter};
 
-use crate::error::Result;
+impl CodeWriter for Vec<Button> {
+    fn write_cs(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        fmt.block("namespace CS2Dumper", false, |fmt| {
+            writeln!(fmt, "// Module: client.dll")?;
 
-impl CodeGen for Vec<Button> {
-    fn to_cs(&self, results: &Results, indent_size: usize) -> Result<String> {
-        self.write_content(results, indent_size, |fmt| {
-            fmt.block("namespace CS2Dumper", false, |fmt| {
-                writeln!(fmt, "// Module: client.dll")?;
+            fmt.block("public static class Buttons", false, |fmt| {
+                for button in self {
+                    writeln!(
+                        fmt,
+                        "public const nint {} = {:#X};",
+                        button.name, button.value
+                    )?;
+                }
 
-                fmt.block("public static class Buttons", false, |fmt| {
-                    for button in self {
-                        writeln!(
-                            fmt,
-                            "public const nint {} = {:#X};",
-                            button.name, button.value
-                        )?;
-                    }
-
-                    Ok(())
-                })
-            })?;
-
-            Ok(())
+                Ok(())
+            })
         })
     }
 
-    fn to_hpp(&self, results: &Results, indent_size: usize) -> Result<String> {
-        self.write_content(results, indent_size, |fmt| {
-            writeln!(fmt, "#pragma once\n")?;
-            writeln!(fmt, "#include <cstddef>\n")?;
+    fn write_hpp(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        writeln!(fmt, "#pragma once\n")?;
+        writeln!(fmt, "#include <cstddef>\n")?;
 
-            fmt.block("namespace cs2_dumper", false, |fmt| {
-                writeln!(fmt, "// Module: client.dll")?;
+        fmt.block("namespace cs2_dumper", false, |fmt| {
+            writeln!(fmt, "// Module: client.dll")?;
 
-                fmt.block("namespace buttons", false, |fmt| {
-                    for button in self {
-                        writeln!(
-                            fmt,
-                            "constexpr std::ptrdiff_t {} = {:#X};",
-                            button.name, button.value
-                        )?;
-                    }
+            fmt.block("namespace buttons", false, |fmt| {
+                for button in self {
+                    writeln!(
+                        fmt,
+                        "constexpr std::ptrdiff_t {} = {:#X};",
+                        button.name, button.value
+                    )?;
+                }
 
-                    Ok(())
-                })
-            })?;
-
-            Ok(())
+                Ok(())
+            })
         })
     }
 
-    fn to_json(&self, _results: &Results, _indent_size: usize) -> Result<String> {
+    fn write_json(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         let content = {
             let buttons: BTreeMap<_, _> = self
                 .iter()
@@ -63,35 +53,28 @@ impl CodeGen for Vec<Button> {
             BTreeMap::from_iter([("client.dll", buttons)])
         };
 
-        serde_json::to_string_pretty(&content).map_err(Into::into)
+        fmt.write_str(&serde_json::to_string_pretty(&content).expect("failed to serialize"))
     }
 
-    fn to_rs(&self, results: &Results, indent_size: usize) -> Result<String> {
-        self.write_content(results, indent_size, |fmt| {
-            writeln!(
-                fmt,
-                "#![allow(non_upper_case_globals, non_camel_case_types, unused)]\n"
-            )?;
+    fn write_rs(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        writeln!(fmt, "#![allow(non_upper_case_globals, unused)]\n")?;
 
-            fmt.block("pub mod cs2_dumper", false, |fmt| {
-                writeln!(fmt, "// Module: client.dll")?;
+        fmt.block("pub mod cs2_dumper", false, |fmt| {
+            writeln!(fmt, "// Module: client.dll")?;
 
-                fmt.block("pub mod buttons", false, |fmt| {
-                    for button in self {
-                        let mut name = button.name.clone();
+            fmt.block("pub mod buttons", false, |fmt| {
+                for button in self {
+                    let mut name = button.name.clone();
 
-                        if name == "use" {
-                            name = format!("r#{}", name);
-                        }
-
-                        writeln!(fmt, "pub const {}: usize = {:#X};", name, button.value)?;
+                    if name == "use" {
+                        name = format!("r#{}", name);
                     }
 
-                    Ok(())
-                })
-            })?;
+                    writeln!(fmt, "pub const {}: usize = {:#X};", name, button.value)?;
+                }
 
-            Ok(())
+                Ok(())
+            })
         })
     }
 }
diff --git a/src/output/formatter.rs b/src/output/formatter.rs
index 21623e6..04134fb 100644
--- a/src/output/formatter.rs
+++ b/src/output/formatter.rs
@@ -1,15 +1,9 @@
 use std::fmt::{self, Write};
 
-#[derive(Debug)]
 pub struct Formatter<'a> {
-    /// Write destination.
-    pub out: &'a mut String,
-
-    /// Number of spaces per indentation level.
-    pub indent_size: usize,
-
-    /// Current indentation level.
-    pub indent_level: usize,
+    out: &'a mut String,
+    indent_size: usize,
+    indent_level: usize,
 }
 
 impl<'a> Formatter<'a> {
@@ -34,17 +28,17 @@ impl<'a> Formatter<'a> {
         Ok(())
     }
 
-    pub fn indent<F, R>(&mut self, f: F) -> R
+    pub fn indent<F>(&mut self, f: F) -> fmt::Result
     where
-        F: FnOnce(&mut Self) -> R,
+        F: FnOnce(&mut Self) -> fmt::Result,
     {
         self.indent_level += 1;
 
-        let ret = f(self);
+        f(self)?;
 
         self.indent_level -= 1;
 
-        ret
+        Ok(())
     }
 
     #[inline]
diff --git a/src/output/interfaces.rs b/src/output/interfaces.rs
index 0587efd..d153de3 100644
--- a/src/output/interfaces.rs
+++ b/src/output/interfaces.rs
@@ -1,30 +1,54 @@
 use std::collections::BTreeMap;
-use std::fmt::Write;
+use std::fmt::{self, Write};
 
 use heck::{AsPascalCase, AsSnakeCase};
 
-use super::{CodeGen, InterfaceMap, Results};
+use super::{slugify, CodeWriter, Formatter, InterfaceMap};
 
-use crate::error::Result;
+impl CodeWriter for InterfaceMap {
+    fn write_cs(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        fmt.block("namespace CS2Dumper.Interfaces", false, |fmt| {
+            for (module_name, ifaces) in self {
+                writeln!(fmt, "// Module: {}", module_name)?;
 
-impl CodeGen for InterfaceMap {
-    fn to_cs(&self, results: &Results, indent_size: usize) -> Result<String> {
-        self.write_content(results, indent_size, |fmt| {
-            fmt.block("namespace CS2Dumper.Interfaces", false, |fmt| {
+                fmt.block(
+                    &format!("public static class {}", AsPascalCase(slugify(module_name))),
+                    false,
+                    |fmt| {
+                        for iface in ifaces {
+                            writeln!(
+                                fmt,
+                                "public const nint {} = {:#X};",
+                                iface.name, iface.value
+                            )?;
+                        }
+
+                        Ok(())
+                    },
+                )?;
+            }
+
+            Ok(())
+        })
+    }
+
+    fn write_hpp(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        writeln!(fmt, "#pragma once\n")?;
+        writeln!(fmt, "#include <cstddef>\n")?;
+
+        fmt.block("namespace cs2_dumper", false, |fmt| {
+            fmt.block("namespace interfaces", false, |fmt| {
                 for (module_name, ifaces) in self {
                     writeln!(fmt, "// Module: {}", module_name)?;
 
                     fmt.block(
-                        &format!(
-                            "public static class {}",
-                            AsPascalCase(Self::slugify(module_name))
-                        ),
+                        &format!("namespace {}", AsSnakeCase(slugify(module_name))),
                         false,
                         |fmt| {
                             for iface in ifaces {
                                 writeln!(
                                     fmt,
-                                    "public const nint {} = {:#X};",
+                                    "constexpr std::ptrdiff_t {} = {:#X};",
                                     iface.name, iface.value
                                 )?;
                             }
@@ -35,48 +59,11 @@ impl CodeGen for InterfaceMap {
                 }
 
                 Ok(())
-            })?;
-
-            Ok(())
+            })
         })
     }
 
-    fn to_hpp(&self, results: &Results, indent_size: usize) -> Result<String> {
-        self.write_content(results, indent_size, |fmt| {
-            writeln!(fmt, "#pragma once\n")?;
-            writeln!(fmt, "#include <cstddef>\n")?;
-
-            fmt.block("namespace cs2_dumper", false, |fmt| {
-                fmt.block("namespace interfaces", false, |fmt| {
-                    for (module_name, ifaces) in self {
-                        writeln!(fmt, "// Module: {}", module_name)?;
-
-                        fmt.block(
-                            &format!("namespace {}", AsSnakeCase(Self::slugify(module_name))),
-                            false,
-                            |fmt| {
-                                for iface in ifaces {
-                                    writeln!(
-                                        fmt,
-                                        "constexpr std::ptrdiff_t {} = {:#X};",
-                                        iface.name, iface.value
-                                    )?;
-                                }
-
-                                Ok(())
-                            },
-                        )?;
-                    }
-
-                    Ok(())
-                })
-            })?;
-
-            Ok(())
-        })
-    }
-
-    fn to_json(&self, _results: &Results, _indent_size: usize) -> Result<String> {
+    fn write_json(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         let content: BTreeMap<_, _> = self
             .iter()
             .map(|(module_name, ifaces)| {
@@ -89,43 +76,36 @@ impl CodeGen for InterfaceMap {
             })
             .collect();
 
-        serde_json::to_string_pretty(&content).map_err(Into::into)
+        fmt.write_str(&serde_json::to_string_pretty(&content).expect("failed to serialize"))
     }
 
-    fn to_rs(&self, results: &Results, indent_size: usize) -> Result<String> {
-        self.write_content(results, indent_size, |fmt| {
-            writeln!(
-                fmt,
-                "#![allow(non_upper_case_globals, non_camel_case_types, unused)]\n"
-            )?;
+    fn write_rs(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        writeln!(fmt, "#![allow(non_upper_case_globals, unused)]\n")?;
 
-            fmt.block("pub mod cs2_dumper", false, |fmt| {
-                fmt.block("pub mod interfaces", false, |fmt| {
-                    for (module_name, ifaces) in self {
-                        writeln!(fmt, "// Module: {}", module_name)?;
+        fmt.block("pub mod cs2_dumper", false, |fmt| {
+            fmt.block("pub mod interfaces", false, |fmt| {
+                for (module_name, ifaces) in self {
+                    writeln!(fmt, "// Module: {}", module_name)?;
 
-                        fmt.block(
-                            &format!("pub mod {}", AsSnakeCase(Self::slugify(module_name))),
-                            false,
-                            |fmt| {
-                                for iface in ifaces {
-                                    writeln!(
-                                        fmt,
-                                        "pub const {}: usize = {:#X};",
-                                        iface.name, iface.value
-                                    )?;
-                                }
+                    fmt.block(
+                        &format!("pub mod {}", AsSnakeCase(slugify(module_name))),
+                        false,
+                        |fmt| {
+                            for iface in ifaces {
+                                writeln!(
+                                    fmt,
+                                    "pub const {}: usize = {:#X};",
+                                    iface.name, iface.value
+                                )?;
+                            }
 
-                                Ok(())
-                            },
-                        )?;
-                    }
+                            Ok(())
+                        },
+                    )?;
+                }
 
-                    Ok(())
-                })
-            })?;
-
-            Ok(())
+                Ok(())
+            })
         })
     }
 }
diff --git a/src/output/mod.rs b/src/output/mod.rs
index 6d21049..01cee46 100644
--- a/src/output/mod.rs
+++ b/src/output/mod.rs
@@ -1,4 +1,4 @@
-use std::fmt::Write;
+use std::fmt::{self, Write};
 use std::fs;
 use std::path::Path;
 
@@ -6,7 +6,7 @@ use chrono::{DateTime, Utc};
 
 use memflow::prelude::v1::*;
 
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use serde_json::json;
 
 use formatter::Formatter;
@@ -30,216 +30,160 @@ enum Item<'a> {
 }
 
 impl<'a> Item<'a> {
-    fn generate(&self, results: &Results, indent_size: usize, file_ext: &str) -> Result<String> {
+    fn write(&self, fmt: &mut Formatter<'a>, file_ext: &str) -> fmt::Result {
         match file_ext {
-            "cs" => self.to_cs(results, indent_size),
-            "hpp" => self.to_hpp(results, indent_size),
-            "json" => self.to_json(results, indent_size),
-            "rs" => self.to_rs(results, indent_size),
-            _ => unreachable!(),
+            "cs" => self.write_cs(fmt),
+            "hpp" => self.write_hpp(fmt),
+            "json" => self.write_json(fmt),
+            "rs" => self.write_rs(fmt),
+            _ => unimplemented!(),
         }
     }
 }
 
-trait CodeGen {
-    fn to_cs(&self, results: &Results, indent_size: usize) -> Result<String>;
+trait CodeWriter {
+    fn write_cs(&self, fmt: &mut Formatter<'_>) -> fmt::Result;
 
-    fn to_hpp(&self, results: &Results, indent_size: usize) -> Result<String>;
+    fn write_hpp(&self, fmt: &mut Formatter<'_>) -> fmt::Result;
 
-    fn to_json(&self, results: &Results, indent_size: usize) -> Result<String>;
+    fn write_json(&self, fmt: &mut Formatter<'_>) -> fmt::Result;
 
-    fn to_rs(&self, results: &Results, indent_size: usize) -> Result<String>;
-
-    /// Replaces non-alphanumeric characters in a string with underscores.
-    #[inline]
-    fn slugify(input: &str) -> String {
-        input.replace(|c: char| !c.is_alphanumeric(), "_")
-    }
-
-    fn write_content<F>(&self, results: &Results, indent_size: usize, f: F) -> Result<String>
-    where
-        F: FnOnce(&mut Formatter<'_>) -> Result<()>,
-    {
-        let mut buf = String::new();
-        let mut fmt = Formatter::new(&mut buf, indent_size);
-
-        results.write_banner(&mut fmt)?;
-
-        f(&mut fmt)?;
-
-        Ok(buf)
-    }
+    fn write_rs(&self, fmt: &mut Formatter<'_>) -> fmt::Result;
 }
 
-impl<'a> CodeGen for Item<'a> {
-    fn to_cs(&self, results: &Results, indent_size: usize) -> Result<String> {
+impl<'a> CodeWriter for Item<'a> {
+    fn write_cs(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         match self {
-            Item::Buttons(buttons) => buttons.to_cs(results, indent_size),
-            Item::Interfaces(ifaces) => ifaces.to_cs(results, indent_size),
-            Item::Offsets(offsets) => offsets.to_cs(results, indent_size),
-            Item::Schemas(schemas) => schemas.to_cs(results, indent_size),
+            Item::Buttons(buttons) => buttons.write_cs(fmt),
+            Item::Interfaces(ifaces) => ifaces.write_cs(fmt),
+            Item::Offsets(offsets) => offsets.write_cs(fmt),
+            Item::Schemas(schemas) => schemas.write_cs(fmt),
         }
     }
 
-    fn to_hpp(&self, results: &Results, indent_size: usize) -> Result<String> {
+    fn write_hpp(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         match self {
-            Item::Buttons(buttons) => buttons.to_hpp(results, indent_size),
-            Item::Interfaces(ifaces) => ifaces.to_hpp(results, indent_size),
-            Item::Offsets(offsets) => offsets.to_hpp(results, indent_size),
-            Item::Schemas(schemas) => schemas.to_hpp(results, indent_size),
+            Item::Buttons(buttons) => buttons.write_hpp(fmt),
+            Item::Interfaces(ifaces) => ifaces.write_hpp(fmt),
+            Item::Offsets(offsets) => offsets.write_hpp(fmt),
+            Item::Schemas(schemas) => schemas.write_hpp(fmt),
         }
     }
 
-    fn to_json(&self, results: &Results, indent_size: usize) -> Result<String> {
+    fn write_json(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         match self {
-            Item::Buttons(buttons) => buttons.to_json(results, indent_size),
-            Item::Interfaces(ifaces) => ifaces.to_json(results, indent_size),
-            Item::Offsets(offsets) => offsets.to_json(results, indent_size),
-            Item::Schemas(schemas) => schemas.to_json(results, indent_size),
+            Item::Buttons(buttons) => buttons.write_json(fmt),
+            Item::Interfaces(ifaces) => ifaces.write_json(fmt),
+            Item::Offsets(offsets) => offsets.write_json(fmt),
+            Item::Schemas(schemas) => schemas.write_json(fmt),
         }
     }
 
-    fn to_rs(&self, results: &Results, indent_size: usize) -> Result<String> {
+    fn write_rs(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         match self {
-            Item::Buttons(buttons) => buttons.to_rs(results, indent_size),
-            Item::Interfaces(ifaces) => ifaces.to_rs(results, indent_size),
-            Item::Offsets(offsets) => offsets.to_rs(results, indent_size),
-            Item::Schemas(schemas) => schemas.to_rs(results, indent_size),
+            Item::Buttons(buttons) => buttons.write_rs(fmt),
+            Item::Interfaces(ifaces) => ifaces.write_rs(fmt),
+            Item::Offsets(offsets) => offsets.write_rs(fmt),
+            Item::Schemas(schemas) => schemas.write_rs(fmt),
         }
     }
 }
 
-#[derive(Deserialize, Serialize)]
-pub struct Results {
-    /// Timestamp of the dump.
-    pub timestamp: DateTime<Utc>,
-
-    /// List of buttons to dump.
-    pub buttons: Vec<Button>,
-
-    /// Map of interfaces to dump.
-    pub interfaces: InterfaceMap,
-
-    /// Map of offsets to dump.
-    pub offsets: OffsetMap,
-
-    /// Map of schema classes/enums to dump.
-    pub schemas: SchemaMap,
+pub struct Output<'a> {
+    file_types: &'a Vec<String>,
+    indent_size: usize,
+    out_dir: &'a Path,
+    result: &'a AnalysisResult,
+    timestamp: DateTime<Utc>,
 }
 
-impl Results {
+impl<'a> Output<'a> {
     pub fn new(
-        buttons: Vec<Button>,
-        interfaces: InterfaceMap,
-        offsets: OffsetMap,
-        schemas: SchemaMap,
-    ) -> Self {
-        Self {
-            timestamp: Utc::now(),
-            buttons,
-            interfaces,
-            offsets,
-            schemas,
-        }
-    }
-
-    pub fn dump_all<P: AsRef<Path>>(
-        &self,
-        process: &mut IntoProcessInstanceArcBox<'_>,
-        out_dir: P,
+        file_types: &'a Vec<String>,
         indent_size: usize,
-    ) -> Result<()> {
-        // TODO: Make this user-configurable.
-        const FILE_EXTS: &[&str] = &["cs", "hpp", "json", "rs"];
-
+        out_dir: &'a Path,
+        result: &'a AnalysisResult,
+    ) -> Result<Self> {
         fs::create_dir_all(&out_dir)?;
 
+        Ok(Self {
+            file_types,
+            indent_size,
+            out_dir,
+            result,
+            timestamp: Utc::now(),
+        })
+    }
+
+    pub fn dump_all(&self, process: &mut IntoProcessInstanceArcBox<'_>) -> Result<()> {
         let items = [
-            ("buttons", Item::Buttons(&self.buttons)),
-            ("interfaces", Item::Interfaces(&self.interfaces)),
-            ("offsets", Item::Offsets(&self.offsets)),
+            ("buttons", Item::Buttons(&self.result.buttons)),
+            ("interfaces", Item::Interfaces(&self.result.interfaces)),
+            ("offsets", Item::Offsets(&self.result.offsets)),
         ];
 
         for (file_name, item) in &items {
-            self.dump_item(item, &out_dir, indent_size, FILE_EXTS, file_name)?;
+            self.dump_item(file_name, item)?;
         }
 
-        self.dump_info(process, &out_dir)?;
-        self.dump_schemas(&out_dir, indent_size, FILE_EXTS)?;
+        self.dump_schemas()?;
+        self.dump_info(process)?;
 
         Ok(())
     }
 
-    fn dump_file<P: AsRef<Path>>(
-        &self,
-        out_dir: P,
-        file_name: &str,
-        file_ext: &str,
-        content: &str,
-    ) -> Result<()> {
-        let file_path = out_dir.as_ref().join(format!("{}.{}", file_name, file_ext));
+    fn dump_info(&self, process: &mut IntoProcessInstanceArcBox<'_>) -> Result<()> {
+        let file_path = self.out_dir.join("info.json");
 
-        fs::write(&file_path, content)?;
-
-        Ok(())
-    }
-
-    fn dump_item<P: AsRef<Path>>(
-        &self,
-        item: &Item,
-        out_dir: P,
-        indent_size: usize,
-        file_exts: &[&str],
-        file_name: &str,
-    ) -> Result<()> {
-        for ext in file_exts {
-            let content = item.generate(self, indent_size, ext)?;
-
-            self.dump_file(&out_dir, file_name, ext, &content)?;
-        }
-
-        Ok(())
-    }
-
-    fn dump_info<P: AsRef<Path>>(
-        &self,
-        process: &mut IntoProcessInstanceArcBox<'_>,
-        out_dir: P,
-    ) -> Result<()> {
-        let content = &serde_json::to_string_pretty(&json!({
-            "timestamp": self.timestamp.to_rfc3339(),
-            "build_number": self.read_build_number(process).unwrap_or(0),
-        }))?;
-
-        self.dump_file(&out_dir, "info", "json", &content)
-    }
-
-    fn dump_schemas<P: AsRef<Path>>(
-        &self,
-        out_dir: P,
-        indent_size: usize,
-        file_exts: &[&str],
-    ) -> Result<()> {
-        for (module_name, (classes, enums)) in &self.schemas {
-            let map = SchemaMap::from([(module_name.clone(), (classes.clone(), enums.clone()))]);
-            let item = Item::Schemas(&map);
-
-            self.dump_item(&item, &out_dir, indent_size, file_exts, &module_name)?;
-        }
-
-        Ok(())
-    }
-
-    fn read_build_number(&self, process: &mut IntoProcessInstanceArcBox<'_>) -> Result<u32> {
-        self.offsets
+        let build_number = self
+            .result
+            .offsets
             .iter()
             .find_map(|(module_name, offsets)| {
                 let module = process.module_by_name(module_name).ok()?;
-                let offset = offsets.iter().find(|(name, _)| *name == "dwBuildNumber")?;
+                let offset = offsets.iter().find(|(name, _)| *name == "dwBuildNumber")?.1;
 
-                process.read(module.base + offset.1).ok()
+                process.read::<u32>(module.base + offset).ok()
             })
-            .ok_or(Error::Other("unable to read build number"))
+            .ok_or(Error::Other("unable to read build number"))?;
+
+        let content = serde_json::to_string_pretty(&json!({
+            "timestamp": self.timestamp.to_rfc3339(),
+            "build_number": build_number,
+        }))?;
+
+        fs::write(&file_path, &content)?;
+
+        Ok(())
+    }
+
+    fn dump_item(&self, file_name: &str, item: &Item) -> Result<()> {
+        for file_type in self.file_types {
+            let mut out = String::new();
+            let mut fmt = Formatter::new(&mut out, self.indent_size);
+
+            if file_type != "json" {
+                self.write_banner(&mut fmt)?;
+            }
+
+            item.write(&mut fmt, file_type)?;
+
+            let file_path = self.out_dir.join(format!("{}.{}", file_name, file_type));
+
+            fs::write(&file_path, out)?;
+        }
+
+        Ok(())
+    }
+
+    fn dump_schemas(&self) -> Result<()> {
+        for (module_name, (classes, enums)) in &self.result.schemas {
+            let map = SchemaMap::from([(module_name.clone(), (classes.clone(), enums.clone()))]);
+
+            self.dump_item(module_name, &Item::Schemas(&map))?;
+        }
+
+        Ok(())
     }
 
     fn write_banner(&self, fmt: &mut Formatter<'_>) -> Result<()> {
@@ -249,3 +193,7 @@ impl Results {
         Ok(())
     }
 }
+
+fn slugify(input: &str) -> String {
+    input.replace(|c: char| !c.is_alphanumeric(), "_")
+}
diff --git a/src/output/offsets.rs b/src/output/offsets.rs
index 6ad4067..b2758f3 100644
--- a/src/output/offsets.rs
+++ b/src/output/offsets.rs
@@ -1,27 +1,47 @@
-use std::fmt::Write;
+use std::fmt::{self, Write};
 
 use heck::{AsPascalCase, AsSnakeCase};
 
-use super::{CodeGen, OffsetMap, Results};
+use super::{slugify, CodeWriter, Formatter, OffsetMap};
 
-use crate::error::Result;
+impl CodeWriter for OffsetMap {
+    fn write_cs(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        fmt.block("namespace CS2Dumper.Offsets", false, |fmt| {
+            for (module_name, offsets) in self {
+                writeln!(fmt, "// Module: {}", module_name)?;
 
-impl CodeGen for OffsetMap {
-    fn to_cs(&self, results: &Results, indent_size: usize) -> Result<String> {
-        self.write_content(results, indent_size, |fmt| {
-            fmt.block("namespace CS2Dumper.Offsets", false, |fmt| {
+                fmt.block(
+                    &format!("public static class {}", AsPascalCase(slugify(module_name))),
+                    false,
+                    |fmt| {
+                        for (name, value) in offsets {
+                            writeln!(fmt, "public const nint {} = {:#X};", name, value)?;
+                        }
+
+                        Ok(())
+                    },
+                )?;
+            }
+
+            Ok(())
+        })
+    }
+
+    fn write_hpp(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        writeln!(fmt, "#pragma once\n")?;
+        writeln!(fmt, "#include <cstddef>\n")?;
+
+        fmt.block("namespace cs2_dumper", false, |fmt| {
+            fmt.block("namespace offsets", false, |fmt| {
                 for (module_name, offsets) in self {
                     writeln!(fmt, "// Module: {}", module_name)?;
 
                     fmt.block(
-                        &format!(
-                            "public static class {}",
-                            AsPascalCase(Self::slugify(module_name))
-                        ),
+                        &format!("namespace {}", AsSnakeCase(slugify(module_name))),
                         false,
                         |fmt| {
                             for (name, value) in offsets {
-                                writeln!(fmt, "public const nint {} = {:#X};", name, value)?;
+                                writeln!(fmt, "constexpr std::ptrdiff_t {} = {:#X};", name, value)?;
                             }
 
                             Ok(())
@@ -30,81 +50,37 @@ impl CodeGen for OffsetMap {
                 }
 
                 Ok(())
-            })?;
-
-            Ok(())
+            })
         })
     }
 
-    fn to_hpp(&self, results: &Results, indent_size: usize) -> Result<String> {
-        self.write_content(results, indent_size, |fmt| {
-            writeln!(fmt, "#pragma once\n")?;
-            writeln!(fmt, "#include <cstddef>\n")?;
-
-            fmt.block("namespace cs2_dumper", false, |fmt| {
-                fmt.block("namespace offsets", false, |fmt| {
-                    for (module_name, offsets) in self {
-                        writeln!(fmt, "// Module: {}", module_name)?;
-
-                        fmt.block(
-                            &format!("namespace {}", AsSnakeCase(Self::slugify(module_name))),
-                            false,
-                            |fmt| {
-                                for (name, value) in offsets {
-                                    writeln!(
-                                        fmt,
-                                        "constexpr std::ptrdiff_t {} = {:#X};",
-                                        name, value
-                                    )?;
-                                }
-
-                                Ok(())
-                            },
-                        )?;
-                    }
-
-                    Ok(())
-                })
-            })?;
-
-            Ok(())
-        })
+    fn write_json(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        fmt.write_str(&serde_json::to_string_pretty(self).expect("failed to serialize"))
     }
 
-    fn to_json(&self, _results: &Results, _indent_size: usize) -> Result<String> {
-        serde_json::to_string_pretty(self).map_err(Into::into)
-    }
+    fn write_rs(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        writeln!(fmt, "#![allow(non_upper_case_globals, unused)]\n")?;
 
-    fn to_rs(&self, results: &Results, indent_size: usize) -> Result<String> {
-        self.write_content(results, indent_size, |fmt| {
-            writeln!(
-                fmt,
-                "#![allow(non_upper_case_globals, non_camel_case_types, unused)]\n"
-            )?;
+        fmt.block("pub mod cs2_dumper", false, |fmt| {
+            fmt.block("pub mod offsets", false, |fmt| {
+                for (module_name, offsets) in self {
+                    writeln!(fmt, "// Module: {}", module_name)?;
 
-            fmt.block("pub mod cs2_dumper", false, |fmt| {
-                fmt.block("pub mod offsets", false, |fmt| {
-                    for (module_name, offsets) in self {
-                        writeln!(fmt, "// Module: {}", module_name)?;
+                    fmt.block(
+                        &format!("pub mod {}", AsSnakeCase(slugify(module_name))),
+                        false,
+                        |fmt| {
+                            for (name, value) in offsets {
+                                writeln!(fmt, "pub const {}: usize = {:#X};", name, value)?;
+                            }
 
-                        fmt.block(
-                            &format!("pub mod {}", AsSnakeCase(Self::slugify(module_name))),
-                            false,
-                            |fmt| {
-                                for (name, value) in offsets {
-                                    writeln!(fmt, "pub const {}: usize = {:#X};", name, value)?;
-                                }
+                            Ok(())
+                        },
+                    )?;
+                }
 
-                                Ok(())
-                            },
-                        )?;
-                    }
-
-                    Ok(())
-                })
-            })?;
-
-            Ok(())
+                Ok(())
+            })
         })
     }
 }
diff --git a/src/output/schemas.rs b/src/output/schemas.rs
index 5061268..ec2ceae 100644
--- a/src/output/schemas.rs
+++ b/src/output/schemas.rs
@@ -5,33 +5,113 @@ use heck::{AsPascalCase, AsSnakeCase};
 
 use serde_json::json;
 
-use super::{CodeGen, Formatter, Results, SchemaMap};
+use super::{slugify, CodeWriter, Formatter, SchemaMap};
 
 use crate::analysis::ClassMetadata;
-use crate::error::Result;
 
-impl CodeGen for SchemaMap {
-    fn to_cs(&self, results: &Results, indent_size: usize) -> Result<String> {
-        self.write_content(results, indent_size, |fmt| {
-            fmt.block("namespace CS2Dumper.Schemas", false, |fmt| {
+impl CodeWriter for SchemaMap {
+    fn write_cs(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        fmt.block("namespace CS2Dumper.Schemas", false, |fmt| {
+            for (module_name, (classes, enums)) in self {
+                writeln!(fmt, "// Module: {}", module_name)?;
+                writeln!(fmt, "// Classes count: {}", classes.len())?;
+                writeln!(fmt, "// Enums count: {}", enums.len())?;
+
+                fmt.block(
+                    &format!("public static class {}", AsPascalCase(slugify(module_name))),
+                    false,
+                    |fmt| {
+                        for enum_ in enums {
+                            let type_name = match enum_.alignment {
+                                1 => "byte",
+                                2 => "ushort",
+                                4 => "uint",
+                                8 => "ulong",
+                                _ => continue,
+                            };
+
+                            writeln!(fmt, "// Alignment: {}", enum_.alignment)?;
+                            writeln!(fmt, "// Members count: {}", enum_.size)?;
+
+                            fmt.block(
+                                &format!("public enum {} : {}", slugify(&enum_.name), type_name),
+                                false,
+                                |fmt| {
+                                    // TODO: Handle the case where multiple members share
+                                    // the same value.
+                                    let members = enum_
+                                        .members
+                                        .iter()
+                                        .map(|member| {
+                                            format!("{} = {:#X}", member.name, member.value)
+                                        })
+                                        .collect::<Vec<_>>()
+                                        .join(",\n");
+
+                                    writeln!(fmt, "{}", members)
+                                },
+                            )?;
+                        }
+
+                        for class in classes {
+                            let parent_name = class
+                                .parent
+                                .as_ref()
+                                .map(|parent| slugify(&parent.name))
+                                .unwrap_or_else(|| "None".to_string());
+
+                            writeln!(fmt, "// Parent: {}", parent_name)?;
+                            writeln!(fmt, "// Fields count: {}", class.fields.len())?;
+
+                            write_metadata(fmt, &class.metadata)?;
+
+                            fmt.block(
+                                &format!("public static class {}", slugify(&class.name)),
+                                false,
+                                |fmt| {
+                                    for field in &class.fields {
+                                        writeln!(
+                                            fmt,
+                                            "public const nint {} = {:#X}; // {}",
+                                            field.name, field.offset, field.type_name
+                                        )?;
+                                    }
+
+                                    Ok(())
+                                },
+                            )?;
+                        }
+
+                        Ok(())
+                    },
+                )?;
+            }
+
+            Ok(())
+        })
+    }
+
+    fn write_hpp(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        writeln!(fmt, "#pragma once\n")?;
+        writeln!(fmt, "#include <cstddef>\n")?;
+
+        fmt.block("namespace cs2_dumper", false, |fmt| {
+            fmt.block("namespace schemas", false, |fmt| {
                 for (module_name, (classes, enums)) in self {
                     writeln!(fmt, "// Module: {}", module_name)?;
                     writeln!(fmt, "// Classes count: {}", classes.len())?;
                     writeln!(fmt, "// Enums count: {}", enums.len())?;
 
                     fmt.block(
-                        &format!(
-                            "public static class {}",
-                            AsPascalCase(Self::slugify(module_name))
-                        ),
+                        &format!("namespace {}", AsSnakeCase(slugify(module_name))),
                         false,
                         |fmt| {
                             for enum_ in enums {
                                 let type_name = match enum_.alignment {
-                                    1 => "byte",
-                                    2 => "ushort",
-                                    4 => "uint",
-                                    8 => "ulong",
+                                    1 => "uint8_t",
+                                    2 => "uint16_t",
+                                    4 => "uint32_t",
+                                    8 => "uint64_t",
                                     _ => continue,
                                 };
 
@@ -39,12 +119,8 @@ impl CodeGen for SchemaMap {
                                 writeln!(fmt, "// Members count: {}", enum_.size)?;
 
                                 fmt.block(
-                                    &format!(
-                                        "public enum {} : {}",
-                                        Self::slugify(&enum_.name),
-                                        type_name
-                                    ),
-                                    false,
+                                    &format!("enum class {} : {}", slugify(&enum_.name), type_name),
+                                    true,
                                     |fmt| {
                                         // TODO: Handle the case where multiple members share
                                         // the same value.
@@ -66,7 +142,7 @@ impl CodeGen for SchemaMap {
                                 let parent_name = class
                                     .parent
                                     .as_ref()
-                                    .map(|parent| Self::slugify(&parent.name))
+                                    .map(|parent| slugify(&parent.name))
                                     .unwrap_or_else(|| "None".to_string());
 
                                 writeln!(fmt, "// Parent: {}", parent_name)?;
@@ -75,13 +151,13 @@ impl CodeGen for SchemaMap {
                                 write_metadata(fmt, &class.metadata)?;
 
                                 fmt.block(
-                                    &format!("public static class {}", Self::slugify(&class.name)),
+                                    &format!("namespace {}", slugify(&class.name)),
                                     false,
                                     |fmt| {
                                         for field in &class.fields {
                                             writeln!(
                                                 fmt,
-                                                "public const nint {} = {:#X}; // {}",
+                                                "constexpr std::ptrdiff_t {} = {:#X}; // {}",
                                                 field.name, field.offset, field.type_name
                                             )?;
                                         }
@@ -97,107 +173,11 @@ impl CodeGen for SchemaMap {
                 }
 
                 Ok(())
-            })?;
-
-            Ok(())
+            })
         })
     }
 
-    fn to_hpp(&self, results: &Results, indent_size: usize) -> Result<String> {
-        self.write_content(results, indent_size, |fmt| {
-            writeln!(fmt, "#pragma once\n")?;
-            writeln!(fmt, "#include <cstddef>\n")?;
-
-            fmt.block("namespace cs2_dumper", false, |fmt| {
-                fmt.block("namespace schemas", false, |fmt| {
-                    for (module_name, (classes, enums)) in self {
-                        writeln!(fmt, "// Module: {}", module_name)?;
-                        writeln!(fmt, "// Classes count: {}", classes.len())?;
-                        writeln!(fmt, "// Enums count: {}", enums.len())?;
-
-                        fmt.block(
-                            &format!("namespace {}", AsSnakeCase(Self::slugify(module_name))),
-                            false,
-                            |fmt| {
-                                for enum_ in enums {
-                                    let type_name = match enum_.alignment {
-                                        1 => "uint8_t",
-                                        2 => "uint16_t",
-                                        4 => "uint32_t",
-                                        8 => "uint64_t",
-                                        _ => continue,
-                                    };
-
-                                    writeln!(fmt, "// Alignment: {}", enum_.alignment)?;
-                                    writeln!(fmt, "// Members count: {}", enum_.size)?;
-
-                                    fmt.block(
-                                        &format!(
-                                            "enum class {} : {}",
-                                            Self::slugify(&enum_.name),
-                                            type_name
-                                        ),
-                                        true,
-                                        |fmt| {
-                                            // TODO: Handle the case where multiple members share
-                                            // the same value.
-                                            let members = enum_
-                                                .members
-                                                .iter()
-                                                .map(|member| {
-                                                    format!("{} = {:#X}", member.name, member.value)
-                                                })
-                                                .collect::<Vec<_>>()
-                                                .join(",\n");
-
-                                            writeln!(fmt, "{}", members)
-                                        },
-                                    )?;
-                                }
-
-                                for class in classes {
-                                    let parent_name = class
-                                        .parent
-                                        .as_ref()
-                                        .map(|parent| Self::slugify(&parent.name))
-                                        .unwrap_or_else(|| "None".to_string());
-
-                                    writeln!(fmt, "// Parent: {}", parent_name)?;
-                                    writeln!(fmt, "// Fields count: {}", class.fields.len())?;
-
-                                    write_metadata(fmt, &class.metadata)?;
-
-                                    fmt.block(
-                                        &format!("namespace {}", Self::slugify(&class.name)),
-                                        false,
-                                        |fmt| {
-                                            for field in &class.fields {
-                                                writeln!(
-                                                    fmt,
-                                                    "constexpr std::ptrdiff_t {} = {:#X}; // {}",
-                                                    field.name, field.offset, field.type_name
-                                                )?;
-                                            }
-
-                                            Ok(())
-                                        },
-                                    )?;
-                                }
-
-                                Ok(())
-                            },
-                        )?;
-                    }
-
-                    Ok(())
-                })
-            })?;
-
-            Ok(())
-        })
-    }
-
-    fn to_json(&self, _results: &Results, _indent_size: usize) -> Result<String> {
+    fn write_json(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         let content: BTreeMap<_, _> = self
             .iter()
             .map(|(module_name, (classes, enums))| {
@@ -231,7 +211,7 @@ impl CodeGen for SchemaMap {
                             .collect();
 
                         (
-                            Self::slugify(&class.name),
+                            slugify(&class.name),
                             json!({
                                 "parent": class.parent.as_ref().map(|parent| &parent.name),
                                 "fields": fields,
@@ -259,7 +239,7 @@ impl CodeGen for SchemaMap {
                         };
 
                         (
-                            Self::slugify(&enum_.name),
+                            slugify(&enum_.name),
                             json!({
                                 "alignment": enum_.alignment,
                                 "type": type_name,
@@ -279,110 +259,106 @@ impl CodeGen for SchemaMap {
             })
             .collect();
 
-        serde_json::to_string_pretty(&content).map_err(Into::into)
+        fmt.write_str(&serde_json::to_string_pretty(&content).expect("failed to serialize"))
     }
 
-    fn to_rs(&self, results: &Results, indent_size: usize) -> Result<String> {
-        self.write_content(results, indent_size, |fmt| {
-            writeln!(
-                fmt,
-                "#![allow(non_upper_case_globals, non_camel_case_types, non_snake_case, unused)]\n"
-            )?;
+    fn write_rs(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        writeln!(
+            fmt,
+            "#![allow(non_upper_case_globals, non_camel_case_types, non_snake_case, unused)]\n"
+        )?;
 
-            fmt.block("pub mod cs2_dumper", false, |fmt| {
-                fmt.block("pub mod schemas", false, |fmt| {
-                    for (module_name, (classes, enums)) in self {
-                        writeln!(fmt, "// Module: {}", module_name)?;
-                        writeln!(fmt, "// Classes count: {}", classes.len())?;
-                        writeln!(fmt, "// Enums count: {}", enums.len())?;
+        fmt.block("pub mod cs2_dumper", false, |fmt| {
+            fmt.block("pub mod schemas", false, |fmt| {
+                for (module_name, (classes, enums)) in self {
+                    writeln!(fmt, "// Module: {}", module_name)?;
+                    writeln!(fmt, "// Classes count: {}", classes.len())?;
+                    writeln!(fmt, "// Enums count: {}", enums.len())?;
 
-                        fmt.block(
-                            &format!("pub mod {}", AsSnakeCase(Self::slugify(module_name))),
-                            false,
-                            |fmt| {
-                                for enum_ in enums {
-                                    let type_name = match enum_.alignment {
-                                        1 => "u8",
-                                        2 => "u16",
-                                        4 => "u32",
-                                        8 => "u64",
-                                        _ => continue,
-                                    };
+                    fmt.block(
+                        &format!("pub mod {}", AsSnakeCase(slugify(module_name))),
+                        false,
+                        |fmt| {
+                            for enum_ in enums {
+                                let type_name = match enum_.alignment {
+                                    1 => "u8",
+                                    2 => "u16",
+                                    4 => "u32",
+                                    8 => "u64",
+                                    _ => continue,
+                                };
 
-                                    writeln!(fmt, "// Alignment: {}", enum_.alignment)?;
-                                    writeln!(fmt, "// Members count: {}", enum_.size)?;
+                                writeln!(fmt, "// Alignment: {}", enum_.alignment)?;
+                                writeln!(fmt, "// Members count: {}", enum_.size)?;
 
-                                    fmt.block(
-                                        &format!(
-                                            "#[repr({})]\npub enum {}",
-                                            type_name,
-                                            Self::slugify(&enum_.name),
-                                        ),
-                                        false,
-                                        |fmt| {
-                                            // TODO: Handle the case where multiple members share
-                                            // the same value.
-                                            let members = enum_
-                                                .members
-                                                .iter()
-                                                .map(|member| {
-                                                    format!(
-                                                        "{} = {}",
-                                                        member.name,
-                                                        if member.value == -1 {
-                                                            format!("{}::MAX", type_name)
-                                                        } else {
-                                                            format!("{:#X}", member.value)
-                                                        }
-                                                    )
-                                                })
-                                                .collect::<Vec<_>>()
-                                                .join(",\n");
+                                fmt.block(
+                                    &format!(
+                                        "#[repr({})]\npub enum {}",
+                                        type_name,
+                                        slugify(&enum_.name),
+                                    ),
+                                    false,
+                                    |fmt| {
+                                        // TODO: Handle the case where multiple members share
+                                        // the same value.
+                                        let members = enum_
+                                            .members
+                                            .iter()
+                                            .map(|member| {
+                                                format!(
+                                                    "{} = {}",
+                                                    member.name,
+                                                    if member.value == -1 {
+                                                        format!("{}::MAX", type_name)
+                                                    } else {
+                                                        format!("{:#X}", member.value)
+                                                    }
+                                                )
+                                            })
+                                            .collect::<Vec<_>>()
+                                            .join(",\n");
 
-                                            writeln!(fmt, "{}", members)
-                                        },
-                                    )?;
-                                }
+                                        writeln!(fmt, "{}", members)
+                                    },
+                                )?;
+                            }
 
-                                for class in classes {
-                                    let parent_name = class
-                                        .parent
-                                        .as_ref()
-                                        .map(|parent| Self::slugify(&parent.name))
-                                        .unwrap_or_else(|| "None".to_string());
+                            for class in classes {
+                                let parent_name = class
+                                    .parent
+                                    .as_ref()
+                                    .map(|parent| slugify(&parent.name))
+                                    .unwrap_or_else(|| "None".to_string());
 
-                                    writeln!(fmt, "// Parent: {}", parent_name)?;
-                                    writeln!(fmt, "// Fields count: {}", class.fields.len())?;
+                                writeln!(fmt, "// Parent: {}", parent_name)?;
+                                writeln!(fmt, "// Fields count: {}", class.fields.len())?;
 
-                                    write_metadata(fmt, &class.metadata)?;
+                                write_metadata(fmt, &class.metadata)?;
 
-                                    fmt.block(
-                                        &format!("pub mod {}", Self::slugify(&class.name)),
-                                        false,
-                                        |fmt| {
-                                            for field in &class.fields {
-                                                writeln!(
-                                                    fmt,
-                                                    "pub const {}: usize = {:#X}; // {}",
-                                                    field.name, field.offset, field.type_name
-                                                )?;
-                                            }
+                                fmt.block(
+                                    &format!("pub mod {}", slugify(&class.name)),
+                                    false,
+                                    |fmt| {
+                                        for field in &class.fields {
+                                            writeln!(
+                                                fmt,
+                                                "pub const {}: usize = {:#X}; // {}",
+                                                field.name, field.offset, field.type_name
+                                            )?;
+                                        }
 
-                                            Ok(())
-                                        },
-                                    )?;
-                                }
+                                        Ok(())
+                                    },
+                                )?;
+                            }
 
-                                Ok(())
-                            },
-                        )?;
-                    }
+                            Ok(())
+                        },
+                    )?;
+                }
 
-                    Ok(())
-                })
-            })?;
-
-            Ok(())
+                Ok(())
+            })
         })
     }
 }
diff --git a/src/source2/client/input.rs b/src/source2/client/input.rs
index 459110c..dc805f7 100644
--- a/src/source2/client/input.rs
+++ b/src/source2/client/input.rs
@@ -1,6 +1,5 @@
 use memflow::prelude::v1::*;
 
-/// Represents a keyboard button.
 #[derive(Pod)]
 #[repr(C)]
 pub struct KeyButton {
diff --git a/src/source2/tier1/interface.rs b/src/source2/tier1/interface.rs
index 5fdff42..b114e01 100644
--- a/src/source2/tier1/interface.rs
+++ b/src/source2/tier1/interface.rs
@@ -1,6 +1,5 @@
 use memflow::prelude::v1::*;
 
-/// Represents a node in the linked list of exposed interfaces.
 #[derive(Pod)]
 #[repr(C)]
 pub struct InterfaceReg {
diff --git a/src/source2/tier1/utl_memory.rs b/src/source2/tier1/utl_memory.rs
index 42ad463..86338f5 100644
--- a/src/source2/tier1/utl_memory.rs
+++ b/src/source2/tier1/utl_memory.rs
@@ -2,7 +2,6 @@ use memflow::prelude::v1::*;
 
 use crate::error::{Error, Result};
 
-/// Represents a growable memory class that doubles in size by default.
 #[repr(C)]
 pub struct UtlMemory<T> {
     pub mem: Pointer64<[T]>, // 0x0000
diff --git a/src/source2/tier1/utl_memory_pool.rs b/src/source2/tier1/utl_memory_pool.rs
index 4f67cd1..420200f 100644
--- a/src/source2/tier1/utl_memory_pool.rs
+++ b/src/source2/tier1/utl_memory_pool.rs
@@ -23,7 +23,6 @@ pub struct FreeList {
     pub next: Pointer64<FreeList>, // 0x0000
 }
 
-/// Represents an optimized pool memory allocator.
 #[repr(C)]
 pub struct UtlMemoryPoolBase {
     pub block_size: i32,                                // 0x0000
diff --git a/src/source2/tier1/utl_ts_hash.rs b/src/source2/tier1/utl_ts_hash.rs
index 79e3f17..0cc6f07 100644
--- a/src/source2/tier1/utl_ts_hash.rs
+++ b/src/source2/tier1/utl_ts_hash.rs
@@ -31,7 +31,6 @@ pub struct HashFixedDataInternal<D, K> {
 
 unsafe impl<D: 'static, K: 'static> Pod for HashFixedDataInternal<D, K> {}
 
-/// Represents a thread-safe hash table.
 #[repr(C)]
 pub struct UtlTsHash<D, const C: usize = 256, K = u64> {
     pub entry_mem: UtlMemoryPoolBase,   // 0x0000
@@ -63,7 +62,7 @@ where
         self.entry_mem.peak_alloc
     }
 
-    /// Returns all elements in the hash table.
+    // TODO:
     pub fn elements(&self, process: &mut IntoProcessInstanceArcBox<'_>) -> Result<Vec<D>> {
         let blocks_alloc = self.blocks_alloc() as usize;
         let peak_alloc = self.peak_count() as usize;
diff --git a/src/source2/tier1/utl_vector.rs b/src/source2/tier1/utl_vector.rs
index cad45b3..47b7daa 100644
--- a/src/source2/tier1/utl_vector.rs
+++ b/src/source2/tier1/utl_vector.rs
@@ -2,7 +2,6 @@ use memflow::prelude::v1::*;
 
 use crate::error::{Error, Result};
 
-/// Represents a growable array class that doubles in size by default.
 #[repr(C)]
 pub struct UtlVector<T> {
     pub size: i32,           // 0x0000