"""
An armor technology used in BattleMech construction.
Total armor weight = total_armor_points / points_per_ton.
"""
type ArmorTypeGql {
	"""
	Unique identifier (same as slug).
	"""
	id: ID!
	"""
	Lowercase, hyphen-separated identifier (e.g. "ferro-fibrous-is").
	"""
	slug: String!
	"""
	Human-readable armor name (e.g. "Ferro-Fibrous (IS)").
	"""
	name: String!
	"""
	Technology base required for this armor type.
	"""
	techBase: String!
	"""
	Minimum rules level needed to use this armor type.
	"""
	rulesLevel: String!
	"""
	Armor points provided per ton of armor weight.
	"""
	pointsPerTon: Float!
	"""
	Total critical slots consumed across all locations.
	"""
	crits: Int!
	"""
	In-universe year when this armor type was first produced.
	"""
	introYear: Int
}

"""
A record of a unit's availability to a specific faction during a specific era.
"""
type AvailabilityGql {
	"""
	Lowercase, hyphen-separated faction identifier (e.g. "clan-wolf").
	"""
	factionSlug: String!
	"""
	Human-readable faction name.
	"""
	factionName: String!
	"""
	Lowercase, hyphen-separated era identifier (e.g. "clan-invasion").
	"""
	eraSlug: String!
	"""
	Human-readable era name.
	"""
	eraName: String!
	"""
	MegaMek availability rating code (e.g. "A", "B", "F"). Null if unrated.
	"""
	availabilityCode: String
	"""
	Additional notes about this availability entry.
	"""
	notes: String
}

"""
A cockpit type used in BattleMech construction.
"""
type CockpitTypeGql {
	"""
	Unique identifier (same as slug).
	"""
	id: ID!
	"""
	Lowercase, hyphen-separated identifier (e.g. "small", "command-console").
	"""
	slug: String!
	"""
	Human-readable cockpit name (e.g. "Small Cockpit").
	"""
	name: String!
	"""
	Technology base required. Null means tech-base-agnostic.
	"""
	techBase: String
	"""
	Minimum rules level needed to use this cockpit type.
	"""
	rulesLevel: String!
	"""
	Weight in tons.
	"""
	weight: Int!
	"""
	Total critical slots consumed.
	"""
	crits: Int!
	"""
	In-universe year when this cockpit type was first produced.
	"""
	introYear: Int
}

"""
All construction reference data in a single response. Fetch once and cache locally for builder initialization.
"""
type ConstructionReferenceGql {
	"""
	All available engine types.
	"""
	engineTypes: [EngineTypeGql!]!
	"""
	All available armor types.
	"""
	armorTypes: [ArmorTypeGql!]!
	"""
	All available internal structure types.
	"""
	structureTypes: [StructureTypeGql!]!
	"""
	All available heat sink types.
	"""
	heatsinkTypes: [HeatsinkTypeGql!]!
	"""
	All available gyroscope types.
	"""
	gyroTypes: [GyroTypeGql!]!
	"""
	All available cockpit types.
	"""
	cockpitTypes: [CockpitTypeGql!]!
	"""
	All available myomer types.
	"""
	myomerTypes: [MyomerTypeGql!]!
	"""
	Engine weight lookup table (rating → standard weight).
	"""
	engineWeights: [EngineWeightGql!]!
	"""
	Internal structure points by mech tonnage.
	"""
	internalStructure: [InternalStructureGql!]!
}

"""
Metadata about the imported MegaMek dataset (version, schema, release date).
"""
type DatasetMetadataGql {
	"""
	MegaMek version string the data was imported from (e.g. "0.50.11").
	"""
	version: String!
	"""
	Database schema version number. Used by the /ready endpoint for compatibility checks.
	"""
	schemaVersion: Int!
	"""
	Flavor text or summary of the dataset contents.
	"""
	description: String
	"""
	Date the MegaMek release was published, formatted as YYYY-MM-DD. Null if unknown.
	"""
	releaseDate: String
}

"""
A fusion or combustion engine type used in BattleMech construction.
Weight = engine_weight_table[rating].standard_weight * weight_multiplier.
"""
type EngineTypeGql {
	"""
	Unique identifier (same as slug).
	"""
	id: ID!
	"""
	Lowercase, hyphen-separated identifier (e.g. "xl-is", "standard-fusion").
	"""
	slug: String!
	"""
	Human-readable engine name (e.g. "XL Engine (IS)").
	"""
	name: String!
	"""
	Technology base required for this engine type.
	"""
	techBase: String!
	"""
	Minimum rules level needed to use this engine type.
	"""
	rulesLevel: String!
	"""
	Multiplier applied to standard engine weight from engine_weight_table.
	"""
	weightMultiplier: Float!
	"""
	Critical slots consumed in the center torso.
	"""
	ctCrits: Int!
	"""
	Critical slots consumed in each side torso.
	"""
	stCrits: Int!
	"""
	In-universe year when this engine type was first produced.
	"""
	introYear: Int
}

