schema {
  query: query_root
  mutation: mutation_root
  subscription: subscription_root
}

"""
columns and relationships of "Account"
"""
type Account {
  """An object relationship"""
  Player: Player!
  identifier: String!
  player_id: uuid!
  type: AccountType_enum!
}

"""
aggregated selection of "Account"
"""
type Account_aggregate {
  aggregate: Account_aggregate_fields
  nodes: [Account!]!
}

"""
aggregate fields of "Account"
"""
type Account_aggregate_fields {
  count(columns: [Account_select_column!], distinct: Boolean): Int
  max: Account_max_fields
  min: Account_min_fields
}

"""
order by aggregate values of table "Account"
"""
input Account_aggregate_order_by {
  count: order_by
  max: Account_max_order_by
  min: Account_min_order_by
}

"""
input type for inserting array relation for remote table "Account"
"""
input Account_arr_rel_insert_input {
  data: [Account_insert_input!]!
  on_conflict: Account_on_conflict
}

"""
Boolean expression to filter rows from the table "Account". All fields are combined with a logical 'AND'.
"""
input Account_bool_exp {
  Player: Player_bool_exp
  _and: [Account_bool_exp]
  _not: Account_bool_exp
  _or: [Account_bool_exp]
  identifier: String_comparison_exp
  player_id: uuid_comparison_exp
  type: AccountType_enum_comparison_exp
}

"""
unique or primary key constraints on table "Account"
"""
enum Account_constraint {
  """unique or primary key constraint"""
  Account_identifier_type_key
}

"""
input type for inserting data into table "Account"
"""
input Account_insert_input {
  Player: Player_obj_rel_insert_input
  identifier: String
  player_id: uuid
  type: AccountType_enum
}

"""aggregate max on columns"""
type Account_max_fields {
  identifier: String
  player_id: uuid
}

"""
order by max() on columns of table "Account"
"""
input Account_max_order_by {
  identifier: order_by
  player_id: order_by
}

"""aggregate min on columns"""
type Account_min_fields {
  identifier: String
  player_id: uuid
}

"""
order by min() on columns of table "Account"
"""
input Account_min_order_by {
  identifier: order_by
  player_id: order_by
}

"""
response of any mutation on the table "Account"
"""
type Account_mutation_response {
  """number of affected rows by the mutation"""
  affected_rows: Int!

  """data of the affected rows by the mutation"""
  returning: [Account!]!
}

"""
input type for inserting object relation for remote table "Account"
"""
input Account_obj_rel_insert_input {
  data: Account_insert_input!
  on_conflict: Account_on_conflict
}

"""
on conflict condition type for table "Account"
"""
input Account_on_conflict {
  constraint: Account_constraint!
  update_columns: [Account_update_column!]!
  where: Account_bool_exp
}

"""
ordering options when selecting data from "Account"
"""
input Account_order_by {
  Player: Player_order_by
  identifier: order_by
  player_id: order_by
  type: order_by
}

"""
select columns of table "Account"
"""
enum Account_select_column {
  """column name"""
  identifier

  """column name"""
  player_id

  """column name"""
  type
}

"""
input type for updating data in table "Account"
"""
input Account_set_input {
  identifier: String
  player_id: uuid
  type: AccountType_enum
}

"""
update columns of table "Account"
"""
enum Account_update_column {
  """column name"""
  identifier

  """column name"""
  player_id

  """column name"""
  type
}

"""
columns and relationships of "AccountType"
"""
type AccountType {
  type: String!
}

"""
aggregated selection of "AccountType"
"""
type AccountType_aggregate {
  aggregate: AccountType_aggregate_fields
  nodes: [AccountType!]!
}

"""
aggregate fields of "AccountType"
"""
type AccountType_aggregate_fields {
  count(columns: [AccountType_select_column!], distinct: Boolean): Int
  max: AccountType_max_fields
  min: AccountType_min_fields
}

"""
order by aggregate values of table "AccountType"
"""
input AccountType_aggregate_order_by {
  count: order_by
  max: AccountType_max_order_by
  min: AccountType_min_order_by
}

"""
input type for inserting array relation for remote table "AccountType"
"""
input AccountType_arr_rel_insert_input {
  data: [AccountType_insert_input!]!
  on_conflict: AccountType_on_conflict
}

"""
Boolean expression to filter rows from the table "AccountType". All fields are combined with a logical 'AND'.
"""
input AccountType_bool_exp {
  _and: [AccountType_bool_exp]
  _not: AccountType_bool_exp
  _or: [AccountType_bool_exp]
  type: String_comparison_exp
}

"""
unique or primary key constraints on table "AccountType"
"""
enum AccountType_constraint {
  """unique or primary key constraint"""
  AccountType_pkey
}

enum AccountType_enum {
  DISCORD
  DISCOURSE
  ETHEREUM
  GITHUB
  TWITTER
}

"""
expression to compare columns of type AccountType_enum. All fields are combined with logical 'AND'.
"""
input AccountType_enum_comparison_exp {
  _eq: AccountType_enum
  _in: [AccountType_enum!]
  _is_null: Boolean
  _neq: AccountType_enum
  _nin: [AccountType_enum!]
}

"""
input type for inserting data into table "AccountType"
"""
input AccountType_insert_input {
  type: String
}

"""aggregate max on columns"""
type AccountType_max_fields {
  type: String
}

"""
order by max() on columns of table "AccountType"
"""
input AccountType_max_order_by {
  type: order_by
}

"""aggregate min on columns"""
type AccountType_min_fields {
  type: String
}

"""
order by min() on columns of table "AccountType"
"""
input AccountType_min_order_by {
  type: order_by
}

"""
response of any mutation on the table "AccountType"
"""
type AccountType_mutation_response {
  """number of affected rows by the mutation"""
  affected_rows: Int!

  """data of the affected rows by the mutation"""
  returning: [AccountType!]!
}

"""
input type for inserting object relation for remote table "AccountType"
"""
input AccountType_obj_rel_insert_input {
  data: AccountType_insert_input!
  on_conflict: AccountType_on_conflict
}

"""
on conflict condition type for table "AccountType"
"""
input AccountType_on_conflict {
  constraint: AccountType_constraint!
  update_columns: [AccountType_update_column!]!
  where: AccountType_bool_exp
}

"""
ordering options when selecting data from "AccountType"
"""
input AccountType_order_by {
  type: order_by
}

"""
primary key columns input for table: "AccountType"
"""
input AccountType_pk_columns_input {
  type: String!
}

"""
select columns of table "AccountType"
"""
enum AccountType_select_column {
  """column name"""
  type
}

"""
input type for updating data in table "AccountType"
"""
input AccountType_set_input {
  type: String
}

"""
update columns of table "AccountType"
"""
enum AccountType_update_column {
  """column name"""
  type
}

type BoxProfile {
  coverImageUrl: String
  description: String
  emoji: String
  ethereumAddress: String
  imageUrl: String
  job: String
  location: String
  name: String
  website: String
}

"""
columns and relationships of "EnneagramType"
"""
type EnneagramType {
  description: String!
  name: String!
}

"""
aggregated selection of "EnneagramType"
"""
type EnneagramType_aggregate {
  aggregate: EnneagramType_aggregate_fields
  nodes: [EnneagramType!]!
}

"""
aggregate fields of "EnneagramType"
"""
type EnneagramType_aggregate_fields {
  count(columns: [EnneagramType_select_column!], distinct: Boolean): Int
  max: EnneagramType_max_fields
  min: EnneagramType_min_fields
}

"""
order by aggregate values of table "EnneagramType"
"""
input EnneagramType_aggregate_order_by {
  count: order_by
  max: EnneagramType_max_order_by
  min: EnneagramType_min_order_by
}

"""
input type for inserting array relation for remote table "EnneagramType"
"""
input EnneagramType_arr_rel_insert_input {
  data: [EnneagramType_insert_input!]!
  on_conflict: EnneagramType_on_conflict
}

"""
Boolean expression to filter rows from the table "EnneagramType". All fields are combined with a logical 'AND'.
"""
input EnneagramType_bool_exp {
  _and: [EnneagramType_bool_exp]
  _not: EnneagramType_bool_exp
  _or: [EnneagramType_bool_exp]
  description: String_comparison_exp
  name: String_comparison_exp
}

"""
unique or primary key constraints on table "EnneagramType"
"""
enum EnneagramType_constraint {
  """unique or primary key constraint"""
  EnneagramType_pkey
}

enum EnneagramType_enum {
  """Adaptive, Excelling, Driven, and Image-Conscious"""
  ACHIEVER

  """Self-Confident, Decisive, Willful, and Confrontational"""
  CHALLENGER

  """Spontaneous, Versatile, Distractible, and Scattered"""
  ENTHUSIAST

  """Demonstrative, Generous, People-Pleasing, and Possessive"""
  HELPER

  """Expressive, Dramatic, Self-Absorbed, and Temperamental"""
  INDIVIDUALIST

  """Perceptive, Innovative, Secretive, and Isolated"""
  INVESTIGATOR

  """Engaging, Responsible, Anxious, and Suspicious"""
  LOYALIST

  """Receptive, Reassuring, Agreeable, and Complacent"""
  PEACEMAKER

  """Principled, Purposeful, Self-Controlled, and Perfectionistic"""
  REFORMER
}

"""
expression to compare columns of type EnneagramType_enum. All fields are combined with logical 'AND'.
"""
input EnneagramType_enum_comparison_exp {
  _eq: EnneagramType_enum
  _in: [EnneagramType_enum!]
  _is_null: Boolean
  _neq: EnneagramType_enum
  _nin: [EnneagramType_enum!]
}

"""
input type for inserting data into table "EnneagramType"
"""
input EnneagramType_insert_input {
  description: String
  name: String
}

"""aggregate max on columns"""
type EnneagramType_max_fields {
  description: String
  name: String
}

"""
order by max() on columns of table "EnneagramType"
"""
input EnneagramType_max_order_by {
  description: order_by
  name: order_by
}

"""aggregate min on columns"""
type EnneagramType_min_fields {
  description: String
  name: String
}

"""
order by min() on columns of table "EnneagramType"
"""
input EnneagramType_min_order_by {
  description: order_by
  name: order_by
}

"""
response of any mutation on the table "EnneagramType"
"""
type EnneagramType_mutation_response {
  """number of affected rows by the mutation"""
  affected_rows: Int!

  """data of the affected rows by the mutation"""
  returning: [EnneagramType!]!
}

"""
input type for inserting object relation for remote table "EnneagramType"
"""
input EnneagramType_obj_rel_insert_input {
  data: EnneagramType_insert_input!
  on_conflict: EnneagramType_on_conflict
}

"""
on conflict condition type for table "EnneagramType"
"""
input EnneagramType_on_conflict {
  constraint: EnneagramType_constraint!
  update_columns: [EnneagramType_update_column!]!
  where: EnneagramType_bool_exp
}

"""
ordering options when selecting data from "EnneagramType"
"""
input EnneagramType_order_by {
  description: order_by
  name: order_by
}

"""
primary key columns input for table: "EnneagramType"
"""
input EnneagramType_pk_columns_input {
  name: String!
}

"""
select columns of table "EnneagramType"
"""
enum EnneagramType_select_column {
  """column name"""
  description

