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
  MEETWITHWALLET
  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 BrightIdStatus {
  app: String!
  context: String!
  contextIds: [String!]!
  unique: Boolean!
}

type CacheProcessOutput {
  error: String
  queued: Boolean!
  success: Boolean!
}

type CollectiblesFavorites {
  address: String
  tokenId: String
}

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

  """An array relationship"""
  profiles(
    """distinct select on columns"""
    distinct_on: [profile_select_column!]

    """limit the number of rows returned"""
    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_order_by!]

    """filter the rows returned"""
    where: profile_bool_exp
  ): [profile!]!

  """An aggregated array relationship"""
  profiles_aggregate(
    """distinct select on columns"""
    distinct_on: [profile_select_column!]

    """limit the number of rows returned"""
    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_order_by!]

    """filter the rows returned"""
    where: profile_bool_exp
  ): profile_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
  profiles: profile_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
  profiles: profile_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
  profiles_aggregate: profile_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 {
  questId: String!
  submissionLink: String
  submissionText: String
}

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

input CreateQuestInput {
  cooldown: Int
  description: String
  externalLink: String
  guildId: uuid!
  repetition: QuestRepetition_ActionEnum
  roleIds: [uuid]!
  skillIds: [uuid]!
  title: String!
}

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

"""
columns and relationships of "dao"
"""
type dao {
  contractAddress: String!

  """An object relationship"""
  guild: guild
  guildId: uuid
  id: uuid!
  label: String
  network: String!

  """An array relationship"""
  players(
    """distinct select on columns"""
    distinct_on: [dao_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: [dao_player_order_by!]

    """filter the rows returned"""
    where: dao_player_bool_exp
  ): [dao_player!]!

  """An aggregated array relationship"""
  players_aggregate(
    """distinct select on columns"""
    distinct_on: [dao_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: [dao_player_order_by!]

    """filter the rows returned"""
    where: dao_player_bool_exp
  ): dao_player_aggregate!
  url: String
}

"""
aggregated selection of "dao"
"""
type dao_aggregate {
  aggregate: dao_aggregate_fields
  nodes: [dao!]!
}

"""
aggregate fields of "dao"
"""
type dao_aggregate_fields {
  count(columns: [dao_select_column!], distinct: Boolean): Int
  max: dao_max_fields
  min: dao_min_fields
}

"""
order by aggregate values of table "dao"
"""
input dao_aggregate_order_by {
  count: order_by
  max: dao_max_order_by
  min: dao_min_order_by
}

"""
input type for inserting array relation for remote table "dao"
"""
input dao_arr_rel_insert_input {
  data: [dao_insert_input!]!
  on_conflict: dao_on_conflict
}

"""
Boolean expression to filter rows from the table "dao". All fields are combined with a logical 'AND'.
"""
input dao_bool_exp {
  _and: [dao_bool_exp]
  _not: dao_bool_exp
  _or: [dao_bool_exp]
  contractAddress: String_comparison_exp
  guild: guild_bool_exp
  guildId: uuid_comparison_exp
  id: uuid_comparison_exp
  label: String_comparison_exp
  network: String_comparison_exp
  players: dao_player_bool_exp
  url: String_comparison_exp
}

"""
unique or primary key constraints on table "dao"
"""
enum dao_constraint {
  """unique or primary key constraint"""
  dao_contract_address_key

  """unique or primary key constraint"""
  dao_pkey
}

"""
input type for inserting data into table "dao"
"""
input dao_insert_input {
  contractAddress: String
  guild: guild_obj_rel_insert_input
  guildId: uuid
  id: uuid
  label: String
  network: String
  players: dao_player_arr_rel_insert_input
  url: String
}

"""aggregate max on columns"""
type dao_max_fields {
  contractAddress: String
  guildId: uuid
  id: uuid
  label: String
  network: String
  url: String
}

"""
order by max() on columns of table "dao"
"""
input dao_max_order_by {
  contractAddress: order_by
  guildId: order_by
  id: order_by
  label: order_by
  network: order_by
  url: order_by
}

"""aggregate min on columns"""
type dao_min_fields {
  contractAddress: String
  guildId: uuid
  id: uuid
  label: String
  network: String
  url: String
}

"""
order by min() on columns of table "dao"
"""
input dao_min_order_by {
  contractAddress: order_by
  guildId: order_by
  id: order_by
  label: order_by
  network: order_by
  url: order_by
}

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

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

"""
input type for inserting object relation for remote table "dao"
"""
input dao_obj_rel_insert_input {
  data: dao_insert_input!
  on_conflict: dao_on_conflict
}

"""
on conflict condition type for table "dao"
"""
input dao_on_conflict {
  constraint: dao_constraint!
  update_columns: [dao_update_column!]!
  where: dao_bool_exp
}

"""
ordering options when selecting data from "dao"
"""
input dao_order_by {
  contractAddress: order_by
  guild: guild_order_by
  guildId: order_by
  id: order_by
  label: order_by
  network: order_by
  players_aggregate: dao_player_aggregate_order_by
  url: order_by
}

"""
primary key columns input for table: "dao"
"""
input dao_pk_columns_input {
  id: uuid!
}

"""
columns and relationships of "dao_player"
"""
type dao_player {
  daoId: uuid!
  playerId: uuid!
  visible: Boolean
}

"""
aggregated selection of "dao_player"
"""
type dao_player_aggregate {
  aggregate: dao_player_aggregate_fields
  nodes: [dao_player!]!
}

"""
aggregate fields of "dao_player"
"""
type dao_player_aggregate_fields {
  count(columns: [dao_player_select_column!], distinct: Boolean): Int
  max: dao_player_max_fields
  min: dao_player_min_fields
}

"""
order by aggregate values of table "dao_player"
"""
input dao_player_aggregate_order_by {
  count: order_by
  max: dao_player_max_order_by
  min: dao_player_min_order_by
}

"""
input type for inserting array relation for remote table "dao_player"
"""
input dao_player_arr_rel_insert_input {
  data: [dao_player_insert_input!]!
  on_conflict: dao_player_on_conflict
}

"""
Boolean expression to filter rows from the table "dao_player". All fields are combined with a logical 'AND'.
"""
input dao_player_bool_exp {
  _and: [dao_player_bool_exp]
  _not: dao_player_bool_exp
  _or: [dao_player_bool_exp]
  daoId: uuid_comparison_exp
  playerId: uuid_comparison_exp
  visible: Boolean_comparison_exp
}

"""
unique or primary key constraints on table "dao_player"
"""
enum dao_player_constraint {
  """unique or primary key constraint"""
  dao_player_pkey
}

"""
input type for inserting data into table "dao_player"
"""
input dao_player_insert_input {
  daoId: uuid
  playerId: uuid
  visible: Boolean
}

"""aggregate max on columns"""
type dao_player_max_fields {
  daoId: uuid
  playerId: uuid
}

"""
order by max() on columns of table "dao_player"
"""
input dao_player_max_order_by {
  daoId: order_by
  playerId: order_by
}

"""aggregate min on columns"""
type dao_player_min_fields {
  daoId: uuid
  playerId: uuid
}

"""
order by min() on columns of table "dao_player"
"""
input dao_player_min_order_by {
  daoId: order_by
  playerId: order_by
}

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

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

"""
input type for inserting object relation for remote table "dao_player"
"""
input dao_player_obj_rel_insert_input {
  data: dao_player_insert_input!
  on_conflict: dao_player_on_conflict
}

"""
on conflict condition type for table "dao_player"
"""
input dao_player_on_conflict {
  constraint: dao_player_constraint!
  update_columns: [dao_player_update_column!]!
  where: dao_player_bool_exp
}

"""
ordering options when selecting data from "dao_player"
"""
input dao_player_order_by {
  daoId: order_by
  playerId: order_by
  visible: order_by
}

"""
primary key columns input for table: "dao_player"
"""
input dao_player_pk_columns_input {
  daoId: uuid!
  playerId: uuid!
}

"""
select columns of table "dao_player"
"""
enum dao_player_select_column {
  """column name"""
  daoId

  """column name"""
  playerId

  """column name"""
  visible
}

"""
input type for updating data in table "dao_player"
"""
input dao_player_set_input {
  daoId: uuid
  playerId: uuid
  visible: Boolean
}

"""
update columns of table "dao_player"
"""
enum dao_player_update_column {
  """column name"""
  daoId

  """column name"""
  playerId

  """column name"""
  visible
}

"""
select columns of table "dao"
"""
enum dao_select_column {
  """column name"""
  contractAddress

  """column name"""
  guildId

  """column name"""
  id

  """column name"""
  label

  """column name"""
  network

  """column name"""
  url
}

"""
input type for updating data in table "dao"
"""
input dao_set_input {
  contractAddress: String
  guildId: uuid
  id: uuid
  label: String
  network: String
  url: String
}

"""
update columns of table "dao"
"""
enum dao_update_column {
  """column name"""
  contractAddress

  """column name"""
  guildId

  """column name"""
  id

  """column name"""
  label

  """column name"""
  network

  """column name"""
  url
}

type DaoMetadata {
  avatarImg: String
  contractAddress: String!
  description: String!
  name: String!
  network: String!
}

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 "ExplorerType"
"""
type ExplorerType {
  description: String!
  id: Int!
  imageURL: String

  """An array relationship"""
  profiles(
    """distinct select on columns"""
    distinct_on: [profile_select_column!]

    """limit the number of rows returned"""
    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_order_by!]

    """filter the rows returned"""
    where: profile_bool_exp
  ): [profile!]!

  """An aggregated array relationship"""
  profiles_aggregate(
    """distinct select on columns"""
    distinct_on: [profile_select_column!]

    """limit the number of rows returned"""
    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_order_by!]

    """filter the rows returned"""
    where: profile_bool_exp
  ): profile_aggregate!
  title: String!
}

"""
aggregated selection of "ExplorerType"
"""
type ExplorerType_aggregate {
  aggregate: ExplorerType_aggregate_fields
  nodes: [ExplorerType!]!
}

"""
aggregate fields of "ExplorerType"
"""
type ExplorerType_aggregate_fields {
  avg: ExplorerType_avg_fields
  count(columns: [ExplorerType_select_column!], distinct: Boolean): Int
  max: ExplorerType_max_fields
  min: ExplorerType_min_fields
  stddev: ExplorerType_stddev_fields
  stddev_pop: ExplorerType_stddev_pop_fields
  stddev_samp: ExplorerType_stddev_samp_fields
  sum: ExplorerType_sum_fields
  var_pop: ExplorerType_var_pop_fields
  var_samp: ExplorerType_var_samp_fields
  variance: ExplorerType_variance_fields
}

"""
order by aggregate values of table "ExplorerType"
"""
input ExplorerType_aggregate_order_by {
  avg: ExplorerType_avg_order_by
  count: order_by
  max: ExplorerType_max_order_by
  min: ExplorerType_min_order_by
  stddev: ExplorerType_stddev_order_by
  stddev_pop: ExplorerType_stddev_pop_order_by
  stddev_samp: ExplorerType_stddev_samp_order_by
  sum: ExplorerType_sum_order_by
  var_pop: ExplorerType_var_pop_order_by
  var_samp: ExplorerType_var_samp_order_by
  variance: ExplorerType_variance_order_by
}

"""
input type for inserting array relation for remote table "ExplorerType"
"""
input ExplorerType_arr_rel_insert_input {
  data: [ExplorerType_insert_input!]!
  on_conflict: ExplorerType_on_conflict
}

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

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

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

"""
unique or primary key constraints on table "ExplorerType"
"""
enum ExplorerType_constraint {
  """unique or primary key constraint"""
  PlayerType_pkey

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

"""
input type for incrementing integer column in table "ExplorerType"
"""
input ExplorerType_inc_input {
  id: Int
}

"""
input type for inserting data into table "ExplorerType"
"""
input ExplorerType_insert_input {
  description: String
  id: Int
  imageURL: String
  profiles: profile_arr_rel_insert_input
  title: String
}

"""aggregate max on columns"""
type ExplorerType_max_fields {
  description: String
  id: Int
  imageURL: String
  title: String
}

"""
order by max() on columns of table "ExplorerType"
"""
input ExplorerType_max_order_by {
  description: order_by
  id: order_by
  imageURL: order_by
  title: order_by
}

"""aggregate min on columns"""
type ExplorerType_min_fields {
  description: String
  id: Int
  imageURL: String
  title: String
}

"""
order by min() on columns of table "ExplorerType"
"""
input ExplorerType_min_order_by {
  description: order_by
  id: order_by
  imageURL: order_by
  title: order_by
}

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

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

"""
input type for inserting object relation for remote table "ExplorerType"
"""
input ExplorerType_obj_rel_insert_input {
  data: ExplorerType_insert_input!
  on_conflict: ExplorerType_on_conflict
}

"""
on conflict condition type for table "ExplorerType"
"""
input ExplorerType_on_conflict {
  constraint: ExplorerType_constraint!
  update_columns: [ExplorerType_update_column!]!
  where: ExplorerType_bool_exp
}

"""
ordering options when selecting data from "ExplorerType"
"""
input ExplorerType_order_by {
  description: order_by
  id: order_by
  imageURL: order_by
  profiles_aggregate: profile_aggregate_order_by
  title: order_by
}

"""
primary key columns input for table: "ExplorerType"
"""
input ExplorerType_pk_columns_input {
  id: Int!
}

"""
select columns of table "ExplorerType"
"""
enum ExplorerType_select_column {
  """column name"""
  description

  """column name"""
  id

  """column name"""
  imageURL

  """column name"""
  title
}

"""
input type for updating data in table "ExplorerType"
"""
input ExplorerType_set_input {
  description: String
  id: Int
  imageURL: String
  title: String
}

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

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

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

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

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

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

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

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

"""
update columns of table "ExplorerType"
"""
enum ExplorerType_update_column {
  """column name"""
  description

  """column name"""
  id

  """column name"""
  imageURL

  """column name"""
  title
}

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

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

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

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

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

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

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

  """An array relationship"""
  daos(
    """distinct select on columns"""
    distinct_on: [dao_select_column!]

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

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

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

    """filter the rows returned"""
    where: dao_bool_exp
  ): [dao!]!

  """An aggregated array relationship"""
  daos_aggregate(
    """distinct select on columns"""
    distinct_on: [dao_select_column!]

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

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

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

    """filter the rows returned"""
    where: dao_bool_exp
  ): dao_aggregate!
  description: String

  """Remote relationship field"""
  discordAnnouncements: [String!]
  discordId: String
  discordInviteUrl: String
  githubUrl: 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!
  joinButtonUrl: String
  logo: String
  membershipThroughDiscord: Boolean!

  """An object relationship"""
  metadata: guild_metadata
  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!
  showDiscordAnnouncements: Boolean!
  status: GuildStatus_enum!
  twitterUrl: String

  """The area of focus for the guild (e.g. funding, project, etc)"""
  type: GuildType_enum!
  websiteUrl: 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]
  daos: dao_bool_exp
  description: String_comparison_exp
  discordId: String_comparison_exp
  discordInviteUrl: String_comparison_exp
  githubUrl: String_comparison_exp
  guild_players: guild_player_bool_exp
  guildname: String_comparison_exp
  id: uuid_comparison_exp
  joinButtonUrl: String_comparison_exp
  logo: String_comparison_exp
  membershipThroughDiscord: Boolean_comparison_exp
  metadata: guild_metadata_bool_exp
  name: String_comparison_exp
  position: GuildPosition_enum_comparison_exp
  quests: quest_bool_exp
  showDiscordAnnouncements: Boolean_comparison_exp
  status: GuildStatus_enum_comparison_exp
  twitterUrl: String_comparison_exp
  type: GuildType_enum_comparison_exp
  websiteUrl: 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
  daos: dao_arr_rel_insert_input
  description: String
  discordId: String
  discordInviteUrl: String
  githubUrl: String
  guild_players: guild_player_arr_rel_insert_input
  guildname: String
  id: uuid
  joinButtonUrl: String
  logo: String
  membershipThroughDiscord: Boolean
  metadata: guild_metadata_obj_rel_insert_input
  name: String
  position: GuildPosition_enum
  quests: quest_arr_rel_insert_input
  showDiscordAnnouncements: Boolean
  status: GuildStatus_enum
  twitterUrl: String
  type: GuildType_enum
  websiteUrl: String
}

"""aggregate max on columns"""
type guild_max_fields {
  description: String
  discordId: String
  discordInviteUrl: String
  githubUrl: String
  guildname: String
  id: uuid
  joinButtonUrl: String
  logo: String
  name: String
  twitterUrl: String
  websiteUrl: String
}

"""
order by max() on columns of table "guild"
"""
input guild_max_order_by {
  description: order_by
  discordId: order_by
  discordInviteUrl: order_by
  githubUrl: order_by
  guildname: order_by
  id: order_by
  joinButtonUrl: order_by
  logo: order_by
  name: order_by
  twitterUrl: order_by
  websiteUrl: order_by
}

"""
Used to hold private information for guilds


columns and relationships of "guild_metadata"

"""
type guild_metadata {
  creatorId: uuid
  discordId: String!
  discordMetadata(
    """JSON select path"""
    path: String
  ): jsonb

  """Remote relationship field"""
  discordRoles: [DiscordRole!]!

  """An object relationship"""
  guild: guild!
  guildId: 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 {
  discordMetadata: 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]
  creatorId: uuid_comparison_exp
  discordId: String_comparison_exp
  discordMetadata: jsonb_comparison_exp
  guild: guild_bool_exp
  guildId: 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 {
  discordMetadata: [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 {
  discordMetadata: Int
}

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

"""
input type for inserting data into table "guild_metadata"
"""
input guild_metadata_insert_input {
  creatorId: uuid
  discordId: String
  discordMetadata: jsonb
  guild: guild_obj_rel_insert_input
  guildId: uuid
  player: player_obj_rel_insert_input
}

"""aggregate max on columns"""
type guild_metadata_max_fields {
  creatorId: uuid
  discordId: String
  guildId: uuid
}

"""
order by max() on columns of table "guild_metadata"
"""
input guild_metadata_max_order_by {
  creatorId: order_by
  discordId: order_by
  guildId: order_by
}

"""aggregate min on columns"""
type guild_metadata_min_fields {
  creatorId: uuid
  discordId: String
  guildId: uuid
}

"""
order by min() on columns of table "guild_metadata"
"""
input guild_metadata_min_order_by {
  creatorId: order_by
  discordId: order_by
  guildId: 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 {
  creatorId: order_by
  discordId: order_by
  discordMetadata: order_by
  guild: guild_order_by
  guildId: order_by
  player: player_order_by
}

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

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

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

  """column name"""
  discordId

  """column name"""
  discordMetadata

  """column name"""
  guildId
}

"""
input type for updating data in table "guild_metadata"
"""
input guild_metadata_set_input {
  creatorId: uuid
  discordId: String
  discordMetadata: jsonb
  guildId: uuid
}

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

  """column name"""
  discordId

  """column name"""
  discordMetadata

  """column name"""
  guildId
}

"""aggregate min on columns"""
type guild_min_fields {
  description: String
  discordId: String
  discordInviteUrl: String
  githubUrl: String
  guildname: String
  id: uuid
  joinButtonUrl: String
  logo: String
  name: String
  twitterUrl: String
  websiteUrl: String
}

"""
order by min() on columns of table "guild"
"""
input guild_min_order_by {
  description: order_by
  discordId: order_by
  discordInviteUrl: order_by
  githubUrl: order_by
  guildname: order_by
  id: order_by
  joinButtonUrl: order_by
  logo: order_by
  name: order_by
  twitterUrl: order_by
  websiteUrl: 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
  daos_aggregate: dao_aggregate_order_by
  description: order_by
  discordId: order_by
  discordInviteUrl: order_by
  githubUrl: order_by
  guild_players_aggregate: guild_player_aggregate_order_by
  guildname: order_by
  id: order_by
  joinButtonUrl: order_by
  logo: order_by
  membershipThroughDiscord: order_by
  metadata: guild_metadata_order_by
  name: order_by
  position: order_by
  quests_aggregate: quest_aggregate_order_by
  showDiscordAnnouncements: order_by
  status: order_by
  twitterUrl: order_by
  type: order_by
  websiteUrl: 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!]!
  guildId: uuid!
  playerId: 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]
  guildId: uuid_comparison_exp
  playerId: 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
  guildId: uuid
  playerId: uuid
}

"""aggregate max on columns"""
type guild_player_max_fields {
  guildId: uuid
  playerId: uuid
}

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

"""aggregate min on columns"""
type guild_player_min_fields {
  guildId: uuid
  playerId: uuid
}

"""
order by min() on columns of table "guild_player"
"""
input guild_player_min_order_by {
  guildId: order_by
  playerId: 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
  guildId: order_by
  playerId: order_by
}

"""
primary key columns input for table: "guild_player"
"""
input guild_player_pk_columns_input {
  guildId: uuid!
  playerId: uuid!
}

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

  """column name"""
  playerId
}

"""
input type for updating data in table "guild_player"
"""
input guild_player_set_input {
  guildId: uuid
  playerId: uuid
}

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

  """column name"""
  playerId
}

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

  """column name"""
  discordId

  """column name"""
  discordInviteUrl

  """column name"""
  githubUrl

  """column name"""
  guildname

  """column name"""
  id

  """column name"""
  joinButtonUrl

  """column name"""
  logo

  """column name"""
  membershipThroughDiscord

  """column name"""
  name

  """column name"""
  position

  """column name"""
  showDiscordAnnouncements

  """column name"""
  status

  """column name"""
  twitterUrl

  """column name"""
  type

  """column name"""
  websiteUrl
}

"""
input type for updating data in table "guild"
"""
input guild_set_input {
  description: String
  discordId: String
  discordInviteUrl: String
  githubUrl: String
  guildname: String
  id: uuid
  joinButtonUrl: String
  logo: String
  membershipThroughDiscord: Boolean
  name: String
  position: GuildPosition_enum
  showDiscordAnnouncements: Boolean
  status: GuildStatus_enum
  twitterUrl: String
  type: GuildType_enum
  websiteUrl: String
}

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

  """column name"""
  discordId

  """column name"""
  discordInviteUrl

  """column name"""
  githubUrl

  """column name"""
  guildname

  """column name"""
  id

  """column name"""
  joinButtonUrl

  """column name"""
  logo

  """column name"""
  membershipThroughDiscord

  """column name"""
  name

  """column name"""
  position

  """column name"""
  showDiscordAnnouncements

  """column name"""
  status

  """column name"""
  twitterUrl

  """column name"""
  type

  """column name"""
  websiteUrl
}

input GuildDaoInput {
  contractAddress: String!
  label: String
  network: String!
  url: String
}

input GuildInfoInput {
  daos: [GuildDaoInput!]
  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 {
  ethereumAddress: 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
}

"""
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]
  ethereumAddress: String_comparison_exp
  id: uuid_comparison_exp
  player: player_bool_exp
  username: String_comparison_exp
}

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

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

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

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

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

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

  """column name"""
  id

  """column name"""
  username
}

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

