TheGame/schema.graphql

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

"""
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
}

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

type BoxProfile {
  collectiblesFavorites: [CollectiblesFavorites!]
  coverImageURL: String
  description: String
  emoji: String
  ethereumAddress: String
  imageURL: String
  job: String
  location: String
  name: String
  website: String
}

type BrightIdStatus {
  app: String!
  context: String!
  contextIds: [String!]!
  unique: Boolean!
}

type CacheProcessOutput {
  error: String
  success: Boolean!
}

type CollectiblesFavorites {
  address: String
  tokenId: String
}

"""
columns and relationships of "ColorAspect"
"""
type ColorAspect {
  description: String
  mask: Int!
  name: String!

  """An array relationship"""
  players(
    """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!]!

  """An aggregated array relationship"""
  players_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!
}

"""
aggregated selection of "ColorAspect"
"""
type ColorAspect_aggregate {
  aggregate: ColorAspect_aggregate_fields
  nodes: [ColorAspect!]!
}

"""
aggregate fields of "ColorAspect"
"""
type ColorAspect_aggregate_fields {
  avg: ColorAspect_avg_fields
  count(columns: [ColorAspect_select_column!], distinct: Boolean): Int
  max: ColorAspect_max_fields
  min: ColorAspect_min_fields
  stddev: ColorAspect_stddev_fields
  stddev_pop: ColorAspect_stddev_pop_fields
  stddev_samp: ColorAspect_stddev_samp_fields
  sum: ColorAspect_sum_fields
  var_pop: ColorAspect_var_pop_fields
  var_samp: ColorAspect_var_samp_fields
  variance: ColorAspect_variance_fields
}

"""
order by aggregate values of table "ColorAspect"
"""
input ColorAspect_aggregate_order_by {
  avg: ColorAspect_avg_order_by
  count: order_by
  max: ColorAspect_max_order_by
  min: ColorAspect_min_order_by
  stddev: ColorAspect_stddev_order_by
  stddev_pop: ColorAspect_stddev_pop_order_by
  stddev_samp: ColorAspect_stddev_samp_order_by
  sum: ColorAspect_sum_order_by
  var_pop: ColorAspect_var_pop_order_by
  var_samp: ColorAspect_var_samp_order_by
  variance: ColorAspect_variance_order_by
}

"""
input type for inserting array relation for remote table "ColorAspect"
"""
input ColorAspect_arr_rel_insert_input {
  data: [ColorAspect_insert_input!]!
  on_conflict: ColorAspect_on_conflict
}

"""aggregate avg on columns"""
type ColorAspect_avg_fields {
  mask: Float
}

"""
order by avg() on columns of table "ColorAspect"
"""
input ColorAspect_avg_order_by {
  mask: order_by
}

"""
Boolean expression to filter rows from the table "ColorAspect". All fields are combined with a logical 'AND'.
"""
input ColorAspect_bool_exp {
  _and: [ColorAspect_bool_exp]
  _not: ColorAspect_bool_exp
  _or: [ColorAspect_bool_exp]
  description: String_comparison_exp
  mask: Int_comparison_exp
  name: String_comparison_exp
  players: player_bool_exp
}

"""
unique or primary key constraints on table "ColorAspect"
"""
enum ColorAspect_constraint {
  """unique or primary key constraint"""
  ColorAspect_name_key

  """unique or primary key constraint"""
  ColorAspect_pkey
}

"""
input type for incrementing integer column in table "ColorAspect"
"""
input ColorAspect_inc_input {
  mask: Int
}

"""
input type for inserting data into table "ColorAspect"
"""
input ColorAspect_insert_input {
  description: String
  mask: Int
  name: String
  players: player_arr_rel_insert_input
}

"""aggregate max on columns"""
type ColorAspect_max_fields {
  description: String
  mask: Int
  name: String
}

"""
order by max() on columns of table "ColorAspect"
"""
input ColorAspect_max_order_by {
  description: order_by
  mask: order_by
  name: order_by
}

"""aggregate min on columns"""
type ColorAspect_min_fields {
  description: String
  mask: Int
  name: String
}

"""
order by min() on columns of table "ColorAspect"
"""
input ColorAspect_min_order_by {
  description: order_by
  mask: order_by
  name: order_by
}

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

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

"""
input type for inserting object relation for remote table "ColorAspect"
"""
input ColorAspect_obj_rel_insert_input {
  data: ColorAspect_insert_input!
  on_conflict: ColorAspect_on_conflict
}

"""
on conflict condition type for table "ColorAspect"
"""
input ColorAspect_on_conflict {
  constraint: ColorAspect_constraint!
  update_columns: [ColorAspect_update_column!]!
  where: ColorAspect_bool_exp
}

"""
ordering options when selecting data from "ColorAspect"
"""
input ColorAspect_order_by {
  description: order_by
  mask: order_by
  name: order_by
  players_aggregate: player_aggregate_order_by
}

"""
primary key columns input for table: "ColorAspect"
"""
input ColorAspect_pk_columns_input {
  mask: Int!
}

"""
select columns of table "ColorAspect"
"""
enum ColorAspect_select_column {
  """column name"""
  description

  """column name"""
  mask

  """column name"""
  name
}

"""
input type for updating data in table "ColorAspect"
"""
input ColorAspect_set_input {
  description: String
  mask: Int
  name: String
}

"""aggregate stddev on columns"""
type ColorAspect_stddev_fields {
  mask: Float
}

"""
order by stddev() on columns of table "ColorAspect"
"""
input ColorAspect_stddev_order_by {
  mask: order_by
}

"""aggregate stddev_pop on columns"""
type ColorAspect_stddev_pop_fields {
  mask: Float
}

"""
order by stddev_pop() on columns of table "ColorAspect"
"""
input ColorAspect_stddev_pop_order_by {
  mask: order_by
}

"""aggregate stddev_samp on columns"""
type ColorAspect_stddev_samp_fields {
  mask: Float
}

"""
order by stddev_samp() on columns of table "ColorAspect"
"""
input ColorAspect_stddev_samp_order_by {
  mask: order_by
}

"""aggregate sum on columns"""
type ColorAspect_sum_fields {
  mask: Int
}

"""
order by sum() on columns of table "ColorAspect"
"""
input ColorAspect_sum_order_by {
  mask: order_by
}

"""
update columns of table "ColorAspect"
"""
enum ColorAspect_update_column {
  """column name"""
  description

  """column name"""
  mask

  """column name"""
  name
}

"""aggregate var_pop on columns"""
type ColorAspect_var_pop_fields {
  mask: Float
}

"""
order by var_pop() on columns of table "ColorAspect"
"""
input ColorAspect_var_pop_order_by {
  mask: order_by
}

"""aggregate var_samp on columns"""
type ColorAspect_var_samp_fields {
  mask: Float
}

"""
order by var_samp() on columns of table "ColorAspect"
"""
input ColorAspect_var_samp_order_by {
  mask: order_by
}

"""aggregate variance on columns"""
type ColorAspect_variance_fields {
  mask: Float
}

"""
order by variance() on columns of table "ColorAspect"
"""
input ColorAspect_variance_order_by {
  mask: order_by
}

input CreateQuestCompletionInput {
  quest_id: String!
  submission_link: String
  submission_text: String
}

type CreateQuestCompletionOutput {
  error: String
  quest_completion: quest_completion
  quest_completion_id: uuid
  success: Boolean!
}

input CreateQuestInput {
  cooldown: Int
  description: String
  external_link: String
  guild_id: uuid!
  repetition: QuestRepetition_ActionEnum
  skills_id: [uuid]!
  title: String!
}

type CreateQuestOutput {
  error: String
  quest: quest
  quest_id: uuid
  success: Boolean!
}

type DiscordGuildAuthResponse {
  error: String
  exists: Boolean
  guildname: String
  success: Boolean!
}

type DiscordRole {
  id: String!
  name: String!
  position: Int!
}

type ExpiredPlayerProfiles {
  ids: [String]!
}

"""
columns and relationships of "guild"
"""
type guild {
  """An object relationship"""
  GuildType: GuildType!
  description: String
  discord_id: String
  discord_invite_url: String
  github_url: String

  """An array relationship"""
  guild_players(
    """distinct select on columns"""
    distinct_on: [guild_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: [guild_player_order_by!]

    """filter the rows returned"""
    where: guild_player_bool_exp
  ): [guild_player!]!

  """An aggregated array relationship"""
  guild_players_aggregate(
    """distinct select on columns"""
    distinct_on: [guild_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: [guild_player_order_by!]

    """filter the rows returned"""
    where: guild_player_bool_exp
  ): guild_player_aggregate!

  """Unique friendly identifier for the Guild (used in URL)"""
  guildname: String!
  id: uuid!
  join_button_url: String
  logo: String
  membership_through_discord: Boolean!
  moloch_address: String
  name: String!
  position: GuildPosition_enum

  """An array relationship"""
  quests(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_order_by!]

    """filter the rows returned"""
    where: quest_bool_exp
  ): [quest!]!

  """An aggregated array relationship"""
  quests_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_order_by!]

    """filter the rows returned"""
    where: quest_bool_exp
  ): quest_aggregate!
  status: GuildStatus_enum!
  twitter_url: String

  """The area of focus for the guild (e.g. funding, project, etc)"""
  type: GuildType_enum!
  website_url: String
}

"""
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]
  description: String_comparison_exp
  discord_id: String_comparison_exp
  discord_invite_url: String_comparison_exp
  github_url: String_comparison_exp
  guild_players: guild_player_bool_exp
  guildname: String_comparison_exp
  id: uuid_comparison_exp
  join_button_url: String_comparison_exp
  logo: String_comparison_exp
  membership_through_discord: Boolean_comparison_exp
  moloch_address: String_comparison_exp
  name: String_comparison_exp
  position: GuildPosition_enum_comparison_exp
  quests: quest_bool_exp
  status: GuildStatus_enum_comparison_exp
  twitter_url: String_comparison_exp
  type: GuildType_enum_comparison_exp
  website_url: String_comparison_exp
}

"""
unique or primary key constraints on table "guild"
"""
enum guild_constraint {
  """unique or primary key constraint"""
  Guild_guildname_key

  """unique or primary key constraint"""
  Guild_pkey

  """unique or primary key constraint"""
  guild_discord_id_key
}

"""
input type for inserting data into table "guild"
"""
input guild_insert_input {
  GuildType: GuildType_obj_rel_insert_input
  description: String
  discord_id: String
  discord_invite_url: String
  github_url: String
  guild_players: guild_player_arr_rel_insert_input
  guildname: String
  id: uuid
  join_button_url: String
  logo: String
  membership_through_discord: Boolean
  moloch_address: String
  name: String
  position: GuildPosition_enum
  quests: quest_arr_rel_insert_input
  status: GuildStatus_enum
  twitter_url: String
  type: GuildType_enum
  website_url: String
}

"""aggregate max on columns"""
type guild_max_fields {
  description: String
  discord_id: String
  discord_invite_url: String
  github_url: String
  guildname: String
  id: uuid
  join_button_url: String
  logo: String
  moloch_address: String
  name: String
  twitter_url: String
  website_url: String
}

"""
order by max() on columns of table "guild"
"""
input guild_max_order_by {
  description: order_by
  discord_id: order_by
  discord_invite_url: order_by
  github_url: order_by
  guildname: order_by
  id: order_by
  join_button_url: order_by
  logo: order_by
  moloch_address: order_by
  name: order_by
  twitter_url: order_by
  website_url: order_by
}

"""
Used to hold private information for guilds


columns and relationships of "guild_metadata"