"""
Standard fusion engine weight entry from TechManual.
Actual engine weight = standard_weight * engine_type.weight_multiplier.
"""
type EngineWeightGql {
	"""
	Engine rating (10-400 in increments of 5).
	"""
	rating: Int!
	"""
	Standard fusion engine weight in tons for this rating.
	"""
	standardWeight: Float!
}

"""
Equipment category filter.
"""
enum EquipmentCategoryFilter {
	"""
	Energy-based weapons (lasers, PPCs, flamers).
	"""
	ENERGY_WEAPON
	"""
	Ballistic weapons (autocannons, Gauss rifles, machine guns).
	"""
	BALLISTIC_WEAPON
	"""
	Missile weapons (LRMs, SRMs, MRMs).
	"""
	MISSILE_WEAPON
	"""
	Physical attack weapons (hatchets, swords, claws).
	"""
	PHYSICAL_WEAPON
	"""
	Ammunition for ballistic and missile weapons.
	"""
	AMMUNITION
	"""
	General equipment (ECM, BAP, CASE, etc.).
	"""
	EQUIPMENT
	"""
	Armor systems.
	"""
	ARMOR
	"""
	Internal structure systems.
	"""
	STRUCTURE
	"""
	Engine systems.
	"""
	ENGINE
	"""
	Gyroscope systems.
	"""
	GYRO
	"""
	Cockpit systems.
	"""
	COCKPIT
	"""
	Arm/leg actuators.
	"""
	ACTUATOR
	"""
	Heat dissipation systems.
	"""
	HEAT_SINK
	"""
	Jump jets and improved jump jets.
	"""
	JUMP_JET
	"""
	Targeting computers.
	"""
	TARGETING_COMPUTER
}

"""
Relay-style paginated list of equipment items with cursor-based navigation.
"""
type EquipmentConnection {
	"""
	List of equipment edges in this page.
	"""
	edges: [EquipmentEdge!]!
	"""
	Pagination metadata including cursors and total count.
	"""
	pageInfo: PageInfo!
}

"""
A single edge in a paginated equipment list, pairing a cursor with its equipment node.
"""
type EquipmentEdge {
	"""
	Opaque pagination cursor for this edge. Can be used as the "after" parameter.
	"""
	cursor: String!
	"""
	The equipment item at this position in the result set.
	"""
	node: EquipmentGql!
}

"""
An equipment item (weapon, ammo, armor, engine, etc.) that can be mounted on units.
"""
type EquipmentGql {
	"""
	Unique identifier (same as slug).
	"""
	id: ID!
	"""
	Lowercase, hyphen-separated identifier (e.g. "medium-laser", "clan-er-large-laser").
	"""
	slug: String!
	"""
	Human-readable equipment name (e.g. "Medium Laser").
	"""
	name: String!
	"""
	Equipment category in snake_case. One of: energy_weapon, ballistic_weapon, missile_weapon, ammo, physical_weapon, equipment, armor, structure, engine, targeting_system, myomer, heat_sink, jump_jet, communications.
	"""
	category: String!
	"""
	Technology base. One of: inner_sphere, clan, mixed, primitive.
	"""
	techBase: String!
	"""
	Rules level governing which game modes allow this equipment. One of: introductory, standard, advanced, experimental, unofficial.
	"""
	rulesLevel: String!
	"""
	Weight in metric tons. Null for zero-weight or non-applicable items.
	"""
	tonnage: Float
	"""
	Number of critical hit slots consumed when mounted. Null if not applicable.
	"""
	crits: Int
	"""
	Damage value as a string (may contain special formats like "2/hit" or "10+5"). Null for non-damaging equipment.
	"""
	damage: String
	"""
	Heat generated when fired, in heat points. Null for non-heat-generating equipment.
	"""
	heat: Int
	"""
	Minimum range in tabletop hexes. Attacks within this range suffer a penalty. Null if no minimum range.
	"""
	rangeMin: Int
	"""
	Short range bracket in tabletop hexes. Null if not a ranged weapon.
	"""
	rangeShort: Int
	"""
	Medium range bracket in tabletop hexes. Null if not a ranged weapon.
	"""
	rangeMedium: Int
	"""
	Long range bracket in tabletop hexes. Null if not a ranged weapon.
	"""
	rangeLong: Int
	"""
	Battle Value — composite combat effectiveness score used for game balancing. Null if not computed.
	"""
	bv: Int
	"""
	In-universe BattleTech year when this equipment was first produced (e.g. 3025). Not a real-world date.
	"""
	introYear: Int
	"""
	Source book or technical readout where this equipment is published.
	"""
	sourceBook: String
	"""
	Flavor text or technical description of the equipment item.
	"""
	description: String
	"""
	Body locations where this equipment has been observed mounted across existing units.
	Null means locations are unknown or unrestricted.
	"""
	observedLocations: [String!]
	"""
	Source of the latest stats update (e.g. "seed", "manual"). Null if stats are from initial import.
	"""
	statsSource: String
	"""
	Number of rounds of ammunition per ton. Null for non-ammo equipment.
	"""
	shotsPerTon: Int
	"""
	The weapon this ammo is compatible with. Null for non-ammo equipment.
	"""
	ammoFor: EquipmentGql
	"""
	Ammo types compatible with this weapon. Empty for non-weapon equipment.
	"""
	ammoTypes: [EquipmentGql!]!
}