  """column name"""
  name
}

"""
input type for updating data in table "EnneagramType"
"""
input EnneagramType_set_input {
  description: String
  name: String
}

"""
update columns of table "EnneagramType"
"""
enum EnneagramType_update_column {
  """column name"""
  description

  """column name"""
  name
}

"""
columns and relationships of "Guild"
"""
type Guild {
  """An object relationship"""
  GuildType: GuildType!
  id: uuid!
  identifier: String!
  logo: String
  name: String!
  type: GuildType_enum!
}

"""
aggregated selection of "Guild"
"""
type Guild_aggregate {
  aggregate: Guild_aggregate_fields
  nodes: [Guild!]!
}

"""
aggregate fields of "Guild"
"""
type Guild_aggregate_fields {
  count(columns: [Guild_select_column!], distinct: Boolean): Int
  max: Guild_max_fields
  min: Guild_min_fields
}

"""
order by aggregate values of table "Guild"
"""
input Guild_aggregate_order_by {
  count: order_by
  max: Guild_max_order_by
  min: Guild_min_order_by
}

"""
input type for inserting array relation for remote table "Guild"
"""
input Guild_arr_rel_insert_input {
  data: [Guild_insert_input!]!
  on_conflict: Guild_on_conflict
}

"""
Boolean expression to filter rows from the table "Guild". All fields are combined with a logical 'AND'.
"""
input Guild_bool_exp {
  GuildType: GuildType_bool_exp
  _and: [Guild_bool_exp]
  _not: Guild_bool_exp
  _or: [Guild_bool_exp]
  id: uuid_comparison_exp
  identifier: String_comparison_exp
  logo: String_comparison_exp
  name: String_comparison_exp
  type: GuildType_enum_comparison_exp
}

"""
unique or primary key constraints on table "Guild"
"""
enum Guild_constraint {
  """unique or primary key constraint"""
  Guild_pkey
}

"""
input type for inserting data into table "Guild"
"""
input Guild_insert_input {
  GuildType: GuildType_obj_rel_insert_input
  id: uuid
  identifier: String
  logo: String
  name: String
  type: GuildType_enum
}

"""aggregate max on columns"""
type Guild_max_fields {
  id: uuid
  identifier: String
  logo: String
  name: String
}

"""
order by max() on columns of table "Guild"
"""
input Guild_max_order_by {
  id: order_by
  identifier: order_by
  logo: order_by
  name: order_by
}

"""aggregate min on columns"""
type Guild_min_fields {
  id: uuid
  identifier: String
  logo: String
  name: String
}

"""
order by min() on columns of table "Guild"
"""
input Guild_min_order_by {
  id: order_by
  identifier: order_by
  logo: order_by
  name: order_by
}

"""
response of any mutation on the table "Guild"
"""
type Guild_mutation_response {
  """number of affected rows by the mutation"""
  affected_rows: Int!

  """data of the affected rows by the mutation"""
  returning: [Guild!]!
}

"""
input type for inserting object relation for remote table "Guild"
"""
input Guild_obj_rel_insert_input {
  data: Guild_insert_input!
  on_conflict: Guild_on_conflict
}

"""
on conflict condition type for table "Guild"
"""
input Guild_on_conflict {
  constraint: Guild_constraint!
  update_columns: [Guild_update_column!]!
  where: Guild_bool_exp
}

"""
ordering options when selecting data from "Guild"
"""
input Guild_order_by {
  GuildType: GuildType_order_by
  id: order_by
  identifier: order_by
  logo: order_by
  name: order_by
  type: order_by
}

"""
primary key columns input for table: "Guild"
"""
input Guild_pk_columns_input {
  id: uuid!
}

"""
select columns of table "Guild"
"""
enum Guild_select_column {
  """column name"""
  id

  """column name"""
  identifier

  """column name"""
  logo

  """column name"""
  name

  """column name"""
  type
}

"""
input type for updating data in table "Guild"
"""
input Guild_set_input {
  id: uuid
  identifier: String
  logo: String
  name: String
  type: GuildType_enum
}

"""
update columns of table "Guild"
"""
enum Guild_update_column {
  """column name"""
  id

  """column name"""
  identifier

  """column name"""
  logo

  """column name"""
  name

  """column name"""
  type
}

"""
columns and relationships of "GuildType"
"""
type GuildType {
  """An array relationship"""
  Guilds(
    """distinct select on columns"""
    distinct_on: [Guild_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Guild_order_by!]

    """filter the rows returned"""
    where: Guild_bool_exp
  ): [Guild!]!

  """An aggregated array relationship"""
  Guilds_aggregate(
    """distinct select on columns"""
    distinct_on: [Guild_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Guild_order_by!]

    """filter the rows returned"""
    where: Guild_bool_exp
  ): Guild_aggregate!
  name: String!
}

"""
aggregated selection of "GuildType"
"""
type GuildType_aggregate {
  aggregate: GuildType_aggregate_fields
  nodes: [GuildType!]!
}

"""
aggregate fields of "GuildType"
"""
type GuildType_aggregate_fields {
  count(columns: [GuildType_select_column!], distinct: Boolean): Int
  max: GuildType_max_fields
  min: GuildType_min_fields
}

"""
order by aggregate values of table "GuildType"
"""
input GuildType_aggregate_order_by {
  count: order_by
  max: GuildType_max_order_by
  min: GuildType_min_order_by
}

"""
input type for inserting array relation for remote table "GuildType"
"""
input GuildType_arr_rel_insert_input {
  data: [GuildType_insert_input!]!
  on_conflict: GuildType_on_conflict
}

"""
Boolean expression to filter rows from the table "GuildType". All fields are combined with a logical 'AND'.
"""
input GuildType_bool_exp {
  Guilds: Guild_bool_exp
  _and: [GuildType_bool_exp]
  _not: GuildType_bool_exp
  _or: [GuildType_bool_exp]
  name: String_comparison_exp
}

"""
unique or primary key constraints on table "GuildType"
"""
enum GuildType_constraint {
  """unique or primary key constraint"""
  GuildType_pkey
}

enum GuildType_enum {
  ARAGON
  EVEREST
  MOLOCH
}

"""
expression to compare columns of type GuildType_enum. All fields are combined with logical 'AND'.
"""
input GuildType_enum_comparison_exp {
  _eq: GuildType_enum
  _in: [GuildType_enum!]
  _is_null: Boolean
  _neq: GuildType_enum
  _nin: [GuildType_enum!]
}

"""
input type for inserting data into table "GuildType"
"""
input GuildType_insert_input {
  Guilds: Guild_arr_rel_insert_input
  name: String
}

"""aggregate max on columns"""
type GuildType_max_fields {
  name: String
}

"""
order by max() on columns of table "GuildType"
"""
input GuildType_max_order_by {
  name: order_by
}

"""aggregate min on columns"""
type GuildType_min_fields {
  name: String
}

"""
order by min() on columns of table "GuildType"
"""
input GuildType_min_order_by {
  name: order_by
}

"""
response of any mutation on the table "GuildType"
"""
type GuildType_mutation_response {
  """number of affected rows by the mutation"""
  affected_rows: Int!

  """data of the affected rows by the mutation"""
  returning: [GuildType!]!
}

"""
input type for inserting object relation for remote table "GuildType"
"""
input GuildType_obj_rel_insert_input {
  data: GuildType_insert_input!
  on_conflict: GuildType_on_conflict
}

"""
on conflict condition type for table "GuildType"
"""
input GuildType_on_conflict {
  constraint: GuildType_constraint!
  update_columns: [GuildType_update_column!]!
  where: GuildType_bool_exp
}

"""
ordering options when selecting data from "GuildType"
"""
input GuildType_order_by {
  Guilds_aggregate: Guild_aggregate_order_by
  name: order_by
}

"""
primary key columns input for table: "GuildType"
"""
input GuildType_pk_columns_input {
  name: String!
}

"""
select columns of table "GuildType"
"""
enum GuildType_select_column {
  """column name"""
  name
}

"""
input type for updating data in table "GuildType"
"""
input GuildType_set_input {
  name: String
}

"""
update columns of table "GuildType"
"""
enum GuildType_update_column {
  """column name"""
  name
}

"""
expression to compare columns of type Int. All fields are combined with logical 'AND'.
"""
input Int_comparison_exp {
  _eq: Int
  _gt: Int
  _gte: Int
  _in: [Int!]
  _is_null: Boolean
  _lt: Int
  _lte: Int
  _neq: Int
  _nin: [Int!]
}

scalar json

"""
expression to compare columns of type json. All fields are combined with logical 'AND'.
"""
input json_comparison_exp {
  _eq: json
  _gt: json
  _gte: json
  _in: [json!]
  _is_null: Boolean
  _lt: json
  _lte: json
  _neq: json
  _nin: [json!]
}

"""
columns and relationships of "me"
"""
type me {
  ethereum_address: String
  id: uuid

  """An object relationship"""
  player: Player
  username: String
}

"""
aggregated selection of "me"
"""
type me_aggregate {
  aggregate: me_aggregate_fields
  nodes: [me!]!
}

"""
aggregate fields of "me"
"""
type me_aggregate_fields {
  count(columns: [me_select_column!], distinct: Boolean): Int
  max: me_max_fields
  min: me_min_fields
}

"""
order by aggregate values of table "me"
"""
input me_aggregate_order_by {
  count: order_by
  max: me_max_order_by
  min: me_min_order_by
}

"""
input type for inserting array relation for remote table "me"
"""
input me_arr_rel_insert_input {
  data: [me_insert_input!]!
}

"""
Boolean expression to filter rows from the table "me". All fields are combined with a logical 'AND'.
"""
input me_bool_exp {
  _and: [me_bool_exp]
  _not: me_bool_exp
  _or: [me_bool_exp]
  ethereum_address: String_comparison_exp
  id: uuid_comparison_exp
  player: Player_bool_exp
  username: String_comparison_exp
}

"""
input type for inserting data into table "me"
"""
input me_insert_input {
  ethereum_address: String
  id: uuid
  player: Player_obj_rel_insert_input
  username: String
}

"""aggregate max on columns"""
type me_max_fields {
  ethereum_address: String
  id: uuid
  username: String
}

"""
order by max() on columns of table "me"
"""
input me_max_order_by {
  ethereum_address: order_by
  id: order_by
  username: order_by
}

"""aggregate min on columns"""
type me_min_fields {
  ethereum_address: String
  id: uuid
  username: String
}

"""
order by min() on columns of table "me"
"""
input me_min_order_by {
  ethereum_address: order_by
  id: order_by
  username: order_by
}

"""
response of any mutation on the table "me"
"""
type me_mutation_response {
  """number of affected rows by the mutation"""
  affected_rows: Int!

  """data of the affected rows by the mutation"""
  returning: [me!]!
}

"""
input type for inserting object relation for remote table "me"
"""
input me_obj_rel_insert_input {
  data: me_insert_input!
}

"""
ordering options when selecting data from "me"
"""
input me_order_by {
  ethereum_address: order_by
  id: order_by
  player: Player_order_by
  username: order_by
}

"""
select columns of table "me"
"""
enum me_select_column {
  """column name"""
  ethereum_address

  """column name"""
  id