"""
type guild_metadata {
  creator_id: uuid

  """Remote relationship field"""
  discordRoles: [DiscordRole!]!
  discord_id: String!
  discord_metadata(
    """JSON select path"""
    path: String
  ): jsonb

  """An object relationship"""
  guild: guild!
  guild_id: uuid!

  """An object relationship"""
  player: player
}

"""
aggregated selection of "guild_metadata"
"""
type guild_metadata_aggregate {
  aggregate: guild_metadata_aggregate_fields
  nodes: [guild_metadata!]!
}

"""
aggregate fields of "guild_metadata"
"""
type guild_metadata_aggregate_fields {
  count(columns: [guild_metadata_select_column!], distinct: Boolean): Int
  max: guild_metadata_max_fields
  min: guild_metadata_min_fields
}

"""
order by aggregate values of table "guild_metadata"
"""
input guild_metadata_aggregate_order_by {
  count: order_by
  max: guild_metadata_max_order_by
  min: guild_metadata_min_order_by
}

"""append existing jsonb value of filtered columns with new jsonb value"""
input guild_metadata_append_input {
  discord_metadata: jsonb
}

"""
input type for inserting array relation for remote table "guild_metadata"
"""
input guild_metadata_arr_rel_insert_input {
  data: [guild_metadata_insert_input!]!
  on_conflict: guild_metadata_on_conflict
}

"""
Boolean expression to filter rows from the table "guild_metadata". All fields are combined with a logical 'AND'.
"""
input guild_metadata_bool_exp {
  _and: [guild_metadata_bool_exp]
  _not: guild_metadata_bool_exp
  _or: [guild_metadata_bool_exp]
  creator_id: uuid_comparison_exp
  discord_id: String_comparison_exp
  discord_metadata: jsonb_comparison_exp
  guild: guild_bool_exp
  guild_id: uuid_comparison_exp
  player: player_bool_exp
}

"""
unique or primary key constraints on table "guild_metadata"
"""
enum guild_metadata_constraint {
  """unique or primary key constraint"""
  guild_metadata_pkey
}

"""
delete the field or element with specified path (for JSON arrays, negative integers count from the end)
"""
input guild_metadata_delete_at_path_input {
  discord_metadata: [String]
}

"""
delete the array element with specified index (negative integers count from the
end). throws an error if top level container is not an array
"""
input guild_metadata_delete_elem_input {
  discord_metadata: Int
}

"""
delete key/value pair or string element. key/value pairs are matched based on their key value
"""
input guild_metadata_delete_key_input {
  discord_metadata: String
}

"""
input type for inserting data into table "guild_metadata"
"""
input guild_metadata_insert_input {
  creator_id: uuid
  discord_id: String
  discord_metadata: jsonb
  guild: guild_obj_rel_insert_input
  guild_id: uuid
  player: player_obj_rel_insert_input
}

"""aggregate max on columns"""
type guild_metadata_max_fields {
  creator_id: uuid
  discord_id: String
  guild_id: uuid
}

"""
order by max() on columns of table "guild_metadata"
"""
input guild_metadata_max_order_by {
  creator_id: order_by
  discord_id: order_by
  guild_id: order_by
}

"""aggregate min on columns"""
type guild_metadata_min_fields {
  creator_id: uuid
  discord_id: String
  guild_id: uuid
}

"""
order by min() on columns of table "guild_metadata"
"""
input guild_metadata_min_order_by {
  creator_id: order_by
  discord_id: order_by
  guild_id: order_by
}

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

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

"""
input type for inserting object relation for remote table "guild_metadata"
"""
input guild_metadata_obj_rel_insert_input {
  data: guild_metadata_insert_input!
  on_conflict: guild_metadata_on_conflict
}

"""
on conflict condition type for table "guild_metadata"
"""
input guild_metadata_on_conflict {
  constraint: guild_metadata_constraint!
  update_columns: [guild_metadata_update_column!]!
  where: guild_metadata_bool_exp
}

"""
ordering options when selecting data from "guild_metadata"
"""
input guild_metadata_order_by {
  creator_id: order_by
  discord_id: order_by
  discord_metadata: order_by
  guild: guild_order_by
  guild_id: order_by
  player: player_order_by
}

"""
primary key columns input for table: "guild_metadata"
"""
input guild_metadata_pk_columns_input {
  guild_id: uuid!
}

"""prepend existing jsonb value of filtered columns with new jsonb value"""
input guild_metadata_prepend_input {
  discord_metadata: jsonb
}

"""
select columns of table "guild_metadata"
"""
enum guild_metadata_select_column {
  """column name"""
  creator_id

  """column name"""
  discord_id

  """column name"""
  discord_metadata

  """column name"""
  guild_id
}

"""
input type for updating data in table "guild_metadata"
"""
input guild_metadata_set_input {
  creator_id: uuid
  discord_id: String
  discord_metadata: jsonb
  guild_id: uuid
}

"""
update columns of table "guild_metadata"
"""
enum guild_metadata_update_column {
  """column name"""
  creator_id

  """column name"""
  discord_id

  """column name"""
  discord_metadata

  """column name"""
  guild_id
}

"""aggregate min on columns"""
type guild_min_fields {
  description: String
  discord_id: String
  discord_invite_url: String
  github_url: String
  guildname: String
  id: uuid
  join_button_url: String
  logo: String
  moloch_address: String
  name: String
  twitter_url: String
  website_url: String
}

"""
order by min() on columns of table "guild"
"""
input guild_min_order_by {
  description: order_by
  discord_id: order_by
  discord_invite_url: order_by
  github_url: order_by
  guildname: order_by
  id: order_by
  join_button_url: order_by
  logo: order_by
  moloch_address: order_by
  name: order_by
  twitter_url: order_by
  website_url: 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
  description: order_by
  discord_id: order_by
  discord_invite_url: order_by
  github_url: order_by
  guild_players_aggregate: guild_player_aggregate_order_by
  guildname: order_by
  id: order_by
  join_button_url: order_by
  logo: order_by
  membership_through_discord: order_by
  moloch_address: order_by
  name: order_by
  position: order_by
  quests_aggregate: quest_aggregate_order_by
  status: order_by
  twitter_url: order_by
  type: order_by
  website_url: order_by
}

"""
primary key columns input for table: "guild"
"""
input guild_pk_columns_input {
  id: uuid!
}

"""
columns and relationships of "guild_player"
"""
type guild_player {
  """An object relationship"""
  Guild: guild!

  """An object relationship"""
  Player: player!

  """Remote relationship field"""
  discordRoles: [DiscordRole!]!
  guild_id: uuid!
  player_id: uuid!
}

"""
aggregated selection of "guild_player"
"""
type guild_player_aggregate {
  aggregate: guild_player_aggregate_fields
  nodes: [guild_player!]!
}

"""
aggregate fields of "guild_player"
"""
type guild_player_aggregate_fields {
  count(columns: [guild_player_select_column!], distinct: Boolean): Int
  max: guild_player_max_fields
  min: guild_player_min_fields
}

"""
order by aggregate values of table "guild_player"
"""
input guild_player_aggregate_order_by {
  count: order_by
  max: guild_player_max_order_by
  min: guild_player_min_order_by
}

"""
input type for inserting array relation for remote table "guild_player"
"""
input guild_player_arr_rel_insert_input {
  data: [guild_player_insert_input!]!
  on_conflict: guild_player_on_conflict
}

"""
Boolean expression to filter rows from the table "guild_player". All fields are combined with a logical 'AND'.
"""
input guild_player_bool_exp {
  Guild: guild_bool_exp
  Player: player_bool_exp
  _and: [guild_player_bool_exp]
  _not: guild_player_bool_exp
  _or: [guild_player_bool_exp]
  guild_id: uuid_comparison_exp
  player_id: uuid_comparison_exp
}

"""
unique or primary key constraints on table "guild_player"
"""
enum guild_player_constraint {
  """unique or primary key constraint"""
  guild_player_pkey
}

"""
input type for inserting data into table "guild_player"
"""
input guild_player_insert_input {
  Guild: guild_obj_rel_insert_input
  Player: player_obj_rel_insert_input
  guild_id: uuid
  player_id: uuid
}

"""aggregate max on columns"""
type guild_player_max_fields {
  guild_id: uuid
  player_id: uuid
}

"""
order by max() on columns of table "guild_player"
"""
input guild_player_max_order_by {
  guild_id: order_by
  player_id: order_by
}

"""aggregate min on columns"""
type guild_player_min_fields {
  guild_id: uuid
  player_id: uuid
}

"""
order by min() on columns of table "guild_player"
"""
input guild_player_min_order_by {
  guild_id: order_by
  player_id: order_by
}

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

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

"""
input type for inserting object relation for remote table "guild_player"
"""
input guild_player_obj_rel_insert_input {
  data: guild_player_insert_input!
  on_conflict: guild_player_on_conflict
}

"""
on conflict condition type for table "guild_player"
"""
input guild_player_on_conflict {
  constraint: guild_player_constraint!
  update_columns: [guild_player_update_column!]!
  where: guild_player_bool_exp
}

"""
ordering options when selecting data from "guild_player"
"""
input guild_player_order_by {
  Guild: guild_order_by
  Player: player_order_by
  guild_id: order_by
  player_id: order_by
}

"""
primary key columns input for table: "guild_player"
"""
input guild_player_pk_columns_input {
  guild_id: uuid!
  player_id: uuid!
}

"""
select columns of table "guild_player"
"""
enum guild_player_select_column {
  """column name"""
  guild_id

  """column name"""
  player_id
}

"""
input type for updating data in table "guild_player"
"""
input guild_player_set_input {
  guild_id: uuid
  player_id: uuid
}

"""
update columns of table "guild_player"
"""
enum guild_player_update_column {
  """column name"""
  guild_id

  """column name"""
  player_id
}

"""
select columns of table "guild"
"""
enum guild_select_column {
  """column name"""
  description

  """column name"""
  discord_id

  """column name"""
  discord_invite_url

  """column name"""
  github_url

  """column name"""
  guildname

  """column name"""
  id

  """column name"""
  join_button_url

  """column name"""
  logo

  """column name"""
  membership_through_discord

  """column name"""
  moloch_address

  """column name"""
  name

  """column name"""
  position

  """column name"""
  status

  """column name"""
  twitter_url

  """column name"""
  type

  """column name"""
  website_url
}

"""
input type for updating data in table "guild"
"""
input guild_set_input {
  description: String
  discord_id: String
  discord_invite_url: String
  github_url: String
  guildname: String
  id: uuid
  join_button_url: String
  logo: String
  membership_through_discord: Boolean
  moloch_address: String
  name: String
  position: GuildPosition_enum
  status: GuildStatus_enum
  twitter_url: String
  type: GuildType_enum
  website_url: String
}

"""
update columns of table "guild"
"""
enum guild_update_column {
  """column name"""
  description

  """column name"""
  discord_id

  """column name"""
  discord_invite_url

  """column name"""
  github_url

  """column name"""
  guildname

  """column name"""
  id

  """column name"""
  join_button_url

  """column name"""
  logo

  """column name"""
  membership_through_discord

  """column name"""
  moloch_address

  """column name"""
  name

  """column name"""
  position

  """column name"""
  status

  """column name"""
  twitter_url

  """column name"""
  type

  """column name"""
  website_url
}

input GuildInfo {
  daoAddress: String
  description: String
  discordAdminRoles: [String]!
  discordInviteUrl: String
  discordMembershipRoles: [String]!
  githubUrl: String
  guildname: String!
  joinUrl: String
  logoUrl: String
  membershipThroughDiscord: Boolean
  name: String!
  twitterUrl: String
  type: GuildType_ActionEnum!
  uuid: String!
  websiteUrl: String
}

"""
columns and relationships of "GuildPosition"
"""
type GuildPosition {
  position: String!
}

"""
aggregated selection of "GuildPosition"
"""
type GuildPosition_aggregate {
  aggregate: GuildPosition_aggregate_fields
  nodes: [GuildPosition!]!
}

"""
aggregate fields of "GuildPosition"
"""
type GuildPosition_aggregate_fields {
  count(columns: [GuildPosition_select_column!], distinct: Boolean): Int
  max: GuildPosition_max_fields
  min: GuildPosition_min_fields
}

"""
order by aggregate values of table "GuildPosition"
"""
input GuildPosition_aggregate_order_by {
  count: order_by
  max: GuildPosition_max_order_by
  min: GuildPosition_min_order_by
}

"""
input type for inserting array relation for remote table "GuildPosition"
"""
input GuildPosition_arr_rel_insert_input {
  data: [GuildPosition_insert_input!]!
  on_conflict: GuildPosition_on_conflict
}

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

"""
unique or primary key constraints on table "GuildPosition"
"""
enum GuildPosition_constraint {
  """unique or primary key constraint"""
  GuildPosition_pkey
}

enum GuildPosition_enum {
  EXTERNAL
  INTERNAL
}

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

"""
input type for inserting data into table "GuildPosition"
"""
input GuildPosition_insert_input {
  position: String
}

"""aggregate max on columns"""
type GuildPosition_max_fields {
  position: String
}

"""
order by max() on columns of table "GuildPosition"
"""
input GuildPosition_max_order_by {
  position: order_by
}

"""aggregate min on columns"""
type GuildPosition_min_fields {
  position: String
}

"""
order by min() on columns of table "GuildPosition"
"""
input GuildPosition_min_order_by {
  position: order_by
}

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

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

"""
input type for inserting object relation for remote table "GuildPosition"
"""
input GuildPosition_obj_rel_insert_input {
  data: GuildPosition_insert_input!
  on_conflict: GuildPosition_on_conflict
}

"""
on conflict condition type for table "GuildPosition"
"""
input GuildPosition_on_conflict {
  constraint: GuildPosition_constraint!
  update_columns: [GuildPosition_update_column!]!
  where: GuildPosition_bool_exp
}

"""
ordering options when selecting data from "GuildPosition"
"""
input GuildPosition_order_by {
  position: order_by
}

"""
primary key columns input for table: "GuildPosition"
"""
input GuildPosition_pk_columns_input {
  position: String!
}

"""
select columns of table "GuildPosition"
"""
enum GuildPosition_select_column {
  """column name"""
  position
}

"""
input type for updating data in table "GuildPosition"
"""
input GuildPosition_set_input {
  position: String
}

"""
update columns of table "GuildPosition"
"""
enum GuildPosition_update_column {
  """column name"""
  position
}

"""
columns and relationships of "GuildStatus"
"""
type GuildStatus {
  status: String!
}

"""
aggregated selection of "GuildStatus"
"""
type GuildStatus_aggregate {
  aggregate: GuildStatus_aggregate_fields
  nodes: [GuildStatus!]!
}

"""
aggregate fields of "GuildStatus"
"""
type GuildStatus_aggregate_fields {
  count(columns: [GuildStatus_select_column!], distinct: Boolean): Int
  max: GuildStatus_max_fields
  min: GuildStatus_min_fields
}

"""
order by aggregate values of table "GuildStatus"
"""
input GuildStatus_aggregate_order_by {
  count: order_by
  max: GuildStatus_max_order_by
  min: GuildStatus_min_order_by
}

"""
input type for inserting array relation for remote table "GuildStatus"
"""
input GuildStatus_arr_rel_insert_input {
  data: [GuildStatus_insert_input!]!
  on_conflict: GuildStatus_on_conflict
}

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

"""
unique or primary key constraints on table "GuildStatus"
"""
enum GuildStatus_constraint {
  """unique or primary key constraint"""
  GuildStatus_pkey
}

enum GuildStatus_enum {
  ACTIVE
  INACTIVE
  PENDING
}

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

"""
input type for inserting data into table "GuildStatus"
"""
input GuildStatus_insert_input {
  status: String
}

"""aggregate max on columns"""
type GuildStatus_max_fields {
  status: String
}

"""
order by max() on columns of table "GuildStatus"
"""
input GuildStatus_max_order_by {
  status: order_by
}

"""aggregate min on columns"""
type GuildStatus_min_fields {
  status: String
}

"""
order by min() on columns of table "GuildStatus"
"""
input GuildStatus_min_order_by {
  status: order_by
}

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

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

"""
input type for inserting object relation for remote table "GuildStatus"
"""
input GuildStatus_obj_rel_insert_input {
  data: GuildStatus_insert_input!
  on_conflict: GuildStatus_on_conflict
}

"""
on conflict condition type for table "GuildStatus"
"""
input GuildStatus_on_conflict {
  constraint: GuildStatus_constraint!
  update_columns: [GuildStatus_update_column!]!
  where: GuildStatus_bool_exp
}

"""
ordering options when selecting data from "GuildStatus"
"""
input GuildStatus_order_by {
  status: order_by
}

"""
primary key columns input for table: "GuildStatus"
"""
input GuildStatus_pk_columns_input {
  status: String!
}

"""
select columns of table "GuildStatus"
"""
enum GuildStatus_select_column {
  """column name"""
  status
}

"""
input type for updating data in table "GuildStatus"
"""
input GuildStatus_set_input {
  status: String
}

"""
update columns of table "GuildStatus"
"""
enum GuildStatus_update_column {
  """column name"""
  status
}

"""
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!
}

enum GuildType_ActionEnum {
  FUNDING
  PROJECT
  RESEARCH
  SERVICE
  SOCIAL
}

"""
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 {
  FUNDING
  PROJECT
  RESEARCH
  SERVICE
  SOCIAL
}

"""
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!]
}

scalar jsonb

"""
expression to compare columns of type jsonb. All fields are combined with logical 'AND'.
"""
input jsonb_comparison_exp {
  """is the column contained in the given json value"""
  _contained_in: jsonb

  """does the column contain the given json value at the top level"""
  _contains: jsonb
  _eq: jsonb
  _gt: jsonb
  _gte: jsonb

  """does the string exist as a top-level key in the column"""
  _has_key: String

  """do all of these strings exist as top-level keys in the column"""
  _has_keys_all: [String!]

  """do any of these strings exist as top-level keys in the column"""
  _has_keys_any: [String!]
  _in: [jsonb!]
  _is_null: Boolean
  _lt: jsonb
  _lte: jsonb
  _neq: jsonb
  _nin: [jsonb!]
}