type Moloch {
  avatarURL: String
  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: "ExplorerType"
  """
  delete_ExplorerType(
    """filter the rows which have to be deleted"""
    where: ExplorerType_bool_exp!
  ): ExplorerType_mutation_response

  """
  delete single row from the table: "ExplorerType"
  """
  delete_ExplorerType_by_pk(id: Int!): ExplorerType

  """
  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: "dao"
  """
  delete_dao(
    """filter the rows which have to be deleted"""
    where: dao_bool_exp!
  ): dao_mutation_response

  """
  delete single row from the table: "dao"
  """
  delete_dao_by_pk(id: uuid!): dao

  """
  delete data from the table: "dao_player"
  """
  delete_dao_player(
    """filter the rows which have to be deleted"""
    where: dao_player_bool_exp!
  ): dao_player_mutation_response

  """
  delete single row from the table: "dao_player"
  """
  delete_dao_player_by_pk(daoId: uuid!, playerId: uuid!): dao_player

  """
  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(guildId: 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(guildId: uuid!, playerId: uuid!): guild_player

  """
  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: "profile"
  """
  delete_profile(
    """filter the rows which have to be deleted"""
    where: profile_bool_exp!
  ): profile_mutation_response

  """
  delete single row from the table: "profile"
  """
  delete_profile_by_pk(id: uuid!): profile

  """
  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(questId: 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(questId: uuid!, skillId: 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: "ExplorerType"
  """
  insert_ExplorerType(
    """the rows to be inserted"""
    objects: [ExplorerType_insert_input!]!

    """on conflict condition"""
    on_conflict: ExplorerType_on_conflict
  ): ExplorerType_mutation_response

  """
  insert a single row into the table: "ExplorerType"
  """
  insert_ExplorerType_one(
    """the row to be inserted"""
    object: ExplorerType_insert_input!

    """on conflict condition"""
    on_conflict: ExplorerType_on_conflict
  ): ExplorerType

  """
  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: "dao"
  """
  insert_dao(
    """the rows to be inserted"""
    objects: [dao_insert_input!]!

    """on conflict condition"""
    on_conflict: dao_on_conflict
  ): dao_mutation_response

  """
  insert a single row into the table: "dao"
  """
  insert_dao_one(
    """the row to be inserted"""
    object: dao_insert_input!

    """on conflict condition"""
    on_conflict: dao_on_conflict
  ): dao

  """
  insert data into the table: "dao_player"
  """
  insert_dao_player(
    """the rows to be inserted"""
    objects: [dao_player_insert_input!]!

    """on conflict condition"""
    on_conflict: dao_player_on_conflict
  ): dao_player_mutation_response

  """
  insert a single row into the table: "dao_player"
  """
  insert_dao_player_one(
    """the row to be inserted"""
    object: dao_player_insert_input!

    """on conflict condition"""
    on_conflict: dao_player_on_conflict
  ): dao_player

  """
  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: "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: "profile"
  """
  insert_profile(
    """the rows to be inserted"""
    objects: [profile_insert_input!]!

    """on conflict condition"""
    on_conflict: profile_on_conflict
  ): profile_mutation_response

  """
  insert a single row into the table: "profile"
  """
  insert_profile_one(
    """the row to be inserted"""
    object: profile_insert_input!

    """on conflict condition"""
    on_conflict: profile_on_conflict
  ): profile

  """
  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: GuildInfoInput!): 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: "ExplorerType"
  """
  update_ExplorerType(
    """increments the integer columns with given value of the filtered values"""
    _inc: ExplorerType_inc_input

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

    """filter the rows which have to be updated"""
    where: ExplorerType_bool_exp!
  ): ExplorerType_mutation_response

  """
  update single row of the table: "ExplorerType"
  """
  update_ExplorerType_by_pk(
    """increments the integer columns with given value of the filtered values"""
    _inc: ExplorerType_inc_input

    """sets the columns of the filtered rows to the given values"""
    _set: ExplorerType_set_input
    pk_columns: ExplorerType_pk_columns_input!
  ): ExplorerType

  """
  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: "dao"
  """
  update_dao(
    """sets the columns of the filtered rows to the given values"""
    _set: dao_set_input

    """filter the rows which have to be updated"""
    where: dao_bool_exp!
  ): dao_mutation_response

  """
  update single row of the table: "dao"
  """
  update_dao_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: dao_set_input
    pk_columns: dao_pk_columns_input!
  ): dao

  """
  update data of the table: "dao_player"
  """
  update_dao_player(
    """sets the columns of the filtered rows to the given values"""
    _set: dao_player_set_input

    """filter the rows which have to be updated"""
    where: dao_player_bool_exp!
  ): dao_player_mutation_response

  """
  update single row of the table: "dao_player"
  """
  update_dao_player_by_pk(
    """sets the columns of the filtered rows to the given values"""
    _set: dao_player_set_input
    pk_columns: dao_player_pk_columns_input!
  ): dao_player

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

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

    """filter the rows which have to be updated"""
    where: profile_bool_exp!
  ): profile_mutation_response

  """
  update single row of the table: "profile"
  """
  update_profile_by_pk(
    """increments the integer columns with given value of the filtered values"""
    _inc: profile_inc_input

    """sets the columns of the filtered rows to the given values"""
    _set: profile_set_input
    pk_columns: profile_pk_columns_input!
  ): profile

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

  """Remote relationship field"""
  brightid_status: BrightIdStatus
  createdAt: timestamptz

  """Remote relationship field"""
  daohausMemberships: [Member!]!

  """An array relationship"""
  daos(
    """distinct select on columns"""
    distinct_on: [dao_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: [dao_player_order_by!]

    """filter the rows returned"""
    where: dao_player_bool_exp
  ): [dao_player!]!

  """An aggregated array relationship"""
  daos_aggregate(
    """distinct select on columns"""
    distinct_on: [dao_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: [dao_player_order_by!]

    """filter the rows returned"""
    where: dao_player_bool_exp
  ): dao_player_aggregate!
  discordId: String
  ethereumAddress: 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!

  """An object relationship"""
  profile: profile
  profileLayout: 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!
  seasonXP: 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!

  """Remote relationship field"""
  token_balances: TokenBalances
  totalXP: numeric
  updatedAt: timestamptz
}

"""
columns and relationships of "player_account"
"""
type player_account {
  """An object relationship"""
  Player: player!
  identifier: String!
  playerId: 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
  playerId: 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
  playerId: uuid
  type: AccountType_enum
}

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

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

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

"""
order by min() on columns of table "player_account"
"""
input player_account_min_order_by {
  identifier: order_by
  playerId: 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
  playerId: order_by
  type: order_by
}

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

  """column name"""
  playerId

  """column name"""
  type
}

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

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

  """column name"""
  playerId

  """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 {
  seasonXP: Float
  totalXP: Float
}

"""
order by avg() on columns of table "player"
"""
input player_avg_order_by {
  seasonXP: order_by
  totalXP: order_by
}

"""
Boolean expression to filter rows from the table "player". All fields are combined with a logical 'AND'.
"""
input player_bool_exp {
  _and: [player_bool_exp]
  _not: player_bool_exp
  _or: [player_bool_exp]
  accounts: player_account_bool_exp
  createdAt: timestamptz_comparison_exp
  daos: dao_player_bool_exp
  discordId: String_comparison_exp
  ethereumAddress: String_comparison_exp
  guilds: guild_player_bool_exp
  id: uuid_comparison_exp
  profile: profile_bool_exp
  profileLayout: 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
  seasonXP: numeric_comparison_exp
  skills: player_skill_bool_exp
  totalXP: numeric_comparison_exp
  updatedAt: timestamptz_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_discord_id_key
}

"""
input type for incrementing integer column in table "player"
"""
input player_inc_input {
  seasonXP: numeric
  totalXP: numeric
}

"""
input type for inserting data into table "player"
"""
input player_insert_input {
  accounts: player_account_arr_rel_insert_input
  createdAt: timestamptz
  daos: dao_player_arr_rel_insert_input
  discordId: String
  ethereumAddress: String
  guilds: guild_player_arr_rel_insert_input
  id: uuid
  profile: profile_obj_rel_insert_input
  profileLayout: 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
  seasonXP: numeric
  skills: player_skill_arr_rel_insert_input
  totalXP: numeric
  updatedAt: timestamptz
}

"""aggregate max on columns"""
type player_max_fields {
  createdAt: timestamptz
  discordId: String
  ethereumAddress: String
  id: uuid
  profileLayout: String
  role: String
  seasonXP: numeric
  totalXP: numeric
  updatedAt: timestamptz
}

"""
order by max() on columns of table "player"
"""
input player_max_order_by {
  createdAt: order_by
  discordId: order_by
  ethereumAddress: order_by
  id: order_by
  profileLayout: order_by
  role: order_by
  seasonXP: order_by
  totalXP: order_by
  updatedAt: order_by
}

"""aggregate min on columns"""
type player_min_fields {
  createdAt: timestamptz
  discordId: String
  ethereumAddress: String
  id: uuid
  profileLayout: String
  role: String
  seasonXP: numeric
  totalXP: numeric
  updatedAt: timestamptz
}

"""
order by min() on columns of table "player"
"""
input player_min_order_by {
  createdAt: order_by
  discordId: order_by
  ethereumAddress: order_by
  id: order_by
  profileLayout: order_by
  role: order_by
  seasonXP: order_by
  totalXP: order_by
  updatedAt: 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
  createdAt: order_by
  daos_aggregate: dao_player_aggregate_order_by
  discordId: order_by
  ethereumAddress: order_by
  guilds_aggregate: guild_player_aggregate_order_by
  id: order_by
  profile: profile_order_by
  profileLayout: 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
  seasonXP: order_by
  skills_aggregate: player_skill_aggregate_order_by
  totalXP: order_by
  updatedAt: 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"""
  createdAt

  """column name"""
  discordId

  """column name"""
  ethereumAddress

  """column name"""
  id

  """column name"""
  profileLayout

  """column name"""
  rank

  """column name"""
  role

  """column name"""
  seasonXP

  """column name"""
  totalXP

  """column name"""
  updatedAt
}