  """column name"""
  username
}

"""
input type for updating data in table "me"
"""
input me_set_input {
  ethereum_address: String
  id: uuid
  username: String
}

type Member {
  createdAt: String!
  delegateKey: String!
  exists: Boolean!
  id: ID!
  kicked: Boolean
  loot: Int
  memberAddress: String!
  moloch: Moloch!
  molochAddress: String!
  shares: Int!
}

type Moloch {
  id: ID!
  summoner: String!
  title: String
  totalLoot: Int!
  totalShares: Int!
  version: String
}

"""mutation root"""
type mutation_root {
  """
  delete data from the table: "Account"
  """
  delete_Account(
    """filter the rows which have to be deleted"""
    where: Account_bool_exp!
  ): Account_mutation_response

  """
  delete data from the table: "AccountType"
  """
  delete_AccountType(
    """filter the rows which have to be deleted"""
    where: AccountType_bool_exp!
  ): AccountType_mutation_response

  """
  delete single row from the table: "AccountType"
  """
  delete_AccountType_by_pk(type: String!): AccountType

  """
  delete data from the table: "EnneagramType"
  """
  delete_EnneagramType(
    """filter the rows which have to be deleted"""
    where: EnneagramType_bool_exp!
  ): EnneagramType_mutation_response

  """
  delete single row from the table: "EnneagramType"
  """
  delete_EnneagramType_by_pk(name: String!): EnneagramType

  """
  delete data from the table: "Guild"
  """
  delete_Guild(
    """filter the rows which have to be deleted"""
    where: Guild_bool_exp!
  ): Guild_mutation_response

  """
  delete data from the table: "GuildType"
  """
  delete_GuildType(
    """filter the rows which have to be deleted"""
    where: GuildType_bool_exp!
  ): GuildType_mutation_response

  """
  delete single row from the table: "GuildType"
  """
  delete_GuildType_by_pk(name: String!): GuildType

  """
  delete single row from the table: "Guild"
  """
  delete_Guild_by_pk(id: uuid!): Guild

  """
  delete data from the table: "Player"
  """
  delete_Player(
    """filter the rows which have to be deleted"""
    where: Player_bool_exp!
  ): Player_mutation_response

  """
  delete data from the table: "PlayerType"
  """
  delete_PlayerType(
    """filter the rows which have to be deleted"""
    where: PlayerType_bool_exp!
  ): PlayerType_mutation_response

  """
  delete single row from the table: "PlayerType"
  """
  delete_PlayerType_by_pk(id: Int!): PlayerType

  """
  delete data from the table: "Player_Rank"
  """
  delete_Player_Rank(
    """filter the rows which have to be deleted"""
    where: Player_Rank_bool_exp!
  ): Player_Rank_mutation_response

  """
  delete single row from the table: "Player_Rank"
  """
  delete_Player_Rank_by_pk(rank: String!): Player_Rank

  """
  delete data from the table: "Player_Skill"
  """
  delete_Player_Skill(
    """filter the rows which have to be deleted"""
    where: Player_Skill_bool_exp!
  ): Player_Skill_mutation_response

  """
  delete single row from the table: "Player_Skill"
  """
  delete_Player_Skill_by_pk(player_id: uuid!, skill_id: uuid!): Player_Skill

  """
  delete single row from the table: "Player"
  """
  delete_Player_by_pk(id: uuid!): Player

  """
  delete data from the table: "Skill"
  """
  delete_Skill(
    """filter the rows which have to be deleted"""
    where: Skill_bool_exp!
  ): Skill_mutation_response

  """
  delete data from the table: "SkillCategory"
  """
  delete_SkillCategory(
    """filter the rows which have to be deleted"""
    where: SkillCategory_bool_exp!
  ): SkillCategory_mutation_response

  """
  delete single row from the table: "SkillCategory"
  """
  delete_SkillCategory_by_pk(name: String!): SkillCategory

  """
  delete single row from the table: "Skill"
  """
  delete_Skill_by_pk(id: uuid!): Skill

  """
  delete data from the table: "me"
  """
  delete_me(
    """filter the rows which have to be deleted"""
    where: me_bool_exp!
  ): me_mutation_response

  """
  insert data into the table: "Account"
  """
  insert_Account(
    """the rows to be inserted"""
    objects: [Account_insert_input!]!

    """on conflict condition"""
    on_conflict: Account_on_conflict
  ): Account_mutation_response

  """
  insert data into the table: "AccountType"
  """
  insert_AccountType(
    """the rows to be inserted"""
    objects: [AccountType_insert_input!]!

    """on conflict condition"""
    on_conflict: AccountType_on_conflict
  ): AccountType_mutation_response

  """
  insert a single row into the table: "AccountType"
  """
  insert_AccountType_one(
    """the row to be inserted"""
    object: AccountType_insert_input!

    """on conflict condition"""
    on_conflict: AccountType_on_conflict
  ): AccountType

  """
  insert a single row into the table: "Account"
  """
  insert_Account_one(
    """the row to be inserted"""
    object: Account_insert_input!

    """on conflict condition"""
    on_conflict: Account_on_conflict
  ): Account

  """
  insert data into the table: "EnneagramType"
  """
  insert_EnneagramType(
    """the rows to be inserted"""
    objects: [EnneagramType_insert_input!]!

    """on conflict condition"""
    on_conflict: EnneagramType_on_conflict
  ): EnneagramType_mutation_response

  """
  insert a single row into the table: "EnneagramType"
  """
  insert_EnneagramType_one(
    """the row to be inserted"""
    object: EnneagramType_insert_input!

    """on conflict condition"""
    on_conflict: EnneagramType_on_conflict
  ): EnneagramType

  """
  insert data into the table: "Guild"
  """
  insert_Guild(
    """the rows to be inserted"""
    objects: [Guild_insert_input!]!

    """on conflict condition"""
    on_conflict: Guild_on_conflict
  ): Guild_mutation_response

  """
  insert data into the table: "GuildType"
  """
  insert_GuildType(
    """the rows to be inserted"""
    objects: [GuildType_insert_input!]!

    """on conflict condition"""
    on_conflict: GuildType_on_conflict
  ): GuildType_mutation_response

  """
  insert a single row into the table: "GuildType"
  """
  insert_GuildType_one(
    """the row to be inserted"""
    object: GuildType_insert_input!

    """on conflict condition"""
    on_conflict: GuildType_on_conflict
  ): GuildType

  """
  insert a single row into the table: "Guild"
  """
  insert_Guild_one(
    """the row to be inserted"""
    object: Guild_insert_input!

    """on conflict condition"""
    on_conflict: Guild_on_conflict
  ): Guild

  """
  insert data into the table: "Player"
  """
  insert_Player(
    """the rows to be inserted"""
    objects: [Player_insert_input!]!

    """on conflict condition"""
    on_conflict: Player_on_conflict
  ): Player_mutation_response

  """
  insert data into the table: "PlayerType"
  """
  insert_PlayerType(
    """the rows to be inserted"""
    objects: [PlayerType_insert_input!]!

    """on conflict condition"""
    on_conflict: PlayerType_on_conflict
  ): PlayerType_mutation_response

  """
  insert a single row into the table: "PlayerType"
  """
  insert_PlayerType_one(
    """the row to be inserted"""
    object: PlayerType_insert_input!

    """on conflict condition"""
    on_conflict: PlayerType_on_conflict
  ): PlayerType

  """
  insert data into the table: "Player_Rank"
  """
  insert_Player_Rank(
    """the rows to be inserted"""
    objects: [Player_Rank_insert_input!]!

    """on conflict condition"""
    on_conflict: Player_Rank_on_conflict
  ): Player_Rank_mutation_response

  """
  insert a single row into the table: "Player_Rank"
  """
  insert_Player_Rank_one(
    """the row to be inserted"""
    object: Player_Rank_insert_input!

    """on conflict condition"""
    on_conflict: Player_Rank_on_conflict
  ): Player_Rank

  """
  insert data into the table: "Player_Skill"
  """
  insert_Player_Skill(
    """the rows to be inserted"""
    objects: [Player_Skill_insert_input!]!

    """on conflict condition"""
    on_conflict: Player_Skill_on_conflict
  ): Player_Skill_mutation_response

  """
  insert a single row into the table: "Player_Skill"
  """
  insert_Player_Skill_one(
    """the row to be inserted"""
    object: Player_Skill_insert_input!

    """on conflict condition"""
    on_conflict: Player_Skill_on_conflict
  ): Player_Skill

  """
  insert a single row into the table: "Player"
  """
  insert_Player_one(
    """the row to be inserted"""
    object: Player_insert_input!

    """on conflict condition"""
    on_conflict: Player_on_conflict
  ): Player

  """
  insert data into the table: "Skill"
  """
  insert_Skill(
    """the rows to be inserted"""
    objects: [Skill_insert_input!]!

    """on conflict condition"""
    on_conflict: Skill_on_conflict
  ): Skill_mutation_response

  """
  insert data into the table: "SkillCategory"
  """
  insert_SkillCategory(
    """the rows to be inserted"""
    objects: [SkillCategory_insert_input!]!

    """on conflict condition"""
    on_conflict: SkillCategory_on_conflict
  ): SkillCategory_mutation_response

  """
  insert a single row into the table: "SkillCategory"
  """
  insert_SkillCategory_one(
    """the row to be inserted"""
    object: SkillCategory_insert_input!

    """on conflict condition"""
    on_conflict: SkillCategory_on_conflict
  ): SkillCategory

  """
  insert a single row into the table: "Skill"
  """
  insert_Skill_one(
    """the row to be inserted"""
    object: Skill_insert_input!

    """on conflict condition"""
    on_conflict: Skill_on_conflict
  ): Skill

  """
  insert data into the table: "me"
  """
  insert_me(
    """the rows to be inserted"""
    objects: [me_insert_input!]!
  ): me_mutation_response

  """
  insert a single row into the table: "me"
  """
  insert_me_one(
    """the row to be inserted"""
    object: me_insert_input!
  ): me

  """
  perform the action: "updateBoxProfile"
  """
  updateBoxProfile: UpdateBoxProfileResponse

  """
  update data of the table: "Account"
  """
  update_Account(
    """sets the columns of the filtered rows to the given values"""
    _set: Account_set_input

    """filter the rows which have to be updated"""
    where: Account_bool_exp!
  ): Account_mutation_response

  """
  update data of the table: "AccountType"
  """
  update_AccountType(
    """sets the columns of the filtered rows to the given values"""
    _set: AccountType_set_input

    """filter the rows which have to be updated"""
    where: AccountType_bool_exp!
  ): AccountType_mutation_response

  """
  update single row of the table: "AccountType"
  """
  update_AccountType_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: AccountType_set_input
    pk_columns: AccountType_pk_columns_input!
  ): AccountType

  """
  update data of the table: "EnneagramType"
  """
  update_EnneagramType(
    """sets the columns of the filtered rows to the given values"""
    _set: EnneagramType_set_input

    """filter the rows which have to be updated"""
    where: EnneagramType_bool_exp!
  ): EnneagramType_mutation_response

  """
  update single row of the table: "EnneagramType"
  """
  update_EnneagramType_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: EnneagramType_set_input
    pk_columns: EnneagramType_pk_columns_input!
  ): EnneagramType

  """
  update data of the table: "Guild"
  """
  update_Guild(
    """sets the columns of the filtered rows to the given values"""
    _set: Guild_set_input

    """filter the rows which have to be updated"""
    where: Guild_bool_exp!
  ): Guild_mutation_response

  """
  update data of the table: "GuildType"
  """
  update_GuildType(
    """sets the columns of the filtered rows to the given values"""
    _set: GuildType_set_input

    """filter the rows which have to be updated"""
    where: GuildType_bool_exp!
  ): GuildType_mutation_response

  """
  update single row of the table: "GuildType"
  """
  update_GuildType_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: GuildType_set_input
    pk_columns: GuildType_pk_columns_input!
  ): GuildType

  """
  update single row of the table: "Guild"
  """
  update_Guild_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: Guild_set_input
    pk_columns: Guild_pk_columns_input!
  ): Guild

  """
  update data of the table: "Player"
  """
  update_Player(
    """increments the integer columns with given value of the filtered values"""
    _inc: Player_inc_input

    """sets the columns of the filtered rows to the given values"""
    _set: Player_set_input

    """filter the rows which have to be updated"""
    where: Player_bool_exp!
  ): Player_mutation_response

  """
  update data of the table: "PlayerType"
  """
  update_PlayerType(
    """increments the integer columns with given value of the filtered values"""
    _inc: PlayerType_inc_input

    """sets the columns of the filtered rows to the given values"""
    _set: PlayerType_set_input

    """filter the rows which have to be updated"""
    where: PlayerType_bool_exp!
  ): PlayerType_mutation_response

  """
  update single row of the table: "PlayerType"
  """
  update_PlayerType_by_pk(
    """increments the integer columns with given value of the filtered values"""
    _inc: PlayerType_inc_input

    """sets the columns of the filtered rows to the given values"""
    _set: PlayerType_set_input
    pk_columns: PlayerType_pk_columns_input!
  ): PlayerType

  """
  update data of the table: "Player_Rank"
  """
  update_Player_Rank(
    """sets the columns of the filtered rows to the given values"""
    _set: Player_Rank_set_input

    """filter the rows which have to be updated"""
    where: Player_Rank_bool_exp!
  ): Player_Rank_mutation_response

  """
  update single row of the table: "Player_Rank"
  """
  update_Player_Rank_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: Player_Rank_set_input
    pk_columns: Player_Rank_pk_columns_input!
  ): Player_Rank

  """
  update data of the table: "Player_Skill"
  """
  update_Player_Skill(
    """sets the columns of the filtered rows to the given values"""
    _set: Player_Skill_set_input

    """filter the rows which have to be updated"""
    where: Player_Skill_bool_exp!
  ): Player_Skill_mutation_response

  """
  update single row of the table: "Player_Skill"
  """
  update_Player_Skill_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: Player_Skill_set_input
    pk_columns: Player_Skill_pk_columns_input!
  ): Player_Skill

  """
  update single row of the table: "Player"
  """
  update_Player_by_pk(
    """increments the integer columns with given value of the filtered values"""
    _inc: Player_inc_input

    """sets the columns of the filtered rows to the given values"""
    _set: Player_set_input
    pk_columns: Player_pk_columns_input!
  ): Player

  """
  update data of the table: "Skill"
  """
  update_Skill(
    """sets the columns of the filtered rows to the given values"""
    _set: Skill_set_input

    """filter the rows which have to be updated"""
    where: Skill_bool_exp!
  ): Skill_mutation_response

  """
  update data of the table: "SkillCategory"
  """
  update_SkillCategory(
    """sets the columns of the filtered rows to the given values"""
    _set: SkillCategory_set_input

    """filter the rows which have to be updated"""
    where: SkillCategory_bool_exp!
  ): SkillCategory_mutation_response

  """
  update single row of the table: "SkillCategory"
  """
  update_SkillCategory_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: SkillCategory_set_input
    pk_columns: SkillCategory_pk_columns_input!
  ): SkillCategory

  """
  update single row of the table: "Skill"
  """
  update_Skill_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: Skill_set_input
    pk_columns: Skill_pk_columns_input!
  ): Skill

  """
  update data of the table: "me"
  """
  update_me(
    """sets the columns of the filtered rows to the given values"""
    _set: me_set_input

    """filter the rows which have to be updated"""
    where: me_bool_exp!
  ): me_mutation_response
}

