schema.gql

# ------------------------------------------------------
# THIS FILE WAS AUTOMATICALLY GENERATED (DO NOT MODIFY)
# ------------------------------------------------------

type BanListDeclaration {
  forbidden: [Int!]!
  limit: [Int!]!
  semiLimit: [Int!]!
}

type Card {
  _setcode: Int!
  alias: Int!
  atk: Int!
  attribute: CardAttribute!
  category: Int!
  cropperItem: CardCropperItem
  def: Int!
  hasCropperItem: Boolean!
  id: Int!
  isExtra: Boolean!
  level: Int!
  monsterType: [MonsterCardType!]!
  ot: Int!
  race: CardRace!
  rawType: Int!
  text: Text!
  trapSpellType: TrapSpellCardType!
  type: CardType!
}

enum CardAttribute {
  Dark
  Divine
  Earth
  Fire
  Light
  None
  Water
  Wind
}

input CardCropperDataInput {
  cardId: Int!
  height: Int!
  width: Int!
  x: Int!
  y: Int!
}

type CardCropperItem {
  cardId: Int!
  createdAt: DateTime!
  height: Int!
  id: Int!
  updatedAt: DateTime!
  width: Int!
  x: Int!
  y: Int!
}

enum CardRace {
  Aqua
  Beast
  BeastWarrior
  CreatorGod
  Cybers
  Dinosaur
  Divine
  Dragon
  Fairy
  Fiend
  Fish
  Insect
  Machine
  None
  Plant
  Psycho
  Pyro
  Reptile
  Rock
  SeaSerpent
  SpellCaster
  Thunder
  Warrior
  WindBeast
  Wyrm
  Zombie
}

type CardSuggestion {
  id: Int!
  index: Int!
  name: String!
}

enum CardType {
  Monster
  Spell
  Trap
}

type CardUsage {
  card: Card!
  count: Float!
}

type Championship {
  banList: String!
  createdAt: DateTime!
  id: Int!
  joinUrlCode: String!
  monitorUrlCode: String!
  name: String!
  participantCount: Int!
  participants: [ChampionshipParticipant!]!
  shareBanLists: Boolean!
  shareCardCount: Boolean!
  type: ChampionshipType!
  updatedAt: DateTime!
}

type ChampionshipParticipant {
  createdAt: DateTime!
  extra: [Int!]!
  id: Int!
  main: [Int!]!
  name: String!
  side: [Int!]!
  teamName: String
  updatedAt: DateTime!
}

enum ChampionshipType {
  Individual
  Team
}

input CreateChampionshipArgs {
  banList: String!
  shareBanLists: Boolean!
  shareCardCount: Boolean!
  title: String!
  type: ChampionshipType!
}

type CreateChampionshipResult {
  joinUrl: String!
  monitorUrl: String!
}

"""
A date-time string at UTC, such as 2019-12-03T09:54:33Z, compliant with the date-time format.
"""
scalar DateTime

type Deck {
  createdAt: DateTime!
  extra: [Card!]!
  extraIds: [Int!]!
  id: Int!
  main: [Card!]!
  mainIds: [Int!]!
  recognizedDeckTags: [String!]!
  recognizedName: String!
  recognizedTags: [String!]!
  side: [Card!]!
  sideIds: [Int!]!
  titleCard: DeckTitleCard
  updatedAt: DateTime!
}

type DeckTitleCard {
  card: Card!
  cardId: Int!
  createdAt: DateTime!
  id: Int!
  name: String!
  updatedAt: DateTime!
}

input DeckTitleCardInput {
  cardId: Int!
  deckName: String!
}

type DeckType {
  id: Int!
  name: String!
}

type DeckUsage {
  count: Int!
  deckName: String!
  titleCard: Card
}

type EdoText {
  desc: String!
  id: Int!
  name: String!
  str1: String!
  str2: String!
  str3: String!
  str4: String!
  str5: String!
  str6: String!
  str7: String!
  str8: String!
  str9: String!
  str10: String!
  str11: String!
  str12: String!
  str13: String!
  str14: String!
  str15: String!
  str16: String!
}

type ExecutionResult {
  errors: [String!]!
  succeeded: Boolean!
}