"""
input type for updating data in table "player"
"""
input player_set_input {
  createdAt: timestamptz
  discordId: String
  ethereumAddress: String
  id: uuid
  profileLayout: String
  rank: PlayerRank_enum
  role: String
  seasonXP: numeric
  totalXP: numeric
  updatedAt: timestamptz
}

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

  """unique or primary key constraint"""
  player_skill_player_id_skill_id_key
}

"""
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 {
  seasonXP: Float
  totalXP: Float
}

"""
order by stddev() on columns of table "player"
"""
input player_stddev_order_by {
  seasonXP: order_by
  totalXP: order_by
}

"""aggregate stddev_pop on columns"""
type player_stddev_pop_fields {
  seasonXP: Float
  totalXP: Float
}

"""
order by stddev_pop() on columns of table "player"
"""
input player_stddev_pop_order_by {
  seasonXP: order_by
  totalXP: order_by
}

"""aggregate stddev_samp on columns"""
type player_stddev_samp_fields {
  seasonXP: Float
  totalXP: Float
}

"""
order by stddev_samp() on columns of table "player"
"""
input player_stddev_samp_order_by {
  seasonXP: order_by
  totalXP: order_by
}

"""aggregate sum on columns"""
type player_sum_fields {
  seasonXP: numeric
  totalXP: numeric
}

"""
order by sum() on columns of table "player"
"""
input player_sum_order_by {
  seasonXP: order_by
  totalXP: order_by
}

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

  """column name"""
  discordId

  """column name"""
  ethereumAddress

  """column name"""
  id

  """column name"""
  profileLayout

  """column name"""
  rank

  """column name"""
  role

  """column name"""
  seasonXP

  """column name"""
  totalXP

  """column name"""
  updatedAt
}

"""aggregate var_pop on columns"""
type player_var_pop_fields {
  seasonXP: Float
  totalXP: Float
}

"""
order by var_pop() on columns of table "player"
"""
input player_var_pop_order_by {
  seasonXP: order_by
  totalXP: order_by
}

"""aggregate var_samp on columns"""
type player_var_samp_fields {
  seasonXP: Float
  totalXP: Float
}

"""
order by var_samp() on columns of table "player"
"""
input player_var_samp_order_by {
  seasonXP: order_by
  totalXP: order_by
}

"""aggregate variance on columns"""
type player_variance_fields {
  seasonXP: Float
  totalXP: Float
}

"""
order by variance() on columns of table "player"
"""
input player_variance_order_by {
  seasonXP: order_by
  totalXP: 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 {
  basic: Boolean
  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]
  basic: Boolean_comparison_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 {
  basic: Boolean
  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 {
  basic: 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"""
  basic

  """column name"""
  description

  """column name"""
  label

  """column name"""
  role
}

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

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

  """column name"""
  description

  """column name"""
  label

  """column name"""
  role
}