scalar numeric

"""
expression to compare columns of type numeric. All fields are combined with logical 'AND'.
"""
input numeric_comparison_exp {
  _eq: numeric
  _gt: numeric
  _gte: numeric
  _in: [numeric!]
  _is_null: Boolean
  _lt: numeric
  _lte: numeric
  _neq: numeric
  _nin: [numeric!]
}

"""column ordering options"""
enum order_by {
  """in the ascending order, nulls last"""
  asc

  """in the ascending order, nulls first"""
  asc_nulls_first

  """in the ascending order, nulls last"""
  asc_nulls_last

  """in the descending order, nulls first"""
  desc

  """in the descending order, nulls first"""
  desc_nulls_first

  """in the descending order, nulls last"""
  desc_nulls_last
}

"""
columns and relationships of "Player"
"""
type Player {
  """An array relationship"""
  Accounts(
    """distinct select on columns"""
    distinct_on: [Account_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Account_order_by!]

    """filter the rows returned"""
    where: Account_bool_exp
  ): [Account!]!

  """An aggregated array relationship"""
  Accounts_aggregate(
    """distinct select on columns"""
    distinct_on: [Account_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Account_order_by!]

    """filter the rows returned"""
    where: Account_bool_exp
  ): Account_aggregate!

  """An object relationship"""
  EnneagramType: EnneagramType

  """An array relationship"""
  Player_Skills(
    """distinct select on columns"""
    distinct_on: [Player_Skill_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_Skill_order_by!]

    """filter the rows returned"""
    where: Player_Skill_bool_exp
  ): [Player_Skill!]!

  """An aggregated array relationship"""
  Player_Skills_aggregate(
    """distinct select on columns"""
    distinct_on: [Player_Skill_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_Skill_order_by!]

    """filter the rows returned"""
    where: Player_Skill_bool_exp
  ): Player_Skill_aggregate!
  availability_hours: Int

  """Remote relationship field"""
  box_profile: BoxProfile
  created_at: timestamptz

  """Remote relationship field"""
  daohausMemberships: [Member!]!
  enneagram: EnneagramType_enum
  ethereum_address: String
  id: uuid!

  """An object relationship"""
  playerType: PlayerType
  playerTypeId: Int
  rank: Player_Rank_enum
  role: String
  scIdentityId: String
  timezone: Int
  totalXp: numeric
  updated_at: timestamptz
  username: String!
}

"""
aggregated selection of "Player"
"""
type Player_aggregate {
  aggregate: Player_aggregate_fields
  nodes: [Player!]!
}

"""
aggregate fields of "Player"
"""
type Player_aggregate_fields {
  avg: Player_avg_fields
  count(columns: [Player_select_column!], distinct: Boolean): Int
  max: Player_max_fields
  min: Player_min_fields
  stddev: Player_stddev_fields
  stddev_pop: Player_stddev_pop_fields
  stddev_samp: Player_stddev_samp_fields
  sum: Player_sum_fields
  var_pop: Player_var_pop_fields
  var_samp: Player_var_samp_fields
  variance: Player_variance_fields
}

"""
order by aggregate values of table "Player"
"""
input Player_aggregate_order_by {
  avg: Player_avg_order_by
  count: order_by
  max: Player_max_order_by
  min: Player_min_order_by
  stddev: Player_stddev_order_by
  stddev_pop: Player_stddev_pop_order_by
  stddev_samp: Player_stddev_samp_order_by
  sum: Player_sum_order_by
  var_pop: Player_var_pop_order_by
  var_samp: Player_var_samp_order_by
  variance: Player_variance_order_by
}

"""
input type for inserting array relation for remote table "Player"
"""
input Player_arr_rel_insert_input {
  data: [Player_insert_input!]!
  on_conflict: Player_on_conflict
}

"""aggregate avg on columns"""
type Player_avg_fields {
  availability_hours: Float
  playerTypeId: Float
  timezone: Float
  totalXp: Float
}

"""
order by avg() on columns of table "Player"
"""
input Player_avg_order_by {
  availability_hours: order_by
  playerTypeId: order_by
  timezone: order_by
  totalXp: order_by
}

"""
Boolean expression to filter rows from the table "Player". All fields are combined with a logical 'AND'.
"""
input Player_bool_exp {
  Accounts: Account_bool_exp
  EnneagramType: EnneagramType_bool_exp
  Player_Skills: Player_Skill_bool_exp
  _and: [Player_bool_exp]
  _not: Player_bool_exp
  _or: [Player_bool_exp]
  availability_hours: Int_comparison_exp
  created_at: timestamptz_comparison_exp
  enneagram: EnneagramType_enum_comparison_exp
  ethereum_address: String_comparison_exp
  id: uuid_comparison_exp
  playerType: PlayerType_bool_exp
  playerTypeId: Int_comparison_exp
  rank: Player_Rank_enum_comparison_exp
  role: String_comparison_exp
  scIdentityId: String_comparison_exp
  timezone: Int_comparison_exp
  totalXp: numeric_comparison_exp
  updated_at: timestamptz_comparison_exp
  username: String_comparison_exp
}

"""
unique or primary key constraints on table "Player"
"""
enum Player_constraint {
  """unique or primary key constraint"""
  Player_ethereum_address_unique_key

  """unique or primary key constraint"""
  Player_pkey

  """unique or primary key constraint"""
  Player_scIdentityId_key

  """unique or primary key constraint"""
  Player_username_unique_key
}

"""
input type for incrementing integer column in table "Player"
"""
input Player_inc_input {
  availability_hours: Int
  playerTypeId: Int
  timezone: Int
  totalXp: numeric
}

"""
input type for inserting data into table "Player"
"""
input Player_insert_input {
  Accounts: Account_arr_rel_insert_input
  EnneagramType: EnneagramType_obj_rel_insert_input
  Player_Skills: Player_Skill_arr_rel_insert_input
  availability_hours: Int
  created_at: timestamptz
  enneagram: EnneagramType_enum
  ethereum_address: String
  id: uuid
  playerType: PlayerType_obj_rel_insert_input
  playerTypeId: Int
  rank: Player_Rank_enum
  role: String
  scIdentityId: String
  timezone: Int
  totalXp: numeric
  updated_at: timestamptz
  username: String
}

"""aggregate max on columns"""
type Player_max_fields {
  availability_hours: Int
  created_at: timestamptz
  ethereum_address: String
  id: uuid
  playerTypeId: Int
  role: String
  scIdentityId: String
  timezone: Int
  totalXp: numeric
  updated_at: timestamptz
  username: String
}

"""
order by max() on columns of table "Player"
"""
input Player_max_order_by {
  availability_hours: order_by
  created_at: order_by
  ethereum_address: order_by
  id: order_by
  playerTypeId: order_by
  role: order_by
  scIdentityId: order_by
  timezone: order_by
  totalXp: order_by
  updated_at: order_by
  username: order_by
}