"""
Era filter for availability-based queries.
"""
enum EraFilter {
	"""
	Age of War (2398–2570).
	"""
	AGE_OF_WAR
	"""
	Star League (2571–2780).
	"""
	STAR_LEAGUE
	"""
	Early Succession Wars (2781–2900).
	"""
	EARLY_SUCCESSION_WARS
	"""
	Late Succession Wars / LosTech (2901–3019).
	"""
	LATE_SUCCESSION_WARS
	"""
	Renaissance (3020–3049).
	"""
	RENAISSANCE
	"""
	Clan Invasion (3050–3061).
	"""
	CLAN_INVASION
	"""
	Civil War (3062–3067).
	"""
	CIVIL_WAR
	"""
	Jihad (3068–3080).
	"""
	JIHAD
	"""
	Dark Age (3081–3150).
	"""
	DARK_AGE
	"""
	ilClan (3151–present).
	"""
	IL_CLAN
}

"""
A historical era in the BattleTech timeline (e.g. "Clan Invasion", "Star League").
"""
type EraGql {
	"""
	Unique identifier (same as slug).
	"""
	id: ID!
	"""
	Lowercase, hyphen-separated identifier (e.g. "clan-invasion", "star-league").
	"""
	slug: String!
	"""
	Human-readable era name (e.g. "Clan Invasion").
	"""
	name: String!
	"""
	In-universe BattleTech year when this era begins (e.g. 3049). Not a real-world date.
	"""
	startYear: Int!
	"""
	In-universe BattleTech year when this era ends. Null if the era is ongoing.
	"""
	endYear: Int
	"""
	Flavor text or lore description of the era.
	"""
	description: String
}

"""
A BattleTech faction (e.g. Great House, Clan, mercenary company, or periphery state).
"""
type FactionGql {
	"""
	Unique identifier (same as slug).
	"""
	id: ID!
	"""
	Lowercase, hyphen-separated identifier (e.g. "clan-wolf", "house-steiner").
	"""
	slug: String!
	"""
	Full faction name (e.g. "Clan Wolf", "Lyran Commonwealth").
	"""
	name: String!
	"""
	Abbreviated faction name (e.g. "CW", "LC"). Null if no abbreviation exists.
	"""
	shortName: String
	"""
	Faction classification. One of: great_house, clan, periphery, mercenary, other.
	"""
	factionType: String!
	"""
	True if this faction is a Clan; false otherwise.
	"""
	isClan: Boolean!
	"""
	In-universe BattleTech year when the faction was founded. Not a real-world date.
	"""
	foundingYear: Int
	"""
	In-universe BattleTech year when the faction was dissolved. Null if still active.
	"""
	dissolutionYear: Int
	"""
	Flavor text or lore description of the faction.
	"""
	description: String
	"""
	Eras during which this faction was active, ordered by start year.
	"""
	eras: [EraGql!]!
}

"""
Faction classification filter.
"""
enum FactionTypeFilter {
	"""
	Major Inner Sphere ruling house (Steiner, Davion, Liao, Marik, Kurita).
	"""
	GREAT_HOUSE
	"""
	Clan faction.
	"""
	CLAN
	"""
	Periphery state.
	"""
	PERIPHERY
	"""
	Mercenary organization.
	"""
	MERCENARY
	"""
	Other factions (ComStar, Word of Blake, etc.).
	"""
	OTHER
}

"""
A gyroscope type used in BattleMech construction.
Weight = ceil(engine_rating / 100) * weight_multiplier (standard BT rounding: 0.5 rounds up).
"""
type GyroTypeGql {
	"""
	Unique identifier (same as slug).
	"""
	id: ID!
	"""
	Lowercase, hyphen-separated identifier (e.g. "xl", "compact").
	"""
	slug: String!
	"""
	Human-readable gyro name (e.g. "XL Gyro").
	"""
	name: String!
	"""
	Technology base required. Null means tech-base-agnostic.
	"""
	techBase: String
	"""
	Minimum rules level needed to use this gyro type.
	"""
	rulesLevel: String!
	"""
	Multiplier applied to base gyro weight (ceil(engine_rating / 100)).
	"""
	weightMultiplier: Float!
	"""
	Critical slots consumed in the center torso.
	"""
	crits: Int!
	"""
	True if this gyro type is restricted to superheavy mechs.
	"""
	isSuperheavyOnly: Boolean!
	"""
	In-universe year when this gyro type was first produced.
	"""
	introYear: Int
}