"""
columns and relationships of "profile"
"""
type profile {
  availableHours: Int
  backgroundImageURL: String
  bannerImageURL: String

  """An object relationship"""
  colorAspect: ColorAspect
  colorMask: Int
  countryCode: String
  description: String
  emoji: String

  """An object relationship"""
  explorerType: ExplorerType
  explorerTypeTitle: String
  gender: String
  id: uuid!
  lastCheckedAt: timestamptz
  location: String
  name: String

  """An object relationship"""
  player: player!
  playerId: uuid!
  profileImageURL: String
  pronouns: String
  timeZone: String
  username: String
  website: String
}

"""
aggregated selection of "profile"
"""
type profile_aggregate {
  aggregate: profile_aggregate_fields
  nodes: [profile!]!
}

"""
aggregate fields of "profile"
"""
type profile_aggregate_fields {
  avg: profile_avg_fields
  count(columns: [profile_select_column!], distinct: Boolean): Int
  max: profile_max_fields
  min: profile_min_fields
  stddev: profile_stddev_fields
  stddev_pop: profile_stddev_pop_fields
  stddev_samp: profile_stddev_samp_fields
  sum: profile_sum_fields
  var_pop: profile_var_pop_fields
  var_samp: profile_var_samp_fields
  variance: profile_variance_fields
}