"""aggregate min on columns"""
type Player_min_fields {
  availability_hours: Int
  created_at: timestamptz
  ethereum_address: String
  id: uuid
  playerTypeId: Int
  role: String
  scIdentityId: String
  timezone: Int
  totalXp: numeric
  updated_at: timestamptz
  username: String
}

"""
order by min() on columns of table "Player"
"""
input Player_min_order_by {
  availability_hours: order_by
  created_at: order_by
  ethereum_address: order_by
  id: order_by
  playerTypeId: order_by
  role: order_by
  scIdentityId: order_by
  timezone: order_by
  totalXp: order_by
  updated_at: order_by
  username: order_by
}

"""
response of any mutation on the table "Player"
"""
type Player_mutation_response {
  """number of affected rows by the mutation"""
  affected_rows: Int!

  """data of the affected rows by the mutation"""
  returning: [Player!]!
}

"""
input type for inserting object relation for remote table "Player"
"""
input Player_obj_rel_insert_input {
  data: Player_insert_input!
  on_conflict: Player_on_conflict
}

"""
on conflict condition type for table "Player"
"""
input Player_on_conflict {
  constraint: Player_constraint!
  update_columns: [Player_update_column!]!
  where: Player_bool_exp
}

"""
ordering options when selecting data from "Player"
"""
input Player_order_by {
  Accounts_aggregate: Account_aggregate_order_by
  EnneagramType: EnneagramType_order_by
  Player_Skills_aggregate: Player_Skill_aggregate_order_by
  availability_hours: order_by
  created_at: order_by
  enneagram: order_by
  ethereum_address: order_by
  id: order_by
  playerType: PlayerType_order_by
  playerTypeId: order_by
  rank: order_by
  role: order_by
  scIdentityId: order_by
  timezone: order_by
  totalXp: order_by
  updated_at: order_by
  username: order_by
}

"""
primary key columns input for table: "Player"
"""
input Player_pk_columns_input {
  id: uuid!
}

"""
columns and relationships of "Player_Rank"
"""
type Player_Rank {
  rank: String!
}

"""
aggregated selection of "Player_Rank"
"""
type Player_Rank_aggregate {
  aggregate: Player_Rank_aggregate_fields
  nodes: [Player_Rank!]!
}

"""
aggregate fields of "Player_Rank"
"""
type Player_Rank_aggregate_fields {
  count(columns: [Player_Rank_select_column!], distinct: Boolean): Int
  max: Player_Rank_max_fields
  min: Player_Rank_min_fields
}

"""
order by aggregate values of table "Player_Rank"
"""
input Player_Rank_aggregate_order_by {
  count: order_by
  max: Player_Rank_max_order_by
  min: Player_Rank_min_order_by
}

"""
input type for inserting array relation for remote table "Player_Rank"
"""
input Player_Rank_arr_rel_insert_input {
  data: [Player_Rank_insert_input!]!
  on_conflict: Player_Rank_on_conflict
}

"""
Boolean expression to filter rows from the table "Player_Rank". All fields are combined with a logical 'AND'.
"""
input Player_Rank_bool_exp {
  _and: [Player_Rank_bool_exp]
  _not: Player_Rank_bool_exp
  _or: [Player_Rank_bool_exp]
  rank: String_comparison_exp
}

"""
unique or primary key constraints on table "Player_Rank"
"""
enum Player_Rank_constraint {
  """unique or primary key constraint"""
  Player_Rank_pkey
}

enum Player_Rank_enum {
  BRONZE
  DIAMOND
  GOLD
  PLATINUM
  SILVER
}

"""
expression to compare columns of type Player_Rank_enum. All fields are combined with logical 'AND'.
"""
input Player_Rank_enum_comparison_exp {
  _eq: Player_Rank_enum
  _in: [Player_Rank_enum!]
  _is_null: Boolean
  _neq: Player_Rank_enum
  _nin: [Player_Rank_enum!]
}

"""
input type for inserting data into table "Player_Rank"
"""
input Player_Rank_insert_input {
  rank: String
}

"""aggregate max on columns"""
type Player_Rank_max_fields {
  rank: String
}

"""
order by max() on columns of table "Player_Rank"
"""
input Player_Rank_max_order_by {
  rank: order_by
}

"""aggregate min on columns"""
type Player_Rank_min_fields {
  rank: String
}

"""
order by min() on columns of table "Player_Rank"
"""
input Player_Rank_min_order_by {
  rank: order_by
}

"""
response of any mutation on the table "Player_Rank"
"""
type Player_Rank_mutation_response {
  """number of affected rows by the mutation"""
  affected_rows: Int!

  """data of the affected rows by the mutation"""
  returning: [Player_Rank!]!
}

"""
input type for inserting object relation for remote table "Player_Rank"
"""
input Player_Rank_obj_rel_insert_input {
  data: Player_Rank_insert_input!
  on_conflict: Player_Rank_on_conflict
}

"""
on conflict condition type for table "Player_Rank"
"""
input Player_Rank_on_conflict {
  constraint: Player_Rank_constraint!
  update_columns: [Player_Rank_update_column!]!
  where: Player_Rank_bool_exp
}

"""
ordering options when selecting data from "Player_Rank"
"""
input Player_Rank_order_by {
  rank: order_by
}

"""
primary key columns input for table: "Player_Rank"
"""
input Player_Rank_pk_columns_input {
  rank: String!
}

"""
select columns of table "Player_Rank"
"""
enum Player_Rank_select_column {
  """column name"""
  rank
}

"""
input type for updating data in table "Player_Rank"
"""
input Player_Rank_set_input {
  rank: String
}

"""
update columns of table "Player_Rank"
"""
enum Player_Rank_update_column {
  """column name"""
  rank
}

"""
select columns of table "Player"
"""
enum Player_select_column {
  """column name"""
  availability_hours

  """column name"""
  created_at

  """column name"""
  enneagram

  """column name"""
  ethereum_address

  """column name"""
  id

  """column name"""
  playerTypeId

  """column name"""
  rank

  """column name"""
  role

  """column name"""
  scIdentityId

  """column name"""
  timezone

  """column name"""
  totalXp

  """column name"""
  updated_at

  """column name"""
  username
}

"""
input type for updating data in table "Player"
"""
input Player_set_input {
  availability_hours: Int
  created_at: timestamptz
  enneagram: EnneagramType_enum
  ethereum_address: String
  id: uuid
  playerTypeId: Int
  rank: Player_Rank_enum
  role: String
  scIdentityId: String
  timezone: Int
  totalXp: numeric
  updated_at: timestamptz
  username: String
}

"""
columns and relationships of "Player_Skill"
"""
type Player_Skill {
  """An object relationship"""
  Skill: Skill!
  player_id: uuid!
  skill_id: uuid!
}

"""
aggregated selection of "Player_Skill"
"""
type Player_Skill_aggregate {
  aggregate: Player_Skill_aggregate_fields
  nodes: [Player_Skill!]!
}

"""
aggregate fields of "Player_Skill"
"""
type Player_Skill_aggregate_fields {
  count(columns: [Player_Skill_select_column!], distinct: Boolean): Int
  max: Player_Skill_max_fields
  min: Player_Skill_min_fields
}

"""
order by aggregate values of table "Player_Skill"
"""
input Player_Skill_aggregate_order_by {
  count: order_by
  max: Player_Skill_max_order_by
  min: Player_Skill_min_order_by
}

"""
input type for inserting array relation for remote table "Player_Skill"
"""
input Player_Skill_arr_rel_insert_input {
  data: [Player_Skill_insert_input!]!
  on_conflict: Player_Skill_on_conflict
}

"""
Boolean expression to filter rows from the table "Player_Skill". All fields are combined with a logical 'AND'.
"""
input Player_Skill_bool_exp {
  Skill: Skill_bool_exp
  _and: [Player_Skill_bool_exp]
  _not: Player_Skill_bool_exp
  _or: [Player_Skill_bool_exp]
  player_id: uuid_comparison_exp
  skill_id: uuid_comparison_exp
}

"""
unique or primary key constraints on table "Player_Skill"
"""
enum Player_Skill_constraint {
  """unique or primary key constraint"""
  Player_Skill_unique_key
}

"""
input type for inserting data into table "Player_Skill"
"""
input Player_Skill_insert_input {
  Skill: Skill_obj_rel_insert_input
  player_id: uuid
  skill_id: uuid
}

"""aggregate max on columns"""
type Player_Skill_max_fields {
  player_id: uuid
  skill_id: uuid
}

"""
order by max() on columns of table "Player_Skill"
"""
input Player_Skill_max_order_by {
  player_id: order_by
  skill_id: order_by
}

"""aggregate min on columns"""
type Player_Skill_min_fields {
  player_id: uuid
  skill_id: uuid
}

"""
order by min() on columns of table "Player_Skill"
"""
input Player_Skill_min_order_by {
  player_id: order_by
  skill_id: order_by
}

"""
response of any mutation on the table "Player_Skill"
"""
type Player_Skill_mutation_response {
  """number of affected rows by the mutation"""
  affected_rows: Int!

  """data of the affected rows by the mutation"""
  returning: [Player_Skill!]!
}

"""
input type for inserting object relation for remote table "Player_Skill"
"""
input Player_Skill_obj_rel_insert_input {
  data: Player_Skill_insert_input!
  on_conflict: Player_Skill_on_conflict
}

"""
on conflict condition type for table "Player_Skill"
"""
input Player_Skill_on_conflict {
  constraint: Player_Skill_constraint!
  update_columns: [Player_Skill_update_column!]!
  where: Player_Skill_bool_exp
}

"""
ordering options when selecting data from "Player_Skill"
"""
input Player_Skill_order_by {
  Skill: Skill_order_by
  player_id: order_by
  skill_id: order_by
}

"""
primary key columns input for table: "Player_Skill"
"""
input Player_Skill_pk_columns_input {
  player_id: uuid!
  skill_id: uuid!
}

"""
select columns of table "Player_Skill"
"""
enum Player_Skill_select_column {
  """column name"""
  player_id

  """column name"""
  skill_id
}

"""
input type for updating data in table "Player_Skill"
"""
input Player_Skill_set_input {
  player_id: uuid
  skill_id: uuid
}

"""
update columns of table "Player_Skill"
"""
enum Player_Skill_update_column {
  """column name"""
  player_id

  """column name"""
  skill_id
}

"""aggregate stddev on columns"""
type Player_stddev_fields {
  availability_hours: Float
  playerTypeId: Float
  timezone: Float
  totalXp: Float
}

"""
order by stddev() on columns of table "Player"
"""
input Player_stddev_order_by {
  availability_hours: order_by
  playerTypeId: order_by
  timezone: order_by
  totalXp: order_by
}

"""aggregate stddev_pop on columns"""
type Player_stddev_pop_fields {
  availability_hours: Float
  playerTypeId: Float
  timezone: Float
  totalXp: Float
}

"""
order by stddev_pop() on columns of table "Player"
"""
input Player_stddev_pop_order_by {
  availability_hours: order_by
  playerTypeId: order_by
  timezone: order_by
  totalXp: order_by
}

"""aggregate stddev_samp on columns"""
type Player_stddev_samp_fields {
  availability_hours: Float
  playerTypeId: Float
  timezone: Float
  totalXp: Float
}