type Match {
  away: PlayerDeck!
  createdAt: DateTime!
  finishedAt: DateTime!
  home: PlayerDeck!
  id: Int!
  isRandomMatch: Boolean!
  matchRule: MatchRule!
  players: [Player!]!
  roundCount: Int!
  rounds: [Round!]!
  startedAt: DateTime!
  type: MatchType!
  updatedAt: DateTime!
  winner: Player
}

input MatchFilter {
  banLists: [String!]!
  includeMatches: Boolean!
  includeNormalMatches: Boolean!
  includeSingles: Boolean!
  includeTierMatches: Boolean!
}

type MatchRule {
  banListDate: String!
  drawCount: Int!
  duelRule: Int!
  id: Int!
  isTCG: Boolean!
  mode: Int!
  preventCheckDeck: Boolean!
  preventShuffleDeck: Boolean!
  rule: Int!
  startHand: Int!
  startLifePoint: Int!
  timeLimit: Int!
}

enum MatchType {
  Athletic
  Entertain
  Normal
}

enum MonsterCardType {
  Effect
  Fusion
  Link
  Normal
  Pendulum
  Ritual
  Synchro
  Xyz
}

type Mutation {
  createChampionship(data: CreateChampionshipArgs!): CreateChampionshipResult!
  deleteParticipant(participantId: Int!): ExecutionResult!
  generateDeckRecipeImage(extraDeck: [Int!]!, mainDeck: [Int!]!, sideDeck: [Int!]!): String!
  registerDeckTitleCards(input: [DeckTitleCardInput!]!): [DeckTitleCard!]!
  saveCropperData(input: [CardCropperDataInput!]!): [CardCropperItem!]!
  submitChampionshipParticipants(championshipId: Int!, participants: [SubmitParticipantsArgsInput!]!, teamName: String): ExecutionResult!
}

type Player {
  createdAt: DateTime!
  id: Int!
  ip: String!
  lang: String!
  name: String!
  pos: Int!
  updatedAt: DateTime!
}

type PlayerDeck {
  deck: Deck!
  player: Player!
}

type Query {
  availableBanLists: [String!]!
  banList(title: String!): BanListDeclaration!
  banLists: [String!]!
  card(id: Int!): Card
  cardCount: Int!
  cardSuggestions(count: Int!, query: String!): [CardSuggestion!]!
  cards(ids: [Int!]): [Card!]!
  championship(id: String!): Championship
  cropperItem(id: Int!): CardCropperItem
  deck(id: Int!): Deck
  deckTitleCards: [DeckTitleCard!]!
  deckTypes: [DeckType!]!
  indexedCard(index: Int!): Card
  match(id: Int!): Match
  matchCount: Int!
  matches(after: Int, count: Int!, filter: MatchFilter): [Match!]!
  topUsageCards(count: Int!): [CardUsage!]!
  topUsageDecks(count: Int!): [DeckUsage!]!
  usedCards(deckName: String!): [Card!]!
  winRate(count: Int = 10): [WinRate!]!
}

type Round {
  createdAt: DateTime!
  finishedAt: DateTime!
  id: Int!
  no: Int!
  playerDecks: [PlayerDeck!]!
  startedAt: DateTime!
  updatedAt: DateTime!
}

input SubmitParticipantsArgsInput {
  deckFile: Upload!
  name: String!
}

type Subscription {
  cardUsageListUpdated: [CardUsage!]!
  matchCountUpdated: Int!
  newMatchCreated: Match!
}

type Text {
  desc: String!
  id: Int!
  name: String!
  str1: String!
  str2: String!
  str3: String!
  str4: String!
  str5: String!
  str6: String!
  str7: String!
  str8: String!
  str9: String!
  str10: String!
  str11: String!
  str12: String!
  str13: String!
  str14: String!
  str15: String!
  str16: String!
}

enum TrapSpellCardType {
  Continuous
  Counter
  Equip
  Field
  Normal
  QuickPlay
  Ritual
}

"""The `Upload` scalar type represents a file upload."""
scalar Upload

type WinRate {
  deckName: String!
  rate: Float!
  titleCard: Card
}