"""
order by aggregate values of table "profile"
"""
input profile_aggregate_order_by {
  avg: profile_avg_order_by
  count: order_by
  max: profile_max_order_by
  min: profile_min_order_by
  stddev: profile_stddev_order_by
  stddev_pop: profile_stddev_pop_order_by
  stddev_samp: profile_stddev_samp_order_by
  sum: profile_sum_order_by
  var_pop: profile_var_pop_order_by
  var_samp: profile_var_samp_order_by
  variance: profile_variance_order_by
}

"""
input type for inserting array relation for remote table "profile"
"""
input profile_arr_rel_insert_input {
  data: [profile_insert_input!]!
  on_conflict: profile_on_conflict
}

"""aggregate avg on columns"""
type profile_avg_fields {
  availableHours: Float
  colorMask: Float
}

"""
order by avg() on columns of table "profile"
"""
input profile_avg_order_by {
  availableHours: order_by
  colorMask: order_by
}

"""
Boolean expression to filter rows from the table "profile". All fields are combined with a logical 'AND'.
"""
input profile_bool_exp {
  _and: [profile_bool_exp]
  _not: profile_bool_exp
  _or: [profile_bool_exp]
  availableHours: Int_comparison_exp
  backgroundImageURL: String_comparison_exp
  bannerImageURL: String_comparison_exp
  colorAspect: ColorAspect_bool_exp
  colorMask: Int_comparison_exp
  countryCode: String_comparison_exp
  description: String_comparison_exp
  emoji: String_comparison_exp
  explorerType: ExplorerType_bool_exp
  explorerTypeTitle: String_comparison_exp
  gender: String_comparison_exp
  id: uuid_comparison_exp
  lastCheckedAt: timestamptz_comparison_exp
  location: String_comparison_exp
  name: String_comparison_exp
  player: player_bool_exp
  playerId: uuid_comparison_exp
  profileImageURL: String_comparison_exp
  pronouns: String_comparison_exp
  timeZone: String_comparison_exp
  username: String_comparison_exp
  website: String_comparison_exp
}