"""
order by stddev_samp() on columns of table "Player"
"""
input Player_stddev_samp_order_by {
  availability_hours: order_by
  playerTypeId: order_by
  timezone: order_by
  totalXp: order_by
}

"""aggregate sum on columns"""
type Player_sum_fields {
  availability_hours: Int
  playerTypeId: Int
  timezone: Int
  totalXp: numeric
}

"""
order by sum() on columns of table "Player"
"""
input Player_sum_order_by {
  availability_hours: order_by
  playerTypeId: order_by
  timezone: order_by
  totalXp: order_by
}

"""
update columns of table "Player"
"""
enum Player_update_column {
  """column name"""
  availability_hours

  """column name"""
  created_at

  """column name"""
  enneagram

  """column name"""
  ethereum_address

  """column name"""
  id

  """column name"""
  playerTypeId

  """column name"""
  rank

  """column name"""
  role

  """column name"""
  scIdentityId

  """column name"""
  timezone

  """column name"""
  totalXp

  """column name"""
  updated_at

  """column name"""
  username
}

"""aggregate var_pop on columns"""
type Player_var_pop_fields {
  availability_hours: Float
  playerTypeId: Float
  timezone: Float
  totalXp: Float
}

"""
order by var_pop() on columns of table "Player"
"""
input Player_var_pop_order_by {
  availability_hours: order_by
  playerTypeId: order_by
  timezone: order_by
  totalXp: order_by
}

"""aggregate var_samp on columns"""
type Player_var_samp_fields {
  availability_hours: Float
  playerTypeId: Float
  timezone: Float
  totalXp: Float
}

"""
order by var_samp() on columns of table "Player"
"""
input Player_var_samp_order_by {
  availability_hours: order_by
  playerTypeId: order_by
  timezone: order_by
  totalXp: order_by
}

"""aggregate variance on columns"""
type Player_variance_fields {
  availability_hours: Float
  playerTypeId: Float
  timezone: Float
  totalXp: Float
}

"""
order by variance() on columns of table "Player"
"""
input Player_variance_order_by {
  availability_hours: order_by
  playerTypeId: order_by
  timezone: order_by
  totalXp: order_by
}

"""
columns and relationships of "PlayerType"
"""
type PlayerType {
  description: String!
  id: Int!
  imageUrl: String
  title: String!
}

"""
aggregated selection of "PlayerType"
"""
type PlayerType_aggregate {
  aggregate: PlayerType_aggregate_fields
  nodes: [PlayerType!]!
}

"""
aggregate fields of "PlayerType"
"""
type PlayerType_aggregate_fields {
  avg: PlayerType_avg_fields
  count(columns: [PlayerType_select_column!], distinct: Boolean): Int
  max: PlayerType_max_fields
  min: PlayerType_min_fields
  stddev: PlayerType_stddev_fields
  stddev_pop: PlayerType_stddev_pop_fields
  stddev_samp: PlayerType_stddev_samp_fields
  sum: PlayerType_sum_fields
  var_pop: PlayerType_var_pop_fields
  var_samp: PlayerType_var_samp_fields
  variance: PlayerType_variance_fields
}

"""
order by aggregate values of table "PlayerType"
"""
input PlayerType_aggregate_order_by {
  avg: PlayerType_avg_order_by
  count: order_by
  max: PlayerType_max_order_by
  min: PlayerType_min_order_by
  stddev: PlayerType_stddev_order_by
  stddev_pop: PlayerType_stddev_pop_order_by
  stddev_samp: PlayerType_stddev_samp_order_by
  sum: PlayerType_sum_order_by
  var_pop: PlayerType_var_pop_order_by
  var_samp: PlayerType_var_samp_order_by
  variance: PlayerType_variance_order_by
}

"""
input type for inserting array relation for remote table "PlayerType"
"""
input PlayerType_arr_rel_insert_input {
  data: [PlayerType_insert_input!]!
  on_conflict: PlayerType_on_conflict
}

"""aggregate avg on columns"""
type PlayerType_avg_fields {
  id: Float
}

"""
order by avg() on columns of table "PlayerType"
"""
input PlayerType_avg_order_by {
  id: order_by
}

"""
Boolean expression to filter rows from the table "PlayerType". All fields are combined with a logical 'AND'.
"""
input PlayerType_bool_exp {
  _and: [PlayerType_bool_exp]
  _not: PlayerType_bool_exp
  _or: [PlayerType_bool_exp]
  description: String_comparison_exp
  id: Int_comparison_exp
  imageUrl: String_comparison_exp
  title: String_comparison_exp
}

"""
unique or primary key constraints on table "PlayerType"
"""
enum PlayerType_constraint {
  """unique or primary key constraint"""
  PlayerType_pkey

  """unique or primary key constraint"""
  PlayerType_title_key
}

"""
input type for incrementing integer column in table "PlayerType"
"""
input PlayerType_inc_input {
  id: Int
}

"""
input type for inserting data into table "PlayerType"
"""
input PlayerType_insert_input {
  description: String
  id: Int
  imageUrl: String
  title: String
}

"""aggregate max on columns"""
type PlayerType_max_fields {
  description: String
  id: Int
  imageUrl: String
  title: String
}

"""
order by max() on columns of table "PlayerType"
"""
input PlayerType_max_order_by {
  description: order_by
  id: order_by
  imageUrl: order_by
  title: order_by
}

"""aggregate min on columns"""
type PlayerType_min_fields {
  description: String
  id: Int
  imageUrl: String
  title: String
}

"""
order by min() on columns of table "PlayerType"
"""
input PlayerType_min_order_by {
  description: order_by
  id: order_by
  imageUrl: order_by
  title: order_by
}

"""
response of any mutation on the table "PlayerType"
"""
type PlayerType_mutation_response {
  """number of affected rows by the mutation"""
  affected_rows: Int!

  """data of the affected rows by the mutation"""
  returning: [PlayerType!]!
}

"""
input type for inserting object relation for remote table "PlayerType"
"""
input PlayerType_obj_rel_insert_input {
  data: PlayerType_insert_input!
  on_conflict: PlayerType_on_conflict
}

"""
on conflict condition type for table "PlayerType"
"""
input PlayerType_on_conflict {
  constraint: PlayerType_constraint!
  update_columns: [PlayerType_update_column!]!
  where: PlayerType_bool_exp
}

"""
ordering options when selecting data from "PlayerType"
"""
input PlayerType_order_by {
  description: order_by
  id: order_by
  imageUrl: order_by
  title: order_by
}

"""
primary key columns input for table: "PlayerType"
"""
input PlayerType_pk_columns_input {
  id: Int!
}

"""
select columns of table "PlayerType"
"""
enum PlayerType_select_column {
  """column name"""
  description

  """column name"""
  id

  """column name"""
  imageUrl

  """column name"""
  title
}

"""
input type for updating data in table "PlayerType"
"""
input PlayerType_set_input {
  description: String
  id: Int
  imageUrl: String
  title: String
}

"""aggregate stddev on columns"""
type PlayerType_stddev_fields {
  id: Float
}

"""
order by stddev() on columns of table "PlayerType"
"""
input PlayerType_stddev_order_by {
  id: order_by
}

"""aggregate stddev_pop on columns"""
type PlayerType_stddev_pop_fields {
  id: Float
}

"""
order by stddev_pop() on columns of table "PlayerType"
"""
input PlayerType_stddev_pop_order_by {
  id: order_by
}

"""aggregate stddev_samp on columns"""
type PlayerType_stddev_samp_fields {
  id: Float
}

"""
order by stddev_samp() on columns of table "PlayerType"
"""
input PlayerType_stddev_samp_order_by {
  id: order_by
}

"""aggregate sum on columns"""
type PlayerType_sum_fields {
  id: Int
}

"""
order by sum() on columns of table "PlayerType"
"""
input PlayerType_sum_order_by {
  id: order_by
}

"""
update columns of table "PlayerType"
"""
enum PlayerType_update_column {
  """column name"""
  description

  """column name"""
  id

  """column name"""
  imageUrl

  """column name"""
  title
}

"""aggregate var_pop on columns"""
type PlayerType_var_pop_fields {
  id: Float
}

"""
order by var_pop() on columns of table "PlayerType"
"""
input PlayerType_var_pop_order_by {
  id: order_by
}

"""aggregate var_samp on columns"""
type PlayerType_var_samp_fields {
  id: Float
}

"""
order by var_samp() on columns of table "PlayerType"
"""
input PlayerType_var_samp_order_by {
  id: order_by
}

"""aggregate variance on columns"""
type PlayerType_variance_fields {
  id: Float
}

"""
order by variance() on columns of table "PlayerType"
"""
input PlayerType_variance_order_by {
  id: order_by
}

type Query {
  getBoxProfile(address: String): BoxProfile
  getDaoHausMemberships(memberAddress: String): [Member!]!
}