"""
A heat sink technology used in BattleMech construction.
"""
type HeatsinkTypeGql {
	"""
	Unique identifier (same as slug).
	"""
	id: ID!
	"""
	Lowercase, hyphen-separated identifier (e.g. "double-is").
	"""
	slug: String!
	"""
	Human-readable heat sink name (e.g. "Double Heat Sink (IS)").
	"""
	name: String!
	"""
	Technology base required for this heat sink type.
	"""
	techBase: String!
	"""
	Minimum rules level needed to use this heat sink type.
	"""
	rulesLevel: String!
	"""
	Heat points dissipated per heat sink per turn.
	"""
	dissipation: Int!
	"""
	Critical slots consumed per heat sink.
	"""
	crits: Int!
	"""
	Weight per heat sink in tons.
	"""
	weight: Float!
	"""
	In-universe year when this heat sink type was first produced.
	"""
	introYear: Int
}

"""
Internal structure hit points per location for a given mech tonnage.
Max armor per location = 2 * structure_points (except head max = 9).
"""
type InternalStructureGql {
	"""
	Mech tonnage this row applies to.
	"""
	tonnage: Int!
	"""
	Head structure points (always 3).
	"""
	head: Int!
	"""
	Center torso structure points.
	"""
	centerTorso: Int!
	"""
	Side torso structure points (left and right are equal).
	"""
	sideTorso: Int!
	"""
	Arm structure points (left and right are equal).
	"""
	arm: Int!
	"""
	Leg structure points (left and right are equal).
	"""
	leg: Int!
}

"""
A scalar that can represent any JSON value.
"""
scalar JSON

"""
A single equipment item mounted on a unit at a specific location.
"""
type LoadoutEntryGql {
	"""
	Lowercase, hyphen-separated identifier of the equipment item (e.g. "medium-laser").
	"""
	equipmentSlug: String!
	"""
	Human-readable name of the equipment item.
	"""
	equipmentName: String!
	"""
	Body location where this equipment is mounted (e.g. "right_arm"). Null if location is unspecified.
	"""
	location: String
	"""
	Number of this equipment item mounted at this location.
	"""
	quantity: Int!
	"""
	True if the weapon is rear-facing (fires into the rear arc).
	"""
	isRearFacing: Boolean!
	"""
	Additional notes about this loadout entry, if any.
	"""
	notes: String
	"""
	1-indexed critical slot positions this equipment occupies within its location.
	For example, a 5-crit LRM 20 starting at slot 4 would be [4, 5, 6, 7, 8].
	Null for non-mech units or legacy data without slot information.
	"""
	slots: [Int!]
}

"""
An armor/structure location on a unit (e.g. head, center_torso, left_arm).
"""
type LocationGql {
	"""
	Body location name in snake_case (e.g. "center_torso", "left_arm", "head").
	"""
	location: String!
	"""
	Front armor points at this location. Null if the location has no armor.
	"""
	armorPoints: Int
	"""
	Rear armor points at this location. Only applicable to torso locations; null otherwise.
	"""
	rearArmor: Int
	"""
	Internal structure points at this location. Null if not applicable.
	"""
	structurePoints: Int
}

"""
Mech-specific technical data: engine, movement, heat management, armor/structure type, and chassis configuration.
"""
type MechDataGql {
	"""
	Chassis layout: "Biped", "Quad", "Tripod", or "LAM".
	"""
	config: String!
	"""
	True if this mech is an OmniMech with configurable pod space.
	"""
	isOmnimech: Boolean!
	"""
	Engine power rating (e.g. 300 for a 100-ton mech with walk 3).
	"""
	engineRating: Int
	"""
	Raw engine type string from MegaMek data. Always available.
	"""
	engineTypeRaw: String
	"""
	Resolved engine type with full construction properties. Null if not matched to reference table.
	"""
	engine: EngineTypeGql
	"""
	Walking movement points per turn.
	"""
	walkMp: Int
	"""
	Running movement points per turn. Computed as ceil(walkMp * 1.5).
	"""
	runMp: Int
	"""
	Jump movement points per turn. 0 means no jump capability.
	"""
	jumpMp: Int
	"""
	Total number of heat sinks installed.
	"""
	heatSinkCount: Int
	"""
	Raw heat sink type string from MegaMek data. Always available.
	"""
	heatSinkTypeRaw: String
	"""
	Resolved heat sink type with full construction properties. Null if not matched.
	"""
	heatsink: HeatsinkTypeGql
	"""
	Raw structure type string from MegaMek data. Always available.
	"""
	structureTypeRaw: String
	"""
	Resolved structure type with full construction properties. Null if not matched.
	"""
	structure: StructureTypeGql
	"""
	Raw armor type string from MegaMek data. Always available.
	"""
	armorTypeRaw: String
	"""
	Resolved armor type with full construction properties. Null if not matched.
	"""
	armor: ArmorTypeGql
	"""
	Raw gyro type string from MegaMek data. Always available.
	"""
	gyroTypeRaw: String
	"""
	Resolved gyro type with full construction properties. Null if not matched.
	"""
	gyro: GyroTypeGql
	"""
	Raw cockpit type string from MegaMek data. Always available.
	"""
	cockpitTypeRaw: String
	"""
	Resolved cockpit type with full construction properties. Null if not matched.
	"""
	cockpit: CockpitTypeGql
	"""
	Raw myomer type string from MegaMek data. Always available.
	"""
	myomerTypeRaw: String
	"""
	Resolved myomer type with full construction properties. Null if not matched.
	"""
	myomer: MyomerTypeGql
}

