Merge pull request #19 from Ryex/javas

Add java runtime metadata 

4 files changed, 682 insertions, 18 deletions

diff --git a/meta/model/__init__.py b/meta/model/__init__.py
index fb062f5d35..3d06f998ab 100644
--- a/meta/model/__init__.py
+++ b/meta/model/__init__.py
@@ -4,7 +4,7 @@ from pathlib import Path
 from typing import Optional, List, Dict, Any, Iterator
 
 import pydantic
-from pydantic import Field, validator
+from pydantic import Field, validator  # type: ignore
 
 from ..common import (
     LAUNCHER_MAVEN,
@@ -87,13 +87,16 @@ class GradleSpecifier:
     def is_log4j(self):
         return self.group == "org.apache.logging.log4j"
 
-    def __eq__(self, other):
-        return str(self) == str(other)
+    def __eq__(self, other: Any):
+        if isinstance(other, GradleSpecifier):
+            return str(self) == str(other)
+        else:
+            return False
 
-    def __lt__(self, other):
+    def __lt__(self, other: "GradleSpecifier"):
         return str(self) < str(other)
 
-    def __gt__(self, other):
+    def __gt__(self, other: "GradleSpecifier"):
         return str(self) > str(other)
 
     def __hash__(self):
@@ -122,7 +125,7 @@ class GradleSpecifier:
         return cls(group, artifact, version, classifier, extension)
 
     @classmethod
-    def validate(cls, v):
+    def validate(cls, v: "str | GradleSpecifier"):
         if isinstance(v, cls):
             return v
         if isinstance(v, str):
@@ -131,7 +134,7 @@ class GradleSpecifier:
 
 
 class MetaBase(pydantic.BaseModel):
-    def dict(self, **kwargs) -> Dict[str, Any]:
+    def dict(self, **kwargs: Any) -> Dict[str, Any]:
         for k in ["by_alias"]:
             if k in kwargs:
                 del kwargs[k]
@@ -147,12 +150,12 @@ class MetaBase(pydantic.BaseModel):
             exclude_none=True, sort_keys=True, by_alias=True, indent=4, **kwargs
         )
 
-    def write(self, file_path):
+    def write(self, file_path: str):
         Path(file_path).parent.mkdir(parents=True, exist_ok=True)
         with open(file_path, "w") as f:
             f.write(self.json())
 
-    def merge(self, other):
+    def merge(self, other: "MetaBase"):
         """
         Merge other object with self.
         - Concatenates lists
@@ -176,14 +179,14 @@ class MetaBase(pydantic.BaseModel):
             elif isinstance(ours, set):
                 ours |= theirs
             elif isinstance(ours, dict):
-                result = merge_dict(ours, copy.deepcopy(theirs))
+                result = merge_dict(ours, copy.deepcopy(theirs))  # type: ignore
                 setattr(self, key, result)
             elif MetaBase in get_all_bases(field.type_):
                 ours.merge(theirs)
             else:
                 setattr(self, key, theirs)
 
-    def __hash__(self):
+    def __hash__(self):  # type: ignore
         return hash(self.json())
 
     class Config:
@@ -194,7 +197,7 @@ class MetaBase(pydantic.BaseModel):
 
 class Versioned(MetaBase):
     @validator("format_version")
-    def format_version_must_be_supported(cls, v):
+    def format_version_must_be_supported(cls, v: int):
         assert v <= META_FORMAT_VERSION
         return v
 
@@ -209,7 +212,7 @@ class MojangArtifactBase(MetaBase):
 
 class MojangAssets(MojangArtifactBase):
     @validator("url")
-    def validate_url(cls, v):
+    def validate_url(cls, v: str):
         return replace_old_launchermeta_url(v)
 
     id: str
@@ -245,7 +248,7 @@ class MojangLibraryDownloads(MetaBase):
 
 class OSRule(MetaBase):
     @validator("name")
-    def name_must_be_os(cls, v):
+    def name_must_be_os(cls, v: str):
         assert v in [
             "osx",
             "linux",
@@ -263,7 +266,7 @@ class OSRule(MetaBase):
 
 class MojangRule(MetaBase):
     @validator("action")
-    def action_must_be_allow_disallow(cls, v):
+    def action_must_be_allow_disallow(cls, v: str):
         assert v in ["allow", "disallow"]
         return v
 
@@ -274,10 +277,10 @@ class MojangRule(MetaBase):
 class MojangRules(MetaBase):
     __root__: List[MojangRule]
 
-    def __iter__(self) -> Iterator[MojangRule]:
+    def __iter__(self) -> Iterator[MojangRule]:  # type: ignore
         return iter(self.__root__)
 
-    def __getitem__(self, item) -> MojangRule:
+    def __getitem__(self, item: int) -> MojangRule:
         return self.__root__[item]
 
 
@@ -316,6 +319,7 @@ class MetaVersion(Versioned):
     minecraft_arguments: Optional[str] = Field(alias="minecraftArguments")
     release_time: Optional[datetime] = Field(alias="releaseTime")
     compatible_java_majors: Optional[List[int]] = Field(alias="compatibleJavaMajors")
+    compatible_java_name: Optional[str] = Field(alias="compatibleJavaName")
     additional_traits: Optional[List[str]] = Field(alias="+traits")
     additional_tweakers: Optional[List[str]] = Field(alias="+tweakers")
     additional_jvm_args: Optional[List[str]] = Field(alias="+jvmArgs")
diff --git a/meta/model/enum.py b/meta/model/enum.py
new file mode 100644
index 0000000000..08dda4bf4a
--- /dev/null
+++ b/meta/model/enum.py
@@ -0,0 +1,32 @@
+import enum
+
+
+class StrEnum(str, enum.Enum):
+    """
+    StrEnum is a Python ``enum.Enum`` that inherits from ``str``. The default
+    ``auto()`` behavior uses the member name as its value.
+
+    Example usage::
+
+        class Example(StrEnum):
+            UPPER_CASE = auto()
+            lower_case = auto()
+            MixedCase = auto()
+
+        assert Example.UPPER_CASE == "UPPER_CASE"
+        assert Example.lower_case == "lower_case"
+        assert Example.MixedCase == "MixedCase"
+    """
+
+    def __new__(cls, value, *args, **kwargs):
+        if not isinstance(value, (str, enum.auto)):
+            raise TypeError(
+                f"Values of StrEnums must be strings: {value!r} is a {type(value)}"
+            )
+        return super().__new__(cls, value, *args, **kwargs)
+
+    def __str__(self):
+        return str(self.value)
+
+    def _generate_next_value_(name, *_):
+        return name
diff --git a/meta/model/java.py b/meta/model/java.py
new file mode 100644
index 0000000000..e24932ef85
--- /dev/null
+++ b/meta/model/java.py
@@ -0,0 +1,558 @@
+from . import (
+    MetaBase,
+    MetaVersion,
+    Versioned,
+)
+from pydantic import Field
+from datetime import datetime
+from enum import IntEnum, Enum
+from .enum import StrEnum
+from typing import Optional, Any, NamedTuple, Generator
+from urllib.parse import urlencode, urlparse, urlunparse
+from functools import total_ordering
+
+# namedtuple to match the internal signature of urlunparse
+
+
+class JavaRuntimeOS(StrEnum):
+    MacOsX64 = "mac-os-x64"
+    MacOsX86 = "mac-os-x86"  # rare
+    MacOsArm64 = "mac-os-arm64"
+    # MacOsArm32 = "mac-os-arm32" # doesn't exsist
+    LinuxX64 = "linux-x64"
+    LinuxX86 = "linux-x86"
+    LinuxArm64 = "linux-arm64"
+    LinuxArm32 = "linux-arm32"
+    WindowsX64 = "windows-x64"
+    WindowsX86 = "windows-x86"
+    WindowsArm64 = "windows-arm64"
+    WindowsArm32 = "windows-arm32"
+    Unknown = "unknown"
+
+
+class JavaRuntimeDownloadType(StrEnum):
+    Manifest = "manifest"
+    Archive = "archive"
+
+
+@total_ordering
+class JavaVersionMeta(MetaBase):
+    major: int
+    minor: int
+    security: int
+    build: Optional[int] = None
+    name: Optional[str] = None
+
+    def __str__(self):
+        ver = f"{self.major}.{self.minor}.{self.security}"
+        if self.build is not None:
+            ver = f"{ver}+{self.build}"
+        return ver
+
+    def to_tuple(self):
+        build = 0
+        if self.build is not None:
+            build = self.build
+        return (self.major, self.minor, self.security, build)
+
+    def __eq__(self, other: Any):
+        return self.to_tuple() == other.to_tuple()
+
+    def __lt__(self, other: "JavaVersionMeta"):
+        return self.to_tuple() < other.to_tuple()
+
+
+class JavaChecksumType(StrEnum):
+    Sha1 = "sha1"
+    Sha256 = "sha256"
+
+
+class JavaChecksumMeta(MetaBase):
+    type: JavaChecksumType
+    hash: str
+
+
+class JavaPackageType(StrEnum):
+    Jre = "jre"
+    Jdk = "jdk"
+
+
+class JavaRuntimeMeta(MetaBase):
+    name: str
+    vendor: str
+    url: str
+    release_time: datetime = Field(alias="releaseTime")
+    checksum: Optional[JavaChecksumMeta]
+    download_type: JavaRuntimeDownloadType = Field(alias="downloadType")
+    package_type: JavaPackageType = Field(alias="packageType")
+    version: JavaVersionMeta
+    runtime_os: JavaRuntimeOS = Field(alias="runtimeOS")
+
+
+class JavaRuntimeVersion(MetaVersion):
+    runtimes: list[JavaRuntimeMeta]
+
+
+class URLComponents(NamedTuple):
+    scheme: str
+    netloc: str
+    url: str
+    path: str
+    query: str
+    fragment: str
+
+
+class APIQuery(MetaBase):
+    def to_query(self):
+        set_parts: dict[str, Any] = {}
+        for key, value in self.dict().items():
+            if value is not None:
+                if isinstance(value, Enum):
+                    set_parts[key] = value.value
+                elif isinstance(value, list):
+                    if len(value) > 0:  # type: ignore
+                        set_parts[key] = value
+                elif isinstance(value, datetime):
+                    set_parts[key] = value.isoformat()
+                else:
+                    set_parts[key] = value
+        return urlencode(set_parts, doseq=True)
+
+
+class AdoptiumJvmImpl(StrEnum):
+    Hostspot = "hotspot"
+
+
+class AdoptiumVendor(StrEnum):
+    Eclipse = "eclipse"
+
+
+class AdoptiumArchitecture(StrEnum):
+    X64 = "x64"
+    X86 = "x86"
+    X32 = "x32"
+    Ppc64 = "ppc64"
+    Ppc64le = "ppc64le"
+    S390x = "s390x"
+    Aarch64 = "aarch64"
+    Arm = "arm"
+    Sparcv9 = "sparcv9"
+    Riscv64 = "riscv64"
+
+
+class AdoptiumReleaseType(StrEnum):
+    GenralAccess = "ga"
+    EarlyAccess = "ea"
+
+
+class AdoptiumSortMethod(StrEnum):
+    Default = "DEFAULT"
+    Date = "DATE"
+
+
+class AdoptiumSortOrder(StrEnum):
+    Asc = "ASC"
+    Desc = "DESC"
+
+
+class AdoptiumImageType(StrEnum):
+    Jdk = "jdk"
+    Jre = "jre"
+    Testimage = "testimage"
+    Debugimage = "debugimage"
+    Staticlibs = "staticlibs"
+    Sources = "sources"
+    Sbom = "sbom"
+
+
+class AdoptiumHeapSize(StrEnum):
+    Normal = "normal"
+    Large = "large"
+
+
+class AdoptiumProject(StrEnum):
+    Jdk = "jdk"
+    Valhalla = "valhalla"
+    Metropolis = "metropolis"
+    Jfr = "jfr"
+    Shenandoah = "shenandoah"
+
+
+class AdoptiumCLib(StrEnum):
+    Musl = "musl"
+    Glibc = "glibc"
+
+
+class AdoptiumOs(StrEnum):
+    Linux = "linux"
+    Windows = "windows"
+    Mac = "mac"
+    Solaris = "solaris"
+    Aix = "aix"
+    AlpineLinux = "alpine-linux"
+
+
+ADOPTIUM_API_BASE = " https://api.adoptium.net"
+ADOPTIUM_API_FEATURE_RELEASES = f"{ADOPTIUM_API_BASE}/v3/assets/feature_releases/{{feature_version}}/{{release_type}}"
+# ?image_type={{image_type}}&heap_size={{heap_size}}&project={{project}}&vendor={{vendor}}&page_size={{page_size}}&page={{page}}&sort_method={{sort_method}}&sort_order={{sort_order}}
+ADOPTIUM_API_AVAILABLE_RELEASES = f"{ADOPTIUM_API_BASE}/v3/info/available_releases"
+
+
+class AdoptiumAPIFeatureReleasesQuery(APIQuery):
+    architecture: Optional[AdoptiumArchitecture] = None
+    before: Optional[datetime] = None
+    c_lib: Optional[AdoptiumCLib] = None
+    heap_size: Optional[AdoptiumHeapSize] = AdoptiumHeapSize.Normal
+    image_type: Optional[AdoptiumImageType] = None
+    jvm_impl: Optional[AdoptiumJvmImpl] = None
+    os: Optional[AdoptiumOs] = None
+    page_size: int = 10
+    page: int = 0
+    project: Optional[AdoptiumProject] = AdoptiumProject.Jdk
+    sort_method: Optional[AdoptiumSortMethod] = AdoptiumSortMethod.Default
+    sort_order: Optional[AdoptiumSortOrder] = AdoptiumSortOrder.Desc
+    vendor: Optional[AdoptiumVendor] = AdoptiumVendor.Eclipse
+
+
+def adoptiumAPIFeatureReleasesUrl(
+    feature: int,
+    release_type: AdoptiumReleaseType = AdoptiumReleaseType.GenralAccess,
+    query: AdoptiumAPIFeatureReleasesQuery = AdoptiumAPIFeatureReleasesQuery(),
+):
+    url = urlparse(
+        ADOPTIUM_API_FEATURE_RELEASES.format(
+            feature_version=feature,
+            release_type=release_type.value,
+        )
+    )
+    return urlunparse(url._replace(query=query.to_query()))
+
+
+class AdoptiumAvailableReleases(MetaBase):
+    available_releases: list[int]
+    available_lts_releases: list[int]
+    most_recent_lts: Optional[int]
+    most_recent_feature_release: Optional[int]
+    most_recent_feature_version: Optional[int]
+    tip_version: Optional[int]
+
+
+class AdoptiumFile(MetaBase):
+    name: str
+    link: str
+    size: Optional[int]
+
+
+class AdoptiumPackage(AdoptiumFile):
+    checksum: Optional[str]
+    checksum_link: Optional[str]
+    signature_link: Optional[str]
+    download_count: Optional[int]
+    metadata_link: Optional[str]
+
+
+class AdoptiumBinary(MetaBase):
+    os: str
+    architecture: AdoptiumArchitecture
+    image_type: AdoptiumImageType
+    c_lib: Optional[AdoptiumCLib]
+    jvm_impl: AdoptiumJvmImpl
+    package: Optional[AdoptiumPackage]
+    installer: Optional[AdoptiumPackage]
+    heap_size: AdoptiumHeapSize
+    download_count: Optional[int]
+    updated_at: datetime
+    scm_ref: Optional[str]
+    project: AdoptiumProject
+
+
+class AdoptiumVersion(MetaBase):
+    major: Optional[int]
+    minor: Optional[int]
+    security: Optional[int]
+    patch: Optional[int]
+    pre: Optional[str]
+    adopt_build_number: Optional[int]
+    semver: str
+    openjdk_version: str
+    build: Optional[int]
+    optional: Optional[str]
+
+
+class AdoptiumRelease(MetaBase):
+    release_id: str = Field(alias="id")
+    release_link: str
+    release_name: str
+    timestamp: datetime
+    updated_at: datetime
+    binaries: list[AdoptiumBinary]
+    download_count: Optional[int]
+    release_type: str
+    vendor: AdoptiumVendor
+    version_data: AdoptiumVersion
+    source: Optional[AdoptiumFile]
+    release_notes: Optional[AdoptiumFile]
+
+
+class AdoptiumReleases(MetaBase):
+    __root__: list[AdoptiumRelease]
+
+    def __iter__(self) -> Generator[tuple[str, AdoptiumRelease], None, None]:
+        yield from ((str(i), val) for i, val in enumerate(self.__root__))
+
+    def __getitem__(self, item: int) -> AdoptiumRelease:
+        return self.__root__[item]
+
+    def append(self, rls: AdoptiumRelease):
+        self.__root__.append(rls)
+
+
+class AzulProduct(StrEnum):
+    Zulu = "zulu"
+
+
+class AzulAvailabilityType(StrEnum):
+    SA = "SA"
+    CA = "CA"
+    NV = "NV"
+    _LA = "LA"
+
+
+class AzulJavaPackageType(StrEnum):
+    Jdk = "jdk"
+    Jre = "jre"
+
+
+class AzulReleaseType(StrEnum):
+    CPU = "CPU"
+    PSU = "PSU"
+    LU = "LU"
+
+
+class AzulOs(StrEnum):
+    Linux = "linux"
+    Macos = "macos"
+    Qnx = "qnx"
+    Windows = "windows"
+    Solaris = "solaris"
+
+
+class AzulLibCType(StrEnum):
+    Glibc = "glibc"
+    Uclibc = "uclibc"
+    Musl = "musl"
+
+
+class AzulCPUGen(StrEnum):
+    V5 = "v5"
+    V6kV6kz = "v6k_v6kz"
+    V6t2 = "v6t2"
+    V7 = "v7"
+    V8 = "v8"
+
+
+class AzulArch(StrEnum):
+    Arm = "arm"
+    X86 = "x86"
+    Mips = "mips"
+    Ppc = "ppc"
+    Sparcv9 = "sparcv9"
+    Sparc = "sparc"
+
+
+class AzulHwBitness(IntEnum):
+    X32 = 32
+    X64 = 64
+
+
+class AzulAbi(StrEnum):
+    HardFloat = "hard_float"
+    SoftFloat = "soft_float"
+    Spe = "spe"
+    Any = "any"
+
+
+class AzulArchiveType(StrEnum):
+    Deb = "deb"
+    Rpm = "rpm"
+    Dmg = "dmg"
+    Targz = "tar.gz"
+    Zip = "zip"
+    Cab = "cab"
+    Msi = "msi"
+
+
+class AzulReleaseStatus(StrEnum):
+    Eval = "eval"
+    Ea = "ea"
+    Ga = "ga"
+    Both = "both"
+
+
+class AzulSupportTerm(StrEnum):
+    Sts = "sts"
+    Mts = "mts"
+    Lts = "lts"
+
+
+class AzulCertifications(StrEnum):
+    Tck = "tck"
+    _Aqavit = "aqavit"
+    none = "none"
+
+
+class AzulSignatureType(StrEnum):
+    Openpgp = "openpgp"
+
+
+class AzulOsQueryParam(StrEnum):
+    Macos = "macos"
+    Windows = "windows"
+    Linux = "linux"
+    LinuxMusl = "linux-musl"
+    LinuxGlibc = "linux-glibc"
+    Qnx = "qnx"
+    Solaris = "solaris"
+
+
+class AzulArchQueryParam(StrEnum):
+    X86 = "x86"
+    X64 = "x64"
+    Amd64 = "amd64"
+    I686 = "i686"
+    Arm = "arm"
+    Aarch64 = "aarch64"
+    Aarch32 = "aarch32"
+    Aarch32sf = "aarch32sf"
+    Aarch32hf = "aarch32hf"
+    Ppc = "ppc"
+    Ppc64 = "ppc64"
+    Ppc64hf = "ppc64hf"
+    Ppc32 = "ppc32"
+    Ppc32spe = "ppc32spe"
+    Ppc32hf = "ppc32hf"
+    Sparc = "sparc"
+    Sparc32 = "sparc32"
+    Sparcv9 = "sparcv9"
+    Sparcv9_64 = "sparcv9-64"
+
+
+AZUL_API_BASE = "https://api.azul.com/metadata/v1"
+AZUL_API_PACKAGES = f"{AZUL_API_BASE}/zulu/packages/"
+AZUL_API_PACKAGE_DETAIL = f"{AZUL_API_BASE}/zulu/packages/{{package_uuid}}"
+
+
+class AzulApiPackagesQuery(APIQuery):
+    java_version: Optional[str] = None
+    os: Optional[AzulOsQueryParam] = None
+    arch: Optional[AzulArchQueryParam] = None
+    archive_type: Optional[AzulArchiveType] = None
+    java_package_type: Optional[AzulJavaPackageType] = None
+    javafx_bundled: Optional[bool] = None
+    crac_supported: Optional[bool] = None
+    support_term: Optional[AzulSupportTerm] = None
+    release_type: Optional[AzulReleaseType] = None
+    latest: Optional[bool] = None
+    distro_version: Optional[str] = None
+    java_package_features: list[str] = []
+    release_status: Optional[AzulReleaseStatus] = None
+    availability_types: list[AzulAvailabilityType] = []
+    certifications: list[AzulCertifications] = []
+    include_fields: list[str] = []
+    page: int = 0
+    page_size: int = 100
+
+
+def azulApiPackagesUrl(query: AzulApiPackagesQuery = AzulApiPackagesQuery()):
+    url = urlparse(AZUL_API_PACKAGES)
+    return urlunparse(url._replace(query=query.to_query()))
+
+
+def azulApiPackageDetailUrl(package_uuid: str):
+    return AZUL_API_PACKAGE_DETAIL.format(package_uuid=package_uuid)
+
+
+class ZuluSignatureDetail(MetaBase):
+    type: AzulSignatureType
+    url: str
+    details: dict[str, Any]
+    signature_index: int
+    signature: str
+
+
+class ZuluPackageDetail(MetaBase):
+    package_uuid: str
+    name: Optional[str]
+    md5_hash: Optional[str]
+    sha256_hash: Optional[str]
+    build_date: datetime
+    last_modified: datetime
+    download_url: str
+    product: AzulProduct
+    availability_type: AzulAvailabilityType
+    java_version: list[int]
+    openjdk_build_number: Optional[int]
+    java_package_type: AzulJavaPackageType
+    javafx_bundled: bool
+    release_type: AzulReleaseType
+    os: AzulOs
+    lib_c_type: Optional[AzulLibCType]
+    cpu_gen: Optional[list[AzulCPUGen]]
+    arch: AzulArch
+    hw_bitness: AzulHwBitness
+    abi: AzulAbi
+    archive_type: AzulArchiveType
+    release_status: AzulReleaseStatus
+    support_term: AzulSupportTerm
+    certifications: Optional[list[AzulCertifications]]
+    latest: Optional[bool]
+    size: int
+    distro_version: list[int]
+    signatures: list[ZuluSignatureDetail]
+
+
+class ZuluPackage(MetaBase):
+    package_uuid: str
+    name: Optional[str]
+    java_version: list[int]
+    openjdk_build_number: Optional[int]
+    latest: Optional[bool]
+    download_url: str
+    product: Optional[AzulProduct]
+    distro_version: list[int]
+    availability_type: Optional[AzulAvailabilityType]
+
+
+class ZuluPackageList(MetaBase):
+    __root__: list[ZuluPackage]
+
+    def __iter__(self) -> Generator[tuple[str, ZuluPackage], None, None]:
+        yield from ((str(i), val) for i, val in enumerate(self.__root__))
+
+    def __getitem__(self, item: int) -> ZuluPackage:
+        return self.__root__[item]
+
+    def append(self, pkg: ZuluPackage):
+        self.__root__.append(pkg)
+
+
+class ZuluPackagesDetail(MetaBase):
+    __root__: list[ZuluPackageDetail]
+
+    def __iter__(self) -> Generator[tuple[str, ZuluPackageDetail], None, None]:
+        yield from ((str(i), val) for i, val in enumerate(self.__root__))
+
+    def __getitem__(self, item: int) -> ZuluPackageDetail:
+        return self.__root__[item]
+
+    def append(self, pkg: ZuluPackageDetail):
+        self.__root__.append(pkg)
+
+
+MOJANG_OS_NAMES = ["mac-os", "linux", "windows"]
+
+MOJANG_OS_ARCHITECTURES = [
+    "x64" "x86",
+    "arm64",
+    "arm32",
+]
diff --git a/meta/model/mojang.py b/meta/model/mojang.py
index 221f8e074e..6fb71e7e73 100644
--- a/meta/model/mojang.py
+++ b/meta/model/mojang.py
@@ -1,5 +1,6 @@
 from datetime import datetime
 from typing import Optional, List, Dict, Any, Iterator
+from .enum import StrEnum
 
 from pydantic import validator, Field
 
@@ -17,6 +18,9 @@ from . import (
 SUPPORTED_LAUNCHER_VERSION = 21
 SUPPORTED_COMPLIANCE_LEVEL = 1
 DEFAULT_JAVA_MAJOR = 8  # By default, we should recommend Java 8 if we don't know better
+DEFAULT_JAVA_NAME = (
+    "jre-legacy"  # By default, we should recommend Java 8 if we don't know better
+)
 COMPATIBLE_JAVA_MAPPINGS = {16: [17]}
 SUPPORTED_FEATURES = ["is_quick_play_multiplayer"]
 
@@ -193,11 +197,74 @@ class MojangLogging(MetaBase):
     type: str
 
 
+class MojangJavaComponent(StrEnum):
+    JreLegacy = "jre-legacy"
+    Alpha = "java-runtime-alpha"
+    Beta = "java-runtime-beta"
+    Gamma = "java-runtime-gamma"
+    GammaSnapshot = "java-runtime-gamma-snapshot"
+    Exe = "minecraft-java-exe"
+    Delta = "java-runtime-delta"
+
+
 class JavaVersion(MetaBase):
-    component: str = "jre-legacy"
+    component: MojangJavaComponent = MojangJavaComponent.JreLegacy
     major_version: int = Field(8, alias="majorVersion")
 
 
+class MojangJavaIndexAvailability(MetaBase):
+    group: int
+    progress: int
+
+
+class MojangJavaIndexManifest(MetaBase):
+    sha1: str
+    size: int
+    url: str
+
+
+class MojangJavaIndexVersion(MetaBase):
+    name: str
+    released: datetime
+
+
+class MojangJavaRuntime(MetaBase):
+    availability: MojangJavaIndexAvailability
+    manifest: MojangJavaIndexManifest
+    version: MojangJavaIndexVersion
+
+
+class MojangJavaIndexEntry(MetaBase):
+    __root__: dict[MojangJavaComponent, list[MojangJavaRuntime]]
+
+    def __iter__(self) -> Iterator[MojangJavaComponent]:
+        return iter(self.__root__)
+
+    def __getitem__(self, item) -> list[MojangJavaRuntime]:
+        return self.__root__[item]
+
+
+class MojangJavaOsName(StrEnum):
+    Gamecore = "gamecore"
+    Linux = "linux"
+    Linuxi386 = "linux-i386"
+    MacOs = "mac-os"
+    MacOSArm64 = "mac-os-arm64"
+    WindowsArm64 = "windows-arm64"
+    WindowsX64 = "windows-x64"
+    WindowsX86 = "windows-x86"
+
+
+class JavaIndex(MetaBase):
+    __root__: dict[MojangJavaOsName, MojangJavaIndexEntry]
+
+    def __iter__(self) -> Iterator[MojangJavaOsName]:
+        return iter(self.__root__)
+
+    def __getitem__(self, item) -> MojangJavaIndexEntry:
+        return self.__root__[item]
+
+
 class MojangVersion(MetaBase):
     @validator("minimum_launcher_version")
     def validate_minimum_launcher_version(cls, v):
@@ -256,10 +323,12 @@ class MojangVersion(MetaBase):
             raise Exception(f"Unsupported compliance level {self.compliance_level}")
 
         major = DEFAULT_JAVA_MAJOR
+        javaName = DEFAULT_JAVA_NAME
         if (
             self.javaVersion is not None
         ):  # some versions don't have this. TODO: maybe maintain manual overrides
             major = self.javaVersion.major_version
+            javaName = self.javaVersion.component
 
         compatible_java_majors = [major]
         if (
@@ -281,6 +350,7 @@ class MojangVersion(MetaBase):
             release_time=self.release_time,
             type=new_type,
             compatible_java_majors=compatible_java_majors,
+            compatible_java_name=javaName,
             additional_traits=addn_traits,
             main_jar=main_jar,
         )