Start monorepo migration

packages/daedalus/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "daedalus"
+version = "0.2.3"
+authors = ["Jai A <jai@modrinth.com>"]
+edition = "2021"
+license = "MIT"
+description = "Utilities for querying and parsing Minecraft metadata"
+repository = "https://github.com/modrinth/daedalus/"
+include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE"]
+keywords = ["minecraft", "launcher"]
+categories = ["game-development", "api-bindings"]
+readme = "README.md"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+chrono = { version = "0.4", features = ["serde"] }
+bytes = "1"
+thiserror = "1.0"

packages/daedalus/LICENSE

@@ -0,0 +1,7 @@
+Copyright © 2024 Rinth, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/daedalus/README.md

@@ -0,0 +1,4 @@
+# Daedalus 
+
+Daedalus (the rust library) is a library providing model structs and methods for requesting and parsing things
+from Minecraft and other mod loaders meta APIs. 

packages/daedalus/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@modrinth/daedalus_client",
+  "scripts": {
+    "build": "cargo build --release",
+    "lint": "cargo fmt --check && cargo clippy --all-targets --all-features -- -D warnings",
+    "fix": "cargo fmt && cargo clippy --fix",
+    "dev": "cargo run",
+    "test": "cargo test"
+  }
+}

packages/daedalus/src/lib.rs

@@ -0,0 +1,102 @@
+//! # Daedalus
+//!
+//! Daedalus is a library which provides models and methods to fetch metadata about games
+
+#![warn(missing_docs, unused_import_braces, missing_debug_implementations)]
+
+/// Models and methods for fetching metadata for Minecraft
+pub mod minecraft;
+/// Models and methods for fetching metadata for Minecraft mod loaders
+pub mod modded;
+
+#[derive(thiserror::Error, Debug)]
+/// An error type representing possible errors when fetching metadata
+pub enum Error {
+    /// Error while parsing input
+    #[error("{0}")]
+    ParseError(String),
+}
+
+/// Converts a maven artifact to a path
+pub fn get_path_from_artifact(artifact: &str) -> Result<String, Error> {
+    let name_items = artifact.split(':').collect::<Vec<&str>>();
+
+    let package = name_items.first().ok_or_else(|| {
+        Error::ParseError(format!(
+            "Unable to find package for library {}",
+            &artifact
+        ))
+    })?;
+    let name = name_items.get(1).ok_or_else(|| {
+        Error::ParseError(format!(
+            "Unable to find name for library {}",
+            &artifact
+        ))
+    })?;
+
+    if name_items.len() == 3 {
+        let version_ext = name_items
+            .get(2)
+            .ok_or_else(|| {
+                Error::ParseError(format!(
+                    "Unable to find version for library {}",
+                    &artifact
+                ))
+            })?
+            .split('@')
+            .collect::<Vec<&str>>();
+        let version = version_ext.first().ok_or_else(|| {
+            Error::ParseError(format!(
+                "Unable to find version for library {}",
+                &artifact
+            ))
+        })?;
+        let ext = version_ext.get(1);
+
+        Ok(format!(
+            "{}/{}/{}/{}-{}.{}",
+            package.replace('.', "/"),
+            name,
+            version,
+            name,
+            version,
+            ext.unwrap_or(&"jar")
+        ))
+    } else {
+        let version = name_items.get(2).ok_or_else(|| {
+            Error::ParseError(format!(
+                "Unable to find version for library {}",
+                &artifact
+            ))
+        })?;
+
+        let data_ext = name_items
+            .get(3)
+            .ok_or_else(|| {
+                Error::ParseError(format!(
+                    "Unable to find data for library {}",
+                    &artifact
+                ))
+            })?
+            .split('@')
+            .collect::<Vec<&str>>();
+        let data = data_ext.first().ok_or_else(|| {
+            Error::ParseError(format!(
+                "Unable to find data for library {}",
+                &artifact
+            ))
+        })?;
+        let ext = data_ext.get(1);
+
+        Ok(format!(
+            "{}/{}/{}/{}-{}-{}.{}",
+            package.replace('.', "/"),
+            name,
+            version,
+            name,
+            version,
+            data,
+            ext.unwrap_or(&"jar")
+        ))
+    }
+}