"""
A myomer (muscle fiber) type used in BattleMech construction.
"""
type MyomerTypeGql {
	"""
	Unique identifier (same as slug).
	"""
	id: ID!
	"""
	Lowercase, hyphen-separated identifier (e.g. "tsm", "masc").
	"""
	slug: String!
	"""
	Human-readable myomer name (e.g. "Triple-Strength Myomer").
	"""
	name: String!
	"""
	Technology base required. Null means tech-base-agnostic.
	"""
	techBase: String
	"""
	Minimum rules level needed to use this myomer type.
	"""
	rulesLevel: String!
	"""
	In-universe year when this myomer type was first produced.
	"""
	introYear: Int
	"""
	Type-specific properties as a JSON object (e.g. {"tonnage_fraction": 0.05} for MASC).
	"""
	properties: JSON!
}

"""
Pagination metadata for cursor-based (keyset) pagination.
"""
type PageInfo {
	"""
	True if there are more items after the last edge in this page.
	"""
	hasNextPage: Boolean!
	"""
	True if there are items before the first edge in this page (i.e. a cursor was provided).
	"""
	hasPreviousPage: Boolean!
	"""
	Opaque cursor pointing to the first edge in this page. Null if the page is empty.
	"""
	startCursor: String
	"""
	Opaque cursor pointing to the last edge in this page. Pass this as the "after" parameter to fetch the next page. Null if the page is empty.
	"""
	endCursor: String
	"""
	Total number of items matching the query filters, across all pages.
	"""
	totalCount: Int!
}