"""
unique or primary key constraints on table "profile"
"""
enum profile_constraint {
  """unique or primary key constraint"""
  profile_cache_pkey

  """unique or primary key constraint"""
  profile_id_key

  """unique or primary key constraint"""
  profile_player_id_key

  """unique or primary key constraint"""
  profile_username_key

  """unique or primary key constraint"""
  username_insensitive_unique_idx
}

"""
input type for incrementing integer column in table "profile"
"""
input profile_inc_input {
  availableHours: Int
  colorMask: Int
}

"""
input type for inserting data into table "profile"
"""
input profile_insert_input {
  availableHours: Int
  backgroundImageURL: String
  bannerImageURL: String
  colorAspect: ColorAspect_obj_rel_insert_input
  colorMask: Int
  countryCode: String
  description: String
  emoji: String
  explorerType: ExplorerType_obj_rel_insert_input
  explorerTypeTitle: String
  gender: String
  id: uuid
  lastCheckedAt: timestamptz
  location: String
  name: String
  player: player_obj_rel_insert_input
  playerId: uuid
  profileImageURL: String
  pronouns: String
  timeZone: String
  username: String
  website: String
}

"""aggregate max on columns"""
type profile_max_fields {
  availableHours: Int
  backgroundImageURL: String
  bannerImageURL: String
  colorMask: Int
  countryCode: String
  description: String
  emoji: String
  explorerTypeTitle: String
  gender: String
  id: uuid
  lastCheckedAt: timestamptz
  location: String
  name: String
  playerId: uuid
  profileImageURL: String
  pronouns: String
  timeZone: String
  username: String
  website: String
}

"""
order by max() on columns of table "profile"
"""
input profile_max_order_by {
  availableHours: order_by
  backgroundImageURL: order_by
  bannerImageURL: order_by
  colorMask: order_by
  countryCode: order_by
  description: order_by
  emoji: order_by
  explorerTypeTitle: order_by
  gender: order_by
  id: order_by
  lastCheckedAt: order_by
  location: order_by
  name: order_by
  playerId: order_by
  profileImageURL: order_by
  pronouns: order_by
  timeZone: order_by
  username: order_by
  website: order_by
}

"""aggregate min on columns"""
type profile_min_fields {
  availableHours: Int
  backgroundImageURL: String
  bannerImageURL: String
  colorMask: Int
  countryCode: String
  description: String
  emoji: String
  explorerTypeTitle: String
  gender: String
  id: uuid
  lastCheckedAt: timestamptz
  location: String
  name: String
  playerId: uuid
  profileImageURL: String
  pronouns: String
  timeZone: String
  username: String
  website: String
}

"""
order by min() on columns of table "profile"
"""
input profile_min_order_by {
  availableHours: order_by
  backgroundImageURL: order_by
  bannerImageURL: order_by
  colorMask: order_by
  countryCode: order_by
  description: order_by
  emoji: order_by
  explorerTypeTitle: order_by
  gender: order_by
  id: order_by
  lastCheckedAt: order_by
  location: order_by
  name: order_by
  playerId: order_by
  profileImageURL: order_by
  pronouns: order_by
  timeZone: order_by
  username: order_by
  website: order_by
}

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

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

"""
input type for inserting object relation for remote table "profile"
"""
input profile_obj_rel_insert_input {
  data: profile_insert_input!
  on_conflict: profile_on_conflict
}

"""
on conflict condition type for table "profile"
"""
input profile_on_conflict {
  constraint: profile_constraint!
  update_columns: [profile_update_column!]!
  where: profile_bool_exp
}

"""
ordering options when selecting data from "profile"
"""
input profile_order_by {
  availableHours: order_by
  backgroundImageURL: order_by
  bannerImageURL: order_by
  colorAspect: ColorAspect_order_by
  colorMask: order_by
  countryCode: order_by
  description: order_by
  emoji: order_by
  explorerType: ExplorerType_order_by
  explorerTypeTitle: order_by
  gender: order_by
  id: order_by
  lastCheckedAt: order_by
  location: order_by
  name: order_by
  player: player_order_by
  playerId: order_by
  profileImageURL: order_by
  pronouns: order_by
  timeZone: order_by
  username: order_by
  website: order_by
}

"""
primary key columns input for table: "profile"
"""
input profile_pk_columns_input {
  id: uuid!
}

"""
select columns of table "profile"
"""
enum profile_select_column {
  """column name"""
  availableHours

  """column name"""
  backgroundImageURL

  """column name"""
  bannerImageURL

  """column name"""
  colorMask

  """column name"""
  countryCode

  """column name"""
  description

  """column name"""
  emoji

  """column name"""
  explorerTypeTitle

  """column name"""
  gender

  """column name"""
  id

  """column name"""
  lastCheckedAt

  """column name"""
  location

  """column name"""
  name

  """column name"""
  playerId

  """column name"""
  profileImageURL

  """column name"""
  pronouns

  """column name"""
  timeZone