"""
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: String
  memberAddress: String!
  moloch: Moloch!
  molochAddress: String!
  shares: String!
}

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

"""mutation root"""
type mutation_root {
  """
  perform the action: "authenticateDiscordGuild"
  """
  authenticateDiscordGuild(code: String!): DiscordGuildAuthResponse

  """
  perform the action: "createQuest"
  """
  createQuest(quest: CreateQuestInput!): CreateQuestOutput

  """
  perform the action: "createQuestCompletion"
  """
  createQuestCompletion(questCompletion: CreateQuestCompletionInput!): CreateQuestCompletionOutput

  """
  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: "ColorAspect"
  """
  delete_ColorAspect(
    """filter the rows which have to be deleted"""
    where: ColorAspect_bool_exp!
  ): ColorAspect_mutation_response

  """
  delete single row from the table: "ColorAspect"
  """
  delete_ColorAspect_by_pk(mask: Int!): ColorAspect

  """
  delete data from the table: "GuildPosition"
  """
  delete_GuildPosition(
    """filter the rows which have to be deleted"""
    where: GuildPosition_bool_exp!
  ): GuildPosition_mutation_response

  """
  delete single row from the table: "GuildPosition"
  """
  delete_GuildPosition_by_pk(position: String!): GuildPosition

  """
  delete data from the table: "GuildStatus"
  """
  delete_GuildStatus(
    """filter the rows which have to be deleted"""
    where: GuildStatus_bool_exp!
  ): GuildStatus_mutation_response

  """
  delete single row from the table: "GuildStatus"
  """
  delete_GuildStatus_by_pk(status: String!): GuildStatus

  """
  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 data from the table: "PlayerRank"
  """
  delete_PlayerRank(
    """filter the rows which have to be deleted"""
    where: PlayerRank_bool_exp!
  ): PlayerRank_mutation_response

  """
  delete single row from the table: "PlayerRank"
  """
  delete_PlayerRank_by_pk(rank: String!): PlayerRank

  """
  delete data from the table: "PlayerRole"
  """
  delete_PlayerRole(
    """filter the rows which have to be deleted"""
    where: PlayerRole_bool_exp!
  ): PlayerRole_mutation_response

  """
  delete single row from the table: "PlayerRole"
  """
  delete_PlayerRole_by_pk(role: String!): PlayerRole

  """
  delete data from the table: "QuestCompletionStatus"
  """
  delete_QuestCompletionStatus(
    """filter the rows which have to be deleted"""
    where: QuestCompletionStatus_bool_exp!
  ): QuestCompletionStatus_mutation_response

  """
  delete single row from the table: "QuestCompletionStatus"
  """
  delete_QuestCompletionStatus_by_pk(status: String!): QuestCompletionStatus

  """
  delete data from the table: "QuestRepetition"
  """
  delete_QuestRepetition(
    """filter the rows which have to be deleted"""
    where: QuestRepetition_bool_exp!
  ): QuestRepetition_mutation_response

  """
  delete single row from the table: "QuestRepetition"
  """
  delete_QuestRepetition_by_pk(repetition: String!): QuestRepetition

  """
  delete data from the table: "QuestStatus"
  """
  delete_QuestStatus(
    """filter the rows which have to be deleted"""
    where: QuestStatus_bool_exp!
  ): QuestStatus_mutation_response

  """
  delete single row from the table: "QuestStatus"
  """
  delete_QuestStatus_by_pk(status: String!): QuestStatus

  """
  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 data from the table: "guild"
  """
  delete_guild(
    """filter the rows which have to be deleted"""
    where: guild_bool_exp!
  ): guild_mutation_response

  """
  delete single row from the table: "guild"
  """
  delete_guild_by_pk(id: uuid!): guild

  """
  delete data from the table: "guild_metadata"
  """
  delete_guild_metadata(
    """filter the rows which have to be deleted"""
    where: guild_metadata_bool_exp!
  ): guild_metadata_mutation_response

  """
  delete single row from the table: "guild_metadata"
  """
  delete_guild_metadata_by_pk(guild_id: uuid!): guild_metadata

  """
  delete data from the table: "guild_player"
  """
  delete_guild_player(
    """filter the rows which have to be deleted"""
    where: guild_player_bool_exp!
  ): guild_player_mutation_response

  """
  delete single row from the table: "guild_player"
  """
  delete_guild_player_by_pk(guild_id: uuid!, player_id: uuid!): guild_player

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

  """
  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: "player_account"
  """
  delete_player_account(
    """filter the rows which have to be deleted"""
    where: player_account_bool_exp!
  ): player_account_mutation_response

  """
  delete single row from the table: "player"
  """
  delete_player_by_pk(id: uuid!): player

  """
  delete data from the table: "player_role"
  """
  delete_player_role(
    """filter the rows which have to be deleted"""
    where: player_role_bool_exp!
  ): player_role_mutation_response

  """
  delete single row from the table: "player_role"
  """
  delete_player_role_by_pk(player_id: uuid!, role: String!): player_role

  """
  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(id: uuid!): player_skill

  """
  delete data from the table: "player_type"
  """
  delete_player_type(
    """filter the rows which have to be deleted"""
    where: player_type_bool_exp!
  ): player_type_mutation_response

  """
  delete single row from the table: "player_type"
  """
  delete_player_type_by_pk(id: Int!): player_type

  """
  delete data from the table: "profile_cache"
  """
  delete_profile_cache(
    """filter the rows which have to be deleted"""
    where: profile_cache_bool_exp!
  ): profile_cache_mutation_response

  """
  delete single row from the table: "profile_cache"
  """
  delete_profile_cache_by_pk(id: uuid!): profile_cache

  """
  delete data from the table: "quest"
  """
  delete_quest(
    """filter the rows which have to be deleted"""
    where: quest_bool_exp!
  ): quest_mutation_response

  """
  delete single row from the table: "quest"
  """
  delete_quest_by_pk(id: uuid!): quest

  """
  delete data from the table: "quest_completion"
  """
  delete_quest_completion(
    """filter the rows which have to be deleted"""
    where: quest_completion_bool_exp!
  ): quest_completion_mutation_response

  """
  delete single row from the table: "quest_completion"
  """
  delete_quest_completion_by_pk(id: uuid!): quest_completion

  """
  delete data from the table: "quest_skill"
  """
  delete_quest_skill(
    """filter the rows which have to be deleted"""
    where: quest_skill_bool_exp!
  ): quest_skill_mutation_response

  """
  delete single row from the table: "quest_skill"
  """
  delete_quest_skill_by_pk(quest_id: uuid!, skill_id: uuid!): quest_skill

  """
  delete data from the table: "skill"
  """
  delete_skill(
    """filter the rows which have to be deleted"""
    where: skill_bool_exp!
  ): skill_mutation_response

  """
  delete single row from the table: "skill"
  """
  delete_skill_by_pk(id: uuid!): skill

  """
  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 data into the table: "ColorAspect"
  """
  insert_ColorAspect(
    """the rows to be inserted"""
    objects: [ColorAspect_insert_input!]!

    """on conflict condition"""
    on_conflict: ColorAspect_on_conflict
  ): ColorAspect_mutation_response

  """
  insert a single row into the table: "ColorAspect"
  """
  insert_ColorAspect_one(
    """the row to be inserted"""
    object: ColorAspect_insert_input!

    """on conflict condition"""
    on_conflict: ColorAspect_on_conflict
  ): ColorAspect

  """
  insert data into the table: "GuildPosition"
  """
  insert_GuildPosition(
    """the rows to be inserted"""
    objects: [GuildPosition_insert_input!]!

    """on conflict condition"""
    on_conflict: GuildPosition_on_conflict
  ): GuildPosition_mutation_response

  """
  insert a single row into the table: "GuildPosition"
  """
  insert_GuildPosition_one(
    """the row to be inserted"""
    object: GuildPosition_insert_input!

    """on conflict condition"""
    on_conflict: GuildPosition_on_conflict
  ): GuildPosition

  """
  insert data into the table: "GuildStatus"
  """
  insert_GuildStatus(
    """the rows to be inserted"""
    objects: [GuildStatus_insert_input!]!

    """on conflict condition"""
    on_conflict: GuildStatus_on_conflict
  ): GuildStatus_mutation_response

  """
  insert a single row into the table: "GuildStatus"
  """
  insert_GuildStatus_one(
    """the row to be inserted"""
    object: GuildStatus_insert_input!

    """on conflict condition"""
    on_conflict: GuildStatus_on_conflict
  ): GuildStatus

  """
  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 data into the table: "PlayerRank"
  """
  insert_PlayerRank(
    """the rows to be inserted"""
    objects: [PlayerRank_insert_input!]!

    """on conflict condition"""
    on_conflict: PlayerRank_on_conflict
  ): PlayerRank_mutation_response

  """
  insert a single row into the table: "PlayerRank"
  """
  insert_PlayerRank_one(
    """the row to be inserted"""
    object: PlayerRank_insert_input!

    """on conflict condition"""
    on_conflict: PlayerRank_on_conflict
  ): PlayerRank

  """
  insert data into the table: "PlayerRole"
  """
  insert_PlayerRole(
    """the rows to be inserted"""
    objects: [PlayerRole_insert_input!]!

    """on conflict condition"""
    on_conflict: PlayerRole_on_conflict
  ): PlayerRole_mutation_response

  """
  insert a single row into the table: "PlayerRole"
  """
  insert_PlayerRole_one(
    """the row to be inserted"""
    object: PlayerRole_insert_input!

    """on conflict condition"""
    on_conflict: PlayerRole_on_conflict
  ): PlayerRole

  """
  insert data into the table: "QuestCompletionStatus"
  """
  insert_QuestCompletionStatus(
    """the rows to be inserted"""
    objects: [QuestCompletionStatus_insert_input!]!

    """on conflict condition"""
    on_conflict: QuestCompletionStatus_on_conflict
  ): QuestCompletionStatus_mutation_response

  """
  insert a single row into the table: "QuestCompletionStatus"
  """
  insert_QuestCompletionStatus_one(
    """the row to be inserted"""
    object: QuestCompletionStatus_insert_input!

    """on conflict condition"""
    on_conflict: QuestCompletionStatus_on_conflict
  ): QuestCompletionStatus

  """
  insert data into the table: "QuestRepetition"
  """
  insert_QuestRepetition(
    """the rows to be inserted"""
    objects: [QuestRepetition_insert_input!]!

    """on conflict condition"""
    on_conflict: QuestRepetition_on_conflict
  ): QuestRepetition_mutation_response

  """
  insert a single row into the table: "QuestRepetition"
  """
  insert_QuestRepetition_one(
    """the row to be inserted"""
    object: QuestRepetition_insert_input!

    """on conflict condition"""
    on_conflict: QuestRepetition_on_conflict
  ): QuestRepetition

  """
  insert data into the table: "QuestStatus"
  """
  insert_QuestStatus(
    """the rows to be inserted"""
    objects: [QuestStatus_insert_input!]!

    """on conflict condition"""
    on_conflict: QuestStatus_on_conflict
  ): QuestStatus_mutation_response

  """
  insert a single row into the table: "QuestStatus"
  """
  insert_QuestStatus_one(
    """the row to be inserted"""
    object: QuestStatus_insert_input!

    """on conflict condition"""
    on_conflict: QuestStatus_on_conflict
  ): QuestStatus

  """
  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 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: "guild_metadata"
  """
  insert_guild_metadata(
    """the rows to be inserted"""
    objects: [guild_metadata_insert_input!]!

    """on conflict condition"""
    on_conflict: guild_metadata_on_conflict
  ): guild_metadata_mutation_response

  """
  insert a single row into the table: "guild_metadata"
  """
  insert_guild_metadata_one(
    """the row to be inserted"""
    object: guild_metadata_insert_input!

    """on conflict condition"""
    on_conflict: guild_metadata_on_conflict
  ): guild_metadata

  """
  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: "guild_player"
  """
  insert_guild_player(
    """the rows to be inserted"""
    objects: [guild_player_insert_input!]!

    """on conflict condition"""
    on_conflict: guild_player_on_conflict
  ): guild_player_mutation_response

  """
  insert a single row into the table: "guild_player"
  """
  insert_guild_player_one(
    """the row to be inserted"""
    object: guild_player_insert_input!

    """on conflict condition"""
    on_conflict: guild_player_on_conflict
  ): guild_player

  """
  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

  """
  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: "player_account"
  """
  insert_player_account(
    """the rows to be inserted"""
    objects: [player_account_insert_input!]!

    """on conflict condition"""
    on_conflict: player_account_on_conflict
  ): player_account_mutation_response

  """
  insert a single row into the table: "player_account"
  """
  insert_player_account_one(
    """the row to be inserted"""
    object: player_account_insert_input!

    """on conflict condition"""
    on_conflict: player_account_on_conflict
  ): player_account

  """
  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: "player_role"
  """
  insert_player_role(
    """the rows to be inserted"""
    objects: [player_role_insert_input!]!

    """on conflict condition"""
    on_conflict: player_role_on_conflict
  ): player_role_mutation_response

  """
  insert a single row into the table: "player_role"
  """
  insert_player_role_one(
    """the row to be inserted"""
    object: player_role_insert_input!

    """on conflict condition"""
    on_conflict: player_role_on_conflict
  ): player_role

  """
  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 data into the table: "player_type"
  """
  insert_player_type(
    """the rows to be inserted"""
    objects: [player_type_insert_input!]!

    """on conflict condition"""
    on_conflict: player_type_on_conflict
  ): player_type_mutation_response

  """
  insert a single row into the table: "player_type"
  """
  insert_player_type_one(
    """the row to be inserted"""
    object: player_type_insert_input!

    """on conflict condition"""
    on_conflict: player_type_on_conflict
  ): player_type

  """
  insert data into the table: "profile_cache"
  """
  insert_profile_cache(
    """the rows to be inserted"""
    objects: [profile_cache_insert_input!]!

    """on conflict condition"""
    on_conflict: profile_cache_on_conflict
  ): profile_cache_mutation_response

  """
  insert a single row into the table: "profile_cache"
  """
  insert_profile_cache_one(
    """the row to be inserted"""
    object: profile_cache_insert_input!

    """on conflict condition"""
    on_conflict: profile_cache_on_conflict
  ): profile_cache

  """
  insert data into the table: "quest"
  """
  insert_quest(
    """the rows to be inserted"""
    objects: [quest_insert_input!]!

    """on conflict condition"""
    on_conflict: quest_on_conflict
  ): quest_mutation_response

  """
  insert data into the table: "quest_completion"
  """
  insert_quest_completion(
    """the rows to be inserted"""
    objects: [quest_completion_insert_input!]!

    """on conflict condition"""
    on_conflict: quest_completion_on_conflict
  ): quest_completion_mutation_response

  """
  insert a single row into the table: "quest_completion"
  """
  insert_quest_completion_one(
    """the row to be inserted"""
    object: quest_completion_insert_input!

    """on conflict condition"""
    on_conflict: quest_completion_on_conflict
  ): quest_completion

  """
  insert a single row into the table: "quest"
  """
  insert_quest_one(
    """the row to be inserted"""
    object: quest_insert_input!

    """on conflict condition"""
    on_conflict: quest_on_conflict
  ): quest

  """
  insert data into the table: "quest_skill"
  """
  insert_quest_skill(
    """the rows to be inserted"""
    objects: [quest_skill_insert_input!]!

    """on conflict condition"""
    on_conflict: quest_skill_on_conflict
  ): quest_skill_mutation_response

  """
  insert a single row into the table: "quest_skill"
  """
  insert_quest_skill_one(
    """the row to be inserted"""
    object: quest_skill_insert_input!

    """on conflict condition"""
    on_conflict: quest_skill_on_conflict
  ): quest_skill

  """
  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 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

  """
  perform the action: "saveGuildInformation"
  """
  saveGuildInformation(guildInformation: GuildInfo!): SaveGuildResponse

  """
  perform the action: "updateExpiredIDXProfiles"
  """
  updateExpiredIDXProfiles: ExpiredPlayerProfiles

  """
  perform the action: "updateIDXProfile"
  """
  updateIDXProfile(playerId: uuid): CacheProcessOutput

  """
  perform the action: "updateQuestCompletion"
  """
  updateQuestCompletion(updateData: UpdateQuestCompletionInput!): UpdateQuestCompletionOutput

  """
  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: "ColorAspect"
  """
  update_ColorAspect(
    """increments the integer columns with given value of the filtered values"""
    _inc: ColorAspect_inc_input

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

    """filter the rows which have to be updated"""
    where: ColorAspect_bool_exp!
  ): ColorAspect_mutation_response

  """
  update single row of the table: "ColorAspect"
  """
  update_ColorAspect_by_pk(
    """increments the integer columns with given value of the filtered values"""
    _inc: ColorAspect_inc_input

    """sets the columns of the filtered rows to the given values"""
    _set: ColorAspect_set_input
    pk_columns: ColorAspect_pk_columns_input!
  ): ColorAspect

  """
  update data of the table: "GuildPosition"
  """
  update_GuildPosition(
    """sets the columns of the filtered rows to the given values"""
    _set: GuildPosition_set_input

    """filter the rows which have to be updated"""
    where: GuildPosition_bool_exp!
  ): GuildPosition_mutation_response

  """
  update single row of the table: "GuildPosition"
  """
  update_GuildPosition_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: GuildPosition_set_input
    pk_columns: GuildPosition_pk_columns_input!
  ): GuildPosition

  """
  update data of the table: "GuildStatus"
  """
  update_GuildStatus(
    """sets the columns of the filtered rows to the given values"""
    _set: GuildStatus_set_input

    """filter the rows which have to be updated"""
    where: GuildStatus_bool_exp!
  ): GuildStatus_mutation_response

  """
  update single row of the table: "GuildStatus"
  """
  update_GuildStatus_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: GuildStatus_set_input
    pk_columns: GuildStatus_pk_columns_input!
  ): GuildStatus

  """
  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 data of the table: "PlayerRank"
  """
  update_PlayerRank(
    """sets the columns of the filtered rows to the given values"""
    _set: PlayerRank_set_input

    """filter the rows which have to be updated"""
    where: PlayerRank_bool_exp!
  ): PlayerRank_mutation_response

  """
  update single row of the table: "PlayerRank"
  """
  update_PlayerRank_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: PlayerRank_set_input
    pk_columns: PlayerRank_pk_columns_input!
  ): PlayerRank

  """
  update data of the table: "PlayerRole"
  """
  update_PlayerRole(
    """sets the columns of the filtered rows to the given values"""
    _set: PlayerRole_set_input

    """filter the rows which have to be updated"""
    where: PlayerRole_bool_exp!
  ): PlayerRole_mutation_response

  """
  update single row of the table: "PlayerRole"
  """
  update_PlayerRole_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: PlayerRole_set_input
    pk_columns: PlayerRole_pk_columns_input!
  ): PlayerRole

  """
  update data of the table: "QuestCompletionStatus"
  """
  update_QuestCompletionStatus(
    """sets the columns of the filtered rows to the given values"""
    _set: QuestCompletionStatus_set_input

    """filter the rows which have to be updated"""
    where: QuestCompletionStatus_bool_exp!
  ): QuestCompletionStatus_mutation_response

  """
  update single row of the table: "QuestCompletionStatus"
  """
  update_QuestCompletionStatus_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: QuestCompletionStatus_set_input
    pk_columns: QuestCompletionStatus_pk_columns_input!
  ): QuestCompletionStatus

  """
  update data of the table: "QuestRepetition"
  """
  update_QuestRepetition(
    """sets the columns of the filtered rows to the given values"""
    _set: QuestRepetition_set_input

    """filter the rows which have to be updated"""
    where: QuestRepetition_bool_exp!
  ): QuestRepetition_mutation_response

  """
  update single row of the table: "QuestRepetition"
  """
  update_QuestRepetition_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: QuestRepetition_set_input
    pk_columns: QuestRepetition_pk_columns_input!
  ): QuestRepetition

  """
  update data of the table: "QuestStatus"
  """
  update_QuestStatus(
    """sets the columns of the filtered rows to the given values"""
    _set: QuestStatus_set_input

    """filter the rows which have to be updated"""
    where: QuestStatus_bool_exp!
  ): QuestStatus_mutation_response

  """
  update single row of the table: "QuestStatus"
  """
  update_QuestStatus_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: QuestStatus_set_input
    pk_columns: QuestStatus_pk_columns_input!
  ): QuestStatus

  """
  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 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 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: "guild_metadata"
  """
  update_guild_metadata(
    """append existing jsonb value of filtered columns with new jsonb value"""
    _append: guild_metadata_append_input

    """
    delete the field or element with specified path (for JSON arrays, negative integers count from the end)
    """
    _delete_at_path: guild_metadata_delete_at_path_input

    """
    delete the array element with specified index (negative integers count from
    the end). throws an error if top level container is not an array
    """
    _delete_elem: guild_metadata_delete_elem_input

    """
    delete key/value pair or string element. key/value pairs are matched based on their key value
    """
    _delete_key: guild_metadata_delete_key_input

    """prepend existing jsonb value of filtered columns with new jsonb value"""
    _prepend: guild_metadata_prepend_input

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

    """filter the rows which have to be updated"""
    where: guild_metadata_bool_exp!
  ): guild_metadata_mutation_response

  """
  update single row of the table: "guild_metadata"
  """
  update_guild_metadata_by_pk(
    """append existing jsonb value of filtered columns with new jsonb value"""
    _append: guild_metadata_append_input

    """
    delete the field or element with specified path (for JSON arrays, negative integers count from the end)
    """
    _delete_at_path: guild_metadata_delete_at_path_input

    """
    delete the array element with specified index (negative integers count from
    the end). throws an error if top level container is not an array
    """
    _delete_elem: guild_metadata_delete_elem_input

    """
    delete key/value pair or string element. key/value pairs are matched based on their key value
    """
    _delete_key: guild_metadata_delete_key_input

    """prepend existing jsonb value of filtered columns with new jsonb value"""
    _prepend: guild_metadata_prepend_input

    """sets the columns of the filtered rows to the given values"""
    _set: guild_metadata_set_input
    pk_columns: guild_metadata_pk_columns_input!
  ): guild_metadata

  """
  update data of the table: "guild_player"
  """
  update_guild_player(
    """sets the columns of the filtered rows to the given values"""
    _set: guild_player_set_input

    """filter the rows which have to be updated"""
    where: guild_player_bool_exp!
  ): guild_player_mutation_response

  """
  update single row of the table: "guild_player"
  """
  update_guild_player_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: guild_player_set_input
    pk_columns: guild_player_pk_columns_input!
  ): guild_player

  """
  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

  """
  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: "player_account"
  """
  update_player_account(
    """sets the columns of the filtered rows to the given values"""
    _set: player_account_set_input

    """filter the rows which have to be updated"""
    where: player_account_bool_exp!
  ): player_account_mutation_response

  """
  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: "player_role"
  """
  update_player_role(
    """increments the integer columns with given value of the filtered values"""
    _inc: player_role_inc_input

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

    """filter the rows which have to be updated"""
    where: player_role_bool_exp!
  ): player_role_mutation_response

  """
  update single row of the table: "player_role"
  """
  update_player_role_by_pk(
    """increments the integer columns with given value of the filtered values"""
    _inc: player_role_inc_input

    """sets the columns of the filtered rows to the given values"""
    _set: player_role_set_input
    pk_columns: player_role_pk_columns_input!
  ): player_role

  """
  update data of the table: "player_skill"
  """
  update_player_skill(
    """increments the integer columns with given value of the filtered values"""
    _inc: player_skill_inc_input

    """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(
    """increments the integer columns with given value of the filtered values"""
    _inc: player_skill_inc_input

    """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 data of the table: "player_type"
  """
  update_player_type(
    """increments the integer columns with given value of the filtered values"""
    _inc: player_type_inc_input

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

    """filter the rows which have to be updated"""
    where: player_type_bool_exp!
  ): player_type_mutation_response

  """
  update single row of the table: "player_type"
  """
  update_player_type_by_pk(
    """increments the integer columns with given value of the filtered values"""
    _inc: player_type_inc_input

    """sets the columns of the filtered rows to the given values"""
    _set: player_type_set_input
    pk_columns: player_type_pk_columns_input!
  ): player_type

  """
  update data of the table: "profile_cache"
  """
  update_profile_cache(
    """sets the columns of the filtered rows to the given values"""
    _set: profile_cache_set_input

    """filter the rows which have to be updated"""
    where: profile_cache_bool_exp!
  ): profile_cache_mutation_response

  """
  update single row of the table: "profile_cache"
  """
  update_profile_cache_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: profile_cache_set_input
    pk_columns: profile_cache_pk_columns_input!
  ): profile_cache

  """
  update data of the table: "quest"
  """
  update_quest(
    """increments the integer columns with given value of the filtered values"""
    _inc: quest_inc_input

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

    """filter the rows which have to be updated"""
    where: quest_bool_exp!
  ): quest_mutation_response

  """
  update single row of the table: "quest"
  """
  update_quest_by_pk(
    """increments the integer columns with given value of the filtered values"""
    _inc: quest_inc_input

    """sets the columns of the filtered rows to the given values"""
    _set: quest_set_input
    pk_columns: quest_pk_columns_input!
  ): quest

  """
  update data of the table: "quest_completion"
  """
  update_quest_completion(
    """sets the columns of the filtered rows to the given values"""
    _set: quest_completion_set_input

    """filter the rows which have to be updated"""
    where: quest_completion_bool_exp!
  ): quest_completion_mutation_response

  """
  update single row of the table: "quest_completion"
  """
  update_quest_completion_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: quest_completion_set_input
    pk_columns: quest_completion_pk_columns_input!
  ): quest_completion

  """
  update data of the table: "quest_skill"
  """
  update_quest_skill(
    """sets the columns of the filtered rows to the given values"""
    _set: quest_skill_set_input

    """filter the rows which have to be updated"""
    where: quest_skill_bool_exp!
  ): quest_skill_mutation_response

  """
  update single row of the table: "quest_skill"
  """
  update_quest_skill_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: quest_skill_set_input
    pk_columns: quest_skill_pk_columns_input!
  ): quest_skill

  """
  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 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
}

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: [player_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: [player_account_order_by!]

    """filter the rows returned"""
    where: player_account_bool_exp
  ): [player_account!]!

  """An aggregated array relationship"""
  accounts_aggregate(
    """distinct select on columns"""
    distinct_on: [player_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: [player_account_order_by!]

    """filter the rows returned"""
    where: player_account_bool_exp
  ): player_account_aggregate!
  availability_hours: Int

  """Remote relationship field"""
  box_profile: BoxProfile

  """Remote relationship field"""
  brightid_status: BrightIdStatus

  """An object relationship"""
  color_aspect: ColorAspect
  color_mask: Int
  created_at: timestamptz

  """Remote relationship field"""
  daohausMemberships: [Member!]!
  discord_id: String
  ethereum_address: String!

  """An array relationship"""
  guilds(
    """distinct select on columns"""
    distinct_on: [guild_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: [guild_player_order_by!]

    """filter the rows returned"""
    where: guild_player_bool_exp
  ): [guild_player!]!

  """An aggregated array relationship"""
  guilds_aggregate(
    """distinct select on columns"""
    distinct_on: [guild_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: [guild_player_order_by!]

    """filter the rows returned"""
    where: guild_player_bool_exp
  ): guild_player_aggregate!
  id: uuid!
  player_type_id: Int

  """An object relationship"""
  profile_cache: profile_cache
  pronouns: String

  """An array relationship"""
  quest_completions(
    """distinct select on columns"""
    distinct_on: [quest_completion_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: [quest_completion_order_by!]

    """filter the rows returned"""
    where: quest_completion_bool_exp
  ): [quest_completion!]!

  """An aggregated array relationship"""
  quest_completions_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_completion_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: [quest_completion_order_by!]

    """filter the rows returned"""
    where: quest_completion_bool_exp
  ): quest_completion_aggregate!

  """An array relationship"""
  quests(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_order_by!]

    """filter the rows returned"""
    where: quest_bool_exp
  ): [quest!]!

  """An aggregated array relationship"""
  quests_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_order_by!]

    """filter the rows returned"""
    where: quest_bool_exp
  ): quest_aggregate!
  rank: PlayerRank_enum
  role: String

  """An array relationship"""
  roles(
    """distinct select on columns"""
    distinct_on: [player_role_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_role_order_by!]

    """filter the rows returned"""
    where: player_role_bool_exp
  ): [player_role!]!

  """An aggregated array relationship"""
  roles_aggregate(
    """distinct select on columns"""
    distinct_on: [player_role_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_role_order_by!]

    """filter the rows returned"""
    where: player_role_bool_exp
  ): player_role_aggregate!
  season_xp: numeric!

  """An array relationship"""
  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"""
  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!
  timezone: String

  """Remote relationship field"""
  token_balances: TokenBalances
  total_xp: numeric

  """An object relationship"""
  type: player_type
  updated_at: timestamptz
  username: String!
}

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