type QueryRoot {
	"""
	Current dataset metadata (MegaMek version, schema version, release date).
	"""
	metadata: DatasetMetadataGql
	"""
	All available game rulesets (Introductory, Standard, Advanced, etc.).
	"""
	rulesets: [RulesetGql!]!
	"""
	Look up a single unit variant by its slug.
	"""
	unit(
		"""
		Lowercase, hyphen-separated unit identifier (e.g. "atlas-as7-d").
		"""
		slug: String!
	): UnitGql
	"""
	Batch lookup of units by their slugs. Returns units in the order of the input slugs.
	"""
	unitsByIds(
		"""
		Array of lowercase, hyphen-separated unit slugs. Maximum 24 slugs per call.
		"""
		slugs: [String!]!
	): [UnitGql!]!
	"""
	Paginated, filterable search across all unit variants. Returns a cursor-based connection.
	"""
	units(
		"""
		Items per page. Default 20, max 100.
		"""
		first: Int,
		"""
		Opaque cursor from a previous pageInfo.endCursor. Omit for the first page.
		"""
		after: String,
		"""
		Case-insensitive substring match against the unit's full name.
		"""
		nameSearch: String,
		"""
		Filter by technology base.
		"""
		techBase: TechBaseFilter,
		"""
		Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.
		"""
		rulesLevel: RulesLevelFilter,
		"""
		Minimum tonnage filter (inclusive). Weight in metric tons.
		"""
		tonnageMin: Float,
		"""
		Maximum tonnage filter (inclusive). Weight in metric tons.
		"""
		tonnageMax: Float,
		"""
		Minimum Battle Value filter (inclusive).
		"""
		bvMin: Int,
		"""
		Maximum Battle Value filter (inclusive).
		"""
		bvMax: Int,
		"""
		Filter to units available to this faction. Lowercase, hyphen-separated slug (e.g. "clan-wolf").
		"""
		factionSlug: String,
		"""
		Filter to units available to any faction of these types. Accepts multiple values.
		"""
		factionTypes: [FactionTypeFilter!],
		"""
		Filter to units available in this era.
		"""
		eraSlug: EraFilter,
		"""
		Filter to OmniMechs only (true) or non-OmniMechs (false).
		"""
		isOmnimech: Boolean,
		"""
		Filter by chassis config. One of: Biped, Quad, Tripod, LAM.
		"""
		config: String,
		"""
		Filter by engine type (e.g. "XL Engine", "Fusion Engine").
		"""
		engineType: String,
		"""
		Filter to jump-capable mechs (true) or non-jumpers (false).
		"""
		hasJump: Boolean,
		"""
		Filter by tactical role (e.g. "Juggernaut", "Sniper", "Striker"). Case-sensitive, from Master Unit List.
		"""
		role: String,
		"""
		Filter by unit type.
		"""
		unitType: UnitTypeFilter
	): UnitConnection!
	"""
	Look up a single chassis by its slug. A chassis groups all variants of a unit design.
	"""
	chassis(
		"""
		Lowercase, hyphen-separated chassis identifier including unit type suffix (e.g. "atlas-mech", "demolisher-vehicle").
		"""
		slug: String!
	): UnitChassisGql
	"""
	List all chassis, optionally filtered by unit type, technology base, and/or rules level.
	"""
	allChassis(
		"""
		Filter by unit type.
		"""
		unitType: UnitTypeFilter,
		"""
		Filter by technology base.
		"""
		techBase: TechBaseFilter,
		"""
		Filter to chassis with at least one variant at or below this rules level (cumulative).
		"""
		rulesLevel: RulesLevelFilter
	): [UnitChassisGql!]!
	"""
	Look up a single equipment item by its slug.
	"""
	equipment(
		"""
		Lowercase, hyphen-separated equipment identifier (e.g. "medium-laser").
		"""
		slug: String!
	): EquipmentGql
	"""
	Paginated, filterable search across all equipment items. Returns a cursor-based connection.
	"""
	allEquipment(
		"""
		Items per page. Default 20, max 100.
		"""
		first: Int,
		"""
		Opaque cursor from a previous pageInfo.endCursor. Omit for the first page.
		"""
		after: String,
		"""
		Case-insensitive substring match against the equipment name.
		"""
		nameSearch: String,
		"""
		Filter by equipment category.
		"""
		category: EquipmentCategoryFilter,
		"""
		Filter by technology base.
		"""
		techBase: TechBaseFilter,
		"""
		Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.
		"""
		rulesLevel: RulesLevelFilter,
		"""
		Filter to equipment weighing at most this many tons. Only matches items with known tonnage.
		"""
		maxTonnage: Float,
		"""
		Filter to equipment consuming at most this many critical slots. Only matches items with known crits.
		"""
		maxCrits: Int,
		"""
		Filter to equipment observed in this location across existing units (e.g. "right_arm").
		"""
		observedLocation: String,
		"""
		Filter to ammo types compatible with this weapon slug (e.g. "autocannon-10").
		"""
		ammoForSlug: String
	): EquipmentConnection!
	"""
	Look up a single faction by its slug.
	"""
	faction(
		"""
		Lowercase, hyphen-separated faction identifier (e.g. "clan-wolf").
		"""
		slug: String!
	): FactionGql
	"""
	List all factions, optionally filtered by type, clan status, or era.
	"""
	allFactions(
		"""
		Filter by faction classification.
		"""
		factionType: FactionTypeFilter,
		"""
		Filter by clan status. True returns only Clans; false returns only non-Clans.
		"""
		isClan: Boolean,
		"""
		Filter to factions active in this era.
		"""
		eraSlug: EraFilter
	): [FactionGql!]!
	"""
	Look up a single era by its slug.
	"""
	era(
		"""
		Era identifier.
		"""
		slug: EraFilter!
	): EraGql
	"""
	List all eras in chronological order.
	"""
	allEras: [EraGql!]!
	"""
	Find eras that contain the given in-universe year. May return multiple eras if they overlap.
	"""
	eraByYear(
		"""
		In-universe BattleTech year to look up (e.g. 3055). Not a real-world date.
		"""
		year: Int!
	): [EraGql!]!
	"""
	List all engine types, optionally filtered by technology base and/or rules level.
	"""
	engineTypes(
		"""
		Filter by technology base.
		"""
		techBase: TechBaseFilter,
		"""
		Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.
		"""
		rulesLevel: RulesLevelFilter
	): [EngineTypeGql!]!
	"""
	List all armor types, optionally filtered by technology base and/or rules level.
	"""
	armorTypes(
		"""
		Filter by technology base.
		"""
		techBase: TechBaseFilter,
		"""
		Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.
		"""
		rulesLevel: RulesLevelFilter
	): [ArmorTypeGql!]!
	"""
	List all internal structure types, optionally filtered by technology base and/or rules level.
	"""
	structureTypes(
		"""
		Filter by technology base.
		"""
		techBase: TechBaseFilter,
		"""
		Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.
		"""
		rulesLevel: RulesLevelFilter
	): [StructureTypeGql!]!
	"""
	List all heat sink types, optionally filtered by technology base and/or rules level.
	"""
	heatsinkTypes(
		"""
		Filter by technology base.
		"""
		techBase: TechBaseFilter,
		"""
		Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.
		"""
		rulesLevel: RulesLevelFilter
	): [HeatsinkTypeGql!]!
	"""
	List all gyroscope types, optionally filtered by rules level.
	"""
	gyroTypes(
		"""
		Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.
		"""
		rulesLevel: RulesLevelFilter
	): [GyroTypeGql!]!
	"""
	List all cockpit types, optionally filtered by rules level.
	"""
	cockpitTypes(
		"""
		Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.
		"""
		rulesLevel: RulesLevelFilter
	): [CockpitTypeGql!]!
	"""
	List all myomer types, optionally filtered by rules level.
	"""
	myomerTypes(
		"""
		Filter by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.
		"""
		rulesLevel: RulesLevelFilter
	): [MyomerTypeGql!]!
	"""
	Look up engine weights by rating. Returns all ratings if no filter is given.
	"""
	engineWeights(
		"""
		Filter to a specific engine rating (e.g. 300).
		"""
		rating: Int
	): [EngineWeightGql!]!
	"""
	Look up internal structure hit points for a specific mech tonnage (20-100 in steps of 5).
	"""
	internalStructure(
		"""
		Mech tonnage to look up (20-100 in steps of 5).
		"""
		tonnage: Int!
	): InternalStructureGql
	"""
	Fetch all construction reference data in one round-trip. Ideal for builder client initialization.
	"""
	constructionReference: ConstructionReferenceGql!
}

