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!

  """
  An object relationship
  """
  metadata: guild_metadata
  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
  metadata: guild_metadata_bool_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
  metadata: guild_metadata_obj_rel_insert_input
  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
  metadata: guild_metadata_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_role"
  """
  delete_quest_role(
    """filter the rows which have to be deleted"""
    where: quest_role_bool_exp!
  ): quest_role_mutation_response

  """
  delete single row from the table: "quest_role"
  """
  delete_quest_role_by_pk(quest_id: uuid!, role: String!): quest_role

  """
  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_role"
  """
  insert_quest_role(
    """the rows to be inserted"""
    objects: [quest_role_insert_input!]!

    """on conflict condition"""
    on_conflict: quest_role_on_conflict
  ): quest_role_mutation_response

  """
  insert a single row into the table: "quest_role"
  """
  insert_quest_role_one(
    """the row to be inserted"""
    object: quest_role_insert_input!

    """on conflict condition"""
    on_conflict: quest_role_on_conflict
  ): quest_role

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

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

    """filter the rows which have to be updated"""
    where: quest_role_bool_exp!
  ): quest_role_mutation_response

  """
  update single row of the table: "quest_role"
  """
  update_quest_role_by_pk(
    """increments the integer columns with given value of the filtered values"""
    _inc: quest_role_inc_input

    """sets the columns of the filtered rows to the given values"""
    _set: quest_role_set_input
    pk_columns: quest_role_pk_columns_input!
  ): quest_role

  """
  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
  profile_layout: String
  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
  profile_layout: String_comparison_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
  profile_layout: String
  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
  profile_layout: String
  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
  profile_layout: 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
  profile_layout: String
  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
  profile_layout: 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
  profile_layout: 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
  """
  profile_layout

  """
  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
  profile_layout: String
  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
  """
  profile_layout

  """
  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_role"
  """
  quest_role(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_role_order_by!]

    """filter the rows returned"""
    where: quest_role_bool_exp
  ): [quest_role!]!

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

    """filter the rows returned"""
    where: quest_role_bool_exp
  ): quest_role_aggregate!

  """fetch data from the table: "quest_role" using primary key columns"""
  quest_role_by_pk(quest_id: uuid!, role: String!): quest_role

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

  """
  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_roles(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_role_order_by!]

    """filter the rows returned"""
    where: quest_role_bool_exp
  ): [quest_role!]!

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

    """filter the rows returned"""
    where: quest_role_bool_exp
  ): quest_role_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_roles: quest_role_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_roles: quest_role_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_roles_aggregate: quest_role_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!
}

"""
columns and relationships of "quest_role"
"""
type quest_role {
  """An object relationship"""
  PlayerRole: PlayerRole!

  """An object relationship"""
  quest: quest!
  quest_id: uuid!
  rank: Int!
  role: String!
}

"""
aggregated selection of "quest_role"
"""
type quest_role_aggregate {
  aggregate: quest_role_aggregate_fields
  nodes: [quest_role!]!
}

"""
aggregate fields of "quest_role"
"""
type quest_role_aggregate_fields {
  avg: quest_role_avg_fields
  count(columns: [quest_role_select_column!], distinct: Boolean): Int
  max: quest_role_max_fields
  min: quest_role_min_fields
  stddev: quest_role_stddev_fields
  stddev_pop: quest_role_stddev_pop_fields
  stddev_samp: quest_role_stddev_samp_fields
  sum: quest_role_sum_fields
  var_pop: quest_role_var_pop_fields
  var_samp: quest_role_var_samp_fields
  variance: quest_role_variance_fields
}

"""
order by aggregate values of table "quest_role"
"""
input quest_role_aggregate_order_by {
  avg: quest_role_avg_order_by
  count: order_by
  max: quest_role_max_order_by
  min: quest_role_min_order_by
  stddev: quest_role_stddev_order_by
  stddev_pop: quest_role_stddev_pop_order_by
  stddev_samp: quest_role_stddev_samp_order_by
  sum: quest_role_sum_order_by
  var_pop: quest_role_var_pop_order_by
  var_samp: quest_role_var_samp_order_by
  variance: quest_role_variance_order_by
}

"""
input type for inserting array relation for remote table "quest_role"
"""
input quest_role_arr_rel_insert_input {
  data: [quest_role_insert_input!]!
  on_conflict: quest_role_on_conflict
}

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

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

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

"""
unique or primary key constraints on table "quest_role"
"""
enum quest_role_constraint {
  """unique or primary key constraint"""
  quest_role_pkey

  """unique or primary key constraint"""
  quest_role_quest_id_key
}

"""
input type for incrementing integer column in table "quest_role"
"""
input quest_role_inc_input {
  rank: Int
}

"""
input type for inserting data into table "quest_role"
"""
input quest_role_insert_input {
  PlayerRole: PlayerRole_obj_rel_insert_input
  quest: quest_obj_rel_insert_input
  quest_id: uuid
  rank: Int
  role: String
}

"""aggregate max on columns"""
type quest_role_max_fields {
  quest_id: uuid
  rank: Int
  role: String
}

"""
order by max() on columns of table "quest_role"
"""
input quest_role_max_order_by {
  quest_id: order_by
  rank: order_by
  role: order_by
}

"""aggregate min on columns"""
type quest_role_min_fields {
  quest_id: uuid
  rank: Int
  role: String
}

"""
order by min() on columns of table "quest_role"
"""
input quest_role_min_order_by {
  quest_id: order_by
  rank: order_by
  role: order_by
}

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

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

"""
input type for inserting object relation for remote table "quest_role"
"""
input quest_role_obj_rel_insert_input {
  data: quest_role_insert_input!
  on_conflict: quest_role_on_conflict
}

"""
on conflict condition type for table "quest_role"
"""
input quest_role_on_conflict {
  constraint: quest_role_constraint!
  update_columns: [quest_role_update_column!]!
  where: quest_role_bool_exp
}

"""
ordering options when selecting data from "quest_role"
"""
input quest_role_order_by {
  PlayerRole: PlayerRole_order_by
  quest: quest_order_by
  quest_id: order_by
  rank: order_by
  role: order_by
}

"""
primary key columns input for table: "quest_role"
"""
input quest_role_pk_columns_input {
  quest_id: uuid!
  role: String!
}

"""
select columns of table "quest_role"
"""
enum quest_role_select_column {
  """column name"""
  quest_id

  """column name"""
  rank

  """column name"""
  role
}

"""
input type for updating data in table "quest_role"
"""
input quest_role_set_input {
  quest_id: uuid
  rank: Int
  role: String
}

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

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

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

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

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

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

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

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

"""
update columns of table "quest_role"
"""
enum quest_role_update_column {
  """column name"""
  quest_id

  """column name"""
  rank

  """column name"""
  role
}

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

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

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

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

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

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

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

"""
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_role"
  """
  quest_role(
    """distinct select on columns"""
    distinct_on: [quest_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: [quest_role_order_by!]

    """filter the rows returned"""
    where: quest_role_bool_exp
  ): [quest_role!]!

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

    """filter the rows returned"""
    where: quest_role_bool_exp
  ): quest_role_aggregate!

  """fetch data from the table: "quest_role" using primary key columns"""
  quest_role_by_pk(quest_id: uuid!, role: String!): quest_role

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

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