1447 lines
29 KiB
GraphQL
1447 lines
29 KiB
GraphQL
"""String or list of strings"""
|
|
scalar StringFilter
|
|
|
|
"""
|
|
Int, list of ints, or object with gte (>=), gt (>), lte (<=), and lt (<) properties for range of values
|
|
"""
|
|
scalar IntFilter
|
|
|
|
"""
|
|
Float, list of floats, or object with gte (>=), gt (>), lte (<=), and lt (<) properties for range of values
|
|
"""
|
|
scalar FloatFilter
|
|
|
|
type AbilityScore {
|
|
index: String!
|
|
name: String!
|
|
full_name: String!
|
|
desc: [String!]!
|
|
skills(order_direction: OrderByDirection, name: String): [Skill!]!
|
|
}
|
|
|
|
type Skill {
|
|
index: String!
|
|
name: String!
|
|
desc: [String!]!
|
|
ability_score: AbilityScore!
|
|
}
|
|
|
|
type Alignment {
|
|
index: String!
|
|
name: String!
|
|
abbreviation: String!
|
|
desc: String!
|
|
}
|
|
|
|
type Condition {
|
|
index: String!
|
|
name: String!
|
|
desc: [String!]!
|
|
}
|
|
|
|
type DamageType {
|
|
index: String!
|
|
name: String!
|
|
desc: [String!]!
|
|
}
|
|
|
|
type WeaponProperty {
|
|
index: String!
|
|
name: String!
|
|
desc: [String!]!
|
|
}
|
|
|
|
enum Currency {
|
|
CP
|
|
SP
|
|
GP
|
|
}
|
|
|
|
type Cost {
|
|
quantity: Int!
|
|
unit: Currency!
|
|
}
|
|
|
|
type EquipmentCategory {
|
|
index: String!
|
|
name: String!
|
|
equipment(order: EquipmentCategoryOrder, skip: Int, limit: Int! = 100, name: String): [IEquipmentBase!]!
|
|
}
|
|
|
|
interface IEquipmentBase {
|
|
index: String!
|
|
name: String!
|
|
desc: [String!]
|
|
equipment_category: EquipmentCategory!
|
|
}
|
|
|
|
enum MagicItemRarity {
|
|
VARIES
|
|
COMMON
|
|
UNCOMMON
|
|
RARE
|
|
VERY_RARE
|
|
LEGENDARY
|
|
ARTIFACT
|
|
}
|
|
|
|
type MagicItem implements IEquipmentBase {
|
|
index: String!
|
|
name: String!
|
|
desc: [String!]!
|
|
rarity: MagicItemRarity!
|
|
equipment_category: EquipmentCategory!
|
|
}
|
|
|
|
interface IEquipment implements IEquipmentBase {
|
|
index: String!
|
|
name: String!
|
|
cost: Cost!
|
|
desc: [String!]
|
|
equipment_category: EquipmentCategory!
|
|
weight: Float
|
|
}
|
|
|
|
type Tool implements IEquipment & IEquipmentBase {
|
|
index: String!
|
|
name: String!
|
|
desc: [String!]
|
|
cost: Cost!
|
|
equipment_category: EquipmentCategory!
|
|
weight: Float
|
|
tool_category: EquipmentCategory!
|
|
}
|
|
|
|
interface IGear implements IEquipment & IEquipmentBase {
|
|
index: String!
|
|
name: String!
|
|
cost: Cost!
|
|
desc: [String!]
|
|
equipment_category: EquipmentCategory!
|
|
weight: Float
|
|
gear_category: EquipmentCategory!
|
|
}
|
|
|
|
type Gear implements IGear & IEquipment & IEquipmentBase {
|
|
index: String!
|
|
name: String!
|
|
cost: Cost!
|
|
desc: [String!]
|
|
equipment_category: EquipmentCategory!
|
|
weight: Float
|
|
gear_category: EquipmentCategory!
|
|
}
|
|
|
|
type PackQuantity {
|
|
quantity: Int!
|
|
item: IEquipment!
|
|
}
|
|
|
|
type Quantity {
|
|
quantity: Int!
|
|
equipment: IEquipment!
|
|
}
|
|
|
|
type Pack implements IGear & IEquipment & IEquipmentBase {
|
|
index: String!
|
|
name: String!
|
|
cost: Cost!
|
|
desc: [String!]
|
|
equipment_category: EquipmentCategory!
|
|
weight: Float
|
|
gear_category: EquipmentCategory!
|
|
contents: [PackQuantity!]!
|
|
}
|
|
|
|
type Ammunition implements IGear & IEquipment & IEquipmentBase {
|
|
index: String!
|
|
name: String!
|
|
cost: Cost!
|
|
desc: [String!]
|
|
equipment_category: EquipmentCategory!
|
|
weight: Float
|
|
gear_category: EquipmentCategory!
|
|
quantity: Int!
|
|
}
|
|
|
|
type Damage {
|
|
damage_dice: String!
|
|
damage_type: DamageType!
|
|
}
|
|
|
|
type Range {
|
|
normal: Int!
|
|
long: Int
|
|
}
|
|
|
|
enum WeaponRange {
|
|
MELEE
|
|
RANGED
|
|
}
|
|
|
|
type Weapon implements IEquipment & IEquipmentBase {
|
|
index: String!
|
|
name: String!
|
|
cost: Cost!
|
|
desc: [String!]
|
|
equipment_category: EquipmentCategory!
|
|
weight: Float
|
|
damage: Damage
|
|
range: Range!
|
|
throw_range: Range
|
|
weapon_category: EquipmentCategory!
|
|
weapon_range: WeaponRange!
|
|
category_range: EquipmentCategory!
|
|
two_handed_damage: Damage
|
|
properties(name: String): [WeaponProperty!]!
|
|
special: [String!]
|
|
}
|
|
|
|
type ArmorClass {
|
|
base: Int!
|
|
dex_bonus: Boolean!
|
|
max_bonus: Int
|
|
}
|
|
|
|
type Armor implements IEquipment & IEquipmentBase {
|
|
index: String!
|
|
name: String!
|
|
cost: Cost!
|
|
desc: [String!]
|
|
equipment_category: EquipmentCategory!
|
|
weight: Float
|
|
armor_category: EquipmentCategory!
|
|
str_minimum: Int!
|
|
stealth_disadvantage: Boolean!
|
|
armor_class: ArmorClass!
|
|
}
|
|
|
|
type Speed {
|
|
quantity: Float!
|
|
unit: String!
|
|
}
|
|
|
|
type Vehicle implements IEquipment & IEquipmentBase {
|
|
index: String!
|
|
name: String!
|
|
cost: Cost!
|
|
desc: [String!]
|
|
equipment_category: EquipmentCategory!
|
|
weight: Float
|
|
vehicle_category: EquipmentCategory!
|
|
speed: Speed
|
|
capacity: String
|
|
}
|
|
|
|
type AbilityScorePrerequisite {
|
|
ability_score: AbilityScore!
|
|
minimum_score: Int!
|
|
}
|
|
|
|
type Feat {
|
|
index: String!
|
|
name: String!
|
|
desc: [String!]!
|
|
prerequisites: [AbilityScorePrerequisite!]!
|
|
}
|
|
|
|
enum LanguageType {
|
|
STANDARD
|
|
EXOTIC
|
|
}
|
|
|
|
enum LanguageScript {
|
|
COMMON
|
|
ELVISH
|
|
DWARVISH
|
|
INFERNAL
|
|
DRACONIC
|
|
CELESTIAL
|
|
}
|
|
|
|
"""
|
|
LanguageScript ("COMMON", "ELVISH", "DWARVISH", "INFERNAL", "DRACONIC", "CELESTIAL") or list of LanguageScripts
|
|
"""
|
|
scalar LanguageScriptFilter
|
|
|
|
type Language {
|
|
index: String!
|
|
name: String!
|
|
desc: String
|
|
script: LanguageScript
|
|
type: LanguageType!
|
|
typical_speakers: [String!]!
|
|
}
|
|
|
|
type Rule {
|
|
index: String!
|
|
name: String!
|
|
desc: String!
|
|
subsections(name: String): [RuleSection!]!
|
|
}
|
|
|
|
type RuleSection {
|
|
index: String!
|
|
name: String!
|
|
desc: String!
|
|
}
|
|
|
|
type AreaOfEffect {
|
|
type: AreaOfEffectType!
|
|
size: Int!
|
|
}
|
|
|
|
enum AreaOfEffectType {
|
|
SPHERE
|
|
CUBE
|
|
CYLINDER
|
|
LINE
|
|
CONE
|
|
}
|
|
|
|
"""
|
|
AreaOfEffectType ("SPHERE", "CUBE", "CYLINDER", "LINE", "CONE") or list of AreaOfEffectTypes
|
|
"""
|
|
scalar AreaOfEffectTypeFilter
|
|
|
|
enum SpellComponent {
|
|
V
|
|
S
|
|
M
|
|
}
|
|
|
|
type DamageAtLevel {
|
|
level: Int!
|
|
damage: String!
|
|
}
|
|
|
|
type SpellDamage {
|
|
damage_at_slot_level: [DamageAtLevel!]
|
|
damage_at_character_level: [DamageAtLevel!]
|
|
damage_type: DamageType
|
|
}
|
|
|
|
type HealingAtLevel {
|
|
level: Int!
|
|
healing: String!
|
|
}
|
|
|
|
enum DcSuccess {
|
|
NONE
|
|
HALF
|
|
OTHER
|
|
}
|
|
|
|
type SpellDc {
|
|
success: DcSuccess!
|
|
type: AbilityScore!
|
|
desc: String
|
|
}
|
|
|
|
type MagicSchool {
|
|
index: String!
|
|
name: String!
|
|
desc: String!
|
|
spells(level: IntFilter, class: StringFilter, subclass: StringFilter, concentration: Boolean, ritual: Boolean, attack_type: SpellAttackTypeFilter, casting_time: StringFilter, area_of_effect: AreaOfEffectFilter, damage_type: StringFilter, dc_type: StringFilter, range: StringFilter, order: SpellOrder, skip: Int, limit: Int! = 100, name: String): [Spell!]!
|
|
}
|
|
|
|
enum SpellAttackType {
|
|
MELEE
|
|
RANGED
|
|
}
|
|
|
|
"""SpellAttackType ("MELEE", "RANGED") or list of SpellAttackTypes"""
|
|
scalar SpellAttackTypeFilter
|
|
|
|
type Spell {
|
|
index: String!
|
|
area_of_effect: AreaOfEffect
|
|
attack_type: SpellAttackType
|
|
casting_time: String!
|
|
classes(name: String): [Class!]!
|
|
subclasses(name: String): [Subclass!]!
|
|
components: [SpellComponent]
|
|
concentration: Boolean!
|
|
damage: SpellDamage
|
|
dc: SpellDc
|
|
desc: [String!]!
|
|
duration: String!
|
|
heal_at_slot_level: [HealingAtLevel!]
|
|
higher_level: [String!]
|
|
level: Int!
|
|
material: String
|
|
name: String!
|
|
range: String!
|
|
ritual: Boolean!
|
|
school: MagicSchool!
|
|
}
|
|
|
|
union ProficiencyReference = EquipmentCategory | Skill | AbilityScore | Tool | Armor | Weapon | Vehicle | Gear | Pack | Ammunition
|
|
|
|
enum ProficiencyType {
|
|
WEAPONS
|
|
ARTISANS_TOOLS
|
|
SKILLS
|
|
ARMOR
|
|
MUSICAL_INSTRUMENTS
|
|
SAVING_THROWS
|
|
OTHER
|
|
GAMING_SETS
|
|
VEHICLES
|
|
}
|
|
|
|
"""
|
|
ProficiencyType ("WEAPONS", "ARTISANS_TOOLS", "SKILLS", "ARMOR", "MUSICAL_INSTRUMENTS", "SAVING_THROWS", "OTHER", "GAMING_SETS", "VEHICLES") or list of ProficiencyTypes
|
|
"""
|
|
scalar ProficiencyTypeFilter
|
|
|
|
type Proficiency {
|
|
index: String!
|
|
name: String!
|
|
classes(name: String): [Class!]!
|
|
type: ProficiencyType!
|
|
races(name: String): [ProficiencyRace!]!
|
|
reference: ProficiencyReference!
|
|
}
|
|
|
|
type ActionDc {
|
|
type: AbilityScore!
|
|
value: Int!
|
|
success: DcSuccess!
|
|
}
|
|
|
|
type LegendaryAction {
|
|
name: String!
|
|
desc: String!
|
|
dc: ActionDc
|
|
damage: [Damage!]
|
|
}
|
|
|
|
type MonsterProficiency {
|
|
proficiency: Proficiency!
|
|
value: Int!
|
|
}
|
|
|
|
type Reaction {
|
|
name: String!
|
|
desc: String!
|
|
dc: ActionDc
|
|
}
|
|
|
|
type Senses {
|
|
blindsight: String
|
|
darkvision: String
|
|
passive_perception: Int!
|
|
tremorsense: String
|
|
truesight: String
|
|
}
|
|
|
|
enum RestType {
|
|
SHORT
|
|
LONG
|
|
}
|
|
|
|
enum UsageType {
|
|
AT_WILL
|
|
PER_DAY
|
|
RECHARGE_ON_ROLL
|
|
RECHARGE_AFTER_REST
|
|
PER_REST
|
|
}
|
|
|
|
type Usage {
|
|
type: UsageType!
|
|
times: Int
|
|
rest_types: [RestType!]
|
|
dice: String
|
|
min_value: Int
|
|
}
|
|
|
|
type MonsterSpellSlot {
|
|
level: Int!
|
|
slots: Int!
|
|
}
|
|
|
|
type MonsterSpell {
|
|
spell: Spell!
|
|
usage: Usage
|
|
}
|
|
|
|
type MonsterSpellcasting {
|
|
level: Int
|
|
ability: AbilityScore!
|
|
dc: Int
|
|
modifier: Int
|
|
components_required: [SpellComponent!]
|
|
school: String
|
|
slots: [MonsterSpellSlot!]
|
|
spells: [MonsterSpell!]!
|
|
}
|
|
|
|
type SpecialAbility {
|
|
name: String!
|
|
desc: String!
|
|
usage: Usage
|
|
dc: ActionDc
|
|
spellcasting: MonsterSpellcasting
|
|
damage: [Damage!]
|
|
}
|
|
|
|
type MonsterSpeed {
|
|
burrow: String
|
|
climb: String
|
|
fly: String
|
|
hover: Boolean
|
|
swim: String
|
|
walk: String
|
|
}
|
|
|
|
enum Size {
|
|
TINY
|
|
SMALL
|
|
MEDIUM
|
|
LARGE
|
|
HUGE
|
|
GARGANTUAN
|
|
}
|
|
|
|
"""
|
|
Size ("TINY", "SMALL", "MEDIUM", "LARGE", "HUGE", "GARGANTUAN") or list of sizes
|
|
"""
|
|
scalar SizeFilter
|
|
|
|
enum MonsterType {
|
|
BEAST
|
|
MONSTROSITY
|
|
DRAGON
|
|
HUMANOID
|
|
UNDEAD
|
|
FIEND
|
|
CELESTIAL
|
|
CONSTRUCT
|
|
GIANT
|
|
ELEMENTAL
|
|
FEY
|
|
ABERRATION
|
|
OOZE
|
|
SWARM
|
|
PLANT
|
|
}
|
|
|
|
"""
|
|
MonsterTypes ("BEAST", "MONSTROSITY", "DRAGON", "HUMANOID", "UNDEAD", "FIEND", "CELESTIAL", "CONSTRUCT", "GIANT", "ELEMENTAL", "FEY", "ABERRATION", "OOZE", "SWARM", "PLANT") or list of MonsterTypes
|
|
"""
|
|
scalar MonsterTypeFilter
|
|
|
|
enum MonsterSubtype {
|
|
ANY_RACE
|
|
HUMAN
|
|
DWARF
|
|
ELF
|
|
GOBLINOID
|
|
MERFOLK
|
|
SHAPECHANGER
|
|
DEMON
|
|
DEVIL
|
|
ORC
|
|
SAHUAGIN
|
|
TITAN
|
|
KOBOLD
|
|
GNOLL
|
|
GRIMLOCK
|
|
LIZARDFOLK
|
|
GNOME
|
|
}
|
|
|
|
"""
|
|
MonsterSubtype ("ANY_RACE", "HUMAN", "DWARF", "ELF", "GOBLINOID", "MERFOLK", "SHAPECHANGER", "DEMON", "DEVIL", "ORC", "SAHUAGIN", "TITAN", "KOBOLD", "GNOLL", "GRIMLOCK", "LIZARDFOLK", "GNOME") or list of MonsterSubtypes
|
|
"""
|
|
scalar MonsterSubtypeFilter
|
|
|
|
"""Int or string"""
|
|
scalar ActionCount
|
|
|
|
type ActionOption {
|
|
option_type: String!
|
|
action_name: String!
|
|
count: ActionCount!
|
|
type: String
|
|
}
|
|
|
|
type MultipleActionOption {
|
|
option_type: String!
|
|
items: [ActionOption!]!
|
|
}
|
|
|
|
union MonsterActionOption = ActionOption | MultipleActionOption
|
|
|
|
type MonsterActionOptionSet {
|
|
option_set_type: String!
|
|
options: [MonsterActionOption!]!
|
|
}
|
|
|
|
type MonsterActionChoice {
|
|
choose: Int!
|
|
type: String!
|
|
from: MonsterActionOptionSet!
|
|
}
|
|
|
|
type Action {
|
|
action_name: String!
|
|
count: ActionCount!
|
|
type: String!
|
|
}
|
|
|
|
type Attack {
|
|
damage: [Damage!]
|
|
dc: ActionDc!
|
|
name: String!
|
|
}
|
|
|
|
type DamageOption {
|
|
option_type: String!
|
|
damage_dice: String!
|
|
damage_type: DamageType!
|
|
notes: String
|
|
}
|
|
|
|
type DamageOptionSet {
|
|
option_set_type: String!
|
|
options: [DamageOption!]!
|
|
}
|
|
|
|
type ActionDamage {
|
|
damage_dice: String
|
|
damage_type: DamageType
|
|
choose: Int
|
|
dc: ActionDc
|
|
type: String
|
|
from: DamageOptionSet
|
|
}
|
|
|
|
type BreathOption {
|
|
option_type: String!
|
|
name: String!
|
|
dc: ActionDc!
|
|
damage: [Damage!]
|
|
}
|
|
|
|
type BreathOptionSet {
|
|
option_set_type: String!
|
|
options: [BreathOption!]!
|
|
}
|
|
|
|
type BreathChoice {
|
|
choose: Int!
|
|
type: String!
|
|
from: BreathOptionSet!
|
|
}
|
|
|
|
type MonsterAction {
|
|
action_options: MonsterActionChoice
|
|
actions: [Action!]
|
|
name: String!
|
|
multiattack_type: String
|
|
attack_bonus: Int
|
|
attacks: [Attack!]
|
|
damage: [ActionDamage!]
|
|
desc: String!
|
|
dc: ActionDc
|
|
options: BreathChoice
|
|
usage: Usage
|
|
}
|
|
|
|
enum MonsterArmorClassType {
|
|
dex
|
|
natural
|
|
armor
|
|
spell
|
|
condition
|
|
}
|
|
|
|
type MonsterArmorClass {
|
|
type: MonsterArmorClassType!
|
|
desc: String
|
|
value: Int!
|
|
armor: [Armor]
|
|
spell: Spell
|
|
condition: Condition
|
|
}
|
|
|
|
type Monster {
|
|
index: String!
|
|
name: String!
|
|
alignment: String!
|
|
armor_class: [MonsterArmorClass]
|
|
desc: String
|
|
actions: [MonsterAction!]
|
|
challenge_rating: Float!
|
|
proficiency_bonus: Int!
|
|
charisma: Int!
|
|
condition_immunities: [Condition!]!
|
|
constitution: Int!
|
|
damage_immunities: [String!]!
|
|
damage_resistances: [String!]!
|
|
damage_vulnerabilities: [String!]!
|
|
dexterity: Int!
|
|
forms: [Monster!]
|
|
hit_dice: String!
|
|
hit_points: Int!
|
|
hit_points_roll: String!
|
|
intelligence: Int!
|
|
languages: String!
|
|
legendary_actions: [LegendaryAction!]
|
|
proficiencies: [MonsterProficiency!]!
|
|
reactions: [Reaction!]
|
|
senses: Senses!
|
|
size: Size!
|
|
special_abilities: [SpecialAbility!]
|
|
speed: MonsterSpeed!
|
|
strength: Int!
|
|
subtype: MonsterSubtype
|
|
type: MonsterType!
|
|
wisdom: Int!
|
|
xp: Int!
|
|
image: String
|
|
}
|
|
|
|
type ProficiencyReferenceOption {
|
|
option_type: String!
|
|
item: Proficiency!
|
|
}
|
|
|
|
type ProficiencyChoiceOption {
|
|
option_type: String!
|
|
choice: ProficiencyChoice!
|
|
}
|
|
|
|
union ProficiencyOption = ProficiencyChoiceOption | ProficiencyReferenceOption
|
|
|
|
type ProficiencyOptionSet {
|
|
option_set_type: String!
|
|
options: [ProficiencyOption!]!
|
|
}
|
|
|
|
type ProficiencyChoice {
|
|
desc: String
|
|
choose: Int!
|
|
type: String!
|
|
from: ProficiencyOptionSet!
|
|
}
|
|
|
|
type BreathWeaponDc {
|
|
type: AbilityScore!
|
|
success: DcSuccess!
|
|
}
|
|
|
|
type BreathWeaponUsage {
|
|
times: Int!
|
|
type: UsageType!
|
|
}
|
|
|
|
type BreathWeaponDamage {
|
|
damage_at_character_level: [DamageAtLevel!]!
|
|
damage_type: DamageType!
|
|
}
|
|
|
|
type BreathWeaponTrait {
|
|
name: String!
|
|
desc: String!
|
|
dc: BreathWeaponDc!
|
|
usage: BreathWeaponUsage!
|
|
damage: [BreathWeaponDamage!]!
|
|
area_of_effect: AreaOfEffect!
|
|
}
|
|
|
|
type SpellOption {
|
|
option_type: String!
|
|
item: Spell!
|
|
}
|
|
|
|
type SpellOptionSet {
|
|
option_set_type: String!
|
|
options: [SpellOption!]!
|
|
}
|
|
|
|
type SpellChoice {
|
|
choose: Int!
|
|
type: String!
|
|
from: SpellOptionSet!
|
|
}
|
|
|
|
type TraitOption {
|
|
option_type: String!
|
|
item: Trait!
|
|
}
|
|
|
|
type TraitOptionSet {
|
|
option_set_type: String!
|
|
options: [TraitOption!]!
|
|
}
|
|
|
|
type TraitChoice {
|
|
choose: Int!
|
|
type: String!
|
|
from: TraitOptionSet!
|
|
}
|
|
|
|
type TraitSpecific {
|
|
breath_weapon: BreathWeaponTrait
|
|
damage_type: DamageType
|
|
spell_options: SpellChoice
|
|
subtrait_options: TraitChoice
|
|
}
|
|
|
|
type Trait {
|
|
index: String!
|
|
desc: [String!]!
|
|
name: String!
|
|
proficiencies(name: String): [Proficiency!]!
|
|
parent: Trait
|
|
races(name: String): [Race]!
|
|
subraces(name: String): [Subrace!]!
|
|
proficiency_choices: ProficiencyChoice
|
|
language_options: LanguageChoice
|
|
trait_specific: TraitSpecific
|
|
}
|
|
|
|
type AbilityBonus {
|
|
ability_score: AbilityScore!
|
|
bonus: Int!
|
|
}
|
|
|
|
type AbilityBonusOption {
|
|
option_type: String!
|
|
bonus: Int!
|
|
ability_score: AbilityScore!
|
|
}
|
|
|
|
type AbilityBonusOptionSet {
|
|
option_set_type: String!
|
|
options: [AbilityBonusOption!]!
|
|
}
|
|
|
|
type AbilityBonusChoice {
|
|
choose: Int!
|
|
type: String!
|
|
from: AbilityBonusOptionSet!
|
|
}
|
|
|
|
type LanguageOption {
|
|
option_type: String!
|
|
item: Language!
|
|
}
|
|
|
|
type LanguageOptionSet {
|
|
option_set_type: String!
|
|
options: [LanguageOption!]!
|
|
}
|
|
|
|
type LanguageChoice {
|
|
choose: Int!
|
|
type: String!
|
|
from: LanguageOptionSet!
|
|
}
|
|
|
|
type Race implements ProficiencyRace {
|
|
index: String!
|
|
name: String!
|
|
ability_bonuses: [AbilityBonus!]!
|
|
ability_bonus_options: AbilityBonusChoice
|
|
age: String!
|
|
alignment: String!
|
|
language_desc: String!
|
|
languages(name: String): [Language!]!
|
|
language_options: LanguageChoice
|
|
size: Size!
|
|
size_description: String!
|
|
speed: Int!
|
|
starting_proficiencies(name: String): [Proficiency!]!
|
|
starting_proficiency_options: ProficiencyChoice
|
|
subraces(name: String): [Subrace!]!
|
|
traits(name: String): [Trait!]!
|
|
}
|
|
|
|
type Subrace implements ProficiencyRace {
|
|
index: String!
|
|
name: String!
|
|
ability_bonuses: [AbilityBonus!]!
|
|
desc: String!
|
|
race: Race!
|
|
racial_traits(name: String): [Trait!]!
|
|
starting_proficiencies(name: String): [Proficiency!]!
|
|
language_options: LanguageChoice
|
|
}
|
|
|
|
interface ProficiencyRace {
|
|
index: String!
|
|
name: String!
|
|
ability_bonuses: [AbilityBonus!]!
|
|
}
|
|
|
|
type BackgroundFeature {
|
|
name: String!
|
|
desc: [String!]!
|
|
}
|
|
|
|
type EquipmentCategoryOptionSet {
|
|
option_set_type: String!
|
|
equipment_category: EquipmentCategory!
|
|
}
|
|
|
|
type EquipmentCategoryChoice {
|
|
choose: Int!
|
|
type: String!
|
|
from: EquipmentCategoryOptionSet!
|
|
}
|
|
|
|
type IdealOption {
|
|
option_type: String!
|
|
desc: String!
|
|
alignments: [Alignment!]!
|
|
}
|
|
|
|
type IdealOptionSet {
|
|
option_set_type: String!
|
|
options: [IdealOption!]!
|
|
}
|
|
|
|
type IdealChoice {
|
|
choose: Int!
|
|
type: String!
|
|
from: IdealOptionSet!
|
|
}
|
|
|
|
type StringOption {
|
|
option_type: String!
|
|
string: String!
|
|
}
|
|
|
|
type StringOptionSet {
|
|
option_set_type: String!
|
|
options: [StringOption!]!
|
|
}
|
|
|
|
type StringChoice {
|
|
choose: Int!
|
|
type: String!
|
|
from: StringOptionSet!
|
|
}
|
|
|
|
type Background {
|
|
index: String!
|
|
name: String!
|
|
starting_proficiencies(name: String): [Proficiency!]!
|
|
starting_equipment(name: String): [Quantity!]!
|
|
feature: BackgroundFeature!
|
|
language_options: LanguageChoice!
|
|
starting_equipment_options: [EquipmentCategoryChoice!]!
|
|
ideals: IdealChoice!
|
|
personality_traits: StringChoice!
|
|
bonds: StringChoice!
|
|
flaws: StringChoice!
|
|
}
|
|
|
|
type SpellcastingInfo {
|
|
name: String!
|
|
desc: [String!]!
|
|
}
|
|
|
|
type ClassSpellcasting {
|
|
info: [SpellcastingInfo!]!
|
|
level: Int!
|
|
spellcasting_ability: AbilityScore!
|
|
}
|
|
|
|
type PrerequisiteOption {
|
|
option_type: String!
|
|
ability_score: AbilityScore!
|
|
minimum_score: Int!
|
|
}
|
|
|
|
type PrerequisiteOptionSet {
|
|
option_set_type: String!
|
|
options: [PrerequisiteOption!]!
|
|
}
|
|
|
|
type PrerequisiteChoice {
|
|
choose: Int!
|
|
type: String!
|
|
from: PrerequisiteOptionSet!
|
|
}
|
|
|
|
type Multiclassing {
|
|
prerequisites: [AbilityScorePrerequisite!]
|
|
prerequisite_options: PrerequisiteChoice
|
|
proficiencies: [Proficiency!]!
|
|
proficiency_choices: [ProficiencyChoice!]
|
|
}
|
|
|
|
type ProficiencyPrerequisite {
|
|
type: String!
|
|
proficiency: Proficiency!
|
|
}
|
|
|
|
type CountedReferenceOption {
|
|
option_type: String!
|
|
count: Int!
|
|
of: IEquipment!
|
|
prerequisites: [ProficiencyPrerequisite!]
|
|
}
|
|
|
|
type EquipmentCategoryChoiceOption {
|
|
option_type: String!
|
|
choice: EquipmentCategoryChoice!
|
|
}
|
|
|
|
union EquipmentMultipleItem = CountedReferenceOption | EquipmentCategoryChoiceOption
|
|
|
|
type EquipmentMultipleOption {
|
|
option_type: String!
|
|
items: [EquipmentMultipleItem!]!
|
|
}
|
|
|
|
union EquipmentOption = CountedReferenceOption | EquipmentCategoryChoiceOption | EquipmentMultipleOption
|
|
|
|
type EquipmentOptionSet {
|
|
option_set_type: String!
|
|
options: [EquipmentOption!]!
|
|
}
|
|
|
|
union StartingEquipmentOptionSet = EquipmentCategoryOptionSet | EquipmentOptionSet
|
|
|
|
type StartingEquipmentChoice {
|
|
choose: Int!
|
|
desc: String!
|
|
type: String!
|
|
from: StartingEquipmentOptionSet!
|
|
}
|
|
|
|
type Class {
|
|
index: String!
|
|
name: String!
|
|
hit_die: Int!
|
|
proficiencies(name: String): [Proficiency!]!
|
|
saving_throws: [AbilityScore!]!
|
|
spellcasting: ClassSpellcasting
|
|
spells(school: StringFilter, level: IntFilter, subclass: StringFilter, concentration: Boolean, ritual: Boolean, attack_type: SpellAttackTypeFilter, casting_time: StringFilter, area_of_effect: AreaOfEffectFilter, damage_type: StringFilter, dc_type: StringFilter, range: StringFilter, order: SpellOrder, skip: Int, limit: Int! = 100, name: String): [Spell!]
|
|
starting_equipment: [Quantity!]!
|
|
class_levels: [Level!]!
|
|
subclasses(name: String): [Subclass!]!
|
|
multi_classing: Multiclassing!
|
|
proficiency_choices: [ProficiencyChoice!]!
|
|
starting_equipment_options: [StartingEquipmentChoice!]!
|
|
}
|
|
|
|
type FeaturePrerequisite {
|
|
type: String!
|
|
feature: Feature
|
|
level: Int
|
|
spell: Spell
|
|
}
|
|
|
|
type FeatureOption {
|
|
option_type: String!
|
|
item: Feature!
|
|
}
|
|
|
|
type FeatureOptionSet {
|
|
option_set_type: String!
|
|
options: [FeatureOption!]!
|
|
}
|
|
|
|
type FeatureChoice {
|
|
choose: Int!
|
|
type: String!
|
|
from: FeatureOptionSet!
|
|
}
|
|
|
|
type ExpertiseMultipleOption {
|
|
option_type: String!
|
|
items: [ProficiencyOption!]!
|
|
}
|
|
|
|
union ExpertiseOption = ExpertiseMultipleOption | ProficiencyChoiceOption | ProficiencyReferenceOption
|
|
|
|
type ExpertiseOptionSet {
|
|
option_set_type: String!
|
|
options: [ExpertiseOption!]!
|
|
}
|
|
|
|
type ExpertiseChoice {
|
|
choose: Int!
|
|
type: String!
|
|
from: ExpertiseOptionSet!
|
|
}
|
|
|
|
type FeatureSpecific {
|
|
expertise_options: ExpertiseChoice
|
|
subfeature_options: FeatureChoice
|
|
invocations: [Feature!]
|
|
}
|
|
|
|
type Feature {
|
|
index: String!
|
|
name: String!
|
|
level: Int!
|
|
desc: [String!]!
|
|
parent: Feature
|
|
class: Class!
|
|
subclass: Subclass
|
|
prerequisites: [FeaturePrerequisite!]!
|
|
reference: String
|
|
feature_specific: FeatureSpecific
|
|
}
|
|
|
|
type LevelSpellcasting {
|
|
cantrips_known: Int
|
|
spell_slots_level_1: Int
|
|
spell_slots_level_2: Int
|
|
spell_slots_level_3: Int
|
|
spell_slots_level_4: Int
|
|
spell_slots_level_5: Int
|
|
spell_slots_level_6: Int
|
|
spell_slots_level_7: Int
|
|
spell_slots_level_8: Int
|
|
spell_slots_level_9: Int
|
|
spells_known: Int
|
|
}
|
|
|
|
type Dice {
|
|
dice_count: Int!
|
|
dice_value: Int!
|
|
}
|
|
|
|
type BarbarianSpecific {
|
|
rage_count: Int!
|
|
rage_damage_bonus: Int!
|
|
brutal_critical_dice: Int!
|
|
}
|
|
|
|
type BardSpecific {
|
|
bardic_inspiration_die: Int!
|
|
song_of_rest_die: Int!
|
|
magical_secrets_max_5: Int!
|
|
magical_secrets_max_7: Int!
|
|
magical_secrets_max_9: Int!
|
|
}
|
|
|
|
type ClericSpecific {
|
|
channel_divinity_charges: Int!
|
|
destroy_undead_cr: Float!
|
|
}
|
|
|
|
type DruidSpecific {
|
|
wild_shape_max_cr: Float!
|
|
wild_shape_swim: Boolean!
|
|
wild_shape_fly: Boolean!
|
|
}
|
|
|
|
type FighterSpecific {
|
|
action_surges: Int!
|
|
indomitable_uses: Int!
|
|
extra_attacks: Int!
|
|
}
|
|
|
|
type MonkSpecific {
|
|
martial_arts: Dice!
|
|
ki_points: Int!
|
|
unarmored_movement: Int!
|
|
}
|
|
|
|
type PaladinSpecific {
|
|
aura_range: Int!
|
|
}
|
|
|
|
type RangerSpecific {
|
|
favored_enemies: Int!
|
|
favored_terrain: Int!
|
|
}
|
|
|
|
type RogueSpecific {
|
|
sneak_attack: Dice!
|
|
}
|
|
|
|
type SpellSlotCreation {
|
|
sorcery_point_cost: Int!
|
|
spell_slot_level: Int!
|
|
}
|
|
|
|
type SorcererSpecific {
|
|
sorcery_points: Int!
|
|
metamagic_known: Int!
|
|
creating_spell_slots: [SpellSlotCreation!]!
|
|
}
|
|
|
|
type WarlockSpecific {
|
|
invocations_known: Int!
|
|
mystic_arcanum_level_6: Int!
|
|
mystic_arcanum_level_7: Int!
|
|
mystic_arcanum_level_8: Int!
|
|
mystic_arcanum_level_9: Int!
|
|
}
|
|
|
|
type WizardSpecific {
|
|
arcane_recovery_levels: Int!
|
|
}
|
|
|
|
union ClassSpecific = BarbarianSpecific | BardSpecific | ClericSpecific | DruidSpecific | FighterSpecific | MonkSpecific | PaladinSpecific | RangerSpecific | RogueSpecific | SorcererSpecific | WarlockSpecific | WizardSpecific
|
|
|
|
type DevotionSpecific {
|
|
aura_range: Int!
|
|
}
|
|
|
|
type LoreSpecific {
|
|
additional_magical_secrets_max_lvl: Int!
|
|
}
|
|
|
|
union SubclassSpecific = DevotionSpecific | LoreSpecific
|
|
|
|
type Level {
|
|
index: String!
|
|
level: Int!
|
|
ability_score_bonuses: Int
|
|
class: Class!
|
|
subclass: Subclass
|
|
features(order_direction: OrderByDirection, name: String): [Feature!]!
|
|
prof_bonus: Int
|
|
spellcasting: LevelSpellcasting
|
|
class_specific: ClassSpecific
|
|
subclass_specific: SubclassSpecific
|
|
}
|
|
|
|
union SpellPrerequisite = Feature | Level
|
|
|
|
type SpellWithPrerequisite {
|
|
prerequisites: [SpellPrerequisite]!
|
|
spell: Spell!
|
|
}
|
|
|
|
type Subclass {
|
|
index: String!
|
|
name: String!
|
|
desc: [String!]!
|
|
class: Class!
|
|
subclass_flavor: String!
|
|
subclass_levels: [Level]!
|
|
spells(school: StringFilter, class: StringFilter, level: IntFilter, concentration: Boolean, ritual: Boolean, attack_type: SpellAttackTypeFilter, casting_time: StringFilter, area_of_effect: AreaOfEffectFilter, damage_type: StringFilter, dc_type: StringFilter, range: StringFilter, order: SpellOrder, skip: Int, limit: Int! = 100, name: String): [SpellWithPrerequisite!]
|
|
}
|
|
|
|
input AreaOfEffectFilter {
|
|
type: AreaOfEffectTypeFilter
|
|
size: IntFilter
|
|
}
|
|
|
|
enum OrderByDirection {
|
|
ASCENDING
|
|
DESCENDING
|
|
}
|
|
|
|
input SpellOrder {
|
|
by: SpellOrderBy!
|
|
direction: OrderByDirection! = ASCENDING
|
|
then_by: SpellOrder
|
|
}
|
|
|
|
enum SpellOrderBy {
|
|
NAME
|
|
LEVEL
|
|
AREA_OF_EFFECT_SIZE
|
|
CONCENTRATION
|
|
RITUAL
|
|
SCHOOL
|
|
}
|
|
|
|
input EquipmentOrder {
|
|
by: EquipmentOrderBy!
|
|
direction: OrderByDirection! = ASCENDING
|
|
then_by: EquipmentOrder
|
|
}
|
|
|
|
enum EquipmentOrderBy {
|
|
NAME
|
|
WEIGHT
|
|
EQUIPMENT_CATEGORY
|
|
}
|
|
|
|
input ClassOrder {
|
|
by: ClassOrderBy!
|
|
direction: OrderByDirection! = ASCENDING
|
|
then_by: ClassOrder
|
|
}
|
|
|
|
enum ClassOrderBy {
|
|
NAME
|
|
HIT_DIE
|
|
}
|
|
|
|
input MagicItemOrder {
|
|
by: MagicItemOrderBy!
|
|
direction: OrderByDirection! = ASCENDING
|
|
then_by: MagicItemOrder
|
|
}
|
|
|
|
enum MagicItemOrderBy {
|
|
NAME
|
|
EQUIPMENT_CATEGORY
|
|
}
|
|
|
|
input EquipmentCategoryOrder {
|
|
by: EquipmentCategoryOrderBy!
|
|
direction: OrderByDirection! = ASCENDING
|
|
then_by: EquipmentCategoryOrder
|
|
}
|
|
|
|
enum EquipmentCategoryOrderBy {
|
|
NAME
|
|
WEIGHT
|
|
}
|
|
|
|
input FeatureOrder {
|
|
by: FeatureOrderBy!
|
|
direction: OrderByDirection! = ASCENDING
|
|
then_by: FeatureOrder
|
|
}
|
|
|
|
enum FeatureOrderBy {
|
|
NAME
|
|
LEVEL
|
|
CLASS
|
|
SUBCLASS
|
|
}
|
|
|
|
input LanguageOrder {
|
|
by: LanguageOrderBy!
|
|
direction: OrderByDirection! = ASCENDING
|
|
then_by: LanguageOrder
|
|
}
|
|
|
|
enum LanguageOrderBy {
|
|
NAME
|
|
TYPE
|
|
SCRIPT
|
|
}
|
|
|
|
input LevelOrder {
|
|
by: LevelOrderBy!
|
|
direction: OrderByDirection! = ASCENDING
|
|
then_by: LevelOrder
|
|
}
|
|
|
|
enum LevelOrderBy {
|
|
LEVEL
|
|
CLASS
|
|
SUBCLASS
|
|
PROF_BONUS
|
|
ABILITY_SCORE_BONUSES
|
|
}
|
|
|
|
input MonsterOrder {
|
|
by: MonsterOrderBy!
|
|
direction: OrderByDirection! = ASCENDING
|
|
then_by: MonsterOrder
|
|
}
|
|
|
|
enum MonsterOrderBy {
|
|
NAME
|
|
SIZE
|
|
TYPE
|
|
SUBTYPE
|
|
ARMOR_CLASS
|
|
CHALLENGE_RATING
|
|
CHARISMA
|
|
CONSTITUTION
|
|
STRENGTH
|
|
WISDOM
|
|
INTELLIGENCE
|
|
DEXTERITY
|
|
XP
|
|
}
|
|
|
|
input ProficiencyOrder {
|
|
by: ProficiencyOrderBy!
|
|
direction: OrderByDirection! = ASCENDING
|
|
then_by: ProficiencyOrder
|
|
}
|
|
|
|
enum ProficiencyOrderBy {
|
|
NAME
|
|
TYPE
|
|
}
|
|
|
|
input RaceOrder {
|
|
by: RaceOrderBy!
|
|
direction: OrderByDirection! = ASCENDING
|
|
then_by: RaceOrder
|
|
}
|
|
|
|
enum RaceOrderBy {
|
|
NAME
|
|
SIZE
|
|
SPEED
|
|
}
|
|
|
|
input SkillOrder {
|
|
by: SkillOrderBy!
|
|
direction: OrderByDirection! = ASCENDING
|
|
then_by: SkillOrder
|
|
}
|
|
|
|
enum SkillOrderBy {
|
|
NAME
|
|
ABILITY_SCORE
|
|
}
|
|
|
|
type Query {
|
|
abilityScore(index: String): AbilityScore
|
|
abilityScores(order_direction: OrderByDirection, name: String, full_name: String): [AbilityScore!]
|
|
alignment(index: String): Alignment
|
|
alignments(order_direction: OrderByDirection, name: String): [Alignment!]
|
|
background(index: String): Background
|
|
backgrounds(order_direction: OrderByDirection, name: String): [Background!]!
|
|
class(index: String): Class
|
|
classes(hit_die: IntFilter, order: ClassOrder, name: String): [Class!]!
|
|
condition(index: String): Condition
|
|
conditions(order_direction: OrderByDirection, name: String): [Condition!]
|
|
damageType(index: String): DamageType
|
|
damageTypes(order_direction: OrderByDirection, name: String): [DamageType!]
|
|
equipment(index: String): IEquipment
|
|
equipments(equipment_category: StringFilter, order: EquipmentOrder, skip: Int, limit: Int! = 100, name: String): [IEquipment!]
|
|
equipmentCategory(index: String): EquipmentCategory
|
|
equipmentCategories(order_direction: OrderByDirection, name: String): [EquipmentCategory!]
|
|
feat(index: String): Feat
|
|
feats(order_direction: OrderByDirection, name: String): [Feat!]
|
|
feature(index: String): Feature
|
|
features(level: IntFilter, class: StringFilter, subclass: StringFilter, order: FeatureOrder, skip: Int, limit: Int! = 100, name: String): [Feature!]
|
|
language(index: String): Language
|
|
languages(type: LanguageType, script: LanguageScriptFilter, order: LanguageOrder, name: String): [Language!]
|
|
level(index: String): Level
|
|
levels(class: StringFilter, subclass: StringFilter, level: IntFilter, prof_bonus: IntFilter, ability_score_bonuses: IntFilter, order: LevelOrder, skip: Int, limit: Int! = 100): [Level!]
|
|
magicItem(index: String): MagicItem
|
|
magicItems(equipment_category: StringFilter, order: MagicItemOrder, skip: Int, limit: Int! = 100, name: String): [MagicItem!]
|
|
magicSchool(index: String): MagicSchool
|
|
magicSchools(order_direction: OrderByDirection, name: String): [MagicSchool!]
|
|
monster(index: String): Monster
|
|
monsters(size: SizeFilter, type: MonsterTypeFilter, subtype: MonsterSubtypeFilter, damage_immunity: StringFilter, damage_resistance: StringFilter, damage_vulnerability: StringFilter, armor_class: IntFilter, challenge_rating: FloatFilter, charisma: IntFilter, constitution: IntFilter, dexterity: IntFilter, intelligence: IntFilter, strength: IntFilter, wisdom: IntFilter, xp: IntFilter, order: MonsterOrder, skip: Int, limit: Int! = 100, name: String): [Monster!]
|
|
proficiency(index: String): Proficiency
|
|
proficiencies(class: StringFilter, race: StringFilter, type: ProficiencyTypeFilter, order: ProficiencyOrder, skip: Int, limit: Int! = 100, name: String): [Proficiency!]
|
|
race(index: String): Race
|
|
races(ability_bonus: StringFilter, size: SizeFilter, language: StringFilter, speed: IntFilter, order: RaceOrder, name: String): [Race!]!
|
|
rule(index: String): Rule
|
|
rules(order_direction: OrderByDirection, name: String): [Rule]
|
|
ruleSection(index: String): RuleSection
|
|
ruleSections(order_direction: OrderByDirection, name: String): [RuleSection!]
|
|
skill(index: String): Skill
|
|
skills(ability_score: StringFilter, order: SkillOrder, name: String): [Skill!]
|
|
spell(index: String): Spell
|
|
spells(school: StringFilter, level: IntFilter, class: StringFilter, subclass: StringFilter, concentration: Boolean, ritual: Boolean, attack_type: SpellAttackTypeFilter, casting_time: StringFilter, area_of_effect: AreaOfEffectFilter, damage_type: StringFilter, dc_type: StringFilter, range: StringFilter, order: SpellOrder, skip: Int, limit: Int! = 100, name: String): [Spell!]
|
|
subclass(index: String): Subclass
|
|
subclasses(order_direction: OrderByDirection, name: String): [Subclass!]!
|
|
subrace(index: String): Subrace
|
|
subraces(order_direction: OrderByDirection, name: String): [Subrace!]!
|
|
trait(index: String): Trait
|
|
traits(order_direction: OrderByDirection, name: String): [Trait!]
|
|
weaponProperty(index: String): WeaponProperty
|
|
weaponProperties(order_direction: OrderByDirection, name: String): [WeaponProperty]
|
|
}
|