"""
A quirk affecting a specific unit variant, providing a positive or negative gameplay modifier.
"""
type QuirkGql {
	"""
	Lowercase, hyphen-separated identifier (e.g. "improved-sensors").
	"""
	slug: String!
	"""
	Human-readable quirk name.
	"""
	name: String!
	"""
	True if this quirk is beneficial; false if it is a drawback.
	"""
	isPositive: Boolean!
	"""
	Explanation of the quirk's gameplay effect, if available.
	"""
	description: String
}

"""
Rules level filter.
"""
enum RulesLevelFilter {
	"""
	Basic game rules, limited equipment options.
	"""
	INTRODUCTORY
	"""
	Standard tournament-legal rules.
	"""
	STANDARD
	"""
	Advanced rules with expanded options.
	"""
	ADVANCED
	"""
	Experimental/prototype equipment.
	"""
	EXPERIMENTAL
	"""
	Fan-created or unofficial equipment.
	"""
	UNOFFICIAL
}

"""
A game ruleset level defining which units and equipment are permitted.
"""
type RulesetGql {
	"""
	Lowercase, hyphen-separated identifier for the ruleset.
	"""
	slug: String!
	"""
	Human-readable ruleset name (e.g. "Standard").
	"""
	name: String!
	"""
	Rules level in snake_case. One of: introductory, standard, advanced, experimental, unofficial.
	"""
	level: String!
	"""
	Description of what this ruleset permits.
	"""
	description: String
	"""
	Source book defining this ruleset.
	"""
	sourceBook: String
}

"""
An internal structure technology used in BattleMech construction.
Structure weight = mech_tonnage * weight_fraction.
"""
type StructureTypeGql {
	"""
	Unique identifier (same as slug).
	"""
	id: ID!
	"""
	Lowercase, hyphen-separated identifier (e.g. "endo-steel-is").
	"""
	slug: String!
	"""
	Human-readable structure name (e.g. "Endo Steel (IS)").
	"""
	name: String!
	"""
	Technology base required for this structure type.
	"""
	techBase: String!
	"""
	Minimum rules level needed to use this structure type.
	"""
	rulesLevel: String!
	"""
	Fraction of mech tonnage consumed by the internal structure.
	"""
	weightFraction: Float!
	"""
	Total critical slots consumed across all locations.
	"""
	crits: Int!
	"""
	In-universe year when this structure type was first produced.
	"""
	introYear: Int
}

"""
Technology base filter.
"""
enum TechBaseFilter {
	"""
	Inner Sphere technology.
	"""
	INNER_SPHERE
	"""
	Clan technology.
	"""
	CLAN
	"""
	Mixed Inner Sphere / Clan technology.
	"""
	MIXED
	"""
	Primitive (pre-Star League) technology.
	"""
	PRIMITIVE
}

"""
A chassis (design family) grouping all variants of a unit. For example, the "Atlas" chassis contains AS7-D, AS7-K, etc.
"""
type UnitChassisGql {
	"""
	Unique identifier (same as slug).
	"""
	id: ID!
	"""
	Lowercase, hyphen-separated identifier (e.g. "atlas").
	"""
	slug: String!
	"""
	Human-readable chassis name (e.g. "Atlas").
	"""
	name: String!
	"""
	Unit type category (e.g. "BattleMech", "Vehicle", "AeroSpaceFighter", "DropShip").
	"""
	unitType: String!
	"""
	Technology base. One of: inner_sphere, clan, mixed, primitive.
	"""
	techBase: String!
	"""
	Weight in metric tons. Ranges from 20 (light mechs) to 500,000+ (jumpships).
	"""
	tonnage: Float!
	"""
	In-universe BattleTech year when this chassis was first produced (e.g. 3025). Not a real-world date.
	"""
	introYear: Int
	"""
	Flavor text or lore description of the chassis.
	"""
	description: String
	"""
	All unit variants belonging to this chassis, ordered by variant designation.
	Optionally filtered by maximum rules level (cumulative).
	"""
	variants(
		"""
		Filter variants by maximum rules level (cumulative). E.g. ADVANCED includes introductory, standard, and advanced.
		"""
		rulesLevel: RulesLevelFilter
	): [UnitGql!]!
}