packages/daedalus/src/minecraft.rs

@@ -0,0 +1,461 @@
+use crate::modded::{Processor, SidedDataEntry};
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// The latest version of the format the model structs deserialize to
+pub const CURRENT_FORMAT_VERSION: usize = 0;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "snake_case")]
+/// The version type
+pub enum VersionType {
+    /// A major version, which is stable for all players to use
+    Release,
+    /// An experimental version, which is unstable and used for feature previews and beta testing
+    Snapshot,
+    /// The oldest versions before the game was released
+    OldAlpha,
+    /// Early versions of the game
+    OldBeta,
+}
+
+impl VersionType {
+    /// Converts the version type to a string
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            VersionType::Release => "release",
+            VersionType::Snapshot => "snapshot",
+            VersionType::OldAlpha => "old_alpha",
+            VersionType::OldBeta => "old_beta",
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+/// A game version of Minecraft
+pub struct Version {
+    /// A unique identifier of the version
+    pub id: String,
+    #[serde(rename = "type")]
+    /// The release type of the version
+    pub type_: VersionType,
+    /// A link to additional information about the version
+    pub url: String,
+    /// The latest time a file in this version was updated
+    pub time: DateTime<Utc>,
+    /// The time this version was released
+    pub release_time: DateTime<Utc>,
+    /// The SHA1 hash of the additional information about the version
+    pub sha1: String,
+    /// Whether the version supports the latest player safety features
+    pub compliance_level: u32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// (Modrinth Provided) The SHA1 hash of the original unmodified Minecraft versions JSON
+    pub original_sha1: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+/// The latest snapshot and release of the game
+pub struct LatestVersion {
+    /// The version id of the latest release
+    pub release: String,
+    /// The version id of the latest snapshot
+    pub snapshot: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+/// Data of all game versions of Minecraft
+pub struct VersionManifest {
+    /// A struct containing the latest snapshot and release of the game
+    pub latest: LatestVersion,
+    /// A list of game versions of Minecraft
+    pub versions: Vec<Version>,
+}
+
+/// The URL to the version manifest
+pub const VERSION_MANIFEST_URL: &str =
+    "https://piston-meta.mojang.com/mc/game/version_manifest_v2.json";
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+/// Information about the assets of the game
+pub struct AssetIndex {
+    /// The game version ID the assets are for
+    pub id: String,
+    /// The SHA1 hash of the assets index
+    pub sha1: String,
+    /// The size of the assets index
+    pub size: u32,
+    /// The size of the game version's assets
+    pub total_size: u32,
+    /// A URL to a file which contains information about the version's assets
+    pub url: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Hash)]
+#[serde(rename_all = "snake_case")]
+/// The type of download
+pub enum DownloadType {
+    /// The download is for the game client
+    Client,
+    /// The download is mappings for the game
+    ClientMappings,
+    /// The download is for the game server
+    Server,
+    /// The download is mappings for the game server
+    ServerMappings,
+    /// The download is for the windows server
+    WindowsServer,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+/// Download information of a file
+pub struct Download {
+    /// The SHA1 hash of the file
+    pub sha1: String,
+    /// The size of the file
+    pub size: u32,
+    /// The URL where the file can be downloaded
+    pub url: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+/// Download information of a library
+pub struct LibraryDownload {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The path that the library should be saved to
+    pub path: Option<String>,
+    /// The SHA1 hash of the library
+    pub sha1: String,
+    /// The size of the library
+    pub size: u32,
+    /// The URL where the library can be downloaded
+    pub url: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+/// A list of files that should be downloaded for libraries
+pub struct LibraryDownloads {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The primary library artifact
+    pub artifact: Option<LibraryDownload>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Conditional files that may be needed to be downloaded alongside the library
+    /// The HashMap key specifies a classifier as additional information for downloading files
+    pub classifiers: Option<HashMap<String, LibraryDownload>>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "snake_case")]
+/// The action a rule can follow
+pub enum RuleAction {
+    /// The rule's status allows something to be done
+    Allow,
+    /// The rule's status disallows something to be done
+    Disallow,
+}
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Hash, Clone)]
+#[serde(rename_all = "kebab-case")]
+/// An enum representing the different types of operating systems
+pub enum Os {
+    /// MacOS (x86)
+    Osx,
+    /// M1-Based Macs
+    OsxArm64,
+    /// Windows (x86)
+    Windows,
+    /// Windows ARM
+    WindowsArm64,
+    /// Linux (x86) and its derivatives
+    Linux,
+    /// Linux ARM 64
+    LinuxArm64,
+    /// Linux ARM 32
+    LinuxArm32,
+    /// The OS is unknown
+    Unknown,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+/// A rule which depends on what OS the user is on
+pub struct OsRule {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The name of the OS
+    pub name: Option<Os>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The version of the OS. This is normally a RegEx
+    pub version: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The architecture of the OS
+    pub arch: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+/// A rule which depends on the toggled features of the launcher
+pub struct FeatureRule {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Whether the user is in demo mode
+    pub is_demo_user: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Whether the user is using a custom resolution
+    pub has_custom_resolution: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Whether the launcher has quick plays support
+    pub has_quick_plays_support: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Whether the instance is being launched to a single-player world
+    pub is_quick_play_singleplayer: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Whether the instance is being launched to a multi-player world
+    pub is_quick_play_multiplayer: Option<bool>,
+    ///  Whether the instance is being launched to a realms world
+    pub is_quick_play_realms: Option<bool>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+/// A rule deciding whether a file is downloaded, an argument is used, etc.
+pub struct Rule {
+    /// The action the rule takes
+    pub action: RuleAction,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The OS rule
+    pub os: Option<OsRule>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The feature rule
+    pub features: Option<FeatureRule>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+/// Information delegating the extraction of the library
+pub struct LibraryExtract {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Files/Folders to be excluded from the extraction of the library
+    pub exclude: Option<Vec<String>>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+/// Information about the java version the game needs
+pub struct JavaVersion {
+    /// The component needed for the Java installation
+    pub component: String,
+    /// The major Java version number
+    pub major_version: u32,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+/// A library which the game relies on to run
+pub struct Library {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The files the library has
+    pub downloads: Option<LibraryDownloads>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Rules of the extraction of the file
+    pub extract: Option<LibraryExtract>,
+    /// The maven name of the library. The format is `groupId:artifactId:version`
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The URL to the repository where the library can be downloaded
+    pub url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Native files that the library relies on
+    pub natives: Option<HashMap<Os, String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Rules deciding whether the library should be downloaded or not
+    pub rules: Option<Vec<Rule>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// SHA1 Checksums for validating the library's integrity. Only present for forge libraries
+    pub checksums: Option<Vec<String>>,
+    #[serde(default = "default_include_in_classpath")]
+    /// Whether the library should be included in the classpath at the game's launch
+    pub include_in_classpath: bool,
+    #[serde(default = "default_downloadable")]
+    /// Whether the library should be downloaded
+    pub downloadable: bool,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+/// A partial library which should be merged with a full library
+pub struct PartialLibrary {
+    /// The files the library has
+    pub downloads: Option<LibraryDownloads>,
+    /// Rules of the extraction of the file
+    pub extract: Option<LibraryExtract>,
+    /// The maven name of the library. The format is `groupId:artifactId:version`
+    pub name: Option<String>,
+    /// The URL to the repository where the library can be downloaded
+    pub url: Option<String>,
+    /// Native files that the library relies on
+    pub natives: Option<HashMap<Os, String>>,
+    /// Rules deciding whether the library should be downloaded or not
+    pub rules: Option<Vec<Rule>>,
+    /// SHA1 Checksums for validating the library's integrity. Only present for forge libraries
+    pub checksums: Option<Vec<String>>,
+    /// Whether the library should be included in the classpath at the game's launch
+    pub include_in_classpath: Option<bool>,
+}
+
+/// Merges a partial library to make a complete library
+pub fn merge_partial_library(
+    partial: PartialLibrary,
+    mut merge: Library,
+) -> Library {
+    if let Some(downloads) = partial.downloads {
+        if let Some(merge_downloads) = &mut merge.downloads {
+            if let Some(artifact) = downloads.artifact {
+                merge_downloads.artifact = Some(artifact);
+            }
+            if let Some(classifiers) = downloads.classifiers {
+                if let Some(merge_classifiers) =
+                    &mut merge_downloads.classifiers
+                {
+                    for classifier in classifiers {
+                        merge_classifiers.insert(classifier.0, classifier.1);
+                    }
+                } else {
+                    merge_downloads.classifiers = Some(classifiers);
+                }
+            }
+        } else {
+            merge.downloads = Some(downloads)
+        }
+    }
+    if let Some(extract) = partial.extract {
+        merge.extract = Some(extract)
+    }
+    if let Some(name) = partial.name {
+        merge.name = name
+    }
+    if let Some(url) = partial.url {
+        merge.url = Some(url)
+    }
+    if let Some(natives) = partial.natives {
+        if let Some(merge_natives) = &mut merge.natives {
+            for native in natives {
+                merge_natives.insert(native.0, native.1);
+            }
+        } else {
+            merge.natives = Some(natives);
+        }
+    }
+    if let Some(rules) = partial.rules {
+        if let Some(merge_rules) = &mut merge.rules {
+            for rule in rules {
+                merge_rules.push(rule);
+            }
+        } else {
+            merge.rules = Some(rules)
+        }
+    }
+    if let Some(checksums) = partial.checksums {
+        merge.checksums = Some(checksums)
+    }
+    if let Some(include_in_classpath) = partial.include_in_classpath {
+        merge.include_in_classpath = include_in_classpath
+    }
+
+    merge
+}
+
+fn default_include_in_classpath() -> bool {
+    true
+}
+fn default_downloadable() -> bool {
+    true
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
+/// A container for an argument or multiple arguments
+pub enum ArgumentValue {
+    /// The container has one argument
+    Single(String),
+    /// The container has multiple arguments
+    Many(Vec<String>),
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
+/// A command line argument passed to a program
+pub enum Argument {
+    /// An argument which is applied no matter what
+    Normal(String),
+    /// An argument which is only applied if certain conditions are met
+    Ruled {
+        /// The rules deciding whether the argument(s) is used or not
+        rules: Vec<Rule>,
+        /// The container of the argument(s) that should be applied accordingly
+        value: ArgumentValue,
+    },
+}
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Hash, Clone, Copy)]
+#[serde(rename_all = "snake_case")]
+/// The type of argument
+pub enum ArgumentType {
+    /// The argument is passed to the game
+    Game,
+    /// The argument is passed to the JVM
+    Jvm,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+/// Information about a version
+pub struct VersionInfo {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Arguments passed to the game or JVM
+    pub arguments: Option<HashMap<ArgumentType, Vec<Argument>>>,
+    /// Assets for the game
+    pub asset_index: AssetIndex,
+    /// The version ID of the assets
+    pub assets: String,
+    /// Game downloads of the version
+    pub downloads: HashMap<DownloadType, Download>,
+    /// The version ID of the version
+    pub id: String,
+
+    /// The Java version this version supports
+    pub java_version: Option<JavaVersion>,
+    /// Libraries that the version depends on
+    pub libraries: Vec<Library>,
+    /// The classpath to the main class to launch the game
+    pub main_class: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// (Legacy) Arguments passed to the game
+    pub minecraft_arguments: Option<String>,
+    /// The minimum version of the Minecraft Launcher that can run this version of the game
+    pub minimum_launcher_version: u32,
+    /// The time that the version was released
+    pub release_time: DateTime<Utc>,
+    /// The latest time a file in this version was updated
+    pub time: DateTime<Utc>,
+    #[serde(rename = "type")]
+    /// The type of version
+    pub type_: VersionType,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// (Forge-only)
+    pub data: Option<HashMap<String, SidedDataEntry>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// (Forge-only) The list of processors to run after downloading the files
+    pub processors: Option<Vec<Processor>>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+/// An asset of the game
+pub struct Asset {
+    /// The SHA1 hash of the asset file
+    pub hash: String,
+    /// The size of the asset file
+    pub size: u32,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+/// An index containing all assets the game needs
+pub struct AssetsIndex {
+    /// A hashmap containing the filename (key) and asset (value)
+    pub objects: HashMap<String, Asset>,
+}

packages/daedalus/src/modded.rs

@@ -0,0 +1,208 @@
+use crate::minecraft::{
+    Argument, ArgumentType, Library, VersionInfo, VersionType,
+};
+use chrono::{DateTime, TimeZone, Utc};
+use serde::{Deserialize, Deserializer, Serialize};
+use std::collections::HashMap;
+
+/// The latest version of the format the fabric model structs deserialize to
+pub const CURRENT_FABRIC_FORMAT_VERSION: usize = 0;
+/// The latest version of the format the fabric model structs deserialize to
+pub const CURRENT_FORGE_FORMAT_VERSION: usize = 0;
+/// The latest version of the format the quilt model structs deserialize to
+pub const CURRENT_QUILT_FORMAT_VERSION: usize = 0;
+/// The latest version of the format the neoforge model structs deserialize to
+pub const CURRENT_NEOFORGE_FORMAT_VERSION: usize = 0;
+
+/// The dummy replace string library names, inheritsFrom, and version names should be replaced with
+pub const DUMMY_REPLACE_STRING: &str = "${modrinth.gameVersion}";
+
+/// A data variable entry that depends on the side of the installation
+#[derive(Serialize, Deserialize, Debug)]
+pub struct SidedDataEntry {
+    /// The value on the client
+    pub client: String,
+    /// The value on the server
+    pub server: String,
+}
+
+fn deserialize_date<'de, D>(deserializer: D) -> Result<DateTime<Utc>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let s = String::deserialize(deserializer)?;
+
+    serde_json::from_str::<DateTime<Utc>>(&format!("\"{s}\""))
+        .or_else(|_| Utc.datetime_from_str(&s, "%Y-%m-%dT%H:%M:%S%.9f"))
+        .map_err(serde::de::Error::custom)
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+/// A partial version returned by fabric meta
+pub struct PartialVersionInfo {
+    /// The version ID of the version
+    pub id: String,
+    /// The version ID this partial version inherits from
+    pub inherits_from: String,
+    /// The time that the version was released
+    #[serde(deserialize_with = "deserialize_date")]
+    pub release_time: DateTime<Utc>,
+    /// The latest time a file in this version was updated
+    #[serde(deserialize_with = "deserialize_date")]
+    pub time: DateTime<Utc>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The classpath to the main class to launch the game
+    pub main_class: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// (Legacy) Arguments passed to the game
+    pub minecraft_arguments: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Arguments passed to the game or JVM
+    pub arguments: Option<HashMap<ArgumentType, Vec<Argument>>>,
+    /// Libraries that the version depends on
+    pub libraries: Vec<Library>,
+    #[serde(rename = "type")]
+    /// The type of version
+    pub type_: VersionType,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// (Forge-only)
+    pub data: Option<HashMap<String, SidedDataEntry>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// (Forge-only) The list of processors to run after downloading the files
+    pub processors: Option<Vec<Processor>>,
+}
+
+/// A processor to be ran after downloading the files
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Processor {
+    /// Maven coordinates for the JAR library of this processor.
+    pub jar: String,
+    /// Maven coordinates for all the libraries that must be included in classpath when running this processor.
+    pub classpath: Vec<String>,
+    /// Arguments for this processor.
+    pub args: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Represents a map of outputs. Keys and values can be data values
+    pub outputs: Option<HashMap<String, String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Which sides this processor shall be ran on.
+    /// Valid values: client, server, extract
+    pub sides: Option<Vec<String>>,
+}
+
+/// Merges a partial version into a complete one
+pub fn merge_partial_version(
+    partial: PartialVersionInfo,
+    merge: VersionInfo,
+) -> VersionInfo {
+    let merge_id = merge.id.clone();
+
+    let mut libraries = vec![];
+
+    // We skip duplicate libraries that exist already in the partial version
+    for mut lib in merge.libraries {
+        let lib_artifact = lib.name.rsplit_once(':').map(|x| x.0);
+
+        if let Some(lib_artifact) = lib_artifact {
+            if !partial.libraries.iter().any(|x| {
+                let target_artifact = x.name.rsplit_once(':').map(|x| x.0);
+
+                target_artifact == Some(lib_artifact) && x.include_in_classpath
+            }) {
+                libraries.push(lib);
+            } else {
+                lib.include_in_classpath = false;
+            }
+        } else {
+            libraries.push(lib);
+        }
+    }
+
+    VersionInfo {
+        arguments: if let Some(partial_args) = partial.arguments {
+            if let Some(merge_args) = merge.arguments {
+                let mut new_map = HashMap::new();
+
+                fn add_keys(
+                    new_map: &mut HashMap<ArgumentType, Vec<Argument>>,
+                    args: HashMap<ArgumentType, Vec<Argument>>,
+                ) {
+                    for (type_, arguments) in args {
+                        for arg in arguments {
+                            if let Some(vec) = new_map.get_mut(&type_) {
+                                vec.push(arg);
+                            } else {
+                                new_map.insert(type_, vec![arg]);
+                            }
+                        }
+                    }
+                }
+
+                add_keys(&mut new_map, merge_args);
+                add_keys(&mut new_map, partial_args);
+
+                Some(new_map)
+            } else {
+                Some(partial_args)
+            }
+        } else {
+            merge.arguments
+        },
+        asset_index: merge.asset_index,
+        assets: merge.assets,
+        downloads: merge.downloads,
+        id: partial.id.replace(DUMMY_REPLACE_STRING, &merge_id),
+        java_version: merge.java_version,
+        libraries: libraries.into_iter()
+            .chain(partial.libraries)
+            .map(|mut x| {
+                x.name = x.name.replace(DUMMY_REPLACE_STRING, &merge_id);
+
+                x
+            })
+            .collect::<Vec<_>>(),
+        main_class: if let Some(main_class) = partial.main_class {
+            main_class
+        } else {
+            merge.main_class
+        },
+        minecraft_arguments: partial.minecraft_arguments,
+        minimum_launcher_version: merge.minimum_launcher_version,
+        release_time: partial.release_time,
+        time: partial.time,
+        type_: partial.type_,
+        data: partial.data,
+        processors: partial.processors,
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+/// A manifest containing information about a mod loader's versions
+pub struct Manifest {
+    /// The game versions the mod loader supports
+    pub game_versions: Vec<Version>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+///  A game version of Minecraft
+pub struct Version {
+    /// The minecraft version ID
+    pub id: String,
+    /// Whether the release is stable or not
+    pub stable: bool,
+    /// A map that contains loader versions for the game version
+    pub loaders: Vec<LoaderVersion>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+/// A version of a Minecraft mod loader
+pub struct LoaderVersion {
+    /// The version ID of the loader
+    pub id: String,
+    /// The URL of the version's manifest
+    pub url: String,
+    /// Whether the loader is stable or not
+    pub stable: bool,
+}