  """column name"""
  username

  """column name"""
  website
}

"""
input type for updating data in table "profile"
"""
input profile_set_input {
  availableHours: Int
  backgroundImageURL: String
  bannerImageURL: String
  colorMask: Int
  countryCode: String
  description: String
  emoji: String
  explorerTypeTitle: String
  gender: String
  id: uuid
  lastCheckedAt: timestamptz
  location: String
  name: String
  playerId: uuid
  profileImageURL: String
  pronouns: String
  timeZone: String
  username: String
  website: String
}

"""aggregate stddev on columns"""
type profile_stddev_fields {
  availableHours: Float
  colorMask: Float
}

"""
order by stddev() on columns of table "profile"
"""
input profile_stddev_order_by {
  availableHours: order_by
  colorMask: order_by
}

"""aggregate stddev_pop on columns"""
type profile_stddev_pop_fields {
  availableHours: Float
  colorMask: Float
}

"""
order by stddev_pop() on columns of table "profile"
"""
input profile_stddev_pop_order_by {
  availableHours: order_by
  colorMask: order_by
}

"""aggregate stddev_samp on columns"""
type profile_stddev_samp_fields {
  availableHours: Float
  colorMask: Float
}

"""
order by stddev_samp() on columns of table "profile"
"""
input profile_stddev_samp_order_by {
  availableHours: order_by
  colorMask: order_by
}

"""aggregate sum on columns"""
type profile_sum_fields {
  availableHours: Int
  colorMask: Int
}

"""
order by sum() on columns of table "profile"
"""
input profile_sum_order_by {
  availableHours: order_by
  colorMask: order_by
}

"""
update columns of table "profile"
"""
enum profile_update_column {
  """column name"""
  availableHours

  """column name"""
  backgroundImageURL

  """column name"""
  bannerImageURL

  """column name"""
  colorMask

  """column name"""
  countryCode

  """column name"""
  description

  """column name"""
  emoji

  """column name"""
  explorerTypeTitle

  """column name"""
  gender

  """column name"""
  id

  """column name"""
  lastCheckedAt

  """column name"""
  location

  """column name"""
  name

  """column name"""
  playerId

  """column name"""
  profileImageURL

  """column name"""
  pronouns

  """column name"""
  timeZone

  """column name"""
  username

  """column name"""
  website
}

"""aggregate var_pop on columns"""
type profile_var_pop_fields {
  availableHours: Float
  colorMask: Float
}

"""
order by var_pop() on columns of table "profile"
"""
input profile_var_pop_order_by {
  availableHours: order_by
  colorMask: order_by
}

"""aggregate var_samp on columns"""
type profile_var_samp_fields {
  availableHours: Float
  colorMask: Float
}

"""
order by var_samp() on columns of table "profile"
"""
input profile_var_samp_order_by {
  availableHours: order_by
  colorMask: order_by
}

"""aggregate variance on columns"""
type profile_variance_fields {
  availableHours: Float
  colorMask: Float
}

"""
order by variance() on columns of table "profile"
"""
input profile_variance_order_by {
  availableHours: order_by
  colorMask: order_by
}

type Query {
  getBrightIdStatus(contextId: uuid): BrightIdStatus
  getDaoHausMemberships(memberAddress: String): [Member!]!
  getDiscordServerMemberRoles(guildId: uuid!, playerId: uuid!): [DiscordRole!]!
  getGuildDiscordAnnouncements(guildDiscordId: String): [String!]
  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: "ExplorerType"
  """
  ExplorerType(
    """distinct select on columns"""
    distinct_on: [ExplorerType_select_column!]

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

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

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

    """filter the rows returned"""
    where: ExplorerType_bool_exp
  ): [ExplorerType!]!

  """
  fetch aggregated fields from the table: "ExplorerType"
  """
  ExplorerType_aggregate(
    """distinct select on columns"""
    distinct_on: [ExplorerType_select_column!]

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

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

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

    """filter the rows returned"""
    where: ExplorerType_bool_exp
  ): ExplorerType_aggregate!

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

  """
  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: "dao"
  """
  dao(
    """distinct select on columns"""
    distinct_on: [dao_select_column!]

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

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

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

    """filter the rows returned"""
    where: dao_bool_exp
  ): [dao!]!

  """
  fetch aggregated fields from the table: "dao"
  """
  dao_aggregate(
    """distinct select on columns"""
    distinct_on: [dao_select_column!]

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

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

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

    """filter the rows returned"""
    where: dao_bool_exp
  ): dao_aggregate!

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

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

    """filter the rows returned"""
    where: dao_player_bool_exp
  ): [dao_player!]!

  """
  fetch aggregated fields from the table: "dao_player"
  """
  dao_player_aggregate(
    """distinct select on columns"""
    distinct_on: [dao_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: [dao_player_order_by!]

    """filter the rows returned"""
    where: dao_player_bool_exp
  ): dao_player_aggregate!

  """fetch data from the table: "dao_player" using primary key columns"""
  dao_player_by_pk(daoId: uuid!, playerId: uuid!): dao_player
  getBrightIdStatus(contextId: uuid): BrightIdStatus
  getDaoHausMemberships(memberAddress: String): [Member!]!
  getDiscordServerMemberRoles(guildId: uuid!, playerId: uuid!): [DiscordRole!]!
  getGuildDiscordAnnouncements(guildDiscordId: String): [String!]
  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(guildId: 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(guildId: uuid!, playerId: 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: "profile"
  """
  profile(
    """distinct select on columns"""
    distinct_on: [profile_select_column!]

    """limit the number of rows returned"""
    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_order_by!]

    """filter the rows returned"""
    where: profile_bool_exp
  ): [profile!]!

  """
  fetch aggregated fields from the table: "profile"
  """
  profile_aggregate(
    """distinct select on columns"""
    distinct_on: [profile_select_column!]

    """limit the number of rows returned"""
    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_order_by!]

    """filter the rows returned"""
    where: profile_bool_exp
  ): profile_aggregate!

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

  """
  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(questId: 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(questId: uuid!, skillId: 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
  createdAt: timestamptz!
  createdByPlayerId: uuid!
  description: String
  externalLink: String

  """An object relationship"""
  guild: guild!
  guildId: 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
  createdAt: timestamptz_comparison_exp
  createdByPlayerId: uuid_comparison_exp
  description: String_comparison_exp
  externalLink: String_comparison_exp
  guild: guild_bool_exp
  guildId: 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!

  """An object relationship"""
  completed: quest
  completedByPlayerId: uuid!
  id: uuid!

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

  """An object relationship"""
  quest: quest!
  questId: uuid!
  status: QuestCompletionStatus_enum!
  submissionLink: String
  submissionText: String
  submittedAt: 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: quest_bool_exp
  completedByPlayerId: uuid_comparison_exp
  id: uuid_comparison_exp
  player: player_bool_exp
  quest: quest_bool_exp
  questId: uuid_comparison_exp
  status: QuestCompletionStatus_enum_comparison_exp
  submissionLink: String_comparison_exp
  submissionText: String_comparison_exp
  submittedAt: 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: quest_obj_rel_insert_input
  completedByPlayerId: uuid
  id: uuid
  player: player_obj_rel_insert_input
  quest: quest_obj_rel_insert_input
  questId: uuid
  status: QuestCompletionStatus_enum
  submissionLink: String
  submissionText: String
  submittedAt: timestamptz
}

"""aggregate max on columns"""
type quest_completion_max_fields {
  completedByPlayerId: uuid
  id: uuid
  questId: uuid
  submissionLink: String
  submissionText: String
  submittedAt: timestamptz
}

"""
order by max() on columns of table "quest_completion"
"""
input quest_completion_max_order_by {
  completedByPlayerId: order_by
  id: order_by
  questId: order_by
  submissionLink: order_by
  submissionText: order_by
  submittedAt: order_by
}

"""aggregate min on columns"""
type quest_completion_min_fields {
  completedByPlayerId: uuid
  id: uuid
  questId: uuid
  submissionLink: String
  submissionText: String
  submittedAt: timestamptz
}

"""
order by min() on columns of table "quest_completion"
"""
input quest_completion_min_order_by {
  completedByPlayerId: order_by
  id: order_by
  questId: order_by
  submissionLink: order_by
  submissionText: order_by
  submittedAt: 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: quest_order_by
  completedByPlayerId: order_by
  id: order_by
  player: player_order_by
  quest: quest_order_by
  questId: order_by
  status: order_by
  submissionLink: order_by
  submissionText: order_by
  submittedAt: 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"""
  completedByPlayerId

  """column name"""
  id

  """column name"""
  questId

  """column name"""
  status

  """column name"""
  submissionLink

  """column name"""
  submissionText

  """column name"""
  submittedAt
}