"""
Relay-style paginated list of units with cursor-based navigation.
"""
type UnitConnection {
	"""
	List of unit edges in this page.
	"""
	edges: [UnitEdge!]!
	"""
	Pagination metadata including cursors and total count.
	"""
	pageInfo: PageInfo!
}

"""
A single edge in a paginated unit list, pairing a cursor with its unit node.
"""
type UnitEdge {
	"""
	Opaque pagination cursor for this edge. Can be used as the "after" parameter.
	"""
	cursor: String!
	"""
	The unit at this position in the result set.
	"""
	node: UnitGql!
}

"""
A specific unit variant (e.g. "Atlas AS7-D") with its stats, loadout, armor, quirks, and faction availability.
"""
type UnitGql {
	"""
	Unique identifier (same as slug).
	"""
	id: ID!
	"""
	Lowercase, hyphen-separated identifier (e.g. "atlas-as7-d").
	"""
	slug: String!
	"""
	Variant designation (e.g. "AS7-D", "Prime", "A").
	"""
	variant: String!
	"""
	Full display name combining chassis and variant (e.g. "Atlas AS7-D").
	"""
	fullName: String!
	"""
	Technology base. One of: inner_sphere, clan, mixed, primitive.
	"""
	techBase: String!
	"""
	Rules level governing which game modes allow this unit. One of: introductory, standard, advanced, experimental, unofficial.
	"""
	rulesLevel: String!
	"""
	Weight in metric tons. Ranges from 20 (light mechs) to 500,000+ (jumpships).
	"""
	tonnage: Float!
	"""
	Battle Value — composite combat effectiveness score used for game balancing. Null if not computed.
	"""
	bv: Int
	"""
	Construction cost in C-bills (in-universe currency). Null if not available.
	"""
	cost: Int
	"""
	In-universe BattleTech year when this variant was first produced (e.g. 3025). Not a real-world date.
	"""
	introYear: Int
	"""
	In-universe BattleTech year when this variant went extinct. Null if still in production.
	"""
	extinctionYear: Int
	"""
	In-universe BattleTech year when this variant was reintroduced after extinction. Null if never reintroduced.
	"""
	reintroYear: Int
	"""
	Source book or technical readout where this unit is published.
	"""
	sourceBook: String
	"""
	Flavor text or lore description of the unit variant.
	"""
	description: String
	"""
	Master Unit List numeric ID. Null for units not found in MUL.
	"""
	mulId: Int
	"""
	Tactical role (e.g. "Juggernaut", "Sniper", "Striker"). Null if unassigned.
	"""
	role: String
	"""
	Alternate Clan/IS reporting name (e.g. "Fire Moth A" for "Dasher A"). Null for units without dual names.
	"""
	clanName: String
	"""
	Parent chassis this variant belongs to.
	"""
	chassis: UnitChassisGql
	"""
	Armor and internal structure values for each body location.
	"""
	locations: [LocationGql!]!
	"""
	All equipment items mounted on this unit, grouped by location.
	"""
	loadout: [LoadoutEntryGql!]!
	"""
	Positive and negative quirks unique to this unit variant.
	"""
	quirks: [QuirkGql!]!
	"""
	Faction and era availability records for this unit.
	"""
	availability: [AvailabilityGql!]!
	"""
	Mech-specific technical data. Null for non-mech units (vehicles, aerospace, etc.).
	"""
	mechData: MechDataGql
	"""
	Reserved for future vehicle-specific data (motive type, turret, etc.).
	"""
	vehicleData: Boolean
}

"""
Unit type filter.
"""
enum UnitTypeFilter {
	"""
	BattleMech (bipedal/quad combat walker).
	"""
	MECH
	"""
	Combat vehicle (tracked, wheeled, hover, VTOL).
	"""
	VEHICLE
	"""
	Aerospace fighter or conventional fighter.
	"""
	FIGHTER
	"""
	Other unit types (battle armor, infantry, etc.).
	"""
	OTHER
}

"""
Directs the executor to include this field or fragment only when the `if` argument is true.
"""
directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
"""
Directs the executor to skip this field or fragment when the `if` argument is true.
"""
directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
schema {
	query: QueryRoot
}