"""
aggregated selection of "player_account"
"""
type player_account_aggregate {
  aggregate: player_account_aggregate_fields
  nodes: [player_account!]!
}

"""
aggregate fields of "player_account"
"""
type player_account_aggregate_fields {
  count(columns: [player_account_select_column!], distinct: Boolean): Int
  max: player_account_max_fields
  min: player_account_min_fields
}

"""
order by aggregate values of table "player_account"
"""
input player_account_aggregate_order_by {
  count: order_by
  max: player_account_max_order_by
  min: player_account_min_order_by
}

"""
input type for inserting array relation for remote table "player_account"
"""
input player_account_arr_rel_insert_input {
  data: [player_account_insert_input!]!
  on_conflict: player_account_on_conflict
}

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

"""
unique or primary key constraints on table "player_account"
"""
enum player_account_constraint {
  """unique or primary key constraint"""
  Account_identifier_type_key
}

"""
input type for inserting data into table "player_account"
"""
input player_account_insert_input {
  Player: player_obj_rel_insert_input
  identifier: String
  player_id: uuid
  type: AccountType_enum
}

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

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

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

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

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

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

"""
input type for inserting object relation for remote table "player_account"
"""
input player_account_obj_rel_insert_input {
  data: player_account_insert_input!
  on_conflict: player_account_on_conflict
}

"""
on conflict condition type for table "player_account"
"""
input player_account_on_conflict {
  constraint: player_account_constraint!
  update_columns: [player_account_update_column!]!
  where: player_account_bool_exp
}

"""
ordering options when selecting data from "player_account"
"""
input player_account_order_by {
  Player: player_order_by
  identifier: order_by
  player_id: order_by
  type: order_by
}

"""
select columns of table "player_account"
"""
enum player_account_select_column {
  """column name"""
  identifier

  """column name"""
  player_id

  """column name"""
  type
}

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

"""
update columns of table "player_account"
"""
enum player_account_update_column {
  """column name"""
  identifier

  """column name"""
  player_id

  """column name"""
  type
}

"""
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
  color_mask: Float
  player_type_id: Float
  season_xp: Float
  total_xp: Float
}

"""
order by avg() on columns of table "player"
"""
input player_avg_order_by {
  availability_hours: order_by
  color_mask: order_by
  player_type_id: order_by
  season_xp: order_by
  total_xp: order_by
}

"""
Boolean expression to filter rows from the table "player". All fields are combined with a logical 'AND'.
"""
input player_bool_exp {
  _and: [player_bool_exp]
  _not: player_bool_exp
  _or: [player_bool_exp]
  accounts: player_account_bool_exp
  availability_hours: Int_comparison_exp
  color_aspect: ColorAspect_bool_exp
  color_mask: Int_comparison_exp
  created_at: timestamptz_comparison_exp
  discord_id: String_comparison_exp
  ethereum_address: String_comparison_exp
  guilds: guild_player_bool_exp
  id: uuid_comparison_exp
  player_type_id: Int_comparison_exp
  profile_cache: profile_cache_bool_exp
  pronouns: String_comparison_exp
  quest_completions: quest_completion_bool_exp
  quests: quest_bool_exp
  rank: PlayerRank_enum_comparison_exp
  role: String_comparison_exp
  roles: player_role_bool_exp
  season_xp: numeric_comparison_exp
  skills: player_skill_bool_exp
  timezone: String_comparison_exp
  total_xp: numeric_comparison_exp
  type: player_type_bool_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_username_unique_key

  """unique or primary key constraint"""
  player_discord_id_key
}

"""
input type for incrementing integer column in table "player"
"""
input player_inc_input {
  availability_hours: Int
  color_mask: Int
  player_type_id: Int
  season_xp: numeric
  total_xp: numeric
}

"""
input type for inserting data into table "player"
"""
input player_insert_input {
  accounts: player_account_arr_rel_insert_input
  availability_hours: Int
  color_aspect: ColorAspect_obj_rel_insert_input
  color_mask: Int
  created_at: timestamptz
  discord_id: String
  ethereum_address: String
  guilds: guild_player_arr_rel_insert_input
  id: uuid
  player_type_id: Int
  profile_cache: profile_cache_obj_rel_insert_input
  pronouns: String
  quest_completions: quest_completion_arr_rel_insert_input
  quests: quest_arr_rel_insert_input
  rank: PlayerRank_enum
  role: String
  roles: player_role_arr_rel_insert_input
  season_xp: numeric
  skills: player_skill_arr_rel_insert_input
  timezone: String
  total_xp: numeric
  type: player_type_obj_rel_insert_input
  updated_at: timestamptz
  username: String
}

"""aggregate max on columns"""
type player_max_fields {
  availability_hours: Int
  color_mask: Int
  created_at: timestamptz
  discord_id: String
  ethereum_address: String
  id: uuid
  player_type_id: Int
  pronouns: String
  role: String
  season_xp: numeric
  timezone: String
  total_xp: numeric
  updated_at: timestamptz
  username: String
}

"""
order by max() on columns of table "player"
"""
input player_max_order_by {
  availability_hours: order_by
  color_mask: order_by
  created_at: order_by
  discord_id: order_by
  ethereum_address: order_by
  id: order_by
  player_type_id: order_by
  pronouns: order_by
  role: order_by
  season_xp: order_by
  timezone: order_by
  total_xp: order_by
  updated_at: order_by
  username: order_by
}

"""aggregate min on columns"""
type player_min_fields {
  availability_hours: Int
  color_mask: Int
  created_at: timestamptz
  discord_id: String
  ethereum_address: String
  id: uuid
  player_type_id: Int
  pronouns: String
  role: String
  season_xp: numeric
  timezone: String
  total_xp: numeric
  updated_at: timestamptz
  username: String
}

"""
order by min() on columns of table "player"
"""
input player_min_order_by {
  availability_hours: order_by
  color_mask: order_by
  created_at: order_by
  discord_id: order_by
  ethereum_address: order_by
  id: order_by
  player_type_id: order_by
  pronouns: order_by
  role: order_by
  season_xp: order_by
  timezone: order_by
  total_xp: 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: player_account_aggregate_order_by
  availability_hours: order_by
  color_aspect: ColorAspect_order_by
  color_mask: order_by
  created_at: order_by
  discord_id: order_by
  ethereum_address: order_by
  guilds_aggregate: guild_player_aggregate_order_by
  id: order_by
  player_type_id: order_by
  profile_cache: profile_cache_order_by
  pronouns: order_by
  quest_completions_aggregate: quest_completion_aggregate_order_by
  quests_aggregate: quest_aggregate_order_by
  rank: order_by
  role: order_by
  roles_aggregate: player_role_aggregate_order_by
  season_xp: order_by
  skills_aggregate: player_skill_aggregate_order_by
  timezone: order_by
  total_xp: order_by
  type: player_type_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_role"
"""
type player_role {
  """An object relationship"""
  PlayerRole: PlayerRole!
  player_id: uuid!
  rank: Int!
  role: String!
}

"""
aggregated selection of "player_role"
"""
type player_role_aggregate {
  aggregate: player_role_aggregate_fields
  nodes: [player_role!]!
}

"""
aggregate fields of "player_role"
"""
type player_role_aggregate_fields {
  avg: player_role_avg_fields
  count(columns: [player_role_select_column!], distinct: Boolean): Int
  max: player_role_max_fields
  min: player_role_min_fields
  stddev: player_role_stddev_fields
  stddev_pop: player_role_stddev_pop_fields
  stddev_samp: player_role_stddev_samp_fields
  sum: player_role_sum_fields
  var_pop: player_role_var_pop_fields
  var_samp: player_role_var_samp_fields
  variance: player_role_variance_fields
}

"""
order by aggregate values of table "player_role"
"""
input player_role_aggregate_order_by {
  avg: player_role_avg_order_by
  count: order_by
  max: player_role_max_order_by
  min: player_role_min_order_by
  stddev: player_role_stddev_order_by
  stddev_pop: player_role_stddev_pop_order_by
  stddev_samp: player_role_stddev_samp_order_by
  sum: player_role_sum_order_by
  var_pop: player_role_var_pop_order_by
  var_samp: player_role_var_samp_order_by
  variance: player_role_variance_order_by
}

"""
input type for inserting array relation for remote table "player_role"
"""
input player_role_arr_rel_insert_input {
  data: [player_role_insert_input!]!
  on_conflict: player_role_on_conflict
}

"""aggregate avg on columns"""
type player_role_avg_fields {
  rank: Float
}

"""
order by avg() on columns of table "player_role"
"""
input player_role_avg_order_by {
  rank: order_by
}

"""
Boolean expression to filter rows from the table "player_role". All fields are combined with a logical 'AND'.
"""
input player_role_bool_exp {
  PlayerRole: PlayerRole_bool_exp
  _and: [player_role_bool_exp]
  _not: player_role_bool_exp
  _or: [player_role_bool_exp]
  player_id: uuid_comparison_exp
  rank: Int_comparison_exp
  role: String_comparison_exp
}

"""
unique or primary key constraints on table "player_role"
"""
enum player_role_constraint {
  """unique or primary key constraint"""
  player_role_pkey
}

"""
input type for incrementing integer column in table "player_role"
"""
input player_role_inc_input {
  rank: Int
}

"""
input type for inserting data into table "player_role"
"""
input player_role_insert_input {
  PlayerRole: PlayerRole_obj_rel_insert_input
  player_id: uuid
  rank: Int
  role: String
}

"""aggregate max on columns"""
type player_role_max_fields {
  player_id: uuid
  rank: Int
  role: String
}

"""
order by max() on columns of table "player_role"
"""
input player_role_max_order_by {
  player_id: order_by
  rank: order_by
  role: order_by
}

"""aggregate min on columns"""
type player_role_min_fields {
  player_id: uuid
  rank: Int
  role: String
}

"""
order by min() on columns of table "player_role"
"""
input player_role_min_order_by {
  player_id: order_by
  rank: order_by
  role: order_by
}

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

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

"""
input type for inserting object relation for remote table "player_role"
"""
input player_role_obj_rel_insert_input {
  data: player_role_insert_input!
  on_conflict: player_role_on_conflict
}

"""
on conflict condition type for table "player_role"
"""
input player_role_on_conflict {
  constraint: player_role_constraint!
  update_columns: [player_role_update_column!]!
  where: player_role_bool_exp
}

"""
ordering options when selecting data from "player_role"
"""
input player_role_order_by {
  PlayerRole: PlayerRole_order_by
  player_id: order_by
  rank: order_by
  role: order_by
}

"""
primary key columns input for table: "player_role"
"""
input player_role_pk_columns_input {
  player_id: uuid!
  role: String!
}

"""
select columns of table "player_role"
"""
enum player_role_select_column {
  """column name"""
  player_id

  """column name"""
  rank

  """column name"""
  role
}

"""
input type for updating data in table "player_role"
"""
input player_role_set_input {
  player_id: uuid
  rank: Int
  role: String
}

"""aggregate stddev on columns"""
type player_role_stddev_fields {
  rank: Float
}

"""
order by stddev() on columns of table "player_role"
"""
input player_role_stddev_order_by {
  rank: order_by
}

"""aggregate stddev_pop on columns"""
type player_role_stddev_pop_fields {
  rank: Float
}

"""
order by stddev_pop() on columns of table "player_role"
"""
input player_role_stddev_pop_order_by {
  rank: order_by
}

"""aggregate stddev_samp on columns"""
type player_role_stddev_samp_fields {
  rank: Float
}

"""
order by stddev_samp() on columns of table "player_role"
"""
input player_role_stddev_samp_order_by {
  rank: order_by
}

"""aggregate sum on columns"""
type player_role_sum_fields {
  rank: Int
}

"""
order by sum() on columns of table "player_role"
"""
input player_role_sum_order_by {
  rank: order_by
}

"""
update columns of table "player_role"
"""
enum player_role_update_column {
  """column name"""
  player_id

  """column name"""
  rank

  """column name"""
  role
}

"""aggregate var_pop on columns"""
type player_role_var_pop_fields {
  rank: Float
}

"""
order by var_pop() on columns of table "player_role"
"""
input player_role_var_pop_order_by {
  rank: order_by
}

"""aggregate var_samp on columns"""
type player_role_var_samp_fields {
  rank: Float
}

"""
order by var_samp() on columns of table "player_role"
"""
input player_role_var_samp_order_by {
  rank: order_by
}

"""aggregate variance on columns"""
type player_role_variance_fields {
  rank: Float
}

"""
order by variance() on columns of table "player_role"
"""
input player_role_variance_order_by {
  rank: order_by
}

"""
select columns of table "player"
"""
enum player_select_column {
  """column name"""
  availability_hours

  """column name"""
  color_mask

  """column name"""
  created_at

  """column name"""
  discord_id

  """column name"""
  ethereum_address

  """column name"""
  id

  """column name"""
  player_type_id

  """column name"""
  pronouns

  """column name"""
  rank

  """column name"""
  role

  """column name"""
  season_xp

  """column name"""
  timezone

  """column name"""
  total_xp

  """column name"""
  updated_at

  """column name"""
  username
}

"""
input type for updating data in table "player"
"""
input player_set_input {
  availability_hours: Int
  color_mask: Int
  created_at: timestamptz
  discord_id: String
  ethereum_address: String
  id: uuid
  player_type_id: Int
  pronouns: String
  rank: PlayerRank_enum
  role: String
  season_xp: numeric
  timezone: String
  total_xp: numeric
  updated_at: timestamptz
  username: String
}