"""query root"""
type query_root {
  """
  fetch data from the table: "Account"
  """
  Account(
    """distinct select on columns"""
    distinct_on: [Account_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Account_order_by!]

    """filter the rows returned"""
    where: Account_bool_exp
  ): [Account!]!

  """
  fetch data from the table: "AccountType"
  """
  AccountType(
    """distinct select on columns"""
    distinct_on: [AccountType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [AccountType_order_by!]

    """filter the rows returned"""
    where: AccountType_bool_exp
  ): [AccountType!]!

  """
  fetch aggregated fields from the table: "AccountType"
  """
  AccountType_aggregate(
    """distinct select on columns"""
    distinct_on: [AccountType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [AccountType_order_by!]

    """filter the rows returned"""
    where: AccountType_bool_exp
  ): AccountType_aggregate!

  """fetch data from the table: "AccountType" using primary key columns"""
  AccountType_by_pk(type: String!): AccountType

  """
  fetch aggregated fields from the table: "Account"
  """
  Account_aggregate(
    """distinct select on columns"""
    distinct_on: [Account_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Account_order_by!]

    """filter the rows returned"""
    where: Account_bool_exp
  ): Account_aggregate!

  """
  fetch data from the table: "EnneagramType"
  """
  EnneagramType(
    """distinct select on columns"""
    distinct_on: [EnneagramType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [EnneagramType_order_by!]

    """filter the rows returned"""
    where: EnneagramType_bool_exp
  ): [EnneagramType!]!

  """
  fetch aggregated fields from the table: "EnneagramType"
  """
  EnneagramType_aggregate(
    """distinct select on columns"""
    distinct_on: [EnneagramType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [EnneagramType_order_by!]

    """filter the rows returned"""
    where: EnneagramType_bool_exp
  ): EnneagramType_aggregate!

  """fetch data from the table: "EnneagramType" using primary key columns"""
  EnneagramType_by_pk(name: String!): EnneagramType

  """
  fetch data from the table: "Guild"
  """
  Guild(
    """distinct select on columns"""
    distinct_on: [Guild_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Guild_order_by!]

    """filter the rows returned"""
    where: Guild_bool_exp
  ): [Guild!]!

  """
  fetch data from the table: "GuildType"
  """
  GuildType(
    """distinct select on columns"""
    distinct_on: [GuildType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [GuildType_order_by!]

    """filter the rows returned"""
    where: GuildType_bool_exp
  ): [GuildType!]!

  """
  fetch aggregated fields from the table: "GuildType"
  """
  GuildType_aggregate(
    """distinct select on columns"""
    distinct_on: [GuildType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [GuildType_order_by!]

    """filter the rows returned"""
    where: GuildType_bool_exp
  ): GuildType_aggregate!

  """fetch data from the table: "GuildType" using primary key columns"""
  GuildType_by_pk(name: String!): GuildType

  """
  fetch aggregated fields from the table: "Guild"
  """
  Guild_aggregate(
    """distinct select on columns"""
    distinct_on: [Guild_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Guild_order_by!]

    """filter the rows returned"""
    where: Guild_bool_exp
  ): Guild_aggregate!

  """fetch data from the table: "Guild" using primary key columns"""
  Guild_by_pk(id: uuid!): Guild

  """
  fetch data from the table: "Player"
  """
  Player(
    """distinct select on columns"""
    distinct_on: [Player_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_order_by!]

    """filter the rows returned"""
    where: Player_bool_exp
  ): [Player!]!

  """
  fetch data from the table: "PlayerType"
  """
  PlayerType(
    """distinct select on columns"""
    distinct_on: [PlayerType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [PlayerType_order_by!]

    """filter the rows returned"""
    where: PlayerType_bool_exp
  ): [PlayerType!]!

  """
  fetch aggregated fields from the table: "PlayerType"
  """
  PlayerType_aggregate(
    """distinct select on columns"""
    distinct_on: [PlayerType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [PlayerType_order_by!]

    """filter the rows returned"""
    where: PlayerType_bool_exp
  ): PlayerType_aggregate!

  """fetch data from the table: "PlayerType" using primary key columns"""
  PlayerType_by_pk(id: Int!): PlayerType

  """
  fetch data from the table: "Player_Rank"
  """
  Player_Rank(
    """distinct select on columns"""
    distinct_on: [Player_Rank_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_Rank_order_by!]

    """filter the rows returned"""
    where: Player_Rank_bool_exp
  ): [Player_Rank!]!

  """
  fetch aggregated fields from the table: "Player_Rank"
  """
  Player_Rank_aggregate(
    """distinct select on columns"""
    distinct_on: [Player_Rank_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_Rank_order_by!]

    """filter the rows returned"""
    where: Player_Rank_bool_exp
  ): Player_Rank_aggregate!

  """fetch data from the table: "Player_Rank" using primary key columns"""
  Player_Rank_by_pk(rank: String!): Player_Rank

  """
  fetch data from the table: "Player_Skill"
  """
  Player_Skill(
    """distinct select on columns"""
    distinct_on: [Player_Skill_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_Skill_order_by!]

    """filter the rows returned"""
    where: Player_Skill_bool_exp
  ): [Player_Skill!]!

  """
  fetch aggregated fields from the table: "Player_Skill"
  """
  Player_Skill_aggregate(
    """distinct select on columns"""
    distinct_on: [Player_Skill_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_Skill_order_by!]

    """filter the rows returned"""
    where: Player_Skill_bool_exp
  ): Player_Skill_aggregate!

  """fetch data from the table: "Player_Skill" using primary key columns"""
  Player_Skill_by_pk(player_id: uuid!, skill_id: uuid!): Player_Skill

  """
  fetch aggregated fields from the table: "Player"
  """
  Player_aggregate(
    """distinct select on columns"""
    distinct_on: [Player_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_order_by!]

    """filter the rows returned"""
    where: Player_bool_exp
  ): Player_aggregate!

  """fetch data from the table: "Player" using primary key columns"""
  Player_by_pk(id: uuid!): Player

  """
  fetch data from the table: "Skill"
  """
  Skill(
    """distinct select on columns"""
    distinct_on: [Skill_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Skill_order_by!]

    """filter the rows returned"""
    where: Skill_bool_exp
  ): [Skill!]!

  """
  fetch data from the table: "SkillCategory"
  """
  SkillCategory(
    """distinct select on columns"""
    distinct_on: [SkillCategory_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [SkillCategory_order_by!]

    """filter the rows returned"""
    where: SkillCategory_bool_exp
  ): [SkillCategory!]!

  """
  fetch aggregated fields from the table: "SkillCategory"
  """
  SkillCategory_aggregate(
    """distinct select on columns"""
    distinct_on: [SkillCategory_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [SkillCategory_order_by!]

    """filter the rows returned"""
    where: SkillCategory_bool_exp
  ): SkillCategory_aggregate!

  """fetch data from the table: "SkillCategory" using primary key columns"""
  SkillCategory_by_pk(name: String!): SkillCategory

  """
  fetch aggregated fields from the table: "Skill"
  """
  Skill_aggregate(
    """distinct select on columns"""
    distinct_on: [Skill_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Skill_order_by!]

    """filter the rows returned"""
    where: Skill_bool_exp
  ): Skill_aggregate!

  """fetch data from the table: "Skill" using primary key columns"""
  Skill_by_pk(id: uuid!): Skill
  getBoxProfile(address: String): BoxProfile
  getDaoHausMemberships(memberAddress: String): [Member!]!

  """
  fetch data from the table: "me"
  """
  me(
    """distinct select on columns"""
    distinct_on: [me_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [me_order_by!]

    """filter the rows returned"""
    where: me_bool_exp
  ): [me!]!

  """
  fetch aggregated fields from the table: "me"
  """
  me_aggregate(
    """distinct select on columns"""
    distinct_on: [me_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [me_order_by!]

    """filter the rows returned"""
    where: me_bool_exp
  ): me_aggregate!
}

"""
columns and relationships of "Skill"
"""
type Skill {
  """An array relationship"""
  Player_Skills(
    """distinct select on columns"""
    distinct_on: [Player_Skill_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_Skill_order_by!]

    """filter the rows returned"""
    where: Player_Skill_bool_exp
  ): [Player_Skill!]!

  """An aggregated array relationship"""
  Player_Skills_aggregate(
    """distinct select on columns"""
    distinct_on: [Player_Skill_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_Skill_order_by!]

    """filter the rows returned"""
    where: Player_Skill_bool_exp
  ): Player_Skill_aggregate!
  category: SkillCategory_enum!
  id: uuid!
  name: String!
}

"""
aggregated selection of "Skill"
"""
type Skill_aggregate {
  aggregate: Skill_aggregate_fields
  nodes: [Skill!]!
}

"""
aggregate fields of "Skill"
"""
type Skill_aggregate_fields {
  count(columns: [Skill_select_column!], distinct: Boolean): Int
  max: Skill_max_fields
  min: Skill_min_fields
}

"""
order by aggregate values of table "Skill"
"""
input Skill_aggregate_order_by {
  count: order_by
  max: Skill_max_order_by
  min: Skill_min_order_by
}

"""
input type for inserting array relation for remote table "Skill"
"""
input Skill_arr_rel_insert_input {
  data: [Skill_insert_input!]!
  on_conflict: Skill_on_conflict
}

"""
Boolean expression to filter rows from the table "Skill". All fields are combined with a logical 'AND'.
"""
input Skill_bool_exp {
  Player_Skills: Player_Skill_bool_exp
  _and: [Skill_bool_exp]
  _not: Skill_bool_exp
  _or: [Skill_bool_exp]
  category: SkillCategory_enum_comparison_exp
  id: uuid_comparison_exp
  name: String_comparison_exp
}

"""
unique or primary key constraints on table "Skill"
"""
enum Skill_constraint {
  """unique or primary key constraint"""
  Skill_pkey
}

"""
input type for inserting data into table "Skill"
"""
input Skill_insert_input {
  Player_Skills: Player_Skill_arr_rel_insert_input
  category: SkillCategory_enum
  id: uuid
  name: String
}

"""aggregate max on columns"""
type Skill_max_fields {
  id: uuid
  name: String
}

"""
order by max() on columns of table "Skill"
"""
input Skill_max_order_by {
  id: order_by
  name: order_by
}

"""aggregate min on columns"""
type Skill_min_fields {
  id: uuid
  name: String
}

"""
order by min() on columns of table "Skill"
"""
input Skill_min_order_by {
  id: order_by
  name: order_by
}

"""
response of any mutation on the table "Skill"
"""
type Skill_mutation_response {
  """number of affected rows by the mutation"""
  affected_rows: Int!

  """data of the affected rows by the mutation"""
  returning: [Skill!]!
}

"""
input type for inserting object relation for remote table "Skill"
"""
input Skill_obj_rel_insert_input {
  data: Skill_insert_input!
  on_conflict: Skill_on_conflict
}

"""
on conflict condition type for table "Skill"
"""
input Skill_on_conflict {
  constraint: Skill_constraint!
  update_columns: [Skill_update_column!]!
  where: Skill_bool_exp
}

"""
ordering options when selecting data from "Skill"
"""
input Skill_order_by {
  Player_Skills_aggregate: Player_Skill_aggregate_order_by
  category: order_by
  id: order_by
  name: order_by
}

"""
primary key columns input for table: "Skill"
"""
input Skill_pk_columns_input {
  id: uuid!
}

"""
select columns of table "Skill"
"""
enum Skill_select_column {
  """column name"""
  category

  """column name"""
  id

  """column name"""
  name
}

"""
input type for updating data in table "Skill"
"""
input Skill_set_input {
  category: SkillCategory_enum
  id: uuid
  name: String
}

"""
update columns of table "Skill"
"""
enum Skill_update_column {
  """column name"""
  category

  """column name"""
  id

  """column name"""
  name
}

"""
columns and relationships of "SkillCategory"
"""
type SkillCategory {
  name: String!
}

"""
aggregated selection of "SkillCategory"
"""
type SkillCategory_aggregate {
  aggregate: SkillCategory_aggregate_fields
  nodes: [SkillCategory!]!
}

"""
aggregate fields of "SkillCategory"
"""
type SkillCategory_aggregate_fields {
  count(columns: [SkillCategory_select_column!], distinct: Boolean): Int
  max: SkillCategory_max_fields
  min: SkillCategory_min_fields
}

"""
order by aggregate values of table "SkillCategory"
"""
input SkillCategory_aggregate_order_by {
  count: order_by
  max: SkillCategory_max_order_by
  min: SkillCategory_min_order_by
}

"""
input type for inserting array relation for remote table "SkillCategory"
"""
input SkillCategory_arr_rel_insert_input {
  data: [SkillCategory_insert_input!]!
  on_conflict: SkillCategory_on_conflict
}

"""
Boolean expression to filter rows from the table "SkillCategory". All fields are combined with a logical 'AND'.
"""
input SkillCategory_bool_exp {
  _and: [SkillCategory_bool_exp]
  _not: SkillCategory_bool_exp
  _or: [SkillCategory_bool_exp]
  name: String_comparison_exp
}

"""
unique or primary key constraints on table "SkillCategory"
"""
enum SkillCategory_constraint {
  """unique or primary key constraint"""
  SkillCategory_pkey
}

enum SkillCategory_enum {
  COMMUNITY
  DESIGN
  DEV
  ENGINEERING
  STRATEGY
  TECHNOLOGIES
}

"""
expression to compare columns of type SkillCategory_enum. All fields are combined with logical 'AND'.
"""
input SkillCategory_enum_comparison_exp {
  _eq: SkillCategory_enum
  _in: [SkillCategory_enum!]
  _is_null: Boolean
  _neq: SkillCategory_enum
  _nin: [SkillCategory_enum!]
}

"""
input type for inserting data into table "SkillCategory"
"""
input SkillCategory_insert_input {
  name: String
}

"""aggregate max on columns"""
type SkillCategory_max_fields {
  name: String
}

"""
order by max() on columns of table "SkillCategory"
"""
input SkillCategory_max_order_by {
  name: order_by
}

"""aggregate min on columns"""
type SkillCategory_min_fields {
  name: String
}

"""
order by min() on columns of table "SkillCategory"
"""
input SkillCategory_min_order_by {
  name: order_by
}

"""
response of any mutation on the table "SkillCategory"
"""
type SkillCategory_mutation_response {
  """number of affected rows by the mutation"""
  affected_rows: Int!

  """data of the affected rows by the mutation"""
  returning: [SkillCategory!]!
}

"""
input type for inserting object relation for remote table "SkillCategory"
"""
input SkillCategory_obj_rel_insert_input {
  data: SkillCategory_insert_input!
  on_conflict: SkillCategory_on_conflict
}

"""
on conflict condition type for table "SkillCategory"
"""
input SkillCategory_on_conflict {
  constraint: SkillCategory_constraint!
  update_columns: [SkillCategory_update_column!]!
  where: SkillCategory_bool_exp
}

"""
ordering options when selecting data from "SkillCategory"
"""
input SkillCategory_order_by {
  name: order_by
}

"""
primary key columns input for table: "SkillCategory"
"""
input SkillCategory_pk_columns_input {
  name: String!
}

"""
select columns of table "SkillCategory"
"""
enum SkillCategory_select_column {
  """column name"""
  name
}

"""
input type for updating data in table "SkillCategory"
"""
input SkillCategory_set_input {
  name: String
}

"""
update columns of table "SkillCategory"
"""
enum SkillCategory_update_column {
  """column name"""
  name
}

"""
expression to compare columns of type String. All fields are combined with logical 'AND'.
"""
input String_comparison_exp {
  _eq: String
  _gt: String
  _gte: String
  _ilike: String
  _in: [String!]
  _is_null: Boolean
  _like: String
  _lt: String
  _lte: String
  _neq: String
  _nilike: String
  _nin: [String!]
  _nlike: String
  _nsimilar: String
  _similar: String
}

"""subscription root"""
type subscription_root {
  """
  fetch data from the table: "Account"
  """
  Account(
    """distinct select on columns"""
    distinct_on: [Account_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Account_order_by!]

    """filter the rows returned"""
    where: Account_bool_exp
  ): [Account!]!

  """
  fetch data from the table: "AccountType"
  """
  AccountType(
    """distinct select on columns"""
    distinct_on: [AccountType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [AccountType_order_by!]

    """filter the rows returned"""
    where: AccountType_bool_exp
  ): [AccountType!]!

  """
  fetch aggregated fields from the table: "AccountType"
  """
  AccountType_aggregate(
    """distinct select on columns"""
    distinct_on: [AccountType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [AccountType_order_by!]

    """filter the rows returned"""
    where: AccountType_bool_exp
  ): AccountType_aggregate!

  """fetch data from the table: "AccountType" using primary key columns"""
  AccountType_by_pk(type: String!): AccountType

  """
  fetch aggregated fields from the table: "Account"
  """
  Account_aggregate(
    """distinct select on columns"""
    distinct_on: [Account_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Account_order_by!]

    """filter the rows returned"""
    where: Account_bool_exp
  ): Account_aggregate!

  """
  fetch data from the table: "EnneagramType"
  """
  EnneagramType(
    """distinct select on columns"""
    distinct_on: [EnneagramType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [EnneagramType_order_by!]

    """filter the rows returned"""
    where: EnneagramType_bool_exp
  ): [EnneagramType!]!

  """
  fetch aggregated fields from the table: "EnneagramType"
  """
  EnneagramType_aggregate(
    """distinct select on columns"""
    distinct_on: [EnneagramType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [EnneagramType_order_by!]

    """filter the rows returned"""
    where: EnneagramType_bool_exp
  ): EnneagramType_aggregate!

  """fetch data from the table: "EnneagramType" using primary key columns"""
  EnneagramType_by_pk(name: String!): EnneagramType

  """
  fetch data from the table: "Guild"
  """
  Guild(
    """distinct select on columns"""
    distinct_on: [Guild_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Guild_order_by!]

    """filter the rows returned"""
    where: Guild_bool_exp
  ): [Guild!]!

  """
  fetch data from the table: "GuildType"
  """
  GuildType(
    """distinct select on columns"""
    distinct_on: [GuildType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [GuildType_order_by!]

    """filter the rows returned"""
    where: GuildType_bool_exp
  ): [GuildType!]!

  """
  fetch aggregated fields from the table: "GuildType"
  """
  GuildType_aggregate(
    """distinct select on columns"""
    distinct_on: [GuildType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [GuildType_order_by!]

    """filter the rows returned"""
    where: GuildType_bool_exp
  ): GuildType_aggregate!

  """fetch data from the table: "GuildType" using primary key columns"""
  GuildType_by_pk(name: String!): GuildType

  """
  fetch aggregated fields from the table: "Guild"
  """
  Guild_aggregate(
    """distinct select on columns"""
    distinct_on: [Guild_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Guild_order_by!]

    """filter the rows returned"""
    where: Guild_bool_exp
  ): Guild_aggregate!

  """fetch data from the table: "Guild" using primary key columns"""
  Guild_by_pk(id: uuid!): Guild

  """
  fetch data from the table: "Player"
  """
  Player(
    """distinct select on columns"""
    distinct_on: [Player_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_order_by!]

    """filter the rows returned"""
    where: Player_bool_exp
  ): [Player!]!

  """
  fetch data from the table: "PlayerType"
  """
  PlayerType(
    """distinct select on columns"""
    distinct_on: [PlayerType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [PlayerType_order_by!]

    """filter the rows returned"""
    where: PlayerType_bool_exp
  ): [PlayerType!]!

  """
  fetch aggregated fields from the table: "PlayerType"
  """
  PlayerType_aggregate(
    """distinct select on columns"""
    distinct_on: [PlayerType_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [PlayerType_order_by!]

    """filter the rows returned"""
    where: PlayerType_bool_exp
  ): PlayerType_aggregate!

  """fetch data from the table: "PlayerType" using primary key columns"""
  PlayerType_by_pk(id: Int!): PlayerType

  """
  fetch data from the table: "Player_Rank"
  """
  Player_Rank(
    """distinct select on columns"""
    distinct_on: [Player_Rank_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_Rank_order_by!]

    """filter the rows returned"""
    where: Player_Rank_bool_exp
  ): [Player_Rank!]!

  """
  fetch aggregated fields from the table: "Player_Rank"
  """
  Player_Rank_aggregate(
    """distinct select on columns"""
    distinct_on: [Player_Rank_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_Rank_order_by!]

    """filter the rows returned"""
    where: Player_Rank_bool_exp
  ): Player_Rank_aggregate!

  """fetch data from the table: "Player_Rank" using primary key columns"""
  Player_Rank_by_pk(rank: String!): Player_Rank

  """
  fetch data from the table: "Player_Skill"
  """
  Player_Skill(
    """distinct select on columns"""
    distinct_on: [Player_Skill_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_Skill_order_by!]

    """filter the rows returned"""
    where: Player_Skill_bool_exp
  ): [Player_Skill!]!

  """
  fetch aggregated fields from the table: "Player_Skill"
  """
  Player_Skill_aggregate(
    """distinct select on columns"""
    distinct_on: [Player_Skill_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_Skill_order_by!]

    """filter the rows returned"""
    where: Player_Skill_bool_exp
  ): Player_Skill_aggregate!

  """fetch data from the table: "Player_Skill" using primary key columns"""
  Player_Skill_by_pk(player_id: uuid!, skill_id: uuid!): Player_Skill

  """
  fetch aggregated fields from the table: "Player"
  """
  Player_aggregate(
    """distinct select on columns"""
    distinct_on: [Player_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Player_order_by!]

    """filter the rows returned"""
    where: Player_bool_exp
  ): Player_aggregate!

  """fetch data from the table: "Player" using primary key columns"""
  Player_by_pk(id: uuid!): Player

  """
  fetch data from the table: "Skill"
  """
  Skill(
    """distinct select on columns"""
    distinct_on: [Skill_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Skill_order_by!]

    """filter the rows returned"""
    where: Skill_bool_exp
  ): [Skill!]!

  """
  fetch data from the table: "SkillCategory"
  """
  SkillCategory(
    """distinct select on columns"""
    distinct_on: [SkillCategory_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [SkillCategory_order_by!]

    """filter the rows returned"""
    where: SkillCategory_bool_exp
  ): [SkillCategory!]!

  """
  fetch aggregated fields from the table: "SkillCategory"
  """
  SkillCategory_aggregate(
    """distinct select on columns"""
    distinct_on: [SkillCategory_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [SkillCategory_order_by!]

    """filter the rows returned"""
    where: SkillCategory_bool_exp
  ): SkillCategory_aggregate!

  """fetch data from the table: "SkillCategory" using primary key columns"""
  SkillCategory_by_pk(name: String!): SkillCategory

  """
  fetch aggregated fields from the table: "Skill"
  """
  Skill_aggregate(
    """distinct select on columns"""
    distinct_on: [Skill_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [Skill_order_by!]

    """filter the rows returned"""
    where: Skill_bool_exp
  ): Skill_aggregate!

  """fetch data from the table: "Skill" using primary key columns"""
  Skill_by_pk(id: uuid!): Skill

  """
  fetch data from the table: "me"
  """
  me(
    """distinct select on columns"""
    distinct_on: [me_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [me_order_by!]

    """filter the rows returned"""
    where: me_bool_exp
  ): [me!]!

  """
  fetch aggregated fields from the table: "me"
  """
  me_aggregate(
    """distinct select on columns"""
    distinct_on: [me_select_column!]

    """limit the number of rows returned"""
    limit: Int

    """skip the first n rows. Use only with order_by"""
    offset: Int

    """sort the rows by one or more columns"""
    order_by: [me_order_by!]

    """filter the rows returned"""
    where: me_bool_exp
  ): me_aggregate!
}

scalar timestamptz

"""
expression to compare columns of type timestamptz. All fields are combined with logical 'AND'.
"""
input timestamptz_comparison_exp {
  _eq: timestamptz
  _gt: timestamptz
  _gte: timestamptz
  _in: [timestamptz!]
  _is_null: Boolean
  _lt: timestamptz
  _lte: timestamptz
  _neq: timestamptz
  _nin: [timestamptz!]
}

type UpdateBoxProfileResponse {
  success: Boolean!
  updatedProfiles: [String!]!
}

scalar uuid

"""
expression to compare columns of type uuid. All fields are combined with logical 'AND'.
"""
input uuid_comparison_exp {
  _eq: uuid
  _gt: uuid
  _gte: uuid
  _in: [uuid!]
  _is_null: Boolean
  _lt: uuid
  _lte: uuid
  _neq: uuid
  _nin: [uuid!]
}