"""
input type for updating data in table "quest_completion"
"""
input quest_completion_set_input {
  completedByPlayerId: uuid
  id: uuid
  questId: uuid
  status: QuestCompletionStatus_enum
  submissionLink: String
  submissionText: String
  submittedAt: timestamptz
}

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

  """column name"""
  id

  """column name"""
  questId

  """column name"""
  status

  """column name"""
  submissionLink

  """column name"""
  submissionText

  """column name"""
  submittedAt
}

"""
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
  createdAt: timestamptz
  createdByPlayerId: uuid
  description: String
  externalLink: String
  guild: guild_obj_rel_insert_input
  guildId: 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
  createdAt: timestamptz
  createdByPlayerId: uuid
  description: String
  externalLink: String
  guildId: uuid
  id: uuid
  title: String
}

"""
order by max() on columns of table "quest"
"""
input quest_max_order_by {
  cooldown: order_by
  createdAt: order_by
  createdByPlayerId: order_by
  description: order_by
  externalLink: order_by
  guildId: order_by
  id: order_by
  title: order_by
}

"""aggregate min on columns"""
type quest_min_fields {
  cooldown: Int
  createdAt: timestamptz
  createdByPlayerId: uuid
  description: String
  externalLink: String
  guildId: uuid
  id: uuid
  title: String
}

"""
order by min() on columns of table "quest"
"""
input quest_min_order_by {
  cooldown: order_by
  createdAt: order_by
  createdByPlayerId: order_by
  description: order_by
  externalLink: order_by
  guildId: 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
  createdAt: order_by
  createdByPlayerId: order_by
  description: order_by
  externalLink: order_by
  guild: guild_order_by
  guildId: 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!
  questId: 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
  questId: 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
}

"""
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
  questId: uuid
  rank: Int
  role: String
}

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

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

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

"""
order by min() on columns of table "quest_role"
"""
input quest_role_min_order_by {
  questId: 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
  questId: order_by
  rank: order_by
  role: order_by
}

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

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

  """column name"""
  rank

  """column name"""
  role
}

"""
input type for updating data in table "quest_role"
"""
input quest_role_set_input {
  questId: 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"""
  questId

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

  """column name"""
  createdByPlayerId

  """column name"""
  description

  """column name"""
  externalLink

  """column name"""
  guildId

  """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
  createdAt: timestamptz
  createdByPlayerId: uuid
  description: String
  externalLink: String
  guildId: 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!
  questId: uuid!

  """An object relationship"""
  skill: skill!
  skillId: 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
  questId: uuid_comparison_exp
  skill: skill_bool_exp
  skillId: 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
  questId: uuid
  skill: skill_obj_rel_insert_input
  skillId: uuid
}

"""aggregate max on columns"""
type quest_skill_max_fields {
  questId: uuid
  skillId: uuid
}

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

"""aggregate min on columns"""
type quest_skill_min_fields {
  questId: uuid
  skillId: uuid
}

"""
order by min() on columns of table "quest_skill"
"""
input quest_skill_min_order_by {
  questId: order_by
  skillId: 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
  questId: order_by
  skill: skill_order_by
  skillId: order_by
}

"""
primary key columns input for table: "quest_skill"
"""
input quest_skill_pk_columns_input {
  questId: uuid!
  skillId: uuid!
}

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

  """column name"""
  skillId
}

"""
input type for updating data in table "quest_skill"
"""
input quest_skill_set_input {
  questId: uuid
  skillId: uuid
}

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

  """column name"""
  skillId
}

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

  """column name"""
  createdByPlayerId

  """column name"""
  description

  """column name"""
  externalLink

  """column name"""
  guildId

  """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: "ExplorerType"
  """
  ExplorerType(
    """distinct select on columns"""
    distinct_on: [ExplorerType_select_column!]

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

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

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

    """filter the rows returned"""
    where: ExplorerType_bool_exp
  ): [ExplorerType!]!

  """
  fetch aggregated fields from the table: "ExplorerType"
  """
  ExplorerType_aggregate(
    """distinct select on columns"""
    distinct_on: [ExplorerType_select_column!]

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

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

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

    """filter the rows returned"""
    where: ExplorerType_bool_exp
  ): ExplorerType_aggregate!

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

  """
  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: "dao"
  """
  dao(
    """distinct select on columns"""
    distinct_on: [dao_select_column!]

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

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

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

    """filter the rows returned"""
    where: dao_bool_exp
  ): [dao!]!

  """
  fetch aggregated fields from the table: "dao"
  """
  dao_aggregate(
    """distinct select on columns"""
    distinct_on: [dao_select_column!]

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

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

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

    """filter the rows returned"""
    where: dao_bool_exp
  ): dao_aggregate!

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

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

    """filter the rows returned"""
    where: dao_player_bool_exp
  ): [dao_player!]!

  """
  fetch aggregated fields from the table: "dao_player"
  """
  dao_player_aggregate(
    """distinct select on columns"""
    distinct_on: [dao_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: [dao_player_order_by!]

    """filter the rows returned"""
    where: dao_player_bool_exp
  ): dao_player_aggregate!

  """fetch data from the table: "dao_player" using primary key columns"""
  dao_player_by_pk(daoId: uuid!, playerId: uuid!): dao_player

  """
  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(guildId: 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(guildId: uuid!, playerId: 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: "profile"
  """
  profile(
    """distinct select on columns"""
    distinct_on: [profile_select_column!]

    """limit the number of rows returned"""
    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_order_by!]

    """filter the rows returned"""
    where: profile_bool_exp
  ): [profile!]!

  """
  fetch aggregated fields from the table: "profile"
  """
  profile_aggregate(
    """distinct select on columns"""
    distinct_on: [profile_select_column!]

    """limit the number of rows returned"""
    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_order_by!]

    """filter the rows returned"""
    where: profile_bool_exp
  ): profile_aggregate!

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

  """
  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(questId: 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(questId: uuid!, skillId: 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 UpdateIDXProfileResponse {
  accountLinks: [String]
  ceramic: String!
  did: String
  ethereumAddress: String
  fields: [String]
  success: Boolean!
}

input UpdateQuestCompletionInput {
  questCompletionId: 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!]
}