"""
columns and relationships of "player_skill"
"""
type player_skill {
  """An object relationship"""
  Skill: skill!
  id: uuid!
  player_id: uuid!
  rank: Int
  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 {
  avg: player_skill_avg_fields
  count(columns: [player_skill_select_column!], distinct: Boolean): Int
  max: player_skill_max_fields
  min: player_skill_min_fields
  stddev: player_skill_stddev_fields
  stddev_pop: player_skill_stddev_pop_fields
  stddev_samp: player_skill_stddev_samp_fields
  sum: player_skill_sum_fields
  var_pop: player_skill_var_pop_fields
  var_samp: player_skill_var_samp_fields
  variance: player_skill_variance_fields
}

"""
order by aggregate values of table "player_skill"
"""
input player_skill_aggregate_order_by {
  avg: player_skill_avg_order_by
  count: order_by
  max: player_skill_max_order_by
  min: player_skill_min_order_by
  stddev: player_skill_stddev_order_by
  stddev_pop: player_skill_stddev_pop_order_by
  stddev_samp: player_skill_stddev_samp_order_by
  sum: player_skill_sum_order_by
  var_pop: player_skill_var_pop_order_by
  var_samp: player_skill_var_samp_order_by
  variance: player_skill_variance_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
}

"""aggregate avg on columns"""
type player_skill_avg_fields {
  rank: Float
}

"""
order by avg() on columns of table "player_skill"
"""
input player_skill_avg_order_by {
  rank: order_by
}

"""
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]
  id: uuid_comparison_exp
  player_id: uuid_comparison_exp
  rank: Int_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_pkey
}

"""
input type for incrementing integer column in table "player_skill"
"""
input player_skill_inc_input {
  rank: Int
}

"""
input type for inserting data into table "player_skill"
"""
input player_skill_insert_input {
  Skill: skill_obj_rel_insert_input
  id: uuid
  player_id: uuid
  rank: Int
  skill_id: uuid
}

"""aggregate max on columns"""
type player_skill_max_fields {
  id: uuid
  player_id: uuid
  rank: Int
  skill_id: uuid
}

"""
order by max() on columns of table "player_skill"
"""
input player_skill_max_order_by {
  id: order_by
  player_id: order_by
  rank: order_by
  skill_id: order_by
}

"""aggregate min on columns"""
type player_skill_min_fields {
  id: uuid
  player_id: uuid
  rank: Int
  skill_id: uuid
}

"""
order by min() on columns of table "player_skill"
"""
input player_skill_min_order_by {
  id: order_by
  player_id: order_by
  rank: 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
  id: order_by
  player_id: order_by
  rank: order_by
  skill_id: order_by
}

"""
primary key columns input for table: "player_skill"
"""
input player_skill_pk_columns_input {
  id: uuid!
}

"""
select columns of table "player_skill"
"""
enum player_skill_select_column {
  """column name"""
  id

  """column name"""
  player_id

  """column name"""
  rank

  """column name"""
  skill_id
}

"""
input type for updating data in table "player_skill"
"""
input player_skill_set_input {
  id: uuid
  player_id: uuid
  rank: Int
  skill_id: uuid
}

"""aggregate stddev on columns"""
type player_skill_stddev_fields {
  rank: Float
}

"""
order by stddev() on columns of table "player_skill"
"""
input player_skill_stddev_order_by {
  rank: order_by
}

"""aggregate stddev_pop on columns"""
type player_skill_stddev_pop_fields {
  rank: Float
}

"""
order by stddev_pop() on columns of table "player_skill"
"""
input player_skill_stddev_pop_order_by {
  rank: order_by
}

"""aggregate stddev_samp on columns"""
type player_skill_stddev_samp_fields {
  rank: Float
}

"""
order by stddev_samp() on columns of table "player_skill"
"""
input player_skill_stddev_samp_order_by {
  rank: order_by
}

"""aggregate sum on columns"""
type player_skill_sum_fields {
  rank: Int
}

"""
order by sum() on columns of table "player_skill"
"""
input player_skill_sum_order_by {
  rank: order_by
}

"""
update columns of table "player_skill"
"""
enum player_skill_update_column {
  """column name"""
  id

  """column name"""
  player_id

  """column name"""
  rank

  """column name"""
  skill_id
}

"""aggregate var_pop on columns"""
type player_skill_var_pop_fields {
  rank: Float
}

"""
order by var_pop() on columns of table "player_skill"
"""
input player_skill_var_pop_order_by {
  rank: order_by
}

"""aggregate var_samp on columns"""
type player_skill_var_samp_fields {
  rank: Float
}

"""
order by var_samp() on columns of table "player_skill"
"""
input player_skill_var_samp_order_by {
  rank: order_by
}

"""aggregate variance on columns"""
type player_skill_variance_fields {
  rank: Float
}

"""
order by variance() on columns of table "player_skill"
"""
input player_skill_variance_order_by {
  rank: order_by
}

"""aggregate stddev on columns"""
type player_stddev_fields {
  availability_hours: Float
  color_mask: Float
  player_type_id: Float
  season_xp: Float
  total_xp: Float
}

"""
order by stddev() on columns of table "player"
"""
input player_stddev_order_by {
  availability_hours: order_by
  color_mask: order_by
  player_type_id: order_by
  season_xp: order_by
  total_xp: order_by
}

"""aggregate stddev_pop on columns"""
type player_stddev_pop_fields {
  availability_hours: Float
  color_mask: Float
  player_type_id: Float
  season_xp: Float
  total_xp: Float
}

"""
order by stddev_pop() on columns of table "player"
"""
input player_stddev_pop_order_by {
  availability_hours: order_by
  color_mask: order_by
  player_type_id: order_by
  season_xp: order_by
  total_xp: order_by
}

"""aggregate stddev_samp on columns"""
type player_stddev_samp_fields {
  availability_hours: Float
  color_mask: Float
  player_type_id: Float
  season_xp: Float
  total_xp: Float
}

"""
order by stddev_samp() on columns of table "player"
"""
input player_stddev_samp_order_by {
  availability_hours: order_by
  color_mask: order_by
  player_type_id: order_by
  season_xp: order_by
  total_xp: order_by
}

"""aggregate sum on columns"""
type player_sum_fields {
  availability_hours: Int
  color_mask: Int
  player_type_id: Int
  season_xp: numeric
  total_xp: numeric
}

"""
order by sum() on columns of table "player"
"""
input player_sum_order_by {
  availability_hours: order_by
  color_mask: order_by
  player_type_id: order_by
  season_xp: order_by
  total_xp: order_by
}

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

"""
aggregated selection of "player_type"
"""
type player_type_aggregate {
  aggregate: player_type_aggregate_fields
  nodes: [player_type!]!
}

"""
aggregate fields of "player_type"
"""
type player_type_aggregate_fields {
  avg: player_type_avg_fields
  count(columns: [player_type_select_column!], distinct: Boolean): Int
  max: player_type_max_fields
  min: player_type_min_fields
  stddev: player_type_stddev_fields
  stddev_pop: player_type_stddev_pop_fields
  stddev_samp: player_type_stddev_samp_fields
  sum: player_type_sum_fields
  var_pop: player_type_var_pop_fields
  var_samp: player_type_var_samp_fields
  variance: player_type_variance_fields
}

"""
order by aggregate values of table "player_type"
"""
input player_type_aggregate_order_by {
  avg: player_type_avg_order_by
  count: order_by
  max: player_type_max_order_by
  min: player_type_min_order_by
  stddev: player_type_stddev_order_by
  stddev_pop: player_type_stddev_pop_order_by
  stddev_samp: player_type_stddev_samp_order_by
  sum: player_type_sum_order_by
  var_pop: player_type_var_pop_order_by
  var_samp: player_type_var_samp_order_by
  variance: player_type_variance_order_by
}

"""
input type for inserting array relation for remote table "player_type"
"""
input player_type_arr_rel_insert_input {
  data: [player_type_insert_input!]!
  on_conflict: player_type_on_conflict
}

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

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

"""
Boolean expression to filter rows from the table "player_type". All fields are combined with a logical 'AND'.
"""
input player_type_bool_exp {
  _and: [player_type_bool_exp]
  _not: player_type_bool_exp
  _or: [player_type_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 "player_type"
"""
enum player_type_constraint {
  """unique or primary key constraint"""
  PlayerType_pkey

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

"""
input type for incrementing integer column in table "player_type"
"""
input player_type_inc_input {
  id: Int
}

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

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

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

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

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

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

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

"""
input type for inserting object relation for remote table "player_type"
"""
input player_type_obj_rel_insert_input {
  data: player_type_insert_input!
  on_conflict: player_type_on_conflict
}

"""
on conflict condition type for table "player_type"
"""
input player_type_on_conflict {
  constraint: player_type_constraint!
  update_columns: [player_type_update_column!]!
  where: player_type_bool_exp
}

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

"""
primary key columns input for table: "player_type"
"""
input player_type_pk_columns_input {
  id: Int!
}

"""
select columns of table "player_type"
"""
enum player_type_select_column {
  """column name"""
  description

  """column name"""
  id

  """column name"""
  imageUrl

  """column name"""
  title
}

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

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

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

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

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

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

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

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

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

"""
update columns of table "player_type"
"""
enum player_type_update_column {
  """column name"""
  description

  """column name"""
  id

  """column name"""
  imageUrl

  """column name"""
  title
}

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

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

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

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

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

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

"""
update columns of table "player"
"""
enum player_update_column {
  """column name"""
  availability_hours

  """column name"""
  color_mask

  """column name"""
  created_at

  """column name"""
  discord_id

  """column name"""
  ethereum_address

  """column name"""
  id

  """column name"""
  player_type_id

  """column name"""
  pronouns

  """column name"""
  rank

  """column name"""
  role

  """column name"""
  season_xp

  """column name"""
  timezone

  """column name"""
  total_xp

  """column name"""
  updated_at

  """column name"""
  username
}

"""aggregate var_pop on columns"""
type player_var_pop_fields {
  availability_hours: Float
  color_mask: Float
  player_type_id: Float
  season_xp: Float
  total_xp: Float
}

"""
order by var_pop() on columns of table "player"
"""
input player_var_pop_order_by {
  availability_hours: order_by
  color_mask: order_by
  player_type_id: order_by
  season_xp: order_by
  total_xp: order_by
}

"""aggregate var_samp on columns"""
type player_var_samp_fields {
  availability_hours: Float
  color_mask: Float
  player_type_id: Float
  season_xp: Float
  total_xp: Float
}

"""
order by var_samp() on columns of table "player"
"""
input player_var_samp_order_by {
  availability_hours: order_by
  color_mask: order_by
  player_type_id: order_by
  season_xp: order_by
  total_xp: order_by
}

"""aggregate variance on columns"""
type player_variance_fields {
  availability_hours: Float
  color_mask: Float
  player_type_id: Float
  season_xp: Float
  total_xp: Float
}

"""
order by variance() on columns of table "player"
"""
input player_variance_order_by {
  availability_hours: order_by
  color_mask: order_by
  player_type_id: order_by
  season_xp: order_by
  total_xp: order_by
}

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

"""
aggregated selection of "PlayerRank"
"""
type PlayerRank_aggregate {
  aggregate: PlayerRank_aggregate_fields
  nodes: [PlayerRank!]!
}

"""
aggregate fields of "PlayerRank"
"""
type PlayerRank_aggregate_fields {
  count(columns: [PlayerRank_select_column!], distinct: Boolean): Int
  max: PlayerRank_max_fields
  min: PlayerRank_min_fields
}

"""
order by aggregate values of table "PlayerRank"
"""
input PlayerRank_aggregate_order_by {
  count: order_by
  max: PlayerRank_max_order_by
  min: PlayerRank_min_order_by
}

"""
input type for inserting array relation for remote table "PlayerRank"
"""
input PlayerRank_arr_rel_insert_input {
  data: [PlayerRank_insert_input!]!
  on_conflict: PlayerRank_on_conflict
}

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

"""
unique or primary key constraints on table "PlayerRank"
"""
enum PlayerRank_constraint {
  """unique or primary key constraint"""
  Player_Rank_pkey
}

enum PlayerRank_enum {
  BRONZE
  DIAMOND
  GOLD
  PLATINUM
  SILVER
}

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

"""
input type for inserting data into table "PlayerRank"
"""
input PlayerRank_insert_input {
  rank: String
}

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

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

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

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

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

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

"""
input type for inserting object relation for remote table "PlayerRank"
"""
input PlayerRank_obj_rel_insert_input {
  data: PlayerRank_insert_input!
  on_conflict: PlayerRank_on_conflict
}

"""
on conflict condition type for table "PlayerRank"
"""
input PlayerRank_on_conflict {
  constraint: PlayerRank_constraint!
  update_columns: [PlayerRank_update_column!]!
  where: PlayerRank_bool_exp
}

"""
ordering options when selecting data from "PlayerRank"
"""
input PlayerRank_order_by {
  rank: order_by
}

"""
primary key columns input for table: "PlayerRank"
"""
input PlayerRank_pk_columns_input {
  rank: String!
}

"""
select columns of table "PlayerRank"
"""
enum PlayerRank_select_column {
  """column name"""
  rank
}

"""
input type for updating data in table "PlayerRank"
"""
input PlayerRank_set_input {
  rank: String
}

"""
update columns of table "PlayerRank"
"""
enum PlayerRank_update_column {
  """column name"""
  rank
}

"""
columns and relationships of "PlayerRole"
"""
type PlayerRole {
  description: String
  label: String!
  role: String!
}

"""
aggregated selection of "PlayerRole"
"""
type PlayerRole_aggregate {
  aggregate: PlayerRole_aggregate_fields
  nodes: [PlayerRole!]!
}

"""
aggregate fields of "PlayerRole"
"""
type PlayerRole_aggregate_fields {
  count(columns: [PlayerRole_select_column!], distinct: Boolean): Int
  max: PlayerRole_max_fields
  min: PlayerRole_min_fields
}

"""
order by aggregate values of table "PlayerRole"
"""
input PlayerRole_aggregate_order_by {
  count: order_by
  max: PlayerRole_max_order_by
  min: PlayerRole_min_order_by
}

"""
input type for inserting array relation for remote table "PlayerRole"
"""
input PlayerRole_arr_rel_insert_input {
  data: [PlayerRole_insert_input!]!
  on_conflict: PlayerRole_on_conflict
}

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

"""
unique or primary key constraints on table "PlayerRole"
"""
enum PlayerRole_constraint {
  """unique or primary key constraint"""
  PlayerRole_pkey
}

"""
input type for inserting data into table "PlayerRole"
"""
input PlayerRole_insert_input {
  description: String
  label: String
  role: String
}

"""aggregate max on columns"""
type PlayerRole_max_fields {
  description: String
  label: String
  role: String
}

"""
order by max() on columns of table "PlayerRole"
"""
input PlayerRole_max_order_by {
  description: order_by
  label: order_by
  role: order_by
}

"""aggregate min on columns"""
type PlayerRole_min_fields {
  description: String
  label: String
  role: String
}

"""
order by min() on columns of table "PlayerRole"
"""
input PlayerRole_min_order_by {
  description: order_by
  label: order_by
  role: order_by
}

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

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

"""
input type for inserting object relation for remote table "PlayerRole"
"""
input PlayerRole_obj_rel_insert_input {
  data: PlayerRole_insert_input!
  on_conflict: PlayerRole_on_conflict
}

"""
on conflict condition type for table "PlayerRole"
"""
input PlayerRole_on_conflict {
  constraint: PlayerRole_constraint!
  update_columns: [PlayerRole_update_column!]!
  where: PlayerRole_bool_exp
}

"""
ordering options when selecting data from "PlayerRole"
"""
input PlayerRole_order_by {
  description: order_by
  label: order_by
  role: order_by
}

"""
primary key columns input for table: "PlayerRole"
"""
input PlayerRole_pk_columns_input {
  role: String!
}

"""
select columns of table "PlayerRole"
"""
enum PlayerRole_select_column {
  """column name"""
  description

  """column name"""
  label

  """column name"""
  role
}

"""
input type for updating data in table "PlayerRole"
"""
input PlayerRole_set_input {
  description: String
  label: String
  role: String
}

"""
update columns of table "PlayerRole"
"""
enum PlayerRole_update_column {
  """column name"""
  description

  """column name"""
  label

  """column name"""
  role
}

"""
columns and relationships of "profile_cache"
"""
type profile_cache {
  backgroundImageURL: String
  country: String
  description: String
  emoji: String
  gender: String
  id: uuid!
  imageURL: String
  last_checked_at: timestamptz
  location: String
  name: String

  """An object relationship"""
  player: player!
  playerId: uuid!
  website: String
}

"""
aggregated selection of "profile_cache"
"""
type profile_cache_aggregate {
  aggregate: profile_cache_aggregate_fields
  nodes: [profile_cache!]!
}

"""
aggregate fields of "profile_cache"
"""
type profile_cache_aggregate_fields {
  count(columns: [profile_cache_select_column!], distinct: Boolean): Int
  max: profile_cache_max_fields
  min: profile_cache_min_fields
}

"""
order by aggregate values of table "profile_cache"
"""
input profile_cache_aggregate_order_by {
  count: order_by
  max: profile_cache_max_order_by
  min: profile_cache_min_order_by
}

"""
input type for inserting array relation for remote table "profile_cache"
"""
input profile_cache_arr_rel_insert_input {
  data: [profile_cache_insert_input!]!
  on_conflict: profile_cache_on_conflict
}

"""
Boolean expression to filter rows from the table "profile_cache". All fields are combined with a logical 'AND'.
"""
input profile_cache_bool_exp {
  _and: [profile_cache_bool_exp]
  _not: profile_cache_bool_exp
  _or: [profile_cache_bool_exp]
  backgroundImageURL: String_comparison_exp
  country: String_comparison_exp
  description: String_comparison_exp
  emoji: String_comparison_exp
  gender: String_comparison_exp
  id: uuid_comparison_exp
  imageURL: String_comparison_exp
  last_checked_at: timestamptz_comparison_exp
  location: String_comparison_exp
  name: String_comparison_exp
  player: player_bool_exp
  playerId: uuid_comparison_exp
  website: String_comparison_exp
}

"""
unique or primary key constraints on table "profile_cache"
"""
enum profile_cache_constraint {
  """unique or primary key constraint"""
  profile_cache_pkey

  """unique or primary key constraint"""
  profile_cache_player_id_key
}

"""
input type for inserting data into table "profile_cache"
"""
input profile_cache_insert_input {
  backgroundImageURL: String
  country: String
  description: String
  emoji: String
  gender: String
  id: uuid
  imageURL: String
  last_checked_at: timestamptz
  location: String
  name: String
  player: player_obj_rel_insert_input
  playerId: uuid
  website: String
}

"""aggregate max on columns"""
type profile_cache_max_fields {
  backgroundImageURL: String
  country: String
  description: String
  emoji: String
  gender: String
  id: uuid
  imageURL: String
  last_checked_at: timestamptz
  location: String
  name: String
  playerId: uuid
  website: String
}

"""
order by max() on columns of table "profile_cache"
"""
input profile_cache_max_order_by {
  backgroundImageURL: order_by
  country: order_by
  description: order_by
  emoji: order_by
  gender: order_by
  id: order_by
  imageURL: order_by
  last_checked_at: order_by
  location: order_by
  name: order_by
  playerId: order_by
  website: order_by
}

"""aggregate min on columns"""
type profile_cache_min_fields {
  backgroundImageURL: String
  country: String
  description: String
  emoji: String
  gender: String
  id: uuid
  imageURL: String
  last_checked_at: timestamptz
  location: String
  name: String
  playerId: uuid
  website: String
}

"""
order by min() on columns of table "profile_cache"
"""
input profile_cache_min_order_by {
  backgroundImageURL: order_by
  country: order_by
  description: order_by
  emoji: order_by
  gender: order_by
  id: order_by
  imageURL: order_by
  last_checked_at: order_by
  location: order_by
  name: order_by
  playerId: order_by
  website: order_by
}

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

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

"""
input type for inserting object relation for remote table "profile_cache"
"""
input profile_cache_obj_rel_insert_input {
  data: profile_cache_insert_input!
  on_conflict: profile_cache_on_conflict
}

"""
on conflict condition type for table "profile_cache"
"""
input profile_cache_on_conflict {
  constraint: profile_cache_constraint!
  update_columns: [profile_cache_update_column!]!
  where: profile_cache_bool_exp
}

"""
ordering options when selecting data from "profile_cache"
"""
input profile_cache_order_by {
  backgroundImageURL: order_by
  country: order_by
  description: order_by
  emoji: order_by
  gender: order_by
  id: order_by
  imageURL: order_by
  last_checked_at: order_by
  location: order_by
  name: order_by
  player: player_order_by
  playerId: order_by
  website: order_by
}

"""
primary key columns input for table: "profile_cache"
"""
input profile_cache_pk_columns_input {
  id: uuid!
}

"""
select columns of table "profile_cache"
"""
enum profile_cache_select_column {
  """column name"""
  backgroundImageURL

  """column name"""
  country

  """column name"""
  description

  """column name"""
  emoji

  """column name"""
  gender

  """column name"""
  id

  """column name"""
  imageURL

  """column name"""
  last_checked_at

  """column name"""
  location

  """column name"""
  name

  """column name"""
  playerId

  """column name"""
  website
}

"""
input type for updating data in table "profile_cache"
"""
input profile_cache_set_input {
  backgroundImageURL: String
  country: String
  description: String
  emoji: String
  gender: String
  id: uuid
  imageURL: String
  last_checked_at: timestamptz
  location: String
  name: String
  playerId: uuid
  website: String
}

"""
update columns of table "profile_cache"
"""
enum profile_cache_update_column {
  """column name"""
  backgroundImageURL

  """column name"""
  country

  """column name"""
  description

  """column name"""
  emoji

  """column name"""
  gender

  """column name"""
  id

  """column name"""
  imageURL

  """column name"""
  last_checked_at

  """column name"""
  location

  """column name"""
  name

  """column name"""
  playerId

  """column name"""
  website
}

type Query {
  getBoxProfile(address: String): BoxProfile
  getBrightIdStatus(contextId: uuid): BrightIdStatus
  getDaoHausMemberships(memberAddress: String): [Member!]!
  getDiscordServerMemberRoles(guildId: uuid!, playerId: uuid!): [DiscordRole!]!
  getGuildDiscordRoles(guildDiscordId: String): [DiscordRole!]!
  getTokenBalances(address: String): TokenBalances
  getTopPSeedHolders(limit: Int): [TokenBalances!]
}

"""query root"""
type query_root {
  """
  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 data from the table: "ColorAspect"
  """
  ColorAspect(
    """distinct select on columns"""
    distinct_on: [ColorAspect_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: [ColorAspect_order_by!]

    """filter the rows returned"""
    where: ColorAspect_bool_exp
  ): [ColorAspect!]!

  """
  fetch aggregated fields from the table: "ColorAspect"
  """
  ColorAspect_aggregate(
    """distinct select on columns"""
    distinct_on: [ColorAspect_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: [ColorAspect_order_by!]

    """filter the rows returned"""
    where: ColorAspect_bool_exp
  ): ColorAspect_aggregate!

  """fetch data from the table: "ColorAspect" using primary key columns"""
  ColorAspect_by_pk(mask: Int!): ColorAspect

  """
  fetch data from the table: "GuildPosition"
  """
  GuildPosition(
    """distinct select on columns"""
    distinct_on: [GuildPosition_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: [GuildPosition_order_by!]

    """filter the rows returned"""
    where: GuildPosition_bool_exp
  ): [GuildPosition!]!

  """
  fetch aggregated fields from the table: "GuildPosition"
  """
  GuildPosition_aggregate(
    """distinct select on columns"""
    distinct_on: [GuildPosition_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: [GuildPosition_order_by!]

    """filter the rows returned"""
    where: GuildPosition_bool_exp
  ): GuildPosition_aggregate!

  """fetch data from the table: "GuildPosition" using primary key columns"""
  GuildPosition_by_pk(position: String!): GuildPosition

  """
  fetch data from the table: "GuildStatus"
  """
  GuildStatus(
    """distinct select on columns"""
    distinct_on: [GuildStatus_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: [GuildStatus_order_by!]

    """filter the rows returned"""
    where: GuildStatus_bool_exp
  ): [GuildStatus!]!

  """
  fetch aggregated fields from the table: "GuildStatus"
  """
  GuildStatus_aggregate(
    """distinct select on columns"""
    distinct_on: [GuildStatus_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: [GuildStatus_order_by!]

    """filter the rows returned"""
    where: GuildStatus_bool_exp
  ): GuildStatus_aggregate!

  """fetch data from the table: "GuildStatus" using primary key columns"""
  GuildStatus_by_pk(status: String!): GuildStatus

  """
  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 data from the table: "PlayerRank"
  """
  PlayerRank(
    """distinct select on columns"""
    distinct_on: [PlayerRank_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: [PlayerRank_order_by!]

    """filter the rows returned"""
    where: PlayerRank_bool_exp
  ): [PlayerRank!]!

  """
  fetch aggregated fields from the table: "PlayerRank"
  """
  PlayerRank_aggregate(
    """distinct select on columns"""
    distinct_on: [PlayerRank_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: [PlayerRank_order_by!]

    """filter the rows returned"""
    where: PlayerRank_bool_exp
  ): PlayerRank_aggregate!

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

  """
  fetch data from the table: "PlayerRole"
  """
  PlayerRole(
    """distinct select on columns"""
    distinct_on: [PlayerRole_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: [PlayerRole_order_by!]

    """filter the rows returned"""
    where: PlayerRole_bool_exp
  ): [PlayerRole!]!

  """
  fetch aggregated fields from the table: "PlayerRole"
  """
  PlayerRole_aggregate(
    """distinct select on columns"""
    distinct_on: [PlayerRole_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: [PlayerRole_order_by!]

    """filter the rows returned"""
    where: PlayerRole_bool_exp
  ): PlayerRole_aggregate!

  """fetch data from the table: "PlayerRole" using primary key columns"""
  PlayerRole_by_pk(role: String!): PlayerRole

  """
  fetch data from the table: "QuestCompletionStatus"
  """
  QuestCompletionStatus(
    """distinct select on columns"""
    distinct_on: [QuestCompletionStatus_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: [QuestCompletionStatus_order_by!]

    """filter the rows returned"""
    where: QuestCompletionStatus_bool_exp
  ): [QuestCompletionStatus!]!

  """
  fetch aggregated fields from the table: "QuestCompletionStatus"
  """
  QuestCompletionStatus_aggregate(
    """distinct select on columns"""
    distinct_on: [QuestCompletionStatus_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: [QuestCompletionStatus_order_by!]

    """filter the rows returned"""
    where: QuestCompletionStatus_bool_exp
  ): QuestCompletionStatus_aggregate!

  """
  fetch data from the table: "QuestCompletionStatus" using primary key columns
  """
  QuestCompletionStatus_by_pk(status: String!): QuestCompletionStatus

  """
  fetch data from the table: "QuestRepetition"
  """
  QuestRepetition(
    """distinct select on columns"""
    distinct_on: [QuestRepetition_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: [QuestRepetition_order_by!]

    """filter the rows returned"""
    where: QuestRepetition_bool_exp
  ): [QuestRepetition!]!

  """
  fetch aggregated fields from the table: "QuestRepetition"
  """
  QuestRepetition_aggregate(
    """distinct select on columns"""
    distinct_on: [QuestRepetition_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: [QuestRepetition_order_by!]

    """filter the rows returned"""
    where: QuestRepetition_bool_exp
  ): QuestRepetition_aggregate!

  """fetch data from the table: "QuestRepetition" using primary key columns"""
  QuestRepetition_by_pk(repetition: String!): QuestRepetition

  """
  fetch data from the table: "QuestStatus"
  """
  QuestStatus(
    """distinct select on columns"""
    distinct_on: [QuestStatus_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: [QuestStatus_order_by!]

    """filter the rows returned"""
    where: QuestStatus_bool_exp
  ): [QuestStatus!]!

  """
  fetch aggregated fields from the table: "QuestStatus"
  """
  QuestStatus_aggregate(
    """distinct select on columns"""
    distinct_on: [QuestStatus_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: [QuestStatus_order_by!]

    """filter the rows returned"""
    where: QuestStatus_bool_exp
  ): QuestStatus_aggregate!

  """fetch data from the table: "QuestStatus" using primary key columns"""
  QuestStatus_by_pk(status: String!): QuestStatus

  """
  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
  getBoxProfile(address: String): BoxProfile
  getBrightIdStatus(contextId: uuid): BrightIdStatus
  getDaoHausMemberships(memberAddress: String): [Member!]!
  getDiscordServerMemberRoles(guildId: uuid!, playerId: uuid!): [DiscordRole!]!
  getGuildDiscordRoles(guildDiscordId: String): [DiscordRole!]!
  getTokenBalances(address: String): TokenBalances
  getTopPSeedHolders(limit: Int): [TokenBalances!]

  """
  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 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: "guild_metadata"
  """
  guild_metadata(
    """distinct select on columns"""
    distinct_on: [guild_metadata_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_metadata_order_by!]

    """filter the rows returned"""
    where: guild_metadata_bool_exp
  ): [guild_metadata!]!

  """
  fetch aggregated fields from the table: "guild_metadata"
  """
  guild_metadata_aggregate(
    """distinct select on columns"""
    distinct_on: [guild_metadata_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_metadata_order_by!]

    """filter the rows returned"""
    where: guild_metadata_bool_exp
  ): guild_metadata_aggregate!

  """fetch data from the table: "guild_metadata" using primary key columns"""
  guild_metadata_by_pk(guild_id: uuid!): guild_metadata

  """
  fetch data from the table: "guild_player"
  """
  guild_player(
    """distinct select on columns"""
    distinct_on: [guild_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: [guild_player_order_by!]

    """filter the rows returned"""
    where: guild_player_bool_exp
  ): [guild_player!]!

  """
  fetch aggregated fields from the table: "guild_player"
  """
  guild_player_aggregate(
    """distinct select on columns"""
    distinct_on: [guild_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: [guild_player_order_by!]

    """filter the rows returned"""
    where: guild_player_bool_exp
  ): guild_player_aggregate!

  """fetch data from the table: "guild_player" using primary key columns"""
  guild_player_by_pk(guild_id: uuid!, player_id: uuid!): guild_player

  """
  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!

  """
  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: "player_account"
  """
  player_account(
    """distinct select on columns"""
    distinct_on: [player_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: [player_account_order_by!]

    """filter the rows returned"""
    where: player_account_bool_exp
  ): [player_account!]!

  """
  fetch aggregated fields from the table: "player_account"
  """
  player_account_aggregate(
    """distinct select on columns"""
    distinct_on: [player_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: [player_account_order_by!]

    """filter the rows returned"""
    where: player_account_bool_exp
  ): player_account_aggregate!

  """
  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: "player_role"
  """
  player_role(
    """distinct select on columns"""
    distinct_on: [player_role_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_role_order_by!]

    """filter the rows returned"""
    where: player_role_bool_exp
  ): [player_role!]!

  """
  fetch aggregated fields from the table: "player_role"
  """
  player_role_aggregate(
    """distinct select on columns"""
    distinct_on: [player_role_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_role_order_by!]

    """filter the rows returned"""
    where: player_role_bool_exp
  ): player_role_aggregate!

  """fetch data from the table: "player_role" using primary key columns"""
  player_role_by_pk(player_id: uuid!, role: String!): player_role

  """
  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(id: uuid!): player_skill

  """
  fetch data from the table: "player_type"
  """
  player_type(
    """distinct select on columns"""
    distinct_on: [player_type_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_type_order_by!]

    """filter the rows returned"""
    where: player_type_bool_exp
  ): [player_type!]!

  """
  fetch aggregated fields from the table: "player_type"
  """
  player_type_aggregate(
    """distinct select on columns"""
    distinct_on: [player_type_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_type_order_by!]

    """filter the rows returned"""
    where: player_type_bool_exp
  ): player_type_aggregate!

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

  """
  fetch data from the table: "profile_cache"
  """
  profile_cache(
    """distinct select on columns"""
    distinct_on: [profile_cache_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: [profile_cache_order_by!]

    """filter the rows returned"""
    where: profile_cache_bool_exp
  ): [profile_cache!]!

  """
  fetch aggregated fields from the table: "profile_cache"
  """
  profile_cache_aggregate(
    """distinct select on columns"""
    distinct_on: [profile_cache_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: [profile_cache_order_by!]

    """filter the rows returned"""
    where: profile_cache_bool_exp
  ): profile_cache_aggregate!

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

  """
  fetch data from the table: "quest"
  """
  quest(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_order_by!]

    """filter the rows returned"""
    where: quest_bool_exp
  ): [quest!]!

  """
  fetch aggregated fields from the table: "quest"
  """
  quest_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_order_by!]

    """filter the rows returned"""
    where: quest_bool_exp
  ): quest_aggregate!

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

  """
  fetch data from the table: "quest_completion"
  """
  quest_completion(
    """distinct select on columns"""
    distinct_on: [quest_completion_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: [quest_completion_order_by!]

    """filter the rows returned"""
    where: quest_completion_bool_exp
  ): [quest_completion!]!

  """
  fetch aggregated fields from the table: "quest_completion"
  """
  quest_completion_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_completion_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: [quest_completion_order_by!]

    """filter the rows returned"""
    where: quest_completion_bool_exp
  ): quest_completion_aggregate!

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

  """
  fetch data from the table: "quest_skill"
  """
  quest_skill(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_skill_order_by!]

    """filter the rows returned"""
    where: quest_skill_bool_exp
  ): [quest_skill!]!

  """
  fetch aggregated fields from the table: "quest_skill"
  """
  quest_skill_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_skill_order_by!]

    """filter the rows returned"""
    where: quest_skill_bool_exp
  ): quest_skill_aggregate!

  """fetch data from the table: "quest_skill" using primary key columns"""
  quest_skill_by_pk(quest_id: uuid!, skill_id: uuid!): quest_skill

  """
  execute function "search_guilds" which returns "guild"
  """
  search_guilds(
    """
    input parameters for function "search_guilds"
    """
    args: search_guilds_args!

    """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!]!

  """
  execute function "search_guilds" and query aggregates on result of table type "guild"
  """
  search_guilds_aggregate(
    """
    input parameters for function "search_guilds"
    """
    args: search_guilds_args!

    """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!

  """
  execute function "search_players" which returns "player"
  """
  search_players(
    """
    input parameters for function "search_players"
    """
    args: search_players_args!

    """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!]!

  """
  execute function "search_players" and query aggregates on result of table type "player"
  """
  search_players_aggregate(
    """
    input parameters for function "search_players"
    """
    args: search_players_args!

    """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: "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 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
}

"""
columns and relationships of "quest"
"""
type quest {
  """An object relationship"""
  QuestRepetition: QuestRepetition!

  """An object relationship"""
  QuestStatus: QuestStatus!
  cooldown: Int
  created_at: timestamptz!
  created_by_player_id: uuid!
  description: String
  external_link: String

  """An object relationship"""
  guild: guild!
  guild_id: uuid!
  id: uuid!

  """An object relationship"""
  player: player!

  """An array relationship"""
  quest_completions(
    """distinct select on columns"""
    distinct_on: [quest_completion_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: [quest_completion_order_by!]

    """filter the rows returned"""
    where: quest_completion_bool_exp
  ): [quest_completion!]!

  """An aggregated array relationship"""
  quest_completions_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_completion_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: [quest_completion_order_by!]

    """filter the rows returned"""
    where: quest_completion_bool_exp
  ): quest_completion_aggregate!

  """An array relationship"""
  quest_skills(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_skill_order_by!]

    """filter the rows returned"""
    where: quest_skill_bool_exp
  ): [quest_skill!]!

  """An aggregated array relationship"""
  quest_skills_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_skill_order_by!]

    """filter the rows returned"""
    where: quest_skill_bool_exp
  ): quest_skill_aggregate!
  repetition: QuestRepetition_enum!
  status: QuestStatus_enum!
  title: String!
}

"""
aggregated selection of "quest"
"""
type quest_aggregate {
  aggregate: quest_aggregate_fields
  nodes: [quest!]!
}

"""
aggregate fields of "quest"
"""
type quest_aggregate_fields {
  avg: quest_avg_fields
  count(columns: [quest_select_column!], distinct: Boolean): Int
  max: quest_max_fields
  min: quest_min_fields
  stddev: quest_stddev_fields
  stddev_pop: quest_stddev_pop_fields
  stddev_samp: quest_stddev_samp_fields
  sum: quest_sum_fields
  var_pop: quest_var_pop_fields
  var_samp: quest_var_samp_fields
  variance: quest_variance_fields
}

"""
order by aggregate values of table "quest"
"""
input quest_aggregate_order_by {
  avg: quest_avg_order_by
  count: order_by
  max: quest_max_order_by
  min: quest_min_order_by
  stddev: quest_stddev_order_by
  stddev_pop: quest_stddev_pop_order_by
  stddev_samp: quest_stddev_samp_order_by
  sum: quest_sum_order_by
  var_pop: quest_var_pop_order_by
  var_samp: quest_var_samp_order_by
  variance: quest_variance_order_by
}

"""
input type for inserting array relation for remote table "quest"
"""
input quest_arr_rel_insert_input {
  data: [quest_insert_input!]!
  on_conflict: quest_on_conflict
}

"""aggregate avg on columns"""
type quest_avg_fields {
  cooldown: Float
}

"""
order by avg() on columns of table "quest"
"""
input quest_avg_order_by {
  cooldown: order_by
}

"""
Boolean expression to filter rows from the table "quest". All fields are combined with a logical 'AND'.
"""
input quest_bool_exp {
  QuestRepetition: QuestRepetition_bool_exp
  QuestStatus: QuestStatus_bool_exp
  _and: [quest_bool_exp]
  _not: quest_bool_exp
  _or: [quest_bool_exp]
  cooldown: Int_comparison_exp
  created_at: timestamptz_comparison_exp
  created_by_player_id: uuid_comparison_exp
  description: String_comparison_exp
  external_link: String_comparison_exp
  guild: guild_bool_exp
  guild_id: uuid_comparison_exp
  id: uuid_comparison_exp
  player: player_bool_exp
  quest_completions: quest_completion_bool_exp
  quest_skills: quest_skill_bool_exp
  repetition: QuestRepetition_enum_comparison_exp
  status: QuestStatus_enum_comparison_exp
  title: String_comparison_exp
}

"""
columns and relationships of "quest_completion"
"""
type quest_completion {
  """An object relationship"""
  QuestCompletionStatus: QuestCompletionStatus!
  completed_by_player_id: uuid!
  id: uuid!

  """An object relationship"""
  player: player!

  """An object relationship"""
  quest: quest!
  quest_id: uuid!
  status: QuestCompletionStatus_enum!
  submission_link: String
  submission_text: String
  submitted_at: timestamptz!
}

"""
aggregated selection of "quest_completion"
"""
type quest_completion_aggregate {
  aggregate: quest_completion_aggregate_fields
  nodes: [quest_completion!]!
}

"""
aggregate fields of "quest_completion"
"""
type quest_completion_aggregate_fields {
  count(columns: [quest_completion_select_column!], distinct: Boolean): Int
  max: quest_completion_max_fields
  min: quest_completion_min_fields
}

"""
order by aggregate values of table "quest_completion"
"""
input quest_completion_aggregate_order_by {
  count: order_by
  max: quest_completion_max_order_by
  min: quest_completion_min_order_by
}

"""
input type for inserting array relation for remote table "quest_completion"
"""
input quest_completion_arr_rel_insert_input {
  data: [quest_completion_insert_input!]!
  on_conflict: quest_completion_on_conflict
}

"""
Boolean expression to filter rows from the table "quest_completion". All fields are combined with a logical 'AND'.
"""
input quest_completion_bool_exp {
  QuestCompletionStatus: QuestCompletionStatus_bool_exp
  _and: [quest_completion_bool_exp]
  _not: quest_completion_bool_exp
  _or: [quest_completion_bool_exp]
  completed_by_player_id: uuid_comparison_exp
  id: uuid_comparison_exp
  player: player_bool_exp
  quest: quest_bool_exp
  quest_id: uuid_comparison_exp
  status: QuestCompletionStatus_enum_comparison_exp
  submission_link: String_comparison_exp
  submission_text: String_comparison_exp
  submitted_at: timestamptz_comparison_exp
}

"""
unique or primary key constraints on table "quest_completion"
"""
enum quest_completion_constraint {
  """unique or primary key constraint"""
  quest_completion_pkey
}

"""
input type for inserting data into table "quest_completion"
"""
input quest_completion_insert_input {
  QuestCompletionStatus: QuestCompletionStatus_obj_rel_insert_input
  completed_by_player_id: uuid
  id: uuid
  player: player_obj_rel_insert_input
  quest: quest_obj_rel_insert_input
  quest_id: uuid
  status: QuestCompletionStatus_enum
  submission_link: String
  submission_text: String
  submitted_at: timestamptz
}

"""aggregate max on columns"""
type quest_completion_max_fields {
  completed_by_player_id: uuid
  id: uuid
  quest_id: uuid
  submission_link: String
  submission_text: String
  submitted_at: timestamptz
}

"""
order by max() on columns of table "quest_completion"
"""
input quest_completion_max_order_by {
  completed_by_player_id: order_by
  id: order_by
  quest_id: order_by
  submission_link: order_by
  submission_text: order_by
  submitted_at: order_by
}

"""aggregate min on columns"""
type quest_completion_min_fields {
  completed_by_player_id: uuid
  id: uuid
  quest_id: uuid
  submission_link: String
  submission_text: String
  submitted_at: timestamptz
}

"""
order by min() on columns of table "quest_completion"
"""
input quest_completion_min_order_by {
  completed_by_player_id: order_by
  id: order_by
  quest_id: order_by
  submission_link: order_by
  submission_text: order_by
  submitted_at: order_by
}

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

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

"""
input type for inserting object relation for remote table "quest_completion"
"""
input quest_completion_obj_rel_insert_input {
  data: quest_completion_insert_input!
  on_conflict: quest_completion_on_conflict
}

"""
on conflict condition type for table "quest_completion"
"""
input quest_completion_on_conflict {
  constraint: quest_completion_constraint!
  update_columns: [quest_completion_update_column!]!
  where: quest_completion_bool_exp
}

"""
ordering options when selecting data from "quest_completion"
"""
input quest_completion_order_by {
  QuestCompletionStatus: QuestCompletionStatus_order_by
  completed_by_player_id: order_by
  id: order_by
  player: player_order_by
  quest: quest_order_by
  quest_id: order_by
  status: order_by
  submission_link: order_by
  submission_text: order_by
  submitted_at: order_by
}

"""
primary key columns input for table: "quest_completion"
"""
input quest_completion_pk_columns_input {
  id: uuid!
}

"""
select columns of table "quest_completion"
"""
enum quest_completion_select_column {
  """column name"""
  completed_by_player_id

  """column name"""
  id

  """column name"""
  quest_id

  """column name"""
  status

  """column name"""
  submission_link

  """column name"""
  submission_text

  """column name"""
  submitted_at
}

"""
input type for updating data in table "quest_completion"
"""
input quest_completion_set_input {
  completed_by_player_id: uuid
  id: uuid
  quest_id: uuid
  status: QuestCompletionStatus_enum
  submission_link: String
  submission_text: String
  submitted_at: timestamptz
}

"""
update columns of table "quest_completion"
"""
enum quest_completion_update_column {
  """column name"""
  completed_by_player_id

  """column name"""
  id

  """column name"""
  quest_id

  """column name"""
  status

  """column name"""
  submission_link

  """column name"""
  submission_text

  """column name"""
  submitted_at
}

"""
unique or primary key constraints on table "quest"
"""
enum quest_constraint {
  """unique or primary key constraint"""
  quest_pkey
}

"""
input type for incrementing integer column in table "quest"
"""
input quest_inc_input {
  cooldown: Int
}

"""
input type for inserting data into table "quest"
"""
input quest_insert_input {
  QuestRepetition: QuestRepetition_obj_rel_insert_input
  QuestStatus: QuestStatus_obj_rel_insert_input
  cooldown: Int
  created_at: timestamptz
  created_by_player_id: uuid
  description: String
  external_link: String
  guild: guild_obj_rel_insert_input
  guild_id: uuid
  id: uuid
  player: player_obj_rel_insert_input
  quest_completions: quest_completion_arr_rel_insert_input
  quest_skills: quest_skill_arr_rel_insert_input
  repetition: QuestRepetition_enum
  status: QuestStatus_enum
  title: String
}

"""aggregate max on columns"""
type quest_max_fields {
  cooldown: Int
  created_at: timestamptz
  created_by_player_id: uuid
  description: String
  external_link: String
  guild_id: uuid
  id: uuid
  title: String
}

"""
order by max() on columns of table "quest"
"""
input quest_max_order_by {
  cooldown: order_by
  created_at: order_by
  created_by_player_id: order_by
  description: order_by
  external_link: order_by
  guild_id: order_by
  id: order_by
  title: order_by
}

"""aggregate min on columns"""
type quest_min_fields {
  cooldown: Int
  created_at: timestamptz
  created_by_player_id: uuid
  description: String
  external_link: String
  guild_id: uuid
  id: uuid
  title: String
}

"""
order by min() on columns of table "quest"
"""
input quest_min_order_by {
  cooldown: order_by
  created_at: order_by
  created_by_player_id: order_by
  description: order_by
  external_link: order_by
  guild_id: order_by
  id: order_by
  title: order_by
}

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

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

"""
input type for inserting object relation for remote table "quest"
"""
input quest_obj_rel_insert_input {
  data: quest_insert_input!
  on_conflict: quest_on_conflict
}

"""
on conflict condition type for table "quest"
"""
input quest_on_conflict {
  constraint: quest_constraint!
  update_columns: [quest_update_column!]!
  where: quest_bool_exp
}

"""
ordering options when selecting data from "quest"
"""
input quest_order_by {
  QuestRepetition: QuestRepetition_order_by
  QuestStatus: QuestStatus_order_by
  cooldown: order_by
  created_at: order_by
  created_by_player_id: order_by
  description: order_by
  external_link: order_by
  guild: guild_order_by
  guild_id: order_by
  id: order_by
  player: player_order_by
  quest_completions_aggregate: quest_completion_aggregate_order_by
  quest_skills_aggregate: quest_skill_aggregate_order_by
  repetition: order_by
  status: order_by
  title: order_by
}

"""
primary key columns input for table: "quest"
"""
input quest_pk_columns_input {
  id: uuid!
}

"""
select columns of table "quest"
"""
enum quest_select_column {
  """column name"""
  cooldown

  """column name"""
  created_at

  """column name"""
  created_by_player_id

  """column name"""
  description

  """column name"""
  external_link

  """column name"""
  guild_id

  """column name"""
  id

  """column name"""
  repetition

  """column name"""
  status

  """column name"""
  title
}

"""
input type for updating data in table "quest"
"""
input quest_set_input {
  cooldown: Int
  created_at: timestamptz
  created_by_player_id: uuid
  description: String
  external_link: String
  guild_id: uuid
  id: uuid
  repetition: QuestRepetition_enum
  status: QuestStatus_enum
  title: String
}

"""
columns and relationships of "quest_skill"
"""
type quest_skill {
  """An object relationship"""
  quest: quest!
  quest_id: uuid!

  """An object relationship"""
  skill: skill!
  skill_id: uuid!
}

"""
aggregated selection of "quest_skill"
"""
type quest_skill_aggregate {
  aggregate: quest_skill_aggregate_fields
  nodes: [quest_skill!]!
}

"""
aggregate fields of "quest_skill"
"""
type quest_skill_aggregate_fields {
  count(columns: [quest_skill_select_column!], distinct: Boolean): Int
  max: quest_skill_max_fields
  min: quest_skill_min_fields
}

"""
order by aggregate values of table "quest_skill"
"""
input quest_skill_aggregate_order_by {
  count: order_by
  max: quest_skill_max_order_by
  min: quest_skill_min_order_by
}

"""
input type for inserting array relation for remote table "quest_skill"
"""
input quest_skill_arr_rel_insert_input {
  data: [quest_skill_insert_input!]!
  on_conflict: quest_skill_on_conflict
}

"""
Boolean expression to filter rows from the table "quest_skill". All fields are combined with a logical 'AND'.
"""
input quest_skill_bool_exp {
  _and: [quest_skill_bool_exp]
  _not: quest_skill_bool_exp
  _or: [quest_skill_bool_exp]
  quest: quest_bool_exp
  quest_id: uuid_comparison_exp
  skill: skill_bool_exp
  skill_id: uuid_comparison_exp
}

"""
unique or primary key constraints on table "quest_skill"
"""
enum quest_skill_constraint {
  """unique or primary key constraint"""
  quest_skill_pkey
}

"""
input type for inserting data into table "quest_skill"
"""
input quest_skill_insert_input {
  quest: quest_obj_rel_insert_input
  quest_id: uuid
  skill: skill_obj_rel_insert_input
  skill_id: uuid
}

"""aggregate max on columns"""
type quest_skill_max_fields {
  quest_id: uuid
  skill_id: uuid
}

"""
order by max() on columns of table "quest_skill"
"""
input quest_skill_max_order_by {
  quest_id: order_by
  skill_id: order_by
}

"""aggregate min on columns"""
type quest_skill_min_fields {
  quest_id: uuid
  skill_id: uuid
}

"""
order by min() on columns of table "quest_skill"
"""
input quest_skill_min_order_by {
  quest_id: order_by
  skill_id: order_by
}

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

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

"""
input type for inserting object relation for remote table "quest_skill"
"""
input quest_skill_obj_rel_insert_input {
  data: quest_skill_insert_input!
  on_conflict: quest_skill_on_conflict
}

"""
on conflict condition type for table "quest_skill"
"""
input quest_skill_on_conflict {
  constraint: quest_skill_constraint!
  update_columns: [quest_skill_update_column!]!
  where: quest_skill_bool_exp
}

"""
ordering options when selecting data from "quest_skill"
"""
input quest_skill_order_by {
  quest: quest_order_by
  quest_id: order_by
  skill: skill_order_by
  skill_id: order_by
}

"""
primary key columns input for table: "quest_skill"
"""
input quest_skill_pk_columns_input {
  quest_id: uuid!
  skill_id: uuid!
}

"""
select columns of table "quest_skill"
"""
enum quest_skill_select_column {
  """column name"""
  quest_id

  """column name"""
  skill_id
}

"""
input type for updating data in table "quest_skill"
"""
input quest_skill_set_input {
  quest_id: uuid
  skill_id: uuid
}

"""
update columns of table "quest_skill"
"""
enum quest_skill_update_column {
  """column name"""
  quest_id

  """column name"""
  skill_id
}

"""aggregate stddev on columns"""
type quest_stddev_fields {
  cooldown: Float
}

"""
order by stddev() on columns of table "quest"
"""
input quest_stddev_order_by {
  cooldown: order_by
}

"""aggregate stddev_pop on columns"""
type quest_stddev_pop_fields {
  cooldown: Float
}

"""
order by stddev_pop() on columns of table "quest"
"""
input quest_stddev_pop_order_by {
  cooldown: order_by
}

"""aggregate stddev_samp on columns"""
type quest_stddev_samp_fields {
  cooldown: Float
}

"""
order by stddev_samp() on columns of table "quest"
"""
input quest_stddev_samp_order_by {
  cooldown: order_by
}

"""aggregate sum on columns"""
type quest_sum_fields {
  cooldown: Int
}

"""
order by sum() on columns of table "quest"
"""
input quest_sum_order_by {
  cooldown: order_by
}

"""
update columns of table "quest"
"""
enum quest_update_column {
  """column name"""
  cooldown

  """column name"""
  created_at

  """column name"""
  created_by_player_id

  """column name"""
  description

  """column name"""
  external_link

  """column name"""
  guild_id

  """column name"""
  id

  """column name"""
  repetition

  """column name"""
  status

  """column name"""
  title
}

"""aggregate var_pop on columns"""
type quest_var_pop_fields {
  cooldown: Float
}

"""
order by var_pop() on columns of table "quest"
"""
input quest_var_pop_order_by {
  cooldown: order_by
}

"""aggregate var_samp on columns"""
type quest_var_samp_fields {
  cooldown: Float
}

"""
order by var_samp() on columns of table "quest"
"""
input quest_var_samp_order_by {
  cooldown: order_by
}

"""aggregate variance on columns"""
type quest_variance_fields {
  cooldown: Float
}

"""
order by variance() on columns of table "quest"
"""
input quest_variance_order_by {
  cooldown: order_by
}

"""
columns and relationships of "QuestCompletionStatus"
"""
type QuestCompletionStatus {
  """An array relationship"""
  quest_completions(
    """distinct select on columns"""
    distinct_on: [quest_completion_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: [quest_completion_order_by!]

    """filter the rows returned"""
    where: quest_completion_bool_exp
  ): [quest_completion!]!

  """An aggregated array relationship"""
  quest_completions_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_completion_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: [quest_completion_order_by!]

    """filter the rows returned"""
    where: quest_completion_bool_exp
  ): quest_completion_aggregate!
  status: String!
}

enum QuestCompletionStatus_ActionEnum {
  ACCEPTED
  REJECTED
}

"""
aggregated selection of "QuestCompletionStatus"
"""
type QuestCompletionStatus_aggregate {
  aggregate: QuestCompletionStatus_aggregate_fields
  nodes: [QuestCompletionStatus!]!
}

"""
aggregate fields of "QuestCompletionStatus"
"""
type QuestCompletionStatus_aggregate_fields {
  count(columns: [QuestCompletionStatus_select_column!], distinct: Boolean): Int
  max: QuestCompletionStatus_max_fields
  min: QuestCompletionStatus_min_fields
}

"""
order by aggregate values of table "QuestCompletionStatus"
"""
input QuestCompletionStatus_aggregate_order_by {
  count: order_by
  max: QuestCompletionStatus_max_order_by
  min: QuestCompletionStatus_min_order_by
}

"""
input type for inserting array relation for remote table "QuestCompletionStatus"
"""
input QuestCompletionStatus_arr_rel_insert_input {
  data: [QuestCompletionStatus_insert_input!]!
  on_conflict: QuestCompletionStatus_on_conflict
}

"""
Boolean expression to filter rows from the table "QuestCompletionStatus". All fields are combined with a logical 'AND'.
"""
input QuestCompletionStatus_bool_exp {
  _and: [QuestCompletionStatus_bool_exp]
  _not: QuestCompletionStatus_bool_exp
  _or: [QuestCompletionStatus_bool_exp]
  quest_completions: quest_completion_bool_exp
  status: String_comparison_exp
}

"""
unique or primary key constraints on table "QuestCompletionStatus"
"""
enum QuestCompletionStatus_constraint {
  """unique or primary key constraint"""
  QuestCompletionStatus_pkey
}

enum QuestCompletionStatus_enum {
  ACCEPTED
  PENDING
  REJECTED
}

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

"""
input type for inserting data into table "QuestCompletionStatus"
"""
input QuestCompletionStatus_insert_input {
  quest_completions: quest_completion_arr_rel_insert_input
  status: String
}

"""aggregate max on columns"""
type QuestCompletionStatus_max_fields {
  status: String
}

"""
order by max() on columns of table "QuestCompletionStatus"
"""
input QuestCompletionStatus_max_order_by {
  status: order_by
}

"""aggregate min on columns"""
type QuestCompletionStatus_min_fields {
  status: String
}

"""
order by min() on columns of table "QuestCompletionStatus"
"""
input QuestCompletionStatus_min_order_by {
  status: order_by
}

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

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

"""
input type for inserting object relation for remote table "QuestCompletionStatus"
"""
input QuestCompletionStatus_obj_rel_insert_input {
  data: QuestCompletionStatus_insert_input!
  on_conflict: QuestCompletionStatus_on_conflict
}

"""
on conflict condition type for table "QuestCompletionStatus"
"""
input QuestCompletionStatus_on_conflict {
  constraint: QuestCompletionStatus_constraint!
  update_columns: [QuestCompletionStatus_update_column!]!
  where: QuestCompletionStatus_bool_exp
}

"""
ordering options when selecting data from "QuestCompletionStatus"
"""
input QuestCompletionStatus_order_by {
  quest_completions_aggregate: quest_completion_aggregate_order_by
  status: order_by
}

"""
primary key columns input for table: "QuestCompletionStatus"
"""
input QuestCompletionStatus_pk_columns_input {
  status: String!
}

"""
select columns of table "QuestCompletionStatus"
"""
enum QuestCompletionStatus_select_column {
  """column name"""
  status
}

"""
input type for updating data in table "QuestCompletionStatus"
"""
input QuestCompletionStatus_set_input {
  status: String
}

"""
update columns of table "QuestCompletionStatus"
"""
enum QuestCompletionStatus_update_column {
  """column name"""
  status
}

"""
columns and relationships of "QuestRepetition"
"""
type QuestRepetition {
  """An array relationship"""
  quests(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_order_by!]

    """filter the rows returned"""
    where: quest_bool_exp
  ): [quest!]!

  """An aggregated array relationship"""
  quests_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_order_by!]

    """filter the rows returned"""
    where: quest_bool_exp
  ): quest_aggregate!
  repetition: String!
}

enum QuestRepetition_ActionEnum {
  PERSONAL
  RECURRING
  UNIQUE
}

"""
aggregated selection of "QuestRepetition"
"""
type QuestRepetition_aggregate {
  aggregate: QuestRepetition_aggregate_fields
  nodes: [QuestRepetition!]!
}

"""
aggregate fields of "QuestRepetition"
"""
type QuestRepetition_aggregate_fields {
  count(columns: [QuestRepetition_select_column!], distinct: Boolean): Int
  max: QuestRepetition_max_fields
  min: QuestRepetition_min_fields
}

"""
order by aggregate values of table "QuestRepetition"
"""
input QuestRepetition_aggregate_order_by {
  count: order_by
  max: QuestRepetition_max_order_by
  min: QuestRepetition_min_order_by
}

"""
input type for inserting array relation for remote table "QuestRepetition"
"""
input QuestRepetition_arr_rel_insert_input {
  data: [QuestRepetition_insert_input!]!
  on_conflict: QuestRepetition_on_conflict
}

"""
Boolean expression to filter rows from the table "QuestRepetition". All fields are combined with a logical 'AND'.
"""
input QuestRepetition_bool_exp {
  _and: [QuestRepetition_bool_exp]
  _not: QuestRepetition_bool_exp
  _or: [QuestRepetition_bool_exp]
  quests: quest_bool_exp
  repetition: String_comparison_exp
}

"""
unique or primary key constraints on table "QuestRepetition"
"""
enum QuestRepetition_constraint {
  """unique or primary key constraint"""
  QuestRepetition_pkey
}

enum QuestRepetition_enum {
  PERSONAL
  RECURRING
  UNIQUE
}

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

"""
input type for inserting data into table "QuestRepetition"
"""
input QuestRepetition_insert_input {
  quests: quest_arr_rel_insert_input
  repetition: String
}

"""aggregate max on columns"""
type QuestRepetition_max_fields {
  repetition: String
}

"""
order by max() on columns of table "QuestRepetition"
"""
input QuestRepetition_max_order_by {
  repetition: order_by
}

"""aggregate min on columns"""
type QuestRepetition_min_fields {
  repetition: String
}

"""
order by min() on columns of table "QuestRepetition"
"""
input QuestRepetition_min_order_by {
  repetition: order_by
}

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

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

"""
input type for inserting object relation for remote table "QuestRepetition"
"""
input QuestRepetition_obj_rel_insert_input {
  data: QuestRepetition_insert_input!
  on_conflict: QuestRepetition_on_conflict
}

"""
on conflict condition type for table "QuestRepetition"
"""
input QuestRepetition_on_conflict {
  constraint: QuestRepetition_constraint!
  update_columns: [QuestRepetition_update_column!]!
  where: QuestRepetition_bool_exp
}

"""
ordering options when selecting data from "QuestRepetition"
"""
input QuestRepetition_order_by {
  quests_aggregate: quest_aggregate_order_by
  repetition: order_by
}

"""
primary key columns input for table: "QuestRepetition"
"""
input QuestRepetition_pk_columns_input {
  repetition: String!
}

"""
select columns of table "QuestRepetition"
"""
enum QuestRepetition_select_column {
  """column name"""
  repetition
}

"""
input type for updating data in table "QuestRepetition"
"""
input QuestRepetition_set_input {
  repetition: String
}

"""
update columns of table "QuestRepetition"
"""
enum QuestRepetition_update_column {
  """column name"""
  repetition
}

"""
columns and relationships of "QuestStatus"
"""
type QuestStatus {
  """An array relationship"""
  quests(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_order_by!]

    """filter the rows returned"""
    where: quest_bool_exp
  ): [quest!]!

  """An aggregated array relationship"""
  quests_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_order_by!]

    """filter the rows returned"""
    where: quest_bool_exp
  ): quest_aggregate!
  status: String!
}

"""
aggregated selection of "QuestStatus"
"""
type QuestStatus_aggregate {
  aggregate: QuestStatus_aggregate_fields
  nodes: [QuestStatus!]!
}

"""
aggregate fields of "QuestStatus"
"""
type QuestStatus_aggregate_fields {
  count(columns: [QuestStatus_select_column!], distinct: Boolean): Int
  max: QuestStatus_max_fields
  min: QuestStatus_min_fields
}

"""
order by aggregate values of table "QuestStatus"
"""
input QuestStatus_aggregate_order_by {
  count: order_by
  max: QuestStatus_max_order_by
  min: QuestStatus_min_order_by
}

"""
input type for inserting array relation for remote table "QuestStatus"
"""
input QuestStatus_arr_rel_insert_input {
  data: [QuestStatus_insert_input!]!
  on_conflict: QuestStatus_on_conflict
}

"""
Boolean expression to filter rows from the table "QuestStatus". All fields are combined with a logical 'AND'.
"""
input QuestStatus_bool_exp {
  _and: [QuestStatus_bool_exp]
  _not: QuestStatus_bool_exp
  _or: [QuestStatus_bool_exp]
  quests: quest_bool_exp
  status: String_comparison_exp
}

"""
unique or primary key constraints on table "QuestStatus"
"""
enum QuestStatus_constraint {
  """unique or primary key constraint"""
  QuestStatus_pkey
}

enum QuestStatus_enum {
  CLOSED
  OPEN
}

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

"""
input type for inserting data into table "QuestStatus"
"""
input QuestStatus_insert_input {
  quests: quest_arr_rel_insert_input
  status: String
}

"""aggregate max on columns"""
type QuestStatus_max_fields {
  status: String
}

"""
order by max() on columns of table "QuestStatus"
"""
input QuestStatus_max_order_by {
  status: order_by
}

"""aggregate min on columns"""
type QuestStatus_min_fields {
  status: String
}

"""
order by min() on columns of table "QuestStatus"
"""
input QuestStatus_min_order_by {
  status: order_by
}

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

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

"""
input type for inserting object relation for remote table "QuestStatus"
"""
input QuestStatus_obj_rel_insert_input {
  data: QuestStatus_insert_input!
  on_conflict: QuestStatus_on_conflict
}

"""
on conflict condition type for table "QuestStatus"
"""
input QuestStatus_on_conflict {
  constraint: QuestStatus_constraint!
  update_columns: [QuestStatus_update_column!]!
  where: QuestStatus_bool_exp
}

"""
ordering options when selecting data from "QuestStatus"
"""
input QuestStatus_order_by {
  quests_aggregate: quest_aggregate_order_by
  status: order_by
}

"""
primary key columns input for table: "QuestStatus"
"""
input QuestStatus_pk_columns_input {
  status: String!
}

"""
select columns of table "QuestStatus"
"""
enum QuestStatus_select_column {
  """column name"""
  status
}

"""
input type for updating data in table "QuestStatus"
"""
input QuestStatus_set_input {
  status: String
}

"""
update columns of table "QuestStatus"
"""
enum QuestStatus_update_column {
  """column name"""
  status
}

type SaveGuildResponse {
  error: String
  success: Boolean
}

input search_guilds_args {
  search: String
}

input search_players_args {
  search: String
}

"""
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!

  """An array relationship"""
  quest_skills(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_skill_order_by!]

    """filter the rows returned"""
    where: quest_skill_bool_exp
  ): [quest_skill!]!

  """An aggregated array relationship"""
  quest_skills_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_skill_order_by!]

    """filter the rows returned"""
    where: quest_skill_bool_exp
  ): quest_skill_aggregate!
}

"""
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
  quest_skills: quest_skill_bool_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
  quest_skills: quest_skill_arr_rel_insert_input
}

"""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
  quest_skills_aggregate: quest_skill_aggregate_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: "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 data from the table: "ColorAspect"
  """
  ColorAspect(
    """distinct select on columns"""
    distinct_on: [ColorAspect_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: [ColorAspect_order_by!]

    """filter the rows returned"""
    where: ColorAspect_bool_exp
  ): [ColorAspect!]!

  """
  fetch aggregated fields from the table: "ColorAspect"
  """
  ColorAspect_aggregate(
    """distinct select on columns"""
    distinct_on: [ColorAspect_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: [ColorAspect_order_by!]

    """filter the rows returned"""
    where: ColorAspect_bool_exp
  ): ColorAspect_aggregate!

  """fetch data from the table: "ColorAspect" using primary key columns"""
  ColorAspect_by_pk(mask: Int!): ColorAspect

  """
  fetch data from the table: "GuildPosition"
  """
  GuildPosition(
    """distinct select on columns"""
    distinct_on: [GuildPosition_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: [GuildPosition_order_by!]

    """filter the rows returned"""
    where: GuildPosition_bool_exp
  ): [GuildPosition!]!

  """
  fetch aggregated fields from the table: "GuildPosition"
  """
  GuildPosition_aggregate(
    """distinct select on columns"""
    distinct_on: [GuildPosition_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: [GuildPosition_order_by!]

    """filter the rows returned"""
    where: GuildPosition_bool_exp
  ): GuildPosition_aggregate!

  """fetch data from the table: "GuildPosition" using primary key columns"""
  GuildPosition_by_pk(position: String!): GuildPosition

  """
  fetch data from the table: "GuildStatus"
  """
  GuildStatus(
    """distinct select on columns"""
    distinct_on: [GuildStatus_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: [GuildStatus_order_by!]

    """filter the rows returned"""
    where: GuildStatus_bool_exp
  ): [GuildStatus!]!

  """
  fetch aggregated fields from the table: "GuildStatus"
  """
  GuildStatus_aggregate(
    """distinct select on columns"""
    distinct_on: [GuildStatus_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: [GuildStatus_order_by!]

    """filter the rows returned"""
    where: GuildStatus_bool_exp
  ): GuildStatus_aggregate!

  """fetch data from the table: "GuildStatus" using primary key columns"""
  GuildStatus_by_pk(status: String!): GuildStatus

  """
  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 data from the table: "PlayerRank"
  """
  PlayerRank(
    """distinct select on columns"""
    distinct_on: [PlayerRank_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: [PlayerRank_order_by!]

    """filter the rows returned"""
    where: PlayerRank_bool_exp
  ): [PlayerRank!]!

  """
  fetch aggregated fields from the table: "PlayerRank"
  """
  PlayerRank_aggregate(
    """distinct select on columns"""
    distinct_on: [PlayerRank_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: [PlayerRank_order_by!]

    """filter the rows returned"""
    where: PlayerRank_bool_exp
  ): PlayerRank_aggregate!

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

  """
  fetch data from the table: "PlayerRole"
  """
  PlayerRole(
    """distinct select on columns"""
    distinct_on: [PlayerRole_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: [PlayerRole_order_by!]

    """filter the rows returned"""
    where: PlayerRole_bool_exp
  ): [PlayerRole!]!

  """
  fetch aggregated fields from the table: "PlayerRole"
  """
  PlayerRole_aggregate(
    """distinct select on columns"""
    distinct_on: [PlayerRole_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: [PlayerRole_order_by!]

    """filter the rows returned"""
    where: PlayerRole_bool_exp
  ): PlayerRole_aggregate!

  """fetch data from the table: "PlayerRole" using primary key columns"""
  PlayerRole_by_pk(role: String!): PlayerRole

  """
  fetch data from the table: "QuestCompletionStatus"
  """
  QuestCompletionStatus(
    """distinct select on columns"""
    distinct_on: [QuestCompletionStatus_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: [QuestCompletionStatus_order_by!]

    """filter the rows returned"""
    where: QuestCompletionStatus_bool_exp
  ): [QuestCompletionStatus!]!

  """
  fetch aggregated fields from the table: "QuestCompletionStatus"
  """
  QuestCompletionStatus_aggregate(
    """distinct select on columns"""
    distinct_on: [QuestCompletionStatus_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: [QuestCompletionStatus_order_by!]

    """filter the rows returned"""
    where: QuestCompletionStatus_bool_exp
  ): QuestCompletionStatus_aggregate!

  """
  fetch data from the table: "QuestCompletionStatus" using primary key columns
  """
  QuestCompletionStatus_by_pk(status: String!): QuestCompletionStatus

  """
  fetch data from the table: "QuestRepetition"
  """
  QuestRepetition(
    """distinct select on columns"""
    distinct_on: [QuestRepetition_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: [QuestRepetition_order_by!]

    """filter the rows returned"""
    where: QuestRepetition_bool_exp
  ): [QuestRepetition!]!

  """
  fetch aggregated fields from the table: "QuestRepetition"
  """
  QuestRepetition_aggregate(
    """distinct select on columns"""
    distinct_on: [QuestRepetition_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: [QuestRepetition_order_by!]

    """filter the rows returned"""
    where: QuestRepetition_bool_exp
  ): QuestRepetition_aggregate!

  """fetch data from the table: "QuestRepetition" using primary key columns"""
  QuestRepetition_by_pk(repetition: String!): QuestRepetition

  """
  fetch data from the table: "QuestStatus"
  """
  QuestStatus(
    """distinct select on columns"""
    distinct_on: [QuestStatus_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: [QuestStatus_order_by!]

    """filter the rows returned"""
    where: QuestStatus_bool_exp
  ): [QuestStatus!]!

  """
  fetch aggregated fields from the table: "QuestStatus"
  """
  QuestStatus_aggregate(
    """distinct select on columns"""
    distinct_on: [QuestStatus_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: [QuestStatus_order_by!]

    """filter the rows returned"""
    where: QuestStatus_bool_exp
  ): QuestStatus_aggregate!

  """fetch data from the table: "QuestStatus" using primary key columns"""
  QuestStatus_by_pk(status: String!): QuestStatus

  """
  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 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 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: "guild_metadata"
  """
  guild_metadata(
    """distinct select on columns"""
    distinct_on: [guild_metadata_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_metadata_order_by!]

    """filter the rows returned"""
    where: guild_metadata_bool_exp
  ): [guild_metadata!]!

  """
  fetch aggregated fields from the table: "guild_metadata"
  """
  guild_metadata_aggregate(
    """distinct select on columns"""
    distinct_on: [guild_metadata_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_metadata_order_by!]

    """filter the rows returned"""
    where: guild_metadata_bool_exp
  ): guild_metadata_aggregate!

  """fetch data from the table: "guild_metadata" using primary key columns"""
  guild_metadata_by_pk(guild_id: uuid!): guild_metadata

  """
  fetch data from the table: "guild_player"
  """
  guild_player(
    """distinct select on columns"""
    distinct_on: [guild_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: [guild_player_order_by!]

    """filter the rows returned"""
    where: guild_player_bool_exp
  ): [guild_player!]!

  """
  fetch aggregated fields from the table: "guild_player"
  """
  guild_player_aggregate(
    """distinct select on columns"""
    distinct_on: [guild_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: [guild_player_order_by!]

    """filter the rows returned"""
    where: guild_player_bool_exp
  ): guild_player_aggregate!

  """fetch data from the table: "guild_player" using primary key columns"""
  guild_player_by_pk(guild_id: uuid!, player_id: uuid!): guild_player

  """
  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!

  """
  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: "player_account"
  """
  player_account(
    """distinct select on columns"""
    distinct_on: [player_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: [player_account_order_by!]

    """filter the rows returned"""
    where: player_account_bool_exp
  ): [player_account!]!

  """
  fetch aggregated fields from the table: "player_account"
  """
  player_account_aggregate(
    """distinct select on columns"""
    distinct_on: [player_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: [player_account_order_by!]

    """filter the rows returned"""
    where: player_account_bool_exp
  ): player_account_aggregate!

  """
  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: "player_role"
  """
  player_role(
    """distinct select on columns"""
    distinct_on: [player_role_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_role_order_by!]

    """filter the rows returned"""
    where: player_role_bool_exp
  ): [player_role!]!

  """
  fetch aggregated fields from the table: "player_role"
  """
  player_role_aggregate(
    """distinct select on columns"""
    distinct_on: [player_role_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_role_order_by!]

    """filter the rows returned"""
    where: player_role_bool_exp
  ): player_role_aggregate!

  """fetch data from the table: "player_role" using primary key columns"""
  player_role_by_pk(player_id: uuid!, role: String!): player_role

  """
  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(id: uuid!): player_skill

  """
  fetch data from the table: "player_type"
  """
  player_type(
    """distinct select on columns"""
    distinct_on: [player_type_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_type_order_by!]

    """filter the rows returned"""
    where: player_type_bool_exp
  ): [player_type!]!

  """
  fetch aggregated fields from the table: "player_type"
  """
  player_type_aggregate(
    """distinct select on columns"""
    distinct_on: [player_type_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_type_order_by!]

    """filter the rows returned"""
    where: player_type_bool_exp
  ): player_type_aggregate!

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

  """
  fetch data from the table: "profile_cache"
  """
  profile_cache(
    """distinct select on columns"""
    distinct_on: [profile_cache_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: [profile_cache_order_by!]

    """filter the rows returned"""
    where: profile_cache_bool_exp
  ): [profile_cache!]!

  """
  fetch aggregated fields from the table: "profile_cache"
  """
  profile_cache_aggregate(
    """distinct select on columns"""
    distinct_on: [profile_cache_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: [profile_cache_order_by!]

    """filter the rows returned"""
    where: profile_cache_bool_exp
  ): profile_cache_aggregate!

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

  """
  fetch data from the table: "quest"
  """
  quest(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_order_by!]

    """filter the rows returned"""
    where: quest_bool_exp
  ): [quest!]!

  """
  fetch aggregated fields from the table: "quest"
  """
  quest_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_order_by!]

    """filter the rows returned"""
    where: quest_bool_exp
  ): quest_aggregate!

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

  """
  fetch data from the table: "quest_completion"
  """
  quest_completion(
    """distinct select on columns"""
    distinct_on: [quest_completion_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: [quest_completion_order_by!]

    """filter the rows returned"""
    where: quest_completion_bool_exp
  ): [quest_completion!]!

  """
  fetch aggregated fields from the table: "quest_completion"
  """
  quest_completion_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_completion_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: [quest_completion_order_by!]

    """filter the rows returned"""
    where: quest_completion_bool_exp
  ): quest_completion_aggregate!

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

  """
  fetch data from the table: "quest_skill"
  """
  quest_skill(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_skill_order_by!]

    """filter the rows returned"""
    where: quest_skill_bool_exp
  ): [quest_skill!]!

  """
  fetch aggregated fields from the table: "quest_skill"
  """
  quest_skill_aggregate(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_skill_order_by!]

    """filter the rows returned"""
    where: quest_skill_bool_exp
  ): quest_skill_aggregate!

  """fetch data from the table: "quest_skill" using primary key columns"""
  quest_skill_by_pk(quest_id: uuid!, skill_id: uuid!): quest_skill

  """
  execute function "search_guilds" which returns "guild"
  """
  search_guilds(
    """
    input parameters for function "search_guilds"
    """
    args: search_guilds_args!

    """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!]!

  """
  execute function "search_guilds" and query aggregates on result of table type "guild"
  """
  search_guilds_aggregate(
    """
    input parameters for function "search_guilds"
    """
    args: search_guilds_args!

    """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!

  """
  execute function "search_players" which returns "player"
  """
  search_players(
    """
    input parameters for function "search_players"
    """
    args: search_players_args!

    """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!]!

  """
  execute function "search_players" and query aggregates on result of table type "player"
  """
  search_players_aggregate(
    """
    input parameters for function "search_players"
    """
    args: search_players_args!

    """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: "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 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
}

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 TokenBalances {
  id: ID!
  pSeedBalance: String!
  seedBalance: String!
}

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

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

input UpdateQuestCompletionInput {
  quest_completion_id: String!
  status: QuestCompletionStatus_ActionEnum!
}

type UpdateQuestCompletionOutput {
  error: String
  quest_completion: quest_completion
  quest_completion_id: uuid
  success: Boolean!
}

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!]
}