schema.graphql

schema {
  query: Query
  mutation: Mutation
}

"""This directive allows results to be deferred during execution"""
directive @defer(
  """Deferred behaviour is controlled by this argument"""
  if: Boolean! = true
  """A unique label that represents the fragment being deferred"""
  label: String
) on FRAGMENT_SPREAD | INLINE_FRAGMENT

"""
This directive disables error propagation when a non nullable field returns null for the given operation.
"""
directive @experimental_disableErrorPropagation on MUTATION | QUERY | SUBSCRIPTION

directive @implement(interfaces: [String!]!) on INTERFACE | OBJECT

directive @orderBy on FIELD_DEFINITION

directive @paginated on FIELD_DEFINITION

directive @predicateType on INPUT_OBJECT

"""
Indicates that a field requires the user executing the request to have certain permissions.
"""
directive @requires(permission: Permission) on FIELD_DEFINITION

"""
Indicates that the element (and its children) is unstable and it may change in the future without notice
"""
directive @unstable on FIELD_DEFINITION | OBJECT

"""
Represents an object that can be annotated - method, field or class definition
"""
interface Annotatable {
  """Returns annotations on this object matching the given predicate"""
  annotations(
    """An optional filter to apply to the query"""
    where: AnnotationPredicate
  ): [Annotation!]!
}

"""An annotation instance (the type and its value as a JSON object)"""
type Annotation {
  """The type of the annotation - e.g. `java/lang/Deprecated`"""
  type: String!
  """The value of this annotation as a JSON object"""
  value: JSON
}

"""Used to filter annotations based on different criteria"""
input AnnotationPredicate {
  """Match if all of the given filters match"""
  allOf: [AnnotationPredicate!]
  """Match if any of the given filters matches"""
  anyOf: [AnnotationPredicate!]
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [AnnotationPredicate!]
  """Invert the given filter"""
  not: AnnotationPredicate
  """Filter based on the annotation type"""
  type: StringPredicate
  """Filter based on the annotation value"""
  value: JSONPredicate
}

"""
A base interfaces for classes identified by their name (e.g. `java/lang/String`)
"""
interface BaseClass implements Identifiable {
  """Returns all known concrete definitions of the class"""
  definitions(
    """Optional ordering to apply to the returned elements"""
    order: ClassDefinitionOrdering
    """Optional filter applied to the query"""
    where: ClassDefinitionPredicate
  ): [ClassDefinition!]!
  """
  The fields of this class, optionally matching the given predicate.
  Note that it is not guaranteed that the fields returned have a concrete implementation.
  """
  fields(
    """Limit the amount of fields returned"""
    limit: Int
    """Optional filter to apply to the query"""
    where: FieldPredicate
  ): [Field!]!
  """The unique ID of this object"""
  id: Int!
  """
  The methods of this class, optionally matching the given predicate.
  Note that it is not guaranteed that the methods returned have a concrete implementation.
  """
  methods(
    """Limit the amount of methods returned"""
    limit: Int
    """Optional filter to apply to the query"""
    where: MethodPredicate
  ): [Method!]!
  """The name of this class"""
  name: String!
}

"""
A base interface used to describe the simple properties of an indexed Mod
"""
interface BaseMod implements Identifiable {
  """The authors of this mod (derived from mod metadata)"""
  authors: String
  """The ID of the CurseForge project associated with this mod"""
  curseforgeProjectId: Int
  """The unique ID of this object"""
  id: Int!
  """The time this mod was last indexed"""
  indexedOn: DateTime
  """The license of this mod (derived from mod metadata)"""
  license: String
  """The sections of the manifest of the last jar indexed for this mod"""
  manifest: [ManifestEntry!]!
  """
  The maven coordinates of this mod (only set if this mod was JiJ'd by another mod).
  On Fabric these are not real maven coordinates, rather the ID of the mod if the file is a mod, or if the file is a non-mod library, it will be generated by Loom based on its maven coordinates.
  """
  mavenCoordinates: String
  """
  The metadata of this mod, in JSON format.
  Can be sourced from one of the following files depending on the loader:
  - `META-INF/neoforge.mods.toml` for NeoForge
  - `META-INF/mods.toml` for Forge
  - `fabric.mod.json` for Fabric
  """
  metadata(
    """
    Optional JSONPath to return the element(s) at a specific path from the metadata
    """
    path: String
  ): JSON
  """
  The mod IDs of this mod.
  Some loaders only allow a mod to have one ID (Fabric) while others may allow a mod file to have multiple mod IDs.
  For non-mod files this will be null.
  """
  modIds: [String!]
  """The ID of the Modrinth project associated with this mod"""
  modrinthProjectId: String
  """
  The name of this mod (derived from mod metadata, jar contents or maven coordinates)
  """
  name: String!
  """
  The artifacts this mod file nests within itself, using a jar-in-jar system.
  Note that this is returned as a tree, rather than a flat array containing sub-nested artifacts.
  """
  nestedArtifacts: [NestedArtifactNode!]
  """
  The artifacts this mod file nests within itself, using a jar-in-jar system.
  Note that unlike `nestedArtifacts`, this is returned as a flat array, rather than a tree.
  """
  nestedArtifactsFlat: [NestedArtifact!]
  """The last indexed version of this mod"""
  version: String!
}

"""Represents an artifact nested within another one"""
interface BaseNestedArtifact {
  """The ID of this artifact"""
  id: String!
  """The version of this artifact"""
  version: String!
}

"""
Used to cast objects within predicates to concrete types (useful for JSONPath extract predicates)
"""
input CastingPredicate {
  """Cast the object to int"""
  int: IntPredicate
  """Cast the object to string"""
  string: StringPredicate
}

"""
A class identified by its name (e.g. `java/lang/String`) from which an inheritor search can be started.
"""
type Class implements BaseClass & Identifiable {
  """Returns all known concrete definitions of the class"""
  definitions(
    """Optional ordering to apply to the returned elements"""
    order: ClassDefinitionOrdering
    """Optional filter applied to the query"""
    where: ClassDefinitionPredicate
  ): [ClassDefinition!]!
  """
  The fields of this class, optionally matching the given predicate.
  Note that it is not guaranteed that the fields returned have a concrete implementation.
  """
  fields(
    """Limit the amount of fields returned"""
    limit: Int
    """Optional filter to apply to the query"""
    where: FieldPredicate
  ): [Field!]!
  """The unique ID of this object"""
  id: Int!
  """
  Returns all known classes that inherit from this class and which optionally match the given filter.
  """
  inheritors(
    """Limit the amount of classes returned"""
    limit: Int
    """Optional ordering to apply to the returned elements"""
    order: InheritanceTreeClassOrdering
    """
    A filter to apply to the returned classes.
    Note that this filter applies on each node individually. This means that when a class is removed by the predicate, classes that further inherit from it will still be returned.
    """
    where: InheritorPredicate
  ): [InheritanceTreeClass!]!
  """
  The methods of this class, optionally matching the given predicate.
  Note that it is not guaranteed that the methods returned have a concrete implementation.
  """
  methods(
    """Limit the amount of methods returned"""
    limit: Int
    """Optional filter to apply to the query"""
    where: MethodPredicate
  ): [Method!]!
  """The name of this class"""
  name: String!
}

"""A connection (list) composed of `Class`."""
type ClassConnection {
  """Identifies the amount of items in the returned edges."""
  count: Int!
  """A list of edges."""
  edges: [ClassEdge!]!
  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

"""A concrete definition of a class"""
type ClassDefinition implements Annotatable & ModOwned {
  """Returns annotations on this object matching the given predicate"""
  annotations(
    """An optional filter to apply to the query"""
    where: AnnotationPredicate
  ): [Annotation!]!
  """
  The fields this class defines directly.
  Note that this list is not complete and only contains fields relevant for API usage. Therefore private fields that have no annotations are not tracked.
  """
  fields(
    """Limit the amount of fields returned"""
    limit: Int
    """Optional ordering to apply to the returned elements"""
    order: FieldDefinitionOrdering
    """Optional filter to apply to the query"""
    where: FieldPredicate
  ): [FieldDefinition!]!
  """
  The methods this class defines directly.
  Note that this list is not complete and only contains methods relevant for API usage. Therefore private methods that have no annotations are not tracked.
  """
  methods(
    """Limit the amount of methods returned"""
    limit: Int
    """Optional ordering to apply to the returned elements"""
    order: MethodDefinitionOrdering
    """Optional filter to apply to the query"""
    where: MethodPredicate
  ): [MethodDefinition!]!
  """The mod that owns this object"""
  mod: LightweightMod!
  """The name of this class"""
  name: String!
  """
  Classes this class directly inherits from (both super classes and interfaces)
  """
  parents: [String!]
  """
  The fields this class references.
  Note that this list is not complete and only contains references relevant for API usage. Therefore references to private or static fields of classes in the same mod are not tracked.
  """
  referencedFields: [ReferencedField!]!
  """
  The methods this class references.
  Note that this list is not complete and only contains references relevant for API usage. Therefore references to private, static or non-overriding methods of classes in the same mod are not tracked.
  """
  referencedMethods: [ReferencedMethod!]!
}

"""A connection (list) composed of `ClassDefinition`."""
type ClassDefinitionConnection {
  """Identifies the amount of items in the returned edges."""
  count: Int!
  """A list of edges."""
  edges: [ClassDefinitionEdge!]!
  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

"""An edge of a `ClassDefinition`."""
type ClassDefinitionEdge {
  """The cursor ID of the element."""
  cursor: ID!
  """The item at the end of the edge."""
  node: ClassDefinition!
}

"""Type used to order `ClassDefinition`s"""
input ClassDefinitionOrdering {
  """Order by name"""
  name: OrderMethod
}

"""Used to filter class definitions based on different criteria"""
input ClassDefinitionPredicate {
  """Match if all of the given filters match"""
  allOf: [ClassDefinitionPredicate!]
  """
  A class definition will match if any of its annotations match the given predicate
  """
  anyAnnotation: AnnotationPredicate
  """
  A class definition will match if any of the fields it defines matches the given predicate
  """
  anyField: FieldDefinitionPredicate
  """
  A class definition will match if any of the methods it defines matches the given predicate
  """
  anyMethod: MethodDefinitionPredicate
  """Match if any of the given filters matches"""
  anyOf: [ClassDefinitionPredicate!]
  """
  A class definition will match if any of its <b>direct</b> parents match the given predicate
  """
  anyParent: StringPredicate
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """
  A class definition will match if the mod that defines it matches the given predicate
  """
  mod: ModPredicate
  """Filter based on the class' JVM name"""
  name: StringPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [ClassDefinitionPredicate!]
  """Invert the given filter"""
  not: ClassDefinitionPredicate
}

"""An edge of a `Class`."""
type ClassEdge {
  """The cursor ID of the element."""
  cursor: ID!
  """The item at the end of the edge."""
  node: Class!
}

"""Used to filter classes based on different criteria"""
input ClassPredicate {
  """Match if all of the given filters match"""
  allOf: [ClassPredicate!]
  """A class will match if any of its fields match the given predicate"""
  anyField: FieldPredicate
  """A class will match if any of its methods match the given predicate"""
  anyMethod: MethodPredicate
  """Match if any of the given filters matches"""
  anyOf: [ClassPredicate!]
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the class' JVM name"""
  name: StringPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [ClassPredicate!]
  """Invert the given filter"""
  not: ClassPredicate
}

"""An arbitrary JSON data file"""
type DataFile implements ModOwned {
  """The mod that owns this object"""
  mod: LightweightMod!
  """
  The name of this file (e.g. `mymod:my/file` for a file at `data/mymod/somepath/my/file.json`, with the base path of the query being `somepath`)
  """
  name: String!
  """The contents of the data file."""
  value: JSON!
}

"""A connection (list) composed of `DataFile`."""
type DataFileConnection {
  """Identifies the amount of items in the returned edges."""
  count: Int!
  """A list of edges."""
  edges: [DataFileEdge!]!
  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

"""An edge of a `DataFile`."""
type DataFileEdge {
  """The cursor ID of the element."""
  cursor: ID!
  """The item at the end of the edge."""
  node: DataFile!
}

"""Used to filter data files based on different criteria"""
input DataFilePredicate {
  """Match if all of the given filters match"""
  allOf: [DataFilePredicate!]
  """Match if any of the given filters matches"""
  anyOf: [DataFilePredicate!]
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the data file name"""
  name: StringPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [DataFilePredicate!]
  """Invert the given filter"""
  not: DataFilePredicate
  """Filter based on the data file JSON contents"""
  recipe: JSONPredicate
}

"""A NeoForge data map"""
type DataMap {
  """The entries in this file"""
  entries: [DataMapEntry!]!
  """The name of this data map (e.g. `neoforge:compostables`)"""
  name: String!
}

"""A connection (list) composed of `DataMap`."""
type DataMapConnection {
  """Identifies the amount of items in the returned edges."""
  count: Int!
  """A list of edges."""
  edges: [DataMapEdge!]!
  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

"""An edge of a `DataMap`."""
type DataMapEdge {
  """The cursor ID of the element."""
  cursor: ID!
  """The item at the end of the edge."""
  node: DataMap!
}

"""An entry in a NeoForge data map"""
type DataMapEntry {
  """
  The key of this entry. Can either be the location of a registry object (e.g. `minecraft:coal_block`) or a tag, denoted by a # at the start (e.g. `#minecraft:logs`)
  """
  key: String!
  """The values assigned to this entry by different mods."""
  values: [DataMapValue!]!
}

"""A NeoForge data map file"""
type DataMapFile {
  """The entries in this file"""
  entries: [DataMapFileEntry!]!
  """The name of this data map (e.g. `neoforge:compostables`)"""
  name: String!
}

"""An entry in a NeoForge data map file"""
type DataMapFileEntry {
  """
  The key of this entry. Can either be the location of a registry object (e.g. `minecraft:coal_block`) or a tag, denoted by a # at the start (e.g. `#minecraft:logs`)
  """
  key: String!
  """
  Whether this entry replaces previously added entries for objects within the key without invoking mergers.
  Corresponds to the "replace" field at either the top of the data map file or within individual entries.
  """
  replace: Boolean!
  """
  The value of this entry - i.e. the object attached to the entry with the `key` ID or to entries within the tag, if the `key` is a tag
  """
  value: JSON!
}

"""Used to filter data map files based on different criteria"""
input DataMapFilePredicate {
  """Match if all of the given filters match"""
  allOf: [DataMapFilePredicate!]
  """Match if any of the given filters matches"""
  anyOf: [DataMapFilePredicate!]
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the data map name"""
  name: StringPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [DataMapFilePredicate!]
  """Invert the given filter"""
  not: DataMapFilePredicate
}

"""Used to filter data maps based on different criteria"""
input DataMapPredicate {
  """Match if all of the given filters match"""
  allOf: [DataMapPredicate!]
  """Match if any of the given filters matches"""
  anyOf: [DataMapPredicate!]
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the data map name"""
  name: StringPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [DataMapPredicate!]
  """Invert the given filter"""
  not: DataMapPredicate
}

"""A value within a NeoForge data map, associated with an entry"""
type DataMapValue implements ModOwned {
  """The mod that owns this object"""
  mod: LightweightMod!
  """
  The value of this entry - i.e. the object attached to the entry with the `key` ID or to entries within the tag, if the `key` is a tag
  """
  value: JSON!
}

"""A predicate applied to date types"""
input DatePredicate {
  """Matches if the date is after (greater than) the given date"""
  after: DateTime
  """Match if all of the given filters match"""
  allOf: [DatePredicate!]
  """Match if any of the given filters matches"""
  anyOf: [DatePredicate!]
  """Matches if the date is before (smaller than) the given date"""
  before: DateTime
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [DatePredicate!]
  """Invert the given filter"""
  not: DatePredicate
}

"""A slightly refined version of RFC-3339 compliant DateTime Scalar"""
scalar DateTime

"""A NeoForge enum extension entry"""
type EnumExtension implements ModOwned {
  """The descriptor of the constructor this extension uses"""
  constructor: String!
  """The internal name of the enum this extension targets"""
  enum: String!
  """The mod that owns this object"""
  mod: LightweightMod!
  """The name of the enum field this extension adds"""
  name: String!
  """The source of the parameters"""
  parameters: JSON!
}

"""A connection (list) composed of `EnumExtension`."""
type EnumExtensionConnection {
  """Identifies the amount of items in the returned edges."""
  count: Int!
  """A list of edges."""
  edges: [EnumExtensionEdge!]!
  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

"""An edge of a `EnumExtension`."""
type EnumExtensionEdge {
  """The cursor ID of the element."""
  cursor: ID!
  """The item at the end of the edge."""
  node: EnumExtension!
}

"""Used to filter enum extension entries based on different criteria"""
input EnumExtensionPredicate {
  """Match if all of the given filters match"""
  allOf: [EnumExtensionPredicate!]
  """Match if any of the given filters matches"""
  anyOf: [EnumExtensionPredicate!]
  """Filter based on the enum constructor the extension uses"""
  constructor: String
  """Filter based on the internal name of the enum the extension is for"""
  enum: StringPredicate
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the name of the enum value the extension adds"""
  name: String
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [EnumExtensionPredicate!]
  """Invert the given filter"""
  not: EnumExtensionPredicate
}

"""Represents a method as returned by `Class.fields`"""
type Field implements Identifiable & Referenceable {
  """The unique ID of this object"""
  id: Int!
  """The name of this field"""
  name: String!
  """Returns the references to this element"""
  references(
    """Limit the amount of references returned"""
    limit: Int
    """Optional ordering to apply to the returned elements"""
    order: ReferenceOrdering
    """Optional filter to apply to the query"""
    where: ReferencePredicate
  ): [Reference!]!
  """
  The type of this field
  Can be a JVM internal class like like `java/lang/Object` or a type descriptor like `I`, `Z` or `[Ljava/lang/Object;`.
  """
  type: String!
}

"""A concrete definition of a field"""
type FieldDefinition implements Annotatable {
  """Returns annotations on this object matching the given predicate"""
  annotations(
    """An optional filter to apply to the query"""
    where: AnnotationPredicate
  ): [Annotation!]!
  """The name of this method"""
  name: String!
  """
  The type of this field. This is not a descriptor so classes are in internal JVM format (e.g. `java/lang/String` instead of `Ljava/lang/String;`)
  """
  type: String!
}

"""Type used to order `FieldDefinition`s"""
input FieldDefinitionOrdering {
  """Order by name"""
  name: OrderMethod
  """Order by type"""
  type: OrderMethod
}

"""Used to filter field definitions based on different criteria"""
input FieldDefinitionPredicate {
  """Match if all of the given filters match"""
  allOf: [FieldDefinitionPredicate!]
  """Match if any of the given filters matches"""
  anyOf: [FieldDefinitionPredicate!]
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the field's name"""
  name: StringPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [FieldDefinitionPredicate!]
  """Invert the given filter"""
  not: FieldDefinitionPredicate
  """Filter based on the field's type"""
  type: StringPredicate
}

"""Used to filter fields based on different criteria"""
input FieldPredicate {
  """Match if all of the given filters match"""
  allOf: [FieldPredicate!]
  """Match if any of the given filters matches"""
  anyOf: [FieldPredicate!]
  """
  A field will match if any of the (direct) references to it match the given predicate
  """
  anyReference: ReferencePredicate
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the field's name"""
  name: StringPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [FieldPredicate!]
  """Invert the given filter"""
  not: FieldPredicate
  """Filter based on the field's type"""
  type: StringPredicate
}

"""Represents a version of the game on a loader, which WAIFU is indexing"""
type GameVersion {
  """Internal endpoint. It might be removed at any point"""
  _modInformation(id: Int!): IntModInformation! @deprecated(reason: "No longer supported")
  """
  Get the class with the given `name`. If no such class exists in this game version, this will return `null`.
  In contrast to `GameVersion.classes`, this can only query one class by an exact name match, being easier to use and slightly more efficient.
  """
  class(
    """The name of the class to query"""
    name: String
  ): Class
  """
  Get the class definitions known by this game version that optionally match the given predicate
  """
  classDefinitions(
    """Returns the elements in the list that come after the specified cursor."""
    after: ID
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: ID
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Optional filter applied to the query"""
    where: ClassDefinitionPredicate
  ): ClassDefinitionConnection!
  """
  Get the classes known by this game version that optionally match the given predicate
  """
  classes(
    """Returns the elements in the list that come after the specified cursor."""
    after: ID
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: ID
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Optional filter applied to the query"""
    where: ClassPredicate
  ): ClassConnection!
  """
  Get the data files known by this game version for the given `location` that optionally match the given predicate.
  Note that this will not return files already indexed through other means (i.e. tags, data maps and recipes). Use the dedicated fields to query those.
  """
  dataFiles(
    """Returns the elements in the list that come after the specified cursor."""
    after: ID
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: ID
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """
    The base path of the data files to return.
    For instance, with a base path of `a/b`, data files with a path of `<namespace>/a/b/<path>.json` will be returned.
    """
    location: String
    """An optional filter applied to the returned data files"""
    where: DataFilePredicate
  ): DataFileConnection!
  """
  Get the data maps known by this game version that optionally match the given predicate.
  This returns a different data structure compared to `Mod.dataMaps`, allowing you to query each value assigned to each object
  and the mod that does so.
  """
  dataMaps(
    """Returns the elements in the list that come after the specified cursor."""
    after: ID
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: ID
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """
    The registry to get data maps for.
    The format is namespace:registry (e.g. `minecraft:item` or `minecraft:worldgen/biome`)
    """
    registry: String!
    """Optional filter applied to the query"""
    where: DataMapPredicate
  ): DataMapConnection!
  """
  Get the enum extensions known by this game version that optionally match the given predicate
  """
  enumExtensions(
    """Returns the elements in the list that come after the specified cursor."""
    after: ID
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: ID
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Optional filter applied to the query"""
    where: EnumExtensionPredicate
  ): EnumExtensionConnection!
  """The loader this game version indexes"""
  loader: Loader!
  """Query mods from the database"""
  mods(
    """Returns the elements in the list that come after the specified cursor."""
    after: ID
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: ID
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Optional filter applied to the query"""
    where: ModPredicate
  ): ModConnection!
  """
  Get the mods from the database that have the given IDs.
  Note that the mods are not returned in a specific order relative to the input IDs.
  """
  modsById(
    """Returns the elements in the list that come after the specified cursor."""
    after: ID
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: ID
    """Returns the first _n_ elements from the list."""
    first: Int
    """
    The mod IDs to query.
    If it exceeds the maximum amount of elements that a single query can return you can paginate it further.
    """
    ids: [Int!]!
    """Returns the last _n_ elements from the list."""
    last: Int
  ): ModConnection!
  """
  Get the recipe files known by this game version that optionally match the given predicate
  """
  recipes(
    """Returns the elements in the list that come after the specified cursor."""
    after: ID
    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: ID
    """Returns the first _n_ elements from the list."""
    first: Int
    """Returns the last _n_ elements from the list."""
    last: Int
    """Optional filter applied to the query"""
    where: RecipeFilePredicate
  ): RecipeFileConnection!
  """The Minecraft version this game version indexes"""
  version: String!
}

"""
Represents an object that is identifiable by an unique ID (within its category)
"""
interface Identifiable {
  """The unique ID of this object"""
  id: Int!
}

"""
A class identified by its name (e.g. `java/lang/String`) as returned by `Class.inheritors` which has a certain depth from the root of the inheritance tree.
"""
type InheritanceTreeClass implements BaseClass & Identifiable {
  """Returns all known concrete definitions of the class"""
  definitions(
    """Optional ordering to apply to the returned elements"""
    order: ClassDefinitionOrdering
    """Optional filter applied to the query"""
    where: ClassDefinitionPredicate
  ): [ClassDefinition!]!
  """
  The depth of this class in the inheritance tree.
  Classes with a depth of 1 are direct children of the class from which the search was started, classes with a depth of 2 are their children and so on.
  """
  depth: Int!
  """
  The fields of this class, optionally matching the given predicate.
  Note that it is not guaranteed that the fields returned have a concrete implementation.
  """
  fields(
    """Limit the amount of fields returned"""
    limit: Int
    """Optional filter to apply to the query"""
    where: FieldPredicate
  ): [Field!]!
  """The unique ID of this object"""
  id: Int!
  """
  The methods of this class, optionally matching the given predicate.
  Note that it is not guaranteed that the methods returned have a concrete implementation.
  """
  methods(
    """Limit the amount of methods returned"""
    limit: Int
    """Optional filter to apply to the query"""
    where: MethodPredicate
  ): [Method!]!
  """The name of this class"""
  name: String!
}

"""Type used to order `InheritanceTreeClass`s"""
input InheritanceTreeClassOrdering {
  """Order by depth"""
  depth: OrderMethod
}

"""Used to filter inheriting classes based on different criteria"""
input InheritorPredicate {
  """Match if all of the given filters match"""
  allOf: [InheritorPredicate!]
  """Match if any of the given filters matches"""
  anyOf: [InheritorPredicate!]
  """Filter based on the class' depth in the inheritance tree"""
  depth: IntPredicate
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the class' JVM name"""
  name: StringPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [InheritorPredicate!]
  """Invert the given filter"""
  not: InheritorPredicate
}

type IntModInformation implements BaseMod & Identifiable {
  """The authors of this mod (derived from mod metadata)"""
  authors: String
  curseforge: IntPlatformInformation
  """The ID of the CurseForge project associated with this mod"""
  curseforgeProjectId: Int
  """The unique ID of this object"""
  id: Int!
  """The time this mod was last indexed"""
  indexedOn: DateTime
  """The license of this mod (derived from mod metadata)"""
  license: String
  """The sections of the manifest of the last jar indexed for this mod"""
  manifest: [ManifestEntry!]!
  """
  The maven coordinates of this mod (only set if this mod was JiJ'd by another mod).
  On Fabric these are not real maven coordinates, rather the ID of the mod if the file is a mod, or if the file is a non-mod library, it will be generated by Loom based on its maven coordinates.
  """
  mavenCoordinates: String
  """
  The metadata of this mod, in JSON format.
  Can be sourced from one of the following files depending on the loader:
  - `META-INF/neoforge.mods.toml` for NeoForge
  - `META-INF/mods.toml` for Forge
  - `fabric.mod.json` for Fabric
  """
  metadata(
    """
    Optional JSONPath to return the element(s) at a specific path from the metadata
    """
    path: String
  ): JSON
  """
  The mod IDs of this mod.
  Some loaders only allow a mod to have one ID (Fabric) while others may allow a mod file to have multiple mod IDs.
  For non-mod files this will be null.
  """
  modIds: [String!]
  modrinth: IntPlatformInformation
  """The ID of the Modrinth project associated with this mod"""
  modrinthProjectId: String
  """
  The name of this mod (derived from mod metadata, jar contents or maven coordinates)
  """
  name: String!
  """
  The artifacts this mod file nests within itself, using a jar-in-jar system.
  Note that this is returned as a tree, rather than a flat array containing sub-nested artifacts.
  """
  nestedArtifacts: [NestedArtifactNode!]
  """
  The artifacts this mod file nests within itself, using a jar-in-jar system.
  Note that unlike `nestedArtifacts`, this is returned as a flat array, rather than a tree.
  """
  nestedArtifactsFlat: [NestedArtifact!]
  """The last indexed version of this mod"""
  version: String!
}

type IntPlatformInformation {
  description: String!
  downloads: Int!
  iconUrl: String!
  issuesUrl: String
  projectUrl: String!
  sourceUrl: String
  title: String!
}

"""
Represents a way of filtering numbers based on different rules that are either logical operators
on other filters (NOT, AND, OR) or number comparisons.
"""
input IntPredicate {
  """
  The number being filtered will pass this predicate if its absolute value matches the given predicate.
  """
  abs: IntPredicate
  """Match if all of the given filters match"""
  allOf: [IntPredicate!]
  """Match if any of the given filters matches"""
  anyOf: [IntPredicate!]
  """The number being filtered must be equal to the given number."""
  equals: Int
  """The number being filtered must be greater than the given number."""
  greaterThan: Int
  """
  The number being filtered must be greater than or equal to the given number.
  """
  greaterThanOrEqual: Int
  """
  The number being filtered must be even if this is set to true, or odd otherwise.
  """
  isEven: Boolean
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """The number being filtered must be less than the given number."""
  lessThan: Int
  """
  The number being filtered must be less than or equal to the given number.
  """
  lessThanOrEqual: Int
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [IntPredicate!]
  """Invert the given filter"""
  not: IntPredicate
}

"""A JSON scalar"""
scalar JSON

"""
Predicate used to test objects extracted from a path within a JSON object. For instance, given the following extract predicate:
```json
{
    path: "$.mods[*].id",
    as: {
        string: {
            startsWith: "abc_"
        }
    }
}
```
will match JSON objects that have an `id` element within any element of the top-level `mods` array that, as a string, starts with `abc_`.
"""
input JSONExtractPredicate {
  """
  Cast the extracted object to the given type and check it against the given predicate
  """
  as: CastingPredicate!
  """The path to extract from"""
  path: String!
}

"""
Represents a way of filtering JSON values based on different rules that are either logical operators
on other filters (NOT, AND, OR) or JSON queries.
"""
input JSONPredicate {
  """Match if all of the given filters match"""
  allOf: [JSONPredicate!]
  """Match if any of the given filters matches"""
  anyOf: [JSONPredicate!]
  """
  A JSON value will match if at least one object extracted from the given path matches the given predicate
  """
  extract: JSONExtractPredicate
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [JSONPredicate!]
  """Invert the given filter"""
  not: JSONPredicate
  """
  A JSON value will match this predicate if at least a value matching the given JSONPath exists
  """
  pathExists: String
}

"""
A mod instance which has only basic properties available (properties that do not require joining on tables other than `mods`).
These are returned by objects associated with a mod (like class definitions).
To "upgrade" a lightweight mod to a _Mod_ you can use `modsById`.
"""
type LightweightMod implements BaseMod & Identifiable {
  """The authors of this mod (derived from mod metadata)"""
  authors: String
  """The ID of the CurseForge project associated with this mod"""
  curseforgeProjectId: Int
  """The unique ID of this object"""
  id: Int!
  """The time this mod was last indexed"""
  indexedOn: DateTime
  """The license of this mod (derived from mod metadata)"""
  license: String
  """The sections of the manifest of the last jar indexed for this mod"""
  manifest: [ManifestEntry!]!
  """
  The maven coordinates of this mod (only set if this mod was JiJ'd by another mod).
  On Fabric these are not real maven coordinates, rather the ID of the mod if the file is a mod, or if the file is a non-mod library, it will be generated by Loom based on its maven coordinates.
  """
  mavenCoordinates: String
  """
  The metadata of this mod, in JSON format.
  Can be sourced from one of the following files depending on the loader:
  - `META-INF/neoforge.mods.toml` for NeoForge
  - `META-INF/mods.toml` for Forge
  - `fabric.mod.json` for Fabric
  """
  metadata(
    """
    Optional JSONPath to return the element(s) at a specific path from the metadata
    """
    path: String
  ): JSON
  """
  The mod IDs of this mod.
  Some loaders only allow a mod to have one ID (Fabric) while others may allow a mod file to have multiple mod IDs.
  For non-mod files this will be null.
  """
  modIds: [String!]
  """The ID of the Modrinth project associated with this mod"""
  modrinthProjectId: String
  """
  The name of this mod (derived from mod metadata, jar contents or maven coordinates)
  """
  name: String!
  """
  The artifacts this mod file nests within itself, using a jar-in-jar system.
  Note that this is returned as a tree, rather than a flat array containing sub-nested artifacts.
  """
  nestedArtifacts: [NestedArtifactNode!]
  """
  The artifacts this mod file nests within itself, using a jar-in-jar system.
  Note that unlike `nestedArtifacts`, this is returned as a flat array, rather than a tree.
  """
  nestedArtifactsFlat: [NestedArtifact!]
  """The last indexed version of this mod"""
  version: String!
}

"""Represents the loaders WAIFU supports (the loaders it can index)"""
enum Loader {
  """The NeoForge loader (https://github.com/FabricMC)"""
  Fabric
  """The Forge loader (https://github.com/MinecraftForge)"""
  Forge
  """The NeoForge loader (https://github.com/NeoForged)"""
  NeoForge
}

"""Represents a manifest attribute (e.g. 'Implementation-Version: 1.0')"""
type ManifestAttribute {
  """The key of this attribute"""
  key: String!
  """The value of this attribute"""
  value: String!
}

"""Used to filter manifest attributes based on their name and/or value"""
input ManifestAttributePredicate {
  """Match if all of the given filters match"""
  allOf: [ManifestAttributePredicate!]
  """Match if any of the given filters matches"""
  anyOf: [ManifestAttributePredicate!]
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the attribute name (key)"""
  name: StringPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [ManifestAttributePredicate!]
  """Invert the given filter"""
  not: ManifestAttributePredicate
  """Filter based on the attribute value"""
  value: StringPredicate
}

"""Represents a manifest entry (section)"""
type ManifestEntry {
  """The attributes in this section"""
  attributes: [ManifestAttribute!]!
  """
  The name of this manifest section (the main section has this field blank)
  """
  name: String!
}

"""Represents a method as returned by `Class.methods`"""
type Method implements Identifiable & Referenceable {
  """The descriptor of this method"""
  descriptor: String!
  """The unique ID of this object"""
  id: Int!
  """The name of this method"""
  name: String!
  """Returns the references to this element"""
  references(
    """Limit the amount of references returned"""
    limit: Int
    """Optional ordering to apply to the returned elements"""
    order: ReferenceOrdering
    """Optional filter to apply to the query"""
    where: ReferencePredicate
  ): [Reference!]!
}

"""A concrete definition of a method"""
type MethodDefinition implements Annotatable {
  """Returns annotations on this object matching the given predicate"""
  annotations(
    """An optional filter to apply to the query"""
    where: AnnotationPredicate
  ): [Annotation!]!
  """The descriptor of this method"""
  descriptor: String!
  """The name of this method"""
  name: String!
}

"""Type used to order `MethodDefinition`s"""
input MethodDefinitionOrdering {
  """Order by descriptor"""
  descriptor: OrderMethod
  """Order by name"""
  name: OrderMethod
}

"""Used to filter method definitions based on different criteria"""
input MethodDefinitionPredicate {
  """Match if all of the given filters match"""
  allOf: [MethodDefinitionPredicate!]
  """Match if any of the given filters matches"""
  anyOf: [MethodDefinitionPredicate!]
  """Filter based on the method's descriptor"""
  descriptor: StringPredicate
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the method's name"""
  name: StringPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [MethodDefinitionPredicate!]
  """Invert the given filter"""
  not: MethodDefinitionPredicate
}

"""Used to filter methods based on different criteria"""
input MethodPredicate {
  """Match if all of the given filters match"""
  allOf: [MethodPredicate!]
  """Match if any of the given filters matches"""
  anyOf: [MethodPredicate!]
  """
  A method will match if any of the (direct) references to it match the given predicate
  """
  anyReference: ReferencePredicate
  """Filter based on the method's descriptor"""
  descriptor: StringPredicate
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the method's name"""
  name: StringPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [MethodPredicate!]
  """Invert the given filter"""
  not: MethodPredicate
}

"""
Represents a full mod from which data that requires more complex processing can be queries (classes, tags etc.)
"""
type Mod implements BaseMod & Identifiable {
  """The authors of this mod (derived from mod metadata)"""
  authors: String
  """
  Get the classes this mod defines. Optionally takes in a filter on the class name
  """
  classes(
    limit: Int
    """Optional ordering to apply to the returned elements"""
    order: ClassDefinitionOrdering
    where: ClassDefinitionPredicate
  ): [ClassDefinition!]!
  """The ID of the CurseForge project associated with this mod"""
  curseforgeProjectId: Int
  """
  Get the data files this mod defines for the given `location`.
  Note that this will not return files already indexed through other means (i.e. tags, data maps and recipes). Use the dedicated fields to query those.
  """
  dataFiles(
    """Limit the amount of data files returned"""
    limit: Int
    """
    The base path of the data files to return.
    For instance, with a base path of `a/b`, data files with a path of `<namespace>/a/b/<path>.json` will be returned.
    """
    location: String
    """An optional filter applied to the returned data files"""
    where: DataFilePredicate
  ): [DataFile!]!
  """Get the data maps this mod defines for the given registry"""
  dataMaps(
    """Limit the amount of data map files returned"""
    limit: Int
    """
    The registry to get data maps for.
    The format is namespace:registry (e.g. `minecraft:item` or `minecraft:worldgen/biome`)
    """
    registry: String!
    """An optional filter applied to the returned data map files"""
    where: DataMapFilePredicate
  ): [DataMapFile!]!
  """Get the enum extensions this mod defines"""
  enumExtensions(
    """Limit the amount of entries returned"""
    limit: Int
    """An optional filter applied to the returned entries"""
    where: EnumExtensionPredicate
  ): [EnumExtension!]!
  """The unique ID of this object"""
  id: Int!
  """The time this mod was last indexed"""
  indexedOn: DateTime
  """The license of this mod (derived from mod metadata)"""
  license: String
  """The sections of the manifest of the last jar indexed for this mod"""
  manifest: [ManifestEntry!]!
  """
  The maven coordinates of this mod (only set if this mod was JiJ'd by another mod).
  On Fabric these are not real maven coordinates, rather the ID of the mod if the file is a mod, or if the file is a non-mod library, it will be generated by Loom based on its maven coordinates.
  """
  mavenCoordinates: String
  """
  The metadata of this mod, in JSON format.
  Can be sourced from one of the following files depending on the loader:
  - `META-INF/neoforge.mods.toml` for NeoForge
  - `META-INF/mods.toml` for Forge
  - `fabric.mod.json` for Fabric
  """
  metadata(
    """
    Optional JSONPath to return the element(s) at a specific path from the metadata
    """
    path: String
  ): JSON
  """
  The mod IDs of this mod.
  Some loaders only allow a mod to have one ID (Fabric) while others may allow a mod file to have multiple mod IDs.
  For non-mod files this will be null.
  """
  modIds: [String!]
  """The ID of the Modrinth project associated with this mod"""
  modrinthProjectId: String
  """
  The name of this mod (derived from mod metadata, jar contents or maven coordinates)
  """
  name: String!
  """
  The artifacts this mod file nests within itself, using a jar-in-jar system.
  Note that this is returned as a tree, rather than a flat array containing sub-nested artifacts.
  """
  nestedArtifacts: [NestedArtifactNode!]
  """
  The artifacts this mod file nests within itself, using a jar-in-jar system.
  Note that unlike `nestedArtifacts`, this is returned as a flat array, rather than a tree.
  """
  nestedArtifactsFlat: [NestedArtifact!]
  """Get the recipes this mod defines"""
  recipes(
    """Limit the amount of recipes returned"""
    limit: Int
    """An optional filter applied to the returned recipe files"""
    where: RecipeFilePredicate
  ): [RecipeFile!]!
  """Get the tags this mod defines for the given registry"""
  tags(
    """Limit the amount of tags returned"""
    limit: Int
    """
    The registry to get tags for.
    The format is namespace:registry (e.g. `minecraft:item` or `minecraft:worldgen/biome`)
    """
    registry: String!
    """An optional filter applied to the returned tags"""
    where: TagFilePredicate
  ): [TagFile!]!
  """The last indexed version of this mod"""
  version: String!
}

"""A connection (list) composed of `Mod`."""
type ModConnection {
  """Identifies the amount of items in the returned edges."""
  count: Int!
  """A list of edges."""
  edges: [ModEdge!]!
  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

"""An edge of a `Mod`."""
type ModEdge {
  """The cursor ID of the element."""
  cursor: ID!
  """The item at the end of the edge."""
  node: Mod!
}

"""
Base interface for objects that are owned (have been added) by a specific mod.
Examples of this include class definitions or recipes.
"""
interface ModOwned {
  """The mod that owns this object"""
  mod: LightweightMod!
}

"""Used to filter mods based on different criteria"""
input ModPredicate {
  """Match if all of the given filters match"""
  allOf: [ModPredicate!]
  """
  A mod will match if any of the classes it defines matches the given predicate
  """
  anyClass: ClassDefinitionPredicate
  """
  A mod will match if any of the manifest attributes its jar has matches the given filter
  """
  anyManifestAttribute: ManifestAttributePredicate
  """
  A mod will match if any of the artifacts it nests (this check applies to the whole tree) matches the given predicate
  """
  anyNestedArtifact: NestedArtifactPredicate
  """Match if any of the given filters matches"""
  anyOf: [ModPredicate!]
  """Filter based on the mod's authors (derived from mod metadata)"""
  authors: StringPredicate
  """
  A mod will match if it is associated with the CurseForge project with the given ID
  """
  curseforgeProjectId: IntPredicate
  """Filter based on the mod's description (derived from mod metadata)"""
  description: StringPredicate
  """A mod will match if it is contained in the pack with the given ID"""
  inPack: PlatformProjectIdentifier
  """
  A mod will match if the date it has last been indexed on matches the given predicate
  """
  indexed: DatePredicate
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the mod's license (derived from mod metadata)"""
  license: StringPredicate
  """
  Filter based on the mod's maven coordinates (only non-`null` if the mod was JiJ'd by another mod)
  """
  mavenCoordinates: StringPredicate
  """
  Filter based on the mod's metadata (sourced from the platform's metadata file)
  """
  metadata: JSONPredicate
  """
  Filter based on the mod's mod IDs (derived from mod metadata).
  On Neo/Forge only one of the IDs of a multi mod jar needs to match the filter.
  """
  modId: StringPredicate
  """
  A mod will match if it is associated with the Modrinth project with the given ID
  """
  modrinthProjectId: StringPredicate
  """
  Filter based on the mod's name (derived from mod metadata, jar contents or maven coordinates)
  """
  name: StringPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [ModPredicate!]
  """Invert the given filter"""
  not: ModPredicate
}

type Mutation {
  """
  Stop indexing the given game version.
  Returns `true` if the game version was indexed before and is now no longer actively indexed.
  """
  stopIndexingGameVersion(
    """
    If `true` and there's an index operation in-progress, it will be forcefully stopped. If `false`, the operation will be allowed to finish execution normally.
    """
    force: Boolean
    """The loader"""
    loader: Loader!
    """The Minecraft version"""
    version: String!
  ): Boolean!
}

"""
Represents an artifact nested within another one, in a strictly flat structure.
"""
type NestedArtifact implements BaseNestedArtifact {
  """The ID of this artifact"""
  id: String!
  """The version of this artifact"""
  version: String!
}

"""
Represents an artifact nested within another one, as a tree.
This type provides access to children nested artifacts.
"""
type NestedArtifactNode implements BaseNestedArtifact {
  """The ID of this artifact"""
  id: String!
  """The artifacts this artifact nests further within it"""
  nested: [NestedArtifactNode!]
  """The version of this artifact"""
  version: String!
}

"""
Used to filter nested artifact coordinates based on their ID and/or version
"""
input NestedArtifactPredicate {
  """Match if all of the given filters match"""
  allOf: [NestedArtifactPredicate!]
  """Match if any of the given filters matches"""
  anyOf: [NestedArtifactPredicate!]
  """Filter based on the nested artifact ID"""
  id: StringPredicate
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [NestedArtifactPredicate!]
  """Invert the given filter"""
  not: NestedArtifactPredicate
  """Filter based on the nested artifact version"""
  version: StringPredicate
}

enum OrderDirection {
  asc
  desc
}

input OrderMethod {
  by: OrderRule = value
  direction: OrderDirection = asc
}

enum OrderRule {
  length
  value
}

"""Information about pagination in a connection."""
type PageInfo {
  """
  The cursor ID that points to the last element returned, if there is one
  """
  endCursor: ID
  """Whether there are more elements past the last element of the response"""
  hasNextPage: Boolean!
  """
  Whether there are more elements before the last element of the response.
  Note that this field may be false even if earlier pages exist when it is too expensive to check if earlier pages exist.
  """
  hasPreviousPage: Boolean!
  """
  The cursor ID that points to the first element returned, if there is one
  """
  startCursor: ID
}

"""Permissions that a user can have"""
enum Permission {
  """
  The user has the permission to manage the indexed versions (stop indexing, request that a new version is indexed, etc.)
  """
  MANAGE_VERSIONS
}

"""Represents the ID/slug of a project on CurseForge or Modrinth"""
input PlatformProjectIdentifier {
  """The ID of the project on CurseForge"""
  curseforge: Int
  """The slug of the project on CurseForge"""
  curseforgeSlug: String
  """The ID of the project on Modrinth"""
  modrinth: String
  """The slug of the project on Modrinth"""
  modrinthSlug: String
}

type Query {
  """Query a game version based on the Minecraft version and the loader"""
  gameVersion(
    """The loader"""
    loader: Loader!
    """The Minecraft version"""
    version: String!
  ): GameVersion
  """Get all indexed game versions"""
  gameVersions(
    """Optional filter. Return only game versions with this loader"""
    loader: Loader
  ): [GameVersion!]!
}

"""A Minecraft recipe file"""
type RecipeFile implements ModOwned {
  """The mod that owns this object"""
  mod: LightweightMod!
  """The name of this recipe (e.g. `minecraft:composter`)"""
  name: String!
  """
  The contents of the recipe file, in JSON format. This object does not include the `type`.
  """
  recipe: JSON!
  """The type of this recipe (e.g. `minecraft:crafting_shaped`)"""
  type: String!
}

"""A connection (list) composed of `RecipeFile`."""
type RecipeFileConnection {
  """Identifies the amount of items in the returned edges."""
  count: Int!
  """A list of edges."""
  edges: [RecipeFileEdge!]!
  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

"""An edge of a `RecipeFile`."""
type RecipeFileEdge {
  """The cursor ID of the element."""
  cursor: ID!
  """The item at the end of the edge."""
  node: RecipeFile!
}

"""Used to filter recipes based on different criteria"""
input RecipeFilePredicate {
  """Match if all of the given filters match"""
  allOf: [RecipeFilePredicate!]
  """Match if any of the given filters matches"""
  anyOf: [RecipeFilePredicate!]
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the recipe name"""
  name: StringPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [RecipeFilePredicate!]
  """Invert the given filter"""
  not: RecipeFilePredicate
  """
  Filter based on the recipe JSON (the object given to this predicate does not include the type)
  """
  recipe: JSONPredicate
  """Filter based on the recipe type"""
  type: StringPredicate
}

"""
Represents a reference in the form of the class referencing the method/field and how many times it is referenced in that class
"""
type Reference {
  """The class in which this reference is contained"""
  owner: ClassDefinition!
  """How many times the referenced method/field was referenced in the class"""
  referenceCount: Int!
}

"""Type used to order `Reference`s"""
input ReferenceOrdering {
  """Order by referenceCount"""
  referenceCount: OrderMethod
}

"""Used to filter references based on different criteria"""
input ReferencePredicate {
  """Match if all of the given filters match"""
  allOf: [ReferencePredicate!]
  """Match if any of the given filters matches"""
  anyOf: [ReferencePredicate!]
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the mod that the reference is part of"""
  mod: ModPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [ReferencePredicate!]
  """Invert the given filter"""
  not: ReferencePredicate
  """Filter based on the amount of references"""
  referenceCount: IntPredicate
}

"""
Represents a type that can be referenced by other classes.
Can be method or a field.
"""
interface Referenceable {
  """Returns the references to this element"""
  references(
    """Limit the amount of references returned"""
    limit: Int
    """Optional ordering to apply to the returned elements"""
    order: ReferenceOrdering
    """Optional filter to apply to the query"""
    where: ReferencePredicate
  ): [Reference!]!
}

"""Represents a reference to a field within a concrete class definition"""
type ReferencedField {
  """The name of the class of the referenced field"""
  class: String!
  """The name of the referenced field"""
  name: String!
  """How many times this field was referenced in the class definition"""
  referenceCount: Int!
  """The type of the referenced field"""
  type: String!
}

"""Represents a reference to a method within a concrete class definition"""
type ReferencedMethod {
  """The name of the class of the referenced method"""
  class: String!
  """The descriptor of the referenced method"""
  descriptor: String!
  """The name of the referenced method"""
  name: String!
  """How many times this method was referenced in the class definition"""
  referenceCount: Int!
}

"""
Represents a way of filtering string inputs based on different rules that are either logical operators
on other filters (NOT, AND, OR) or exact / regex matches.
"""
input StringPredicate {
  """Match if all of the given filters match"""
  allOf: [StringPredicate!]
  """Match if any of the given filters matches"""
  anyOf: [StringPredicate!]
  """The string being filtered must be equal to the given string."""
  equals: String
  """
  The string being filtered must be equal to at least one of the given strings.
  """
  isIn: [String!]
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """
  The string being filtered will pass this predicate if its length matches the given predicate.
  """
  length: IntPredicate
  """The string being filtered must match the given regex pattern."""
  matches: String
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [StringPredicate!]
  """Invert the given filter"""
  not: StringPredicate
  """The string being filtered must start with the given string."""
  startsWith: String
}

"""A Minecraft tag file"""
type TagFile {
  """
  The entries added to this tag. These can be either normal objects (e.g. minecraft:stone) or other tags, denoted by a # at the start (e.g. #minecraft:head_armor)
  """
  entries(
    """An optional filter applied to the entries returned"""
    where: StringPredicate
  ): [String!]!
  """The name of this tag (e.g. minecraft:mineable/pickaxe)"""
  name: String!
  """
  Whether this tag overrides all previously added entries.
  Corresponds to the "replace" field in the tag JSON.
  """
  replace: Boolean!
}

"""Used to filter tags based on different criteria"""
input TagFilePredicate {
  """Match if all of the given filters match"""
  allOf: [TagFilePredicate!]
  """
  A tag file will match this predicate if any of its direct entries matches the given predicate
  """
  anyEntry: StringPredicate
  """Match if any of the given filters matches"""
  anyOf: [TagFilePredicate!]
  """
  If `true`, match if the value tested is null. Otherwise, match if non-null.
  """
  isNull: Boolean
  """Filter based on the tag name"""
  name: StringPredicate
  """
  Match if none of the given filters match.
  Prefer using this instead of `not(anyOf(...))` as it is generally faster.
  """
  noneOf: [TagFilePredicate!]
  """Invert the given filter"""
  not: TagFilePredicate
  """
  If set to true, only tags that override existing values will be returned.
  If set to false, only tags that do not override existing values will be returned.
  """
  replace: Boolean
}