generated-schema.graphql

# -----------------------------------------------
# !!! THIS FILE WAS GENERATED BY TYPE-GRAPHQL !!!
# !!!   DO NOT MODIFY THIS FILE BY YOURSELF   !!!
# -----------------------------------------------

type AffectedRowsOutput {
  count: Int!
}

type AggregateCard {
  _avg: CardAvgAggregate
  _count: CardCountAggregate
  _max: CardMaxAggregate
  _min: CardMinAggregate
  _sum: CardSumAggregate
}

type AggregateCard_rank {
  _avg: Card_rankAvgAggregate
  _count: Card_rankCountAggregate
  _max: Card_rankMaxAggregate
  _min: Card_rankMinAggregate
  _sum: Card_rankSumAggregate
}

type AggregateCard_type {
  _avg: Card_typeAvgAggregate
  _count: Card_typeCountAggregate
  _max: Card_typeMaxAggregate
  _min: Card_typeMinAggregate
  _sum: Card_typeSumAggregate
}

type AggregateElement {
  _avg: ElementAvgAggregate
  _count: ElementCountAggregate
  _max: ElementMaxAggregate
  _min: ElementMinAggregate
  _sum: ElementSumAggregate
}

type AggregateElement_affinity {
  _avg: Element_affinityAvgAggregate
  _count: Element_affinityCountAggregate
  _max: Element_affinityMaxAggregate
  _min: Element_affinityMinAggregate
  _sum: Element_affinitySumAggregate
}

type AggregateElement_weakness {
  _avg: Element_weaknessAvgAggregate
  _count: Element_weaknessCountAggregate
  _max: Element_weaknessMaxAggregate
  _min: Element_weaknessMinAggregate
  _sum: Element_weaknessSumAggregate
}

type AggregatePlayer {
  _avg: PlayerAvgAggregate
  _count: PlayerCountAggregate
  _max: PlayerMaxAggregate
  _min: PlayerMinAggregate
  _sum: PlayerSumAggregate
}

type AggregatePlayer_card {
  _avg: Player_cardAvgAggregate
  _count: Player_cardCountAggregate
  _max: Player_cardMaxAggregate
  _min: Player_cardMinAggregate
  _sum: Player_cardSumAggregate
}

type Card {
  _count: CardCount
  card_rank: Card_rank
  card_type: Card_type!
  card_type_id: Int!
  description: String!
  element: Element!
  element_id: Int!
  id: Int!
  max_chain: Int!
  name: String!
  player_card(cursor: Player_cardWhereUniqueInput, distinct: [Player_cardScalarFieldEnum!], orderBy: [Player_cardOrderByWithRelationInput!], skip: Int, take: Int, where: Player_cardWhereInput): [Player_card!]!
  power: Int!
  rank_id: Int
}

type CardAvgAggregate {
  card_type_id: Float
  element_id: Float
  id: Float
  max_chain: Float
  power: Float
  rank_id: Float
}

input CardAvgOrderByAggregateInput {
  card_type_id: SortOrder
  element_id: SortOrder
  id: SortOrder
  max_chain: SortOrder
  power: SortOrder
  rank_id: SortOrder
}

type CardCount {
  player_card: Int!
}

type CardCountAggregate {
  _all: Int!
  card_type_id: Int!
  description: Int!
  element_id: Int!
  id: Int!
  max_chain: Int!
  name: Int!
  power: Int!
  rank_id: Int!
}

input CardCountOrderByAggregateInput {
  card_type_id: SortOrder
  description: SortOrder
  element_id: SortOrder
  id: SortOrder
  max_chain: SortOrder
  name: SortOrder
  power: SortOrder
  rank_id: SortOrder
}

input CardCreateInput {
  card_rank: Card_rankCreateNestedOneWithoutCardInput
  card_type: Card_typeCreateNestedOneWithoutCardInput
  description: String!
  element: ElementCreateNestedOneWithoutCardInput!
  max_chain: Int
  name: String!
  player_card: Player_cardCreateNestedManyWithoutCardInput
  power: Int!
}

input CardCreateManyCard_rankInput {
  card_type_id: Int
  description: String!
  element_id: Int!
  id: Int
  max_chain: Int
  name: String!
  power: Int!
}

input CardCreateManyCard_rankInputEnvelope {
  data: [CardCreateManyCard_rankInput!]!
  skipDuplicates: Boolean
}

input CardCreateManyCard_typeInput {
  description: String!
  element_id: Int!
  id: Int
  max_chain: Int
  name: String!
  power: Int!
  rank_id: Int
}

input CardCreateManyCard_typeInputEnvelope {
  data: [CardCreateManyCard_typeInput!]!
  skipDuplicates: Boolean
}

input CardCreateManyElementInput {
  card_type_id: Int
  description: String!
  id: Int
  max_chain: Int
  name: String!
  power: Int!
  rank_id: Int
}

input CardCreateManyElementInputEnvelope {
  data: [CardCreateManyElementInput!]!
  skipDuplicates: Boolean
}

input CardCreateManyInput {
  card_type_id: Int
  description: String!
  element_id: Int!
  id: Int
  max_chain: Int
  name: String!
  power: Int!
  rank_id: Int
}

input CardCreateNestedManyWithoutCard_rankInput {
  connect: [CardWhereUniqueInput!]
  connectOrCreate: [CardCreateOrConnectWithoutCard_rankInput!]
  create: [CardCreateWithoutCard_rankInput!]
  createMany: CardCreateManyCard_rankInputEnvelope
}

input CardCreateNestedManyWithoutCard_typeInput {
  connect: [CardWhereUniqueInput!]
  connectOrCreate: [CardCreateOrConnectWithoutCard_typeInput!]
  create: [CardCreateWithoutCard_typeInput!]
  createMany: CardCreateManyCard_typeInputEnvelope
}

input CardCreateNestedManyWithoutElementInput {
  connect: [CardWhereUniqueInput!]
  connectOrCreate: [CardCreateOrConnectWithoutElementInput!]
  create: [CardCreateWithoutElementInput!]
  createMany: CardCreateManyElementInputEnvelope
}

input CardCreateNestedOneWithoutPlayer_cardInput {
  connect: CardWhereUniqueInput
  connectOrCreate: CardCreateOrConnectWithoutPlayer_cardInput
  create: CardCreateWithoutPlayer_cardInput
}

input CardCreateOrConnectWithoutCard_rankInput {
  create: CardCreateWithoutCard_rankInput!
  where: CardWhereUniqueInput!
}

input CardCreateOrConnectWithoutCard_typeInput {
  create: CardCreateWithoutCard_typeInput!
  where: CardWhereUniqueInput!
}

input CardCreateOrConnectWithoutElementInput {
  create: CardCreateWithoutElementInput!
  where: CardWhereUniqueInput!
}

input CardCreateOrConnectWithoutPlayer_cardInput {
  create: CardCreateWithoutPlayer_cardInput!
  where: CardWhereUniqueInput!
}

input CardCreateWithoutCard_rankInput {
  card_type: Card_typeCreateNestedOneWithoutCardInput
  description: String!
  element: ElementCreateNestedOneWithoutCardInput!
  max_chain: Int
  name: String!
  player_card: Player_cardCreateNestedManyWithoutCardInput
  power: Int!
}

input CardCreateWithoutCard_typeInput {
  card_rank: Card_rankCreateNestedOneWithoutCardInput
  description: String!
  element: ElementCreateNestedOneWithoutCardInput!
  max_chain: Int
  name: String!
  player_card: Player_cardCreateNestedManyWithoutCardInput
  power: Int!
}

input CardCreateWithoutElementInput {
  card_rank: Card_rankCreateNestedOneWithoutCardInput
  card_type: Card_typeCreateNestedOneWithoutCardInput
  description: String!
  max_chain: Int
  name: String!
  player_card: Player_cardCreateNestedManyWithoutCardInput
  power: Int!
}

input CardCreateWithoutPlayer_cardInput {
  card_rank: Card_rankCreateNestedOneWithoutCardInput
  card_type: Card_typeCreateNestedOneWithoutCardInput
  description: String!
  element: ElementCreateNestedOneWithoutCardInput!
  max_chain: Int
  name: String!
  power: Int!
}

type CardGroupBy {
  _avg: CardAvgAggregate
  _count: CardCountAggregate
  _max: CardMaxAggregate
  _min: CardMinAggregate
  _sum: CardSumAggregate
  card_type_id: Int!
  description: String!
  element_id: Int!
  id: Int!
  max_chain: Int!
  name: String!
  power: Int!
  rank_id: Int
}

input CardListRelationFilter {
  every: CardWhereInput
  none: CardWhereInput
  some: CardWhereInput
}

type CardMaxAggregate {
  card_type_id: Int
  description: String
  element_id: Int
  id: Int
  max_chain: Int
  name: String
  power: Int
  rank_id: Int
}

input CardMaxOrderByAggregateInput {
  card_type_id: SortOrder
  description: SortOrder
  element_id: SortOrder
  id: SortOrder
  max_chain: SortOrder
  name: SortOrder
  power: SortOrder
  rank_id: SortOrder
}

type CardMinAggregate {
  card_type_id: Int
  description: String
  element_id: Int
  id: Int
  max_chain: Int
  name: String
  power: Int
  rank_id: Int
}

input CardMinOrderByAggregateInput {
  card_type_id: SortOrder
  description: SortOrder
  element_id: SortOrder
  id: SortOrder
  max_chain: SortOrder
  name: SortOrder
  power: SortOrder
  rank_id: SortOrder
}

input CardOrderByRelationAggregateInput {
  _count: SortOrder
}

input CardOrderByWithAggregationInput {
  _avg: CardAvgOrderByAggregateInput
  _count: CardCountOrderByAggregateInput
  _max: CardMaxOrderByAggregateInput
  _min: CardMinOrderByAggregateInput
  _sum: CardSumOrderByAggregateInput
  card_type_id: SortOrder
  description: SortOrder
  element_id: SortOrder
  id: SortOrder
  max_chain: SortOrder
  name: SortOrder
  power: SortOrder
  rank_id: SortOrder
}

input CardOrderByWithRelationInput {
  card_rank: Card_rankOrderByWithRelationInput
  card_type: Card_typeOrderByWithRelationInput
  card_type_id: SortOrder
  description: SortOrder
  element: ElementOrderByWithRelationInput
  element_id: SortOrder
  id: SortOrder
  max_chain: SortOrder
  name: SortOrder
  player_card: Player_cardOrderByRelationAggregateInput
  power: SortOrder
  rank_id: SortOrder
}

input CardRelationFilter {
  is: CardWhereInput
  isNot: CardWhereInput
}

enum CardScalarFieldEnum {
  card_type_id
  description
  element_id
  id
  max_chain
  name
  power
  rank_id
}

input CardScalarWhereInput {
  AND: [CardScalarWhereInput!]
  NOT: [CardScalarWhereInput!]
  OR: [CardScalarWhereInput!]
  card_type_id: IntFilter
  description: StringFilter
  element_id: IntFilter
  id: IntFilter
  max_chain: IntFilter
  name: StringFilter
  power: IntFilter
  rank_id: IntNullableFilter
}

input CardScalarWhereWithAggregatesInput {
  AND: [CardScalarWhereWithAggregatesInput!]
  NOT: [CardScalarWhereWithAggregatesInput!]
  OR: [CardScalarWhereWithAggregatesInput!]
  card_type_id: IntWithAggregatesFilter
  description: StringWithAggregatesFilter
  element_id: IntWithAggregatesFilter
  id: IntWithAggregatesFilter
  max_chain: IntWithAggregatesFilter
  name: StringWithAggregatesFilter
  power: IntWithAggregatesFilter
  rank_id: IntNullableWithAggregatesFilter
}

type CardSumAggregate {
  card_type_id: Int
  element_id: Int
  id: Int
  max_chain: Int
  power: Int
  rank_id: Int
}

input CardSumOrderByAggregateInput {
  card_type_id: SortOrder
  element_id: SortOrder
  id: SortOrder
  max_chain: SortOrder
  power: SortOrder
  rank_id: SortOrder
}

input CardUpdateInput {
  card_rank: Card_rankUpdateOneWithoutCardNestedInput
  card_type: Card_typeUpdateOneRequiredWithoutCardNestedInput
  description: StringFieldUpdateOperationsInput
  element: ElementUpdateOneRequiredWithoutCardNestedInput
  max_chain: IntFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
  player_card: Player_cardUpdateManyWithoutCardNestedInput
  power: IntFieldUpdateOperationsInput
}

input CardUpdateManyMutationInput {
  description: StringFieldUpdateOperationsInput
  max_chain: IntFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
  power: IntFieldUpdateOperationsInput
}

input CardUpdateManyWithWhereWithoutCard_rankInput {
  data: CardUpdateManyMutationInput!
  where: CardScalarWhereInput!
}

input CardUpdateManyWithWhereWithoutCard_typeInput {
  data: CardUpdateManyMutationInput!
  where: CardScalarWhereInput!
}

input CardUpdateManyWithWhereWithoutElementInput {
  data: CardUpdateManyMutationInput!
  where: CardScalarWhereInput!
}

input CardUpdateManyWithoutCard_rankNestedInput {
  connect: [CardWhereUniqueInput!]
  connectOrCreate: [CardCreateOrConnectWithoutCard_rankInput!]
  create: [CardCreateWithoutCard_rankInput!]
  createMany: CardCreateManyCard_rankInputEnvelope
  delete: [CardWhereUniqueInput!]
  deleteMany: [CardScalarWhereInput!]
  disconnect: [CardWhereUniqueInput!]
  set: [CardWhereUniqueInput!]
  update: [CardUpdateWithWhereUniqueWithoutCard_rankInput!]
  updateMany: [CardUpdateManyWithWhereWithoutCard_rankInput!]
  upsert: [CardUpsertWithWhereUniqueWithoutCard_rankInput!]
}

input CardUpdateManyWithoutCard_typeNestedInput {
  connect: [CardWhereUniqueInput!]
  connectOrCreate: [CardCreateOrConnectWithoutCard_typeInput!]
  create: [CardCreateWithoutCard_typeInput!]
  createMany: CardCreateManyCard_typeInputEnvelope
  delete: [CardWhereUniqueInput!]
  deleteMany: [CardScalarWhereInput!]
  disconnect: [CardWhereUniqueInput!]
  set: [CardWhereUniqueInput!]
  update: [CardUpdateWithWhereUniqueWithoutCard_typeInput!]
  updateMany: [CardUpdateManyWithWhereWithoutCard_typeInput!]
  upsert: [CardUpsertWithWhereUniqueWithoutCard_typeInput!]
}

input CardUpdateManyWithoutElementNestedInput {
  connect: [CardWhereUniqueInput!]
  connectOrCreate: [CardCreateOrConnectWithoutElementInput!]
  create: [CardCreateWithoutElementInput!]
  createMany: CardCreateManyElementInputEnvelope
  delete: [CardWhereUniqueInput!]
  deleteMany: [CardScalarWhereInput!]
  disconnect: [CardWhereUniqueInput!]
  set: [CardWhereUniqueInput!]
  update: [CardUpdateWithWhereUniqueWithoutElementInput!]
  updateMany: [CardUpdateManyWithWhereWithoutElementInput!]
  upsert: [CardUpsertWithWhereUniqueWithoutElementInput!]
}

input CardUpdateOneRequiredWithoutPlayer_cardNestedInput {
  connect: CardWhereUniqueInput
  connectOrCreate: CardCreateOrConnectWithoutPlayer_cardInput
  create: CardCreateWithoutPlayer_cardInput
  update: CardUpdateWithoutPlayer_cardInput
  upsert: CardUpsertWithoutPlayer_cardInput
}

input CardUpdateWithWhereUniqueWithoutCard_rankInput {
  data: CardUpdateWithoutCard_rankInput!
  where: CardWhereUniqueInput!
}

input CardUpdateWithWhereUniqueWithoutCard_typeInput {
  data: CardUpdateWithoutCard_typeInput!
  where: CardWhereUniqueInput!
}

input CardUpdateWithWhereUniqueWithoutElementInput {
  data: CardUpdateWithoutElementInput!
  where: CardWhereUniqueInput!
}

input CardUpdateWithoutCard_rankInput {
  card_type: Card_typeUpdateOneRequiredWithoutCardNestedInput
  description: StringFieldUpdateOperationsInput
  element: ElementUpdateOneRequiredWithoutCardNestedInput
  max_chain: IntFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
  player_card: Player_cardUpdateManyWithoutCardNestedInput
  power: IntFieldUpdateOperationsInput
}

input CardUpdateWithoutCard_typeInput {
  card_rank: Card_rankUpdateOneWithoutCardNestedInput
  description: StringFieldUpdateOperationsInput
  element: ElementUpdateOneRequiredWithoutCardNestedInput
  max_chain: IntFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
  player_card: Player_cardUpdateManyWithoutCardNestedInput
  power: IntFieldUpdateOperationsInput
}

input CardUpdateWithoutElementInput {
  card_rank: Card_rankUpdateOneWithoutCardNestedInput
  card_type: Card_typeUpdateOneRequiredWithoutCardNestedInput
  description: StringFieldUpdateOperationsInput
  max_chain: IntFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
  player_card: Player_cardUpdateManyWithoutCardNestedInput
  power: IntFieldUpdateOperationsInput
}

input CardUpdateWithoutPlayer_cardInput {
  card_rank: Card_rankUpdateOneWithoutCardNestedInput
  card_type: Card_typeUpdateOneRequiredWithoutCardNestedInput
  description: StringFieldUpdateOperationsInput
  element: ElementUpdateOneRequiredWithoutCardNestedInput
  max_chain: IntFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
  power: IntFieldUpdateOperationsInput
}

input CardUpsertWithWhereUniqueWithoutCard_rankInput {
  create: CardCreateWithoutCard_rankInput!
  update: CardUpdateWithoutCard_rankInput!
  where: CardWhereUniqueInput!
}

input CardUpsertWithWhereUniqueWithoutCard_typeInput {
  create: CardCreateWithoutCard_typeInput!
  update: CardUpdateWithoutCard_typeInput!
  where: CardWhereUniqueInput!
}

input CardUpsertWithWhereUniqueWithoutElementInput {
  create: CardCreateWithoutElementInput!
  update: CardUpdateWithoutElementInput!
  where: CardWhereUniqueInput!
}

input CardUpsertWithoutPlayer_cardInput {
  create: CardCreateWithoutPlayer_cardInput!
  update: CardUpdateWithoutPlayer_cardInput!
}

input CardWhereInput {
  AND: [CardWhereInput!]
  NOT: [CardWhereInput!]
  OR: [CardWhereInput!]
  card_rank: Card_rankRelationFilter
  card_type: Card_typeRelationFilter
  card_type_id: IntFilter
  description: StringFilter
  element: ElementRelationFilter
  element_id: IntFilter
  id: IntFilter
  max_chain: IntFilter
  name: StringFilter
  player_card: Player_cardListRelationFilter
  power: IntFilter
  rank_id: IntNullableFilter
}

input CardWhereUniqueInput {
  id: Int
}

type Card_rank {
  _count: Card_rankCount
  card(cursor: CardWhereUniqueInput, distinct: [CardScalarFieldEnum!], orderBy: [CardOrderByWithRelationInput!], skip: Int, take: Int, where: CardWhereInput): [Card!]!
  code: String!
  id: Int!
  name: String!
}

type Card_rankAvgAggregate {
  id: Float
}

input Card_rankAvgOrderByAggregateInput {
  id: SortOrder
}

type Card_rankCount {
  card: Int!
}

type Card_rankCountAggregate {
  _all: Int!
  code: Int!
  id: Int!
  name: Int!
}

input Card_rankCountOrderByAggregateInput {
  code: SortOrder
  id: SortOrder
  name: SortOrder
}

input Card_rankCreateInput {
  card: CardCreateNestedManyWithoutCard_rankInput
  code: String!
  name: String!
}

input Card_rankCreateManyInput {
  code: String!
  id: Int
  name: String!
}

input Card_rankCreateNestedOneWithoutCardInput {
  connect: Card_rankWhereUniqueInput
  connectOrCreate: Card_rankCreateOrConnectWithoutCardInput
  create: Card_rankCreateWithoutCardInput
}

input Card_rankCreateOrConnectWithoutCardInput {
  create: Card_rankCreateWithoutCardInput!
  where: Card_rankWhereUniqueInput!
}

input Card_rankCreateWithoutCardInput {
  code: String!
  name: String!
}

type Card_rankGroupBy {
  _avg: Card_rankAvgAggregate
  _count: Card_rankCountAggregate
  _max: Card_rankMaxAggregate
  _min: Card_rankMinAggregate
  _sum: Card_rankSumAggregate
  code: String!
  id: Int!
  name: String!
}

type Card_rankMaxAggregate {
  code: String
  id: Int
  name: String
}

input Card_rankMaxOrderByAggregateInput {
  code: SortOrder
  id: SortOrder
  name: SortOrder
}

type Card_rankMinAggregate {
  code: String
  id: Int
  name: String
}

input Card_rankMinOrderByAggregateInput {
  code: SortOrder
  id: SortOrder
  name: SortOrder
}

input Card_rankOrderByWithAggregationInput {
  _avg: Card_rankAvgOrderByAggregateInput
  _count: Card_rankCountOrderByAggregateInput
  _max: Card_rankMaxOrderByAggregateInput
  _min: Card_rankMinOrderByAggregateInput
  _sum: Card_rankSumOrderByAggregateInput
  code: SortOrder
  id: SortOrder
  name: SortOrder
}

input Card_rankOrderByWithRelationInput {
  card: CardOrderByRelationAggregateInput
  code: SortOrder
  id: SortOrder
  name: SortOrder
}

input Card_rankRelationFilter {
  is: Card_rankWhereInput
  isNot: Card_rankWhereInput
}

enum Card_rankScalarFieldEnum {
  code
  id
  name
}

input Card_rankScalarWhereWithAggregatesInput {
  AND: [Card_rankScalarWhereWithAggregatesInput!]
  NOT: [Card_rankScalarWhereWithAggregatesInput!]
  OR: [Card_rankScalarWhereWithAggregatesInput!]
  code: StringWithAggregatesFilter
  id: IntWithAggregatesFilter
  name: StringWithAggregatesFilter
}

type Card_rankSumAggregate {
  id: Int
}

input Card_rankSumOrderByAggregateInput {
  id: SortOrder
}

input Card_rankUpdateInput {
  card: CardUpdateManyWithoutCard_rankNestedInput
  code: StringFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
}

input Card_rankUpdateManyMutationInput {
  code: StringFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
}

input Card_rankUpdateOneWithoutCardNestedInput {
  connect: Card_rankWhereUniqueInput
  connectOrCreate: Card_rankCreateOrConnectWithoutCardInput
  create: Card_rankCreateWithoutCardInput
  delete: Boolean
  disconnect: Boolean
  update: Card_rankUpdateWithoutCardInput
  upsert: Card_rankUpsertWithoutCardInput
}

input Card_rankUpdateWithoutCardInput {
  code: StringFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
}

input Card_rankUpsertWithoutCardInput {
  create: Card_rankCreateWithoutCardInput!
  update: Card_rankUpdateWithoutCardInput!
}

input Card_rankWhereInput {
  AND: [Card_rankWhereInput!]
  NOT: [Card_rankWhereInput!]
  OR: [Card_rankWhereInput!]
  card: CardListRelationFilter
  code: StringFilter
  id: IntFilter
  name: StringFilter
}

input Card_rankWhereUniqueInput {
  id: Int
}

type Card_type {
  _count: Card_typeCount
  card(cursor: CardWhereUniqueInput, distinct: [CardScalarFieldEnum!], orderBy: [CardOrderByWithRelationInput!], skip: Int, take: Int, where: CardWhereInput): [Card!]!
  id: Int!
  name: String!
}

type Card_typeAvgAggregate {
  id: Float
}

input Card_typeAvgOrderByAggregateInput {
  id: SortOrder
}

type Card_typeCount {
  card: Int!
}

type Card_typeCountAggregate {
  _all: Int!
  id: Int!
  name: Int!
}

input Card_typeCountOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
}

input Card_typeCreateInput {
  card: CardCreateNestedManyWithoutCard_typeInput
  name: String!
}

input Card_typeCreateManyInput {
  id: Int
  name: String!
}

input Card_typeCreateNestedOneWithoutCardInput {
  connect: Card_typeWhereUniqueInput
  connectOrCreate: Card_typeCreateOrConnectWithoutCardInput
  create: Card_typeCreateWithoutCardInput
}

input Card_typeCreateOrConnectWithoutCardInput {
  create: Card_typeCreateWithoutCardInput!
  where: Card_typeWhereUniqueInput!
}

input Card_typeCreateWithoutCardInput {
  name: String!
}

type Card_typeGroupBy {
  _avg: Card_typeAvgAggregate
  _count: Card_typeCountAggregate
  _max: Card_typeMaxAggregate
  _min: Card_typeMinAggregate
  _sum: Card_typeSumAggregate
  id: Int!
  name: String!
}

type Card_typeMaxAggregate {
  id: Int
  name: String
}

input Card_typeMaxOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
}

type Card_typeMinAggregate {
  id: Int
  name: String
}

input Card_typeMinOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
}

input Card_typeOrderByWithAggregationInput {
  _avg: Card_typeAvgOrderByAggregateInput
  _count: Card_typeCountOrderByAggregateInput
  _max: Card_typeMaxOrderByAggregateInput
  _min: Card_typeMinOrderByAggregateInput
  _sum: Card_typeSumOrderByAggregateInput
  id: SortOrder
  name: SortOrder
}

input Card_typeOrderByWithRelationInput {
  card: CardOrderByRelationAggregateInput
  id: SortOrder
  name: SortOrder
}

input Card_typeRelationFilter {
  is: Card_typeWhereInput
  isNot: Card_typeWhereInput
}

enum Card_typeScalarFieldEnum {
  id
  name
}

input Card_typeScalarWhereWithAggregatesInput {
  AND: [Card_typeScalarWhereWithAggregatesInput!]
  NOT: [Card_typeScalarWhereWithAggregatesInput!]
  OR: [Card_typeScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  name: StringWithAggregatesFilter
}

type Card_typeSumAggregate {
  id: Int
}

input Card_typeSumOrderByAggregateInput {
  id: SortOrder
}

input Card_typeUpdateInput {
  card: CardUpdateManyWithoutCard_typeNestedInput
  name: StringFieldUpdateOperationsInput
}

input Card_typeUpdateManyMutationInput {
  name: StringFieldUpdateOperationsInput
}

input Card_typeUpdateOneRequiredWithoutCardNestedInput {
  connect: Card_typeWhereUniqueInput
  connectOrCreate: Card_typeCreateOrConnectWithoutCardInput
  create: Card_typeCreateWithoutCardInput
  update: Card_typeUpdateWithoutCardInput
  upsert: Card_typeUpsertWithoutCardInput
}

input Card_typeUpdateWithoutCardInput {
  name: StringFieldUpdateOperationsInput
}

input Card_typeUpsertWithoutCardInput {
  create: Card_typeCreateWithoutCardInput!
  update: Card_typeUpdateWithoutCardInput!
}

input Card_typeWhereInput {
  AND: [Card_typeWhereInput!]
  NOT: [Card_typeWhereInput!]
  OR: [Card_typeWhereInput!]
  card: CardListRelationFilter
  id: IntFilter
  name: StringFilter
}

input Card_typeWhereUniqueInput {
  id: Int
}

type Element {
  _count: ElementCount
  card(cursor: CardWhereUniqueInput, distinct: [CardScalarFieldEnum!], orderBy: [CardOrderByWithRelationInput!], skip: Int, take: Int, where: CardWhereInput): [Card!]!
  element_affinity_elementToelement_affinity_affinity_element(cursor: Element_affinityWhereUniqueInput, distinct: [Element_affinityScalarFieldEnum!], orderBy: [Element_affinityOrderByWithRelationInput!], skip: Int, take: Int, where: Element_affinityWhereInput): [Element_affinity!]!
  element_affinity_elementToelement_affinity_element_id(cursor: Element_affinityWhereUniqueInput, distinct: [Element_affinityScalarFieldEnum!], orderBy: [Element_affinityOrderByWithRelationInput!], skip: Int, take: Int, where: Element_affinityWhereInput): [Element_affinity!]!
  element_weakness_elementToelement_weakness_element_id(cursor: Element_weaknessWhereUniqueInput, distinct: [Element_weaknessScalarFieldEnum!], orderBy: [Element_weaknessOrderByWithRelationInput!], skip: Int, take: Int, where: Element_weaknessWhereInput): [Element_weakness!]!
  element_weakness_elementToelement_weakness_weakness_element_id(cursor: Element_weaknessWhereUniqueInput, distinct: [Element_weaknessScalarFieldEnum!], orderBy: [Element_weaknessOrderByWithRelationInput!], skip: Int, take: Int, where: Element_weaknessWhereInput): [Element_weakness!]!
  id: Int!
  name: String!
}

type ElementAvgAggregate {
  id: Float
}

input ElementAvgOrderByAggregateInput {
  id: SortOrder
}

type ElementCount {
  card: Int!
  element_affinity_elementToelement_affinity_affinity_element: Int!
  element_affinity_elementToelement_affinity_element_id: Int!
  element_weakness_elementToelement_weakness_element_id: Int!
  element_weakness_elementToelement_weakness_weakness_element_id: Int!
}

type ElementCountAggregate {
  _all: Int!
  id: Int!
  name: Int!
}

input ElementCountOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
}

input ElementCreateInput {
  card: CardCreateNestedManyWithoutElementInput
  element_affinity_elementToelement_affinity_affinity_element: Element_affinityCreateNestedManyWithoutElement_elementToelement_affinity_affinity_elementInput
  element_affinity_elementToelement_affinity_element_id: Element_affinityCreateNestedManyWithoutElement_elementToelement_affinity_element_idInput
  element_weakness_elementToelement_weakness_element_id: Element_weaknessCreateNestedManyWithoutElement_elementToelement_weakness_element_idInput
  element_weakness_elementToelement_weakness_weakness_element_id: Element_weaknessCreateNestedManyWithoutElement_elementToelement_weakness_weakness_element_idInput
  name: String!
}

input ElementCreateManyInput {
  id: Int
  name: String!
}

input ElementCreateNestedOneWithoutCardInput {
  connect: ElementWhereUniqueInput
  connectOrCreate: ElementCreateOrConnectWithoutCardInput
  create: ElementCreateWithoutCardInput
}

input ElementCreateNestedOneWithoutElement_affinity_elementToelement_affinity_affinity_elementInput {
  connect: ElementWhereUniqueInput
  connectOrCreate: ElementCreateOrConnectWithoutElement_affinity_elementToelement_affinity_affinity_elementInput
  create: ElementCreateWithoutElement_affinity_elementToelement_affinity_affinity_elementInput
}

input ElementCreateNestedOneWithoutElement_affinity_elementToelement_affinity_element_idInput {
  connect: ElementWhereUniqueInput
  connectOrCreate: ElementCreateOrConnectWithoutElement_affinity_elementToelement_affinity_element_idInput
  create: ElementCreateWithoutElement_affinity_elementToelement_affinity_element_idInput
}

input ElementCreateNestedOneWithoutElement_weakness_elementToelement_weakness_element_idInput {
  connect: ElementWhereUniqueInput
  connectOrCreate: ElementCreateOrConnectWithoutElement_weakness_elementToelement_weakness_element_idInput
  create: ElementCreateWithoutElement_weakness_elementToelement_weakness_element_idInput
}

input ElementCreateNestedOneWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput {
  connect: ElementWhereUniqueInput
  connectOrCreate: ElementCreateOrConnectWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput
  create: ElementCreateWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput
}

input ElementCreateOrConnectWithoutCardInput {
  create: ElementCreateWithoutCardInput!
  where: ElementWhereUniqueInput!
}

input ElementCreateOrConnectWithoutElement_affinity_elementToelement_affinity_affinity_elementInput {
  create: ElementCreateWithoutElement_affinity_elementToelement_affinity_affinity_elementInput!
  where: ElementWhereUniqueInput!
}

input ElementCreateOrConnectWithoutElement_affinity_elementToelement_affinity_element_idInput {
  create: ElementCreateWithoutElement_affinity_elementToelement_affinity_element_idInput!
  where: ElementWhereUniqueInput!
}

input ElementCreateOrConnectWithoutElement_weakness_elementToelement_weakness_element_idInput {
  create: ElementCreateWithoutElement_weakness_elementToelement_weakness_element_idInput!
  where: ElementWhereUniqueInput!
}

input ElementCreateOrConnectWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput {
  create: ElementCreateWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput!
  where: ElementWhereUniqueInput!
}

input ElementCreateWithoutCardInput {
  element_affinity_elementToelement_affinity_affinity_element: Element_affinityCreateNestedManyWithoutElement_elementToelement_affinity_affinity_elementInput
  element_affinity_elementToelement_affinity_element_id: Element_affinityCreateNestedManyWithoutElement_elementToelement_affinity_element_idInput
  element_weakness_elementToelement_weakness_element_id: Element_weaknessCreateNestedManyWithoutElement_elementToelement_weakness_element_idInput
  element_weakness_elementToelement_weakness_weakness_element_id: Element_weaknessCreateNestedManyWithoutElement_elementToelement_weakness_weakness_element_idInput
  name: String!
}

input ElementCreateWithoutElement_affinity_elementToelement_affinity_affinity_elementInput {
  card: CardCreateNestedManyWithoutElementInput
  element_affinity_elementToelement_affinity_element_id: Element_affinityCreateNestedManyWithoutElement_elementToelement_affinity_element_idInput
  element_weakness_elementToelement_weakness_element_id: Element_weaknessCreateNestedManyWithoutElement_elementToelement_weakness_element_idInput
  element_weakness_elementToelement_weakness_weakness_element_id: Element_weaknessCreateNestedManyWithoutElement_elementToelement_weakness_weakness_element_idInput
  name: String!
}

input ElementCreateWithoutElement_affinity_elementToelement_affinity_element_idInput {
  card: CardCreateNestedManyWithoutElementInput
  element_affinity_elementToelement_affinity_affinity_element: Element_affinityCreateNestedManyWithoutElement_elementToelement_affinity_affinity_elementInput
  element_weakness_elementToelement_weakness_element_id: Element_weaknessCreateNestedManyWithoutElement_elementToelement_weakness_element_idInput
  element_weakness_elementToelement_weakness_weakness_element_id: Element_weaknessCreateNestedManyWithoutElement_elementToelement_weakness_weakness_element_idInput
  name: String!
}

input ElementCreateWithoutElement_weakness_elementToelement_weakness_element_idInput {
  card: CardCreateNestedManyWithoutElementInput
  element_affinity_elementToelement_affinity_affinity_element: Element_affinityCreateNestedManyWithoutElement_elementToelement_affinity_affinity_elementInput
  element_affinity_elementToelement_affinity_element_id: Element_affinityCreateNestedManyWithoutElement_elementToelement_affinity_element_idInput
  element_weakness_elementToelement_weakness_weakness_element_id: Element_weaknessCreateNestedManyWithoutElement_elementToelement_weakness_weakness_element_idInput
  name: String!
}

input ElementCreateWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput {
  card: CardCreateNestedManyWithoutElementInput
  element_affinity_elementToelement_affinity_affinity_element: Element_affinityCreateNestedManyWithoutElement_elementToelement_affinity_affinity_elementInput
  element_affinity_elementToelement_affinity_element_id: Element_affinityCreateNestedManyWithoutElement_elementToelement_affinity_element_idInput
  element_weakness_elementToelement_weakness_element_id: Element_weaknessCreateNestedManyWithoutElement_elementToelement_weakness_element_idInput
  name: String!
}

type ElementGroupBy {
  _avg: ElementAvgAggregate
  _count: ElementCountAggregate
  _max: ElementMaxAggregate
  _min: ElementMinAggregate
  _sum: ElementSumAggregate
  id: Int!
  name: String!
}

type ElementMaxAggregate {
  id: Int
  name: String
}

input ElementMaxOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
}

type ElementMinAggregate {
  id: Int
  name: String
}

input ElementMinOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
}

input ElementOrderByWithAggregationInput {
  _avg: ElementAvgOrderByAggregateInput
  _count: ElementCountOrderByAggregateInput
  _max: ElementMaxOrderByAggregateInput
  _min: ElementMinOrderByAggregateInput
  _sum: ElementSumOrderByAggregateInput
  id: SortOrder
  name: SortOrder
}

input ElementOrderByWithRelationInput {
  card: CardOrderByRelationAggregateInput
  element_affinity_elementToelement_affinity_affinity_element: Element_affinityOrderByRelationAggregateInput
  element_affinity_elementToelement_affinity_element_id: Element_affinityOrderByRelationAggregateInput
  element_weakness_elementToelement_weakness_element_id: Element_weaknessOrderByRelationAggregateInput
  element_weakness_elementToelement_weakness_weakness_element_id: Element_weaknessOrderByRelationAggregateInput
  id: SortOrder
  name: SortOrder
}

input ElementRelationFilter {
  is: ElementWhereInput
  isNot: ElementWhereInput
}

enum ElementScalarFieldEnum {
  id
  name
}

input ElementScalarWhereWithAggregatesInput {
  AND: [ElementScalarWhereWithAggregatesInput!]
  NOT: [ElementScalarWhereWithAggregatesInput!]
  OR: [ElementScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  name: StringWithAggregatesFilter
}

type ElementSumAggregate {
  id: Int
}

input ElementSumOrderByAggregateInput {
  id: SortOrder
}

input ElementUpdateInput {
  card: CardUpdateManyWithoutElementNestedInput
  element_affinity_elementToelement_affinity_affinity_element: Element_affinityUpdateManyWithoutElement_elementToelement_affinity_affinity_elementNestedInput
  element_affinity_elementToelement_affinity_element_id: Element_affinityUpdateManyWithoutElement_elementToelement_affinity_element_idNestedInput
  element_weakness_elementToelement_weakness_element_id: Element_weaknessUpdateManyWithoutElement_elementToelement_weakness_element_idNestedInput
  element_weakness_elementToelement_weakness_weakness_element_id: Element_weaknessUpdateManyWithoutElement_elementToelement_weakness_weakness_element_idNestedInput
  name: StringFieldUpdateOperationsInput
}

input ElementUpdateManyMutationInput {
  name: StringFieldUpdateOperationsInput
}

input ElementUpdateOneRequiredWithoutCardNestedInput {
  connect: ElementWhereUniqueInput
  connectOrCreate: ElementCreateOrConnectWithoutCardInput
  create: ElementCreateWithoutCardInput
  update: ElementUpdateWithoutCardInput
  upsert: ElementUpsertWithoutCardInput
}

input ElementUpdateOneRequiredWithoutElement_affinity_elementToelement_affinity_affinity_elementNestedInput {
  connect: ElementWhereUniqueInput
  connectOrCreate: ElementCreateOrConnectWithoutElement_affinity_elementToelement_affinity_affinity_elementInput
  create: ElementCreateWithoutElement_affinity_elementToelement_affinity_affinity_elementInput
  update: ElementUpdateWithoutElement_affinity_elementToelement_affinity_affinity_elementInput
  upsert: ElementUpsertWithoutElement_affinity_elementToelement_affinity_affinity_elementInput
}

input ElementUpdateOneRequiredWithoutElement_affinity_elementToelement_affinity_element_idNestedInput {
  connect: ElementWhereUniqueInput
  connectOrCreate: ElementCreateOrConnectWithoutElement_affinity_elementToelement_affinity_element_idInput
  create: ElementCreateWithoutElement_affinity_elementToelement_affinity_element_idInput
  update: ElementUpdateWithoutElement_affinity_elementToelement_affinity_element_idInput
  upsert: ElementUpsertWithoutElement_affinity_elementToelement_affinity_element_idInput
}

input ElementUpdateOneRequiredWithoutElement_weakness_elementToelement_weakness_element_idNestedInput {
  connect: ElementWhereUniqueInput
  connectOrCreate: ElementCreateOrConnectWithoutElement_weakness_elementToelement_weakness_element_idInput
  create: ElementCreateWithoutElement_weakness_elementToelement_weakness_element_idInput
  update: ElementUpdateWithoutElement_weakness_elementToelement_weakness_element_idInput
  upsert: ElementUpsertWithoutElement_weakness_elementToelement_weakness_element_idInput
}

input ElementUpdateOneRequiredWithoutElement_weakness_elementToelement_weakness_weakness_element_idNestedInput {
  connect: ElementWhereUniqueInput
  connectOrCreate: ElementCreateOrConnectWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput
  create: ElementCreateWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput
  update: ElementUpdateWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput
  upsert: ElementUpsertWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput
}

input ElementUpdateWithoutCardInput {
  element_affinity_elementToelement_affinity_affinity_element: Element_affinityUpdateManyWithoutElement_elementToelement_affinity_affinity_elementNestedInput
  element_affinity_elementToelement_affinity_element_id: Element_affinityUpdateManyWithoutElement_elementToelement_affinity_element_idNestedInput
  element_weakness_elementToelement_weakness_element_id: Element_weaknessUpdateManyWithoutElement_elementToelement_weakness_element_idNestedInput
  element_weakness_elementToelement_weakness_weakness_element_id: Element_weaknessUpdateManyWithoutElement_elementToelement_weakness_weakness_element_idNestedInput
  name: StringFieldUpdateOperationsInput
}

input ElementUpdateWithoutElement_affinity_elementToelement_affinity_affinity_elementInput {
  card: CardUpdateManyWithoutElementNestedInput
  element_affinity_elementToelement_affinity_element_id: Element_affinityUpdateManyWithoutElement_elementToelement_affinity_element_idNestedInput
  element_weakness_elementToelement_weakness_element_id: Element_weaknessUpdateManyWithoutElement_elementToelement_weakness_element_idNestedInput
  element_weakness_elementToelement_weakness_weakness_element_id: Element_weaknessUpdateManyWithoutElement_elementToelement_weakness_weakness_element_idNestedInput
  name: StringFieldUpdateOperationsInput
}

input ElementUpdateWithoutElement_affinity_elementToelement_affinity_element_idInput {
  card: CardUpdateManyWithoutElementNestedInput
  element_affinity_elementToelement_affinity_affinity_element: Element_affinityUpdateManyWithoutElement_elementToelement_affinity_affinity_elementNestedInput
  element_weakness_elementToelement_weakness_element_id: Element_weaknessUpdateManyWithoutElement_elementToelement_weakness_element_idNestedInput
  element_weakness_elementToelement_weakness_weakness_element_id: Element_weaknessUpdateManyWithoutElement_elementToelement_weakness_weakness_element_idNestedInput
  name: StringFieldUpdateOperationsInput
}

input ElementUpdateWithoutElement_weakness_elementToelement_weakness_element_idInput {
  card: CardUpdateManyWithoutElementNestedInput
  element_affinity_elementToelement_affinity_affinity_element: Element_affinityUpdateManyWithoutElement_elementToelement_affinity_affinity_elementNestedInput
  element_affinity_elementToelement_affinity_element_id: Element_affinityUpdateManyWithoutElement_elementToelement_affinity_element_idNestedInput
  element_weakness_elementToelement_weakness_weakness_element_id: Element_weaknessUpdateManyWithoutElement_elementToelement_weakness_weakness_element_idNestedInput
  name: StringFieldUpdateOperationsInput
}

input ElementUpdateWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput {
  card: CardUpdateManyWithoutElementNestedInput
  element_affinity_elementToelement_affinity_affinity_element: Element_affinityUpdateManyWithoutElement_elementToelement_affinity_affinity_elementNestedInput
  element_affinity_elementToelement_affinity_element_id: Element_affinityUpdateManyWithoutElement_elementToelement_affinity_element_idNestedInput
  element_weakness_elementToelement_weakness_element_id: Element_weaknessUpdateManyWithoutElement_elementToelement_weakness_element_idNestedInput
  name: StringFieldUpdateOperationsInput
}

input ElementUpsertWithoutCardInput {
  create: ElementCreateWithoutCardInput!
  update: ElementUpdateWithoutCardInput!
}

input ElementUpsertWithoutElement_affinity_elementToelement_affinity_affinity_elementInput {
  create: ElementCreateWithoutElement_affinity_elementToelement_affinity_affinity_elementInput!
  update: ElementUpdateWithoutElement_affinity_elementToelement_affinity_affinity_elementInput!
}

input ElementUpsertWithoutElement_affinity_elementToelement_affinity_element_idInput {
  create: ElementCreateWithoutElement_affinity_elementToelement_affinity_element_idInput!
  update: ElementUpdateWithoutElement_affinity_elementToelement_affinity_element_idInput!
}

input ElementUpsertWithoutElement_weakness_elementToelement_weakness_element_idInput {
  create: ElementCreateWithoutElement_weakness_elementToelement_weakness_element_idInput!
  update: ElementUpdateWithoutElement_weakness_elementToelement_weakness_element_idInput!
}

input ElementUpsertWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput {
  create: ElementCreateWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput!
  update: ElementUpdateWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput!
}

input ElementWhereInput {
  AND: [ElementWhereInput!]
  NOT: [ElementWhereInput!]
  OR: [ElementWhereInput!]
  card: CardListRelationFilter
  element_affinity_elementToelement_affinity_affinity_element: Element_affinityListRelationFilter
  element_affinity_elementToelement_affinity_element_id: Element_affinityListRelationFilter
  element_weakness_elementToelement_weakness_element_id: Element_weaknessListRelationFilter
  element_weakness_elementToelement_weakness_weakness_element_id: Element_weaknessListRelationFilter
  id: IntFilter
  name: StringFilter
}

input ElementWhereUniqueInput {
  id: Int
}

type Element_affinity {
  affinity_element: Int!
  affinity_type: Int!
  element_elementToelement_affinity_affinity_element: Element!
  element_elementToelement_affinity_element_id: Element!
  element_id: Int!
}

type Element_affinityAvgAggregate {
  affinity_element: Float
  affinity_type: Float
  element_id: Float
}

input Element_affinityAvgOrderByAggregateInput {
  affinity_element: SortOrder
  affinity_type: SortOrder
  element_id: SortOrder
}

type Element_affinityCountAggregate {
  _all: Int!
  affinity_element: Int!
  affinity_type: Int!
  element_id: Int!
}

input Element_affinityCountOrderByAggregateInput {
  affinity_element: SortOrder
  affinity_type: SortOrder
  element_id: SortOrder
}

input Element_affinityCreateInput {
  affinity_type: Int!
  element_elementToelement_affinity_affinity_element: ElementCreateNestedOneWithoutElement_affinity_elementToelement_affinity_affinity_elementInput!
  element_elementToelement_affinity_element_id: ElementCreateNestedOneWithoutElement_affinity_elementToelement_affinity_element_idInput!
}

input Element_affinityCreateManyElement_elementToelement_affinity_affinity_elementInput {
  affinity_type: Int!
  element_id: Int!
}

input Element_affinityCreateManyElement_elementToelement_affinity_affinity_elementInputEnvelope {
  data: [Element_affinityCreateManyElement_elementToelement_affinity_affinity_elementInput!]!
  skipDuplicates: Boolean
}

input Element_affinityCreateManyElement_elementToelement_affinity_element_idInput {
  affinity_element: Int!
  affinity_type: Int!
}

input Element_affinityCreateManyElement_elementToelement_affinity_element_idInputEnvelope {
  data: [Element_affinityCreateManyElement_elementToelement_affinity_element_idInput!]!
  skipDuplicates: Boolean
}

input Element_affinityCreateManyInput {
  affinity_element: Int!
  affinity_type: Int!
  element_id: Int!
}

input Element_affinityCreateNestedManyWithoutElement_elementToelement_affinity_affinity_elementInput {
  connect: [Element_affinityWhereUniqueInput!]
  connectOrCreate: [Element_affinityCreateOrConnectWithoutElement_elementToelement_affinity_affinity_elementInput!]
  create: [Element_affinityCreateWithoutElement_elementToelement_affinity_affinity_elementInput!]
  createMany: Element_affinityCreateManyElement_elementToelement_affinity_affinity_elementInputEnvelope
}

input Element_affinityCreateNestedManyWithoutElement_elementToelement_affinity_element_idInput {
  connect: [Element_affinityWhereUniqueInput!]
  connectOrCreate: [Element_affinityCreateOrConnectWithoutElement_elementToelement_affinity_element_idInput!]
  create: [Element_affinityCreateWithoutElement_elementToelement_affinity_element_idInput!]
  createMany: Element_affinityCreateManyElement_elementToelement_affinity_element_idInputEnvelope
}

input Element_affinityCreateOrConnectWithoutElement_elementToelement_affinity_affinity_elementInput {
  create: Element_affinityCreateWithoutElement_elementToelement_affinity_affinity_elementInput!
  where: Element_affinityWhereUniqueInput!
}

input Element_affinityCreateOrConnectWithoutElement_elementToelement_affinity_element_idInput {
  create: Element_affinityCreateWithoutElement_elementToelement_affinity_element_idInput!
  where: Element_affinityWhereUniqueInput!
}

input Element_affinityCreateWithoutElement_elementToelement_affinity_affinity_elementInput {
  affinity_type: Int!
  element_elementToelement_affinity_element_id: ElementCreateNestedOneWithoutElement_affinity_elementToelement_affinity_element_idInput!
}

input Element_affinityCreateWithoutElement_elementToelement_affinity_element_idInput {
  affinity_type: Int!
  element_elementToelement_affinity_affinity_element: ElementCreateNestedOneWithoutElement_affinity_elementToelement_affinity_affinity_elementInput!
}

type Element_affinityGroupBy {
  _avg: Element_affinityAvgAggregate
  _count: Element_affinityCountAggregate
  _max: Element_affinityMaxAggregate
  _min: Element_affinityMinAggregate
  _sum: Element_affinitySumAggregate
  affinity_element: Int!
  affinity_type: Int!
  element_id: Int!
}

input Element_affinityListRelationFilter {
  every: Element_affinityWhereInput
  none: Element_affinityWhereInput
  some: Element_affinityWhereInput
}

type Element_affinityMaxAggregate {
  affinity_element: Int
  affinity_type: Int
  element_id: Int
}

input Element_affinityMaxOrderByAggregateInput {
  affinity_element: SortOrder
  affinity_type: SortOrder
  element_id: SortOrder
}

type Element_affinityMinAggregate {
  affinity_element: Int
  affinity_type: Int
  element_id: Int
}

input Element_affinityMinOrderByAggregateInput {
  affinity_element: SortOrder
  affinity_type: SortOrder
  element_id: SortOrder
}

input Element_affinityOrderByRelationAggregateInput {
  _count: SortOrder
}

input Element_affinityOrderByWithAggregationInput {
  _avg: Element_affinityAvgOrderByAggregateInput
  _count: Element_affinityCountOrderByAggregateInput
  _max: Element_affinityMaxOrderByAggregateInput
  _min: Element_affinityMinOrderByAggregateInput
  _sum: Element_affinitySumOrderByAggregateInput
  affinity_element: SortOrder
  affinity_type: SortOrder
  element_id: SortOrder
}

input Element_affinityOrderByWithRelationInput {
  affinity_element: SortOrder
  affinity_type: SortOrder
  element_elementToelement_affinity_affinity_element: ElementOrderByWithRelationInput
  element_elementToelement_affinity_element_id: ElementOrderByWithRelationInput
  element_id: SortOrder
}

enum Element_affinityScalarFieldEnum {
  affinity_element
  affinity_type
  element_id
}

input Element_affinityScalarWhereInput {
  AND: [Element_affinityScalarWhereInput!]
  NOT: [Element_affinityScalarWhereInput!]
  OR: [Element_affinityScalarWhereInput!]
  affinity_element: IntFilter
  affinity_type: IntFilter
  element_id: IntFilter
}

input Element_affinityScalarWhereWithAggregatesInput {
  AND: [Element_affinityScalarWhereWithAggregatesInput!]
  NOT: [Element_affinityScalarWhereWithAggregatesInput!]
  OR: [Element_affinityScalarWhereWithAggregatesInput!]
  affinity_element: IntWithAggregatesFilter
  affinity_type: IntWithAggregatesFilter
  element_id: IntWithAggregatesFilter
}

type Element_affinitySumAggregate {
  affinity_element: Int
  affinity_type: Int
  element_id: Int
}

input Element_affinitySumOrderByAggregateInput {
  affinity_element: SortOrder
  affinity_type: SortOrder
  element_id: SortOrder
}

input Element_affinityUpdateInput {
  affinity_type: IntFieldUpdateOperationsInput
  element_elementToelement_affinity_affinity_element: ElementUpdateOneRequiredWithoutElement_affinity_elementToelement_affinity_affinity_elementNestedInput
  element_elementToelement_affinity_element_id: ElementUpdateOneRequiredWithoutElement_affinity_elementToelement_affinity_element_idNestedInput
}

input Element_affinityUpdateManyMutationInput {
  affinity_type: IntFieldUpdateOperationsInput
}

input Element_affinityUpdateManyWithWhereWithoutElement_elementToelement_affinity_affinity_elementInput {
  data: Element_affinityUpdateManyMutationInput!
  where: Element_affinityScalarWhereInput!
}

input Element_affinityUpdateManyWithWhereWithoutElement_elementToelement_affinity_element_idInput {
  data: Element_affinityUpdateManyMutationInput!
  where: Element_affinityScalarWhereInput!
}

input Element_affinityUpdateManyWithoutElement_elementToelement_affinity_affinity_elementNestedInput {
  connect: [Element_affinityWhereUniqueInput!]
  connectOrCreate: [Element_affinityCreateOrConnectWithoutElement_elementToelement_affinity_affinity_elementInput!]
  create: [Element_affinityCreateWithoutElement_elementToelement_affinity_affinity_elementInput!]
  createMany: Element_affinityCreateManyElement_elementToelement_affinity_affinity_elementInputEnvelope
  delete: [Element_affinityWhereUniqueInput!]
  deleteMany: [Element_affinityScalarWhereInput!]
  disconnect: [Element_affinityWhereUniqueInput!]
  set: [Element_affinityWhereUniqueInput!]
  update: [Element_affinityUpdateWithWhereUniqueWithoutElement_elementToelement_affinity_affinity_elementInput!]
  updateMany: [Element_affinityUpdateManyWithWhereWithoutElement_elementToelement_affinity_affinity_elementInput!]
  upsert: [Element_affinityUpsertWithWhereUniqueWithoutElement_elementToelement_affinity_affinity_elementInput!]
}

input Element_affinityUpdateManyWithoutElement_elementToelement_affinity_element_idNestedInput {
  connect: [Element_affinityWhereUniqueInput!]
  connectOrCreate: [Element_affinityCreateOrConnectWithoutElement_elementToelement_affinity_element_idInput!]
  create: [Element_affinityCreateWithoutElement_elementToelement_affinity_element_idInput!]
  createMany: Element_affinityCreateManyElement_elementToelement_affinity_element_idInputEnvelope
  delete: [Element_affinityWhereUniqueInput!]
  deleteMany: [Element_affinityScalarWhereInput!]
  disconnect: [Element_affinityWhereUniqueInput!]
  set: [Element_affinityWhereUniqueInput!]
  update: [Element_affinityUpdateWithWhereUniqueWithoutElement_elementToelement_affinity_element_idInput!]
  updateMany: [Element_affinityUpdateManyWithWhereWithoutElement_elementToelement_affinity_element_idInput!]
  upsert: [Element_affinityUpsertWithWhereUniqueWithoutElement_elementToelement_affinity_element_idInput!]
}

input Element_affinityUpdateWithWhereUniqueWithoutElement_elementToelement_affinity_affinity_elementInput {
  data: Element_affinityUpdateWithoutElement_elementToelement_affinity_affinity_elementInput!
  where: Element_affinityWhereUniqueInput!
}

input Element_affinityUpdateWithWhereUniqueWithoutElement_elementToelement_affinity_element_idInput {
  data: Element_affinityUpdateWithoutElement_elementToelement_affinity_element_idInput!
  where: Element_affinityWhereUniqueInput!
}

input Element_affinityUpdateWithoutElement_elementToelement_affinity_affinity_elementInput {
  affinity_type: IntFieldUpdateOperationsInput
  element_elementToelement_affinity_element_id: ElementUpdateOneRequiredWithoutElement_affinity_elementToelement_affinity_element_idNestedInput
}

input Element_affinityUpdateWithoutElement_elementToelement_affinity_element_idInput {
  affinity_type: IntFieldUpdateOperationsInput
  element_elementToelement_affinity_affinity_element: ElementUpdateOneRequiredWithoutElement_affinity_elementToelement_affinity_affinity_elementNestedInput
}

input Element_affinityUpsertWithWhereUniqueWithoutElement_elementToelement_affinity_affinity_elementInput {
  create: Element_affinityCreateWithoutElement_elementToelement_affinity_affinity_elementInput!
  update: Element_affinityUpdateWithoutElement_elementToelement_affinity_affinity_elementInput!
  where: Element_affinityWhereUniqueInput!
}

input Element_affinityUpsertWithWhereUniqueWithoutElement_elementToelement_affinity_element_idInput {
  create: Element_affinityCreateWithoutElement_elementToelement_affinity_element_idInput!
  update: Element_affinityUpdateWithoutElement_elementToelement_affinity_element_idInput!
  where: Element_affinityWhereUniqueInput!
}

input Element_affinityWhereInput {
  AND: [Element_affinityWhereInput!]
  NOT: [Element_affinityWhereInput!]
  OR: [Element_affinityWhereInput!]
  affinity_element: IntFilter
  affinity_type: IntFilter
  element_elementToelement_affinity_affinity_element: ElementRelationFilter
  element_elementToelement_affinity_element_id: ElementRelationFilter
  element_id: IntFilter
}

input Element_affinityWhereUniqueInput {
  element_id_affinity_element: element_affinityElement_idAffinity_elementCompoundUniqueInput
}

type Element_weakness {
  coef: Float!
  element_elementToelement_weakness_element_id: Element!
  element_elementToelement_weakness_weakness_element_id: Element!
  element_id: Int!
  weakness_element_id: Int!
}

type Element_weaknessAvgAggregate {
  coef: Float
  element_id: Float
  weakness_element_id: Float
}

input Element_weaknessAvgOrderByAggregateInput {
  coef: SortOrder
  element_id: SortOrder
  weakness_element_id: SortOrder
}

type Element_weaknessCountAggregate {
  _all: Int!
  coef: Int!
  element_id: Int!
  weakness_element_id: Int!
}

input Element_weaknessCountOrderByAggregateInput {
  coef: SortOrder
  element_id: SortOrder
  weakness_element_id: SortOrder
}

input Element_weaknessCreateInput {
  coef: Float!
  element_elementToelement_weakness_element_id: ElementCreateNestedOneWithoutElement_weakness_elementToelement_weakness_element_idInput!
  element_elementToelement_weakness_weakness_element_id: ElementCreateNestedOneWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput!
}

input Element_weaknessCreateManyElement_elementToelement_weakness_element_idInput {
  coef: Float!
  weakness_element_id: Int!
}

input Element_weaknessCreateManyElement_elementToelement_weakness_element_idInputEnvelope {
  data: [Element_weaknessCreateManyElement_elementToelement_weakness_element_idInput!]!
  skipDuplicates: Boolean
}

input Element_weaknessCreateManyElement_elementToelement_weakness_weakness_element_idInput {
  coef: Float!
  element_id: Int!
}

input Element_weaknessCreateManyElement_elementToelement_weakness_weakness_element_idInputEnvelope {
  data: [Element_weaknessCreateManyElement_elementToelement_weakness_weakness_element_idInput!]!
  skipDuplicates: Boolean
}

input Element_weaknessCreateManyInput {
  coef: Float!
  element_id: Int!
  weakness_element_id: Int!
}

input Element_weaknessCreateNestedManyWithoutElement_elementToelement_weakness_element_idInput {
  connect: [Element_weaknessWhereUniqueInput!]
  connectOrCreate: [Element_weaknessCreateOrConnectWithoutElement_elementToelement_weakness_element_idInput!]
  create: [Element_weaknessCreateWithoutElement_elementToelement_weakness_element_idInput!]
  createMany: Element_weaknessCreateManyElement_elementToelement_weakness_element_idInputEnvelope
}

input Element_weaknessCreateNestedManyWithoutElement_elementToelement_weakness_weakness_element_idInput {
  connect: [Element_weaknessWhereUniqueInput!]
  connectOrCreate: [Element_weaknessCreateOrConnectWithoutElement_elementToelement_weakness_weakness_element_idInput!]
  create: [Element_weaknessCreateWithoutElement_elementToelement_weakness_weakness_element_idInput!]
  createMany: Element_weaknessCreateManyElement_elementToelement_weakness_weakness_element_idInputEnvelope
}

input Element_weaknessCreateOrConnectWithoutElement_elementToelement_weakness_element_idInput {
  create: Element_weaknessCreateWithoutElement_elementToelement_weakness_element_idInput!
  where: Element_weaknessWhereUniqueInput!
}

input Element_weaknessCreateOrConnectWithoutElement_elementToelement_weakness_weakness_element_idInput {
  create: Element_weaknessCreateWithoutElement_elementToelement_weakness_weakness_element_idInput!
  where: Element_weaknessWhereUniqueInput!
}

input Element_weaknessCreateWithoutElement_elementToelement_weakness_element_idInput {
  coef: Float!
  element_elementToelement_weakness_weakness_element_id: ElementCreateNestedOneWithoutElement_weakness_elementToelement_weakness_weakness_element_idInput!
}

input Element_weaknessCreateWithoutElement_elementToelement_weakness_weakness_element_idInput {
  coef: Float!
  element_elementToelement_weakness_element_id: ElementCreateNestedOneWithoutElement_weakness_elementToelement_weakness_element_idInput!
}

type Element_weaknessGroupBy {
  _avg: Element_weaknessAvgAggregate
  _count: Element_weaknessCountAggregate
  _max: Element_weaknessMaxAggregate
  _min: Element_weaknessMinAggregate
  _sum: Element_weaknessSumAggregate
  coef: Float!
  element_id: Int!
  weakness_element_id: Int!
}

input Element_weaknessListRelationFilter {
  every: Element_weaknessWhereInput
  none: Element_weaknessWhereInput
  some: Element_weaknessWhereInput
}

type Element_weaknessMaxAggregate {
  coef: Float
  element_id: Int
  weakness_element_id: Int
}

input Element_weaknessMaxOrderByAggregateInput {
  coef: SortOrder
  element_id: SortOrder
  weakness_element_id: SortOrder
}

type Element_weaknessMinAggregate {
  coef: Float
  element_id: Int
  weakness_element_id: Int
}

input Element_weaknessMinOrderByAggregateInput {
  coef: SortOrder
  element_id: SortOrder
  weakness_element_id: SortOrder
}

input Element_weaknessOrderByRelationAggregateInput {
  _count: SortOrder
}

input Element_weaknessOrderByWithAggregationInput {
  _avg: Element_weaknessAvgOrderByAggregateInput
  _count: Element_weaknessCountOrderByAggregateInput
  _max: Element_weaknessMaxOrderByAggregateInput
  _min: Element_weaknessMinOrderByAggregateInput
  _sum: Element_weaknessSumOrderByAggregateInput
  coef: SortOrder
  element_id: SortOrder
  weakness_element_id: SortOrder
}

input Element_weaknessOrderByWithRelationInput {
  coef: SortOrder
  element_elementToelement_weakness_element_id: ElementOrderByWithRelationInput
  element_elementToelement_weakness_weakness_element_id: ElementOrderByWithRelationInput
  element_id: SortOrder
  weakness_element_id: SortOrder
}

enum Element_weaknessScalarFieldEnum {
  coef
  element_id
  weakness_element_id
}

input Element_weaknessScalarWhereInput {
  AND: [Element_weaknessScalarWhereInput!]
  NOT: [Element_weaknessScalarWhereInput!]
  OR: [Element_weaknessScalarWhereInput!]
  coef: FloatFilter
  element_id: IntFilter
  weakness_element_id: IntFilter
}

input Element_weaknessScalarWhereWithAggregatesInput {
  AND: [Element_weaknessScalarWhereWithAggregatesInput!]
  NOT: [Element_weaknessScalarWhereWithAggregatesInput!]
  OR: [Element_weaknessScalarWhereWithAggregatesInput!]
  coef: FloatWithAggregatesFilter
  element_id: IntWithAggregatesFilter
  weakness_element_id: IntWithAggregatesFilter
}

type Element_weaknessSumAggregate {
  coef: Float
  element_id: Int
  weakness_element_id: Int
}

input Element_weaknessSumOrderByAggregateInput {
  coef: SortOrder
  element_id: SortOrder
  weakness_element_id: SortOrder
}

input Element_weaknessUpdateInput {
  coef: FloatFieldUpdateOperationsInput
  element_elementToelement_weakness_element_id: ElementUpdateOneRequiredWithoutElement_weakness_elementToelement_weakness_element_idNestedInput
  element_elementToelement_weakness_weakness_element_id: ElementUpdateOneRequiredWithoutElement_weakness_elementToelement_weakness_weakness_element_idNestedInput
}

input Element_weaknessUpdateManyMutationInput {
  coef: FloatFieldUpdateOperationsInput
}

input Element_weaknessUpdateManyWithWhereWithoutElement_elementToelement_weakness_element_idInput {
  data: Element_weaknessUpdateManyMutationInput!
  where: Element_weaknessScalarWhereInput!
}

input Element_weaknessUpdateManyWithWhereWithoutElement_elementToelement_weakness_weakness_element_idInput {
  data: Element_weaknessUpdateManyMutationInput!
  where: Element_weaknessScalarWhereInput!
}

input Element_weaknessUpdateManyWithoutElement_elementToelement_weakness_element_idNestedInput {
  connect: [Element_weaknessWhereUniqueInput!]
  connectOrCreate: [Element_weaknessCreateOrConnectWithoutElement_elementToelement_weakness_element_idInput!]
  create: [Element_weaknessCreateWithoutElement_elementToelement_weakness_element_idInput!]
  createMany: Element_weaknessCreateManyElement_elementToelement_weakness_element_idInputEnvelope
  delete: [Element_weaknessWhereUniqueInput!]
  deleteMany: [Element_weaknessScalarWhereInput!]
  disconnect: [Element_weaknessWhereUniqueInput!]
  set: [Element_weaknessWhereUniqueInput!]
  update: [Element_weaknessUpdateWithWhereUniqueWithoutElement_elementToelement_weakness_element_idInput!]
  updateMany: [Element_weaknessUpdateManyWithWhereWithoutElement_elementToelement_weakness_element_idInput!]
  upsert: [Element_weaknessUpsertWithWhereUniqueWithoutElement_elementToelement_weakness_element_idInput!]
}

input Element_weaknessUpdateManyWithoutElement_elementToelement_weakness_weakness_element_idNestedInput {
  connect: [Element_weaknessWhereUniqueInput!]
  connectOrCreate: [Element_weaknessCreateOrConnectWithoutElement_elementToelement_weakness_weakness_element_idInput!]
  create: [Element_weaknessCreateWithoutElement_elementToelement_weakness_weakness_element_idInput!]
  createMany: Element_weaknessCreateManyElement_elementToelement_weakness_weakness_element_idInputEnvelope
  delete: [Element_weaknessWhereUniqueInput!]
  deleteMany: [Element_weaknessScalarWhereInput!]
  disconnect: [Element_weaknessWhereUniqueInput!]
  set: [Element_weaknessWhereUniqueInput!]
  update: [Element_weaknessUpdateWithWhereUniqueWithoutElement_elementToelement_weakness_weakness_element_idInput!]
  updateMany: [Element_weaknessUpdateManyWithWhereWithoutElement_elementToelement_weakness_weakness_element_idInput!]
  upsert: [Element_weaknessUpsertWithWhereUniqueWithoutElement_elementToelement_weakness_weakness_element_idInput!]
}

input Element_weaknessUpdateWithWhereUniqueWithoutElement_elementToelement_weakness_element_idInput {
  data: Element_weaknessUpdateWithoutElement_elementToelement_weakness_element_idInput!
  where: Element_weaknessWhereUniqueInput!
}

input Element_weaknessUpdateWithWhereUniqueWithoutElement_elementToelement_weakness_weakness_element_idInput {
  data: Element_weaknessUpdateWithoutElement_elementToelement_weakness_weakness_element_idInput!
  where: Element_weaknessWhereUniqueInput!
}

input Element_weaknessUpdateWithoutElement_elementToelement_weakness_element_idInput {
  coef: FloatFieldUpdateOperationsInput
  element_elementToelement_weakness_weakness_element_id: ElementUpdateOneRequiredWithoutElement_weakness_elementToelement_weakness_weakness_element_idNestedInput
}

input Element_weaknessUpdateWithoutElement_elementToelement_weakness_weakness_element_idInput {
  coef: FloatFieldUpdateOperationsInput
  element_elementToelement_weakness_element_id: ElementUpdateOneRequiredWithoutElement_weakness_elementToelement_weakness_element_idNestedInput
}

input Element_weaknessUpsertWithWhereUniqueWithoutElement_elementToelement_weakness_element_idInput {
  create: Element_weaknessCreateWithoutElement_elementToelement_weakness_element_idInput!
  update: Element_weaknessUpdateWithoutElement_elementToelement_weakness_element_idInput!
  where: Element_weaknessWhereUniqueInput!
}

input Element_weaknessUpsertWithWhereUniqueWithoutElement_elementToelement_weakness_weakness_element_idInput {
  create: Element_weaknessCreateWithoutElement_elementToelement_weakness_weakness_element_idInput!
  update: Element_weaknessUpdateWithoutElement_elementToelement_weakness_weakness_element_idInput!
  where: Element_weaknessWhereUniqueInput!
}

input Element_weaknessWhereInput {
  AND: [Element_weaknessWhereInput!]
  NOT: [Element_weaknessWhereInput!]
  OR: [Element_weaknessWhereInput!]
  coef: FloatFilter
  element_elementToelement_weakness_element_id: ElementRelationFilter
  element_elementToelement_weakness_weakness_element_id: ElementRelationFilter
  element_id: IntFilter
  weakness_element_id: IntFilter
}

input Element_weaknessWhereUniqueInput {
  element_id_weakness_element_id: element_weaknessElement_idWeakness_element_idCompoundUniqueInput
}

input FloatFieldUpdateOperationsInput {
  decrement: Float
  divide: Float
  increment: Float
  multiply: Float
  set: Float
}

input FloatFilter {
  equals: Float
  gt: Float
  gte: Float
  in: [Float!]
  lt: Float
  lte: Float
  not: NestedFloatFilter
  notIn: [Float!]
}

input FloatWithAggregatesFilter {
  _avg: NestedFloatFilter
  _count: NestedIntFilter
  _max: NestedFloatFilter
  _min: NestedFloatFilter
  _sum: NestedFloatFilter
  equals: Float
  gt: Float
  gte: Float
  in: [Float!]
  lt: Float
  lte: Float
  not: NestedFloatWithAggregatesFilter
  notIn: [Float!]
}

input IntFieldUpdateOperationsInput {
  decrement: Int
  divide: Int
  increment: Int
  multiply: Int
  set: Int
}

input IntFilter {
  equals: Int
  gt: Int
  gte: Int
  in: [Int!]
  lt: Int
  lte: Int
  not: NestedIntFilter
  notIn: [Int!]
}

input IntNullableFilter {
  equals: Int
  gt: Int
  gte: Int
  in: [Int!]
  lt: Int
  lte: Int
  not: NestedIntNullableFilter
  notIn: [Int!]
}

input IntNullableWithAggregatesFilter {
  _avg: NestedFloatNullableFilter
  _count: NestedIntNullableFilter
  _max: NestedIntNullableFilter
  _min: NestedIntNullableFilter
  _sum: NestedIntNullableFilter
  equals: Int
  gt: Int
  gte: Int
  in: [Int!]
  lt: Int
  lte: Int
  not: NestedIntNullableWithAggregatesFilter
  notIn: [Int!]
}

input IntWithAggregatesFilter {
  _avg: NestedFloatFilter
  _count: NestedIntFilter
  _max: NestedIntFilter
  _min: NestedIntFilter
  _sum: NestedIntFilter
  equals: Int
  gt: Int
  gte: Int
  in: [Int!]
  lt: Int
  lte: Int
  not: NestedIntWithAggregatesFilter
  notIn: [Int!]
}

type Mutation {
  createManyCard(data: [CardCreateManyInput!]!, skipDuplicates: Boolean): AffectedRowsOutput!
  createManyCard_rank(data: [Card_rankCreateManyInput!]!, skipDuplicates: Boolean): AffectedRowsOutput!
  createManyCard_type(data: [Card_typeCreateManyInput!]!, skipDuplicates: Boolean): AffectedRowsOutput!
  createManyElement(data: [ElementCreateManyInput!]!, skipDuplicates: Boolean): AffectedRowsOutput!
  createManyElement_affinity(data: [Element_affinityCreateManyInput!]!, skipDuplicates: Boolean): AffectedRowsOutput!
  createManyElement_weakness(data: [Element_weaknessCreateManyInput!]!, skipDuplicates: Boolean): AffectedRowsOutput!
  createManyPlayer(data: [PlayerCreateManyInput!]!, skipDuplicates: Boolean): AffectedRowsOutput!
  createManyPlayer_card(data: [Player_cardCreateManyInput!]!, skipDuplicates: Boolean): AffectedRowsOutput!
  createOneCard(data: CardCreateInput!): Card!
  createOneCard_rank(data: Card_rankCreateInput!): Card_rank!
  createOneCard_type(data: Card_typeCreateInput!): Card_type!
  createOneElement(data: ElementCreateInput!): Element!
  createOneElement_affinity(data: Element_affinityCreateInput!): Element_affinity!
  createOneElement_weakness(data: Element_weaknessCreateInput!): Element_weakness!
  createOnePlayer(data: PlayerCreateInput!): Player!
  createOnePlayer_card(data: Player_cardCreateInput!): Player_card!
  deleteManyCard(where: CardWhereInput): AffectedRowsOutput!
  deleteManyCard_rank(where: Card_rankWhereInput): AffectedRowsOutput!
  deleteManyCard_type(where: Card_typeWhereInput): AffectedRowsOutput!
  deleteManyElement(where: ElementWhereInput): AffectedRowsOutput!
  deleteManyElement_affinity(where: Element_affinityWhereInput): AffectedRowsOutput!
  deleteManyElement_weakness(where: Element_weaknessWhereInput): AffectedRowsOutput!
  deleteManyPlayer(where: PlayerWhereInput): AffectedRowsOutput!
  deleteManyPlayer_card(where: Player_cardWhereInput): AffectedRowsOutput!
  deleteOneCard(where: CardWhereUniqueInput!): Card
  deleteOneCard_rank(where: Card_rankWhereUniqueInput!): Card_rank
  deleteOneCard_type(where: Card_typeWhereUniqueInput!): Card_type
  deleteOneElement(where: ElementWhereUniqueInput!): Element
  deleteOneElement_affinity(where: Element_affinityWhereUniqueInput!): Element_affinity
  deleteOneElement_weakness(where: Element_weaknessWhereUniqueInput!): Element_weakness
  deleteOnePlayer(where: PlayerWhereUniqueInput!): Player
  deleteOnePlayer_card(where: Player_cardWhereUniqueInput!): Player_card
  updateManyCard(data: CardUpdateManyMutationInput!, where: CardWhereInput): AffectedRowsOutput!
  updateManyCard_rank(data: Card_rankUpdateManyMutationInput!, where: Card_rankWhereInput): AffectedRowsOutput!
  updateManyCard_type(data: Card_typeUpdateManyMutationInput!, where: Card_typeWhereInput): AffectedRowsOutput!
  updateManyElement(data: ElementUpdateManyMutationInput!, where: ElementWhereInput): AffectedRowsOutput!
  updateManyElement_affinity(data: Element_affinityUpdateManyMutationInput!, where: Element_affinityWhereInput): AffectedRowsOutput!
  updateManyElement_weakness(data: Element_weaknessUpdateManyMutationInput!, where: Element_weaknessWhereInput): AffectedRowsOutput!
  updateManyPlayer(data: PlayerUpdateManyMutationInput!, where: PlayerWhereInput): AffectedRowsOutput!
  updateManyPlayer_card(data: Player_cardUpdateManyMutationInput!, where: Player_cardWhereInput): AffectedRowsOutput!
  updateOneCard(data: CardUpdateInput!, where: CardWhereUniqueInput!): Card
  updateOneCard_rank(data: Card_rankUpdateInput!, where: Card_rankWhereUniqueInput!): Card_rank
  updateOneCard_type(data: Card_typeUpdateInput!, where: Card_typeWhereUniqueInput!): Card_type
  updateOneElement(data: ElementUpdateInput!, where: ElementWhereUniqueInput!): Element
  updateOneElement_affinity(data: Element_affinityUpdateInput!, where: Element_affinityWhereUniqueInput!): Element_affinity
  updateOneElement_weakness(data: Element_weaknessUpdateInput!, where: Element_weaknessWhereUniqueInput!): Element_weakness
  updateOnePlayer(data: PlayerUpdateInput!, where: PlayerWhereUniqueInput!): Player
  updateOnePlayer_card(data: Player_cardUpdateInput!, where: Player_cardWhereUniqueInput!): Player_card
  upsertOneCard(create: CardCreateInput!, update: CardUpdateInput!, where: CardWhereUniqueInput!): Card!
  upsertOneCard_rank(create: Card_rankCreateInput!, update: Card_rankUpdateInput!, where: Card_rankWhereUniqueInput!): Card_rank!
  upsertOneCard_type(create: Card_typeCreateInput!, update: Card_typeUpdateInput!, where: Card_typeWhereUniqueInput!): Card_type!
  upsertOneElement(create: ElementCreateInput!, update: ElementUpdateInput!, where: ElementWhereUniqueInput!): Element!
  upsertOneElement_affinity(create: Element_affinityCreateInput!, update: Element_affinityUpdateInput!, where: Element_affinityWhereUniqueInput!): Element_affinity!
  upsertOneElement_weakness(create: Element_weaknessCreateInput!, update: Element_weaknessUpdateInput!, where: Element_weaknessWhereUniqueInput!): Element_weakness!
  upsertOnePlayer(create: PlayerCreateInput!, update: PlayerUpdateInput!, where: PlayerWhereUniqueInput!): Player!
  upsertOnePlayer_card(create: Player_cardCreateInput!, update: Player_cardUpdateInput!, where: Player_cardWhereUniqueInput!): Player_card!
}

input NestedFloatFilter {
  equals: Float
  gt: Float
  gte: Float
  in: [Float!]
  lt: Float
  lte: Float
  not: NestedFloatFilter
  notIn: [Float!]
}

input NestedFloatNullableFilter {
  equals: Float
  gt: Float
  gte: Float
  in: [Float!]
  lt: Float
  lte: Float
  not: NestedFloatNullableFilter
  notIn: [Float!]
}

input NestedFloatWithAggregatesFilter {
  _avg: NestedFloatFilter
  _count: NestedIntFilter
  _max: NestedFloatFilter
  _min: NestedFloatFilter
  _sum: NestedFloatFilter
  equals: Float
  gt: Float
  gte: Float
  in: [Float!]
  lt: Float
  lte: Float
  not: NestedFloatWithAggregatesFilter
  notIn: [Float!]
}

input NestedIntFilter {
  equals: Int
  gt: Int
  gte: Int
  in: [Int!]
  lt: Int
  lte: Int
  not: NestedIntFilter
  notIn: [Int!]
}

input NestedIntNullableFilter {
  equals: Int
  gt: Int
  gte: Int
  in: [Int!]
  lt: Int
  lte: Int
  not: NestedIntNullableFilter
  notIn: [Int!]
}

input NestedIntNullableWithAggregatesFilter {
  _avg: NestedFloatNullableFilter
  _count: NestedIntNullableFilter
  _max: NestedIntNullableFilter
  _min: NestedIntNullableFilter
  _sum: NestedIntNullableFilter
  equals: Int
  gt: Int
  gte: Int
  in: [Int!]
  lt: Int
  lte: Int
  not: NestedIntNullableWithAggregatesFilter
  notIn: [Int!]
}

input NestedIntWithAggregatesFilter {
  _avg: NestedFloatFilter
  _count: NestedIntFilter
  _max: NestedIntFilter
  _min: NestedIntFilter
  _sum: NestedIntFilter
  equals: Int
  gt: Int
  gte: Int
  in: [Int!]
  lt: Int
  lte: Int
  not: NestedIntWithAggregatesFilter
  notIn: [Int!]
}

input NestedStringFilter {
  contains: String
  endsWith: String
  equals: String
  gt: String
  gte: String
  in: [String!]
  lt: String
  lte: String
  not: NestedStringFilter
  notIn: [String!]
  startsWith: String
}

input NestedStringWithAggregatesFilter {
  _count: NestedIntFilter
  _max: NestedStringFilter
  _min: NestedStringFilter
  contains: String
  endsWith: String
  equals: String
  gt: String
  gte: String
  in: [String!]
  lt: String
  lte: String
  not: NestedStringWithAggregatesFilter
  notIn: [String!]
  startsWith: String
}

type Player {
  _count: PlayerCount
  id: Int!
  name: String!
  password: String!
  player_card(cursor: Player_cardWhereUniqueInput, distinct: [Player_cardScalarFieldEnum!], orderBy: [Player_cardOrderByWithRelationInput!], skip: Int, take: Int, where: Player_cardWhereInput): [Player_card!]!
}

type PlayerAvgAggregate {
  id: Float
}

input PlayerAvgOrderByAggregateInput {
  id: SortOrder
}

type PlayerCount {
  player_card: Int!
}

type PlayerCountAggregate {
  _all: Int!
  id: Int!
  name: Int!
  password: Int!
}

input PlayerCountOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
  password: SortOrder
}

input PlayerCreateInput {
  name: String!
  password: String!
  player_card: Player_cardCreateNestedManyWithoutPlayerInput
}

input PlayerCreateManyInput {
  id: Int
  name: String!
  password: String!
}

input PlayerCreateNestedOneWithoutPlayer_cardInput {
  connect: PlayerWhereUniqueInput
  connectOrCreate: PlayerCreateOrConnectWithoutPlayer_cardInput
  create: PlayerCreateWithoutPlayer_cardInput
}

input PlayerCreateOrConnectWithoutPlayer_cardInput {
  create: PlayerCreateWithoutPlayer_cardInput!
  where: PlayerWhereUniqueInput!
}

input PlayerCreateWithoutPlayer_cardInput {
  name: String!
  password: String!
}

type PlayerGroupBy {
  _avg: PlayerAvgAggregate
  _count: PlayerCountAggregate
  _max: PlayerMaxAggregate
  _min: PlayerMinAggregate
  _sum: PlayerSumAggregate
  id: Int!
  name: String!
  password: String!
}

type PlayerMaxAggregate {
  id: Int
  name: String
  password: String
}

input PlayerMaxOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
  password: SortOrder
}

type PlayerMinAggregate {
  id: Int
  name: String
  password: String
}

input PlayerMinOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
  password: SortOrder
}

input PlayerOrderByWithAggregationInput {
  _avg: PlayerAvgOrderByAggregateInput
  _count: PlayerCountOrderByAggregateInput
  _max: PlayerMaxOrderByAggregateInput
  _min: PlayerMinOrderByAggregateInput
  _sum: PlayerSumOrderByAggregateInput
  id: SortOrder
  name: SortOrder
  password: SortOrder
}

input PlayerOrderByWithRelationInput {
  id: SortOrder
  name: SortOrder
  password: SortOrder
  player_card: Player_cardOrderByRelationAggregateInput
}

input PlayerRelationFilter {
  is: PlayerWhereInput
  isNot: PlayerWhereInput
}

enum PlayerScalarFieldEnum {
  id
  name
  password
}

input PlayerScalarWhereWithAggregatesInput {
  AND: [PlayerScalarWhereWithAggregatesInput!]
  NOT: [PlayerScalarWhereWithAggregatesInput!]
  OR: [PlayerScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  name: StringWithAggregatesFilter
  password: StringWithAggregatesFilter
}

type PlayerSumAggregate {
  id: Int
}

input PlayerSumOrderByAggregateInput {
  id: SortOrder
}

input PlayerUpdateInput {
  name: StringFieldUpdateOperationsInput
  password: StringFieldUpdateOperationsInput
  player_card: Player_cardUpdateManyWithoutPlayerNestedInput
}

input PlayerUpdateManyMutationInput {
  name: StringFieldUpdateOperationsInput
  password: StringFieldUpdateOperationsInput
}

input PlayerUpdateOneRequiredWithoutPlayer_cardNestedInput {
  connect: PlayerWhereUniqueInput
  connectOrCreate: PlayerCreateOrConnectWithoutPlayer_cardInput
  create: PlayerCreateWithoutPlayer_cardInput
  update: PlayerUpdateWithoutPlayer_cardInput
  upsert: PlayerUpsertWithoutPlayer_cardInput
}

input PlayerUpdateWithoutPlayer_cardInput {
  name: StringFieldUpdateOperationsInput
  password: StringFieldUpdateOperationsInput
}

input PlayerUpsertWithoutPlayer_cardInput {
  create: PlayerCreateWithoutPlayer_cardInput!
  update: PlayerUpdateWithoutPlayer_cardInput!
}

input PlayerWhereInput {
  AND: [PlayerWhereInput!]
  NOT: [PlayerWhereInput!]
  OR: [PlayerWhereInput!]
  id: IntFilter
  name: StringFilter
  password: StringFilter
  player_card: Player_cardListRelationFilter
}

input PlayerWhereUniqueInput {
  id: Int
}

type Player_card {
  card: Card!
  card_id: Int!
  id: Int!
  name: String!
  player: Player!
  player_id: Int!
}

type Player_cardAvgAggregate {
  card_id: Float
  id: Float
  player_id: Float
}

input Player_cardAvgOrderByAggregateInput {
  card_id: SortOrder
  id: SortOrder
  player_id: SortOrder
}

type Player_cardCountAggregate {
  _all: Int!
  card_id: Int!
  id: Int!
  name: Int!
  player_id: Int!
}

input Player_cardCountOrderByAggregateInput {
  card_id: SortOrder
  id: SortOrder
  name: SortOrder
  player_id: SortOrder
}

input Player_cardCreateInput {
  card: CardCreateNestedOneWithoutPlayer_cardInput!
  name: String!
  player: PlayerCreateNestedOneWithoutPlayer_cardInput!
}

input Player_cardCreateManyCardInput {
  id: Int
  name: String!
  player_id: Int!
}

input Player_cardCreateManyCardInputEnvelope {
  data: [Player_cardCreateManyCardInput!]!
  skipDuplicates: Boolean
}

input Player_cardCreateManyInput {
  card_id: Int!
  id: Int
  name: String!
  player_id: Int!
}

input Player_cardCreateManyPlayerInput {
  card_id: Int!
  id: Int
  name: String!
}

input Player_cardCreateManyPlayerInputEnvelope {
  data: [Player_cardCreateManyPlayerInput!]!
  skipDuplicates: Boolean
}

input Player_cardCreateNestedManyWithoutCardInput {
  connect: [Player_cardWhereUniqueInput!]
  connectOrCreate: [Player_cardCreateOrConnectWithoutCardInput!]
  create: [Player_cardCreateWithoutCardInput!]
  createMany: Player_cardCreateManyCardInputEnvelope
}

input Player_cardCreateNestedManyWithoutPlayerInput {
  connect: [Player_cardWhereUniqueInput!]
  connectOrCreate: [Player_cardCreateOrConnectWithoutPlayerInput!]
  create: [Player_cardCreateWithoutPlayerInput!]
  createMany: Player_cardCreateManyPlayerInputEnvelope
}

input Player_cardCreateOrConnectWithoutCardInput {
  create: Player_cardCreateWithoutCardInput!
  where: Player_cardWhereUniqueInput!
}

input Player_cardCreateOrConnectWithoutPlayerInput {
  create: Player_cardCreateWithoutPlayerInput!
  where: Player_cardWhereUniqueInput!
}

input Player_cardCreateWithoutCardInput {
  name: String!
  player: PlayerCreateNestedOneWithoutPlayer_cardInput!
}

input Player_cardCreateWithoutPlayerInput {
  card: CardCreateNestedOneWithoutPlayer_cardInput!
  name: String!
}

type Player_cardGroupBy {
  _avg: Player_cardAvgAggregate
  _count: Player_cardCountAggregate
  _max: Player_cardMaxAggregate
  _min: Player_cardMinAggregate
  _sum: Player_cardSumAggregate
  card_id: Int!
  id: Int!
  name: String!
  player_id: Int!
}

input Player_cardListRelationFilter {
  every: Player_cardWhereInput
  none: Player_cardWhereInput
  some: Player_cardWhereInput
}

type Player_cardMaxAggregate {
  card_id: Int
  id: Int
  name: String
  player_id: Int
}

input Player_cardMaxOrderByAggregateInput {
  card_id: SortOrder
  id: SortOrder
  name: SortOrder
  player_id: SortOrder
}

type Player_cardMinAggregate {
  card_id: Int
  id: Int
  name: String
  player_id: Int
}

input Player_cardMinOrderByAggregateInput {
  card_id: SortOrder
  id: SortOrder
  name: SortOrder
  player_id: SortOrder
}

input Player_cardOrderByRelationAggregateInput {
  _count: SortOrder
}

input Player_cardOrderByWithAggregationInput {
  _avg: Player_cardAvgOrderByAggregateInput
  _count: Player_cardCountOrderByAggregateInput
  _max: Player_cardMaxOrderByAggregateInput
  _min: Player_cardMinOrderByAggregateInput
  _sum: Player_cardSumOrderByAggregateInput
  card_id: SortOrder
  id: SortOrder
  name: SortOrder
  player_id: SortOrder
}

input Player_cardOrderByWithRelationInput {
  card: CardOrderByWithRelationInput
  card_id: SortOrder
  id: SortOrder
  name: SortOrder
  player: PlayerOrderByWithRelationInput
  player_id: SortOrder
}

enum Player_cardScalarFieldEnum {
  card_id
  id
  name
  player_id
}

input Player_cardScalarWhereInput {
  AND: [Player_cardScalarWhereInput!]
  NOT: [Player_cardScalarWhereInput!]
  OR: [Player_cardScalarWhereInput!]
  card_id: IntFilter
  id: IntFilter
  name: StringFilter
  player_id: IntFilter
}

input Player_cardScalarWhereWithAggregatesInput {
  AND: [Player_cardScalarWhereWithAggregatesInput!]
  NOT: [Player_cardScalarWhereWithAggregatesInput!]
  OR: [Player_cardScalarWhereWithAggregatesInput!]
  card_id: IntWithAggregatesFilter
  id: IntWithAggregatesFilter
  name: StringWithAggregatesFilter
  player_id: IntWithAggregatesFilter
}

type Player_cardSumAggregate {
  card_id: Int
  id: Int
  player_id: Int
}

input Player_cardSumOrderByAggregateInput {
  card_id: SortOrder
  id: SortOrder
  player_id: SortOrder
}

input Player_cardUpdateInput {
  card: CardUpdateOneRequiredWithoutPlayer_cardNestedInput
  name: StringFieldUpdateOperationsInput
  player: PlayerUpdateOneRequiredWithoutPlayer_cardNestedInput
}

input Player_cardUpdateManyMutationInput {
  name: StringFieldUpdateOperationsInput
}

input Player_cardUpdateManyWithWhereWithoutCardInput {
  data: Player_cardUpdateManyMutationInput!
  where: Player_cardScalarWhereInput!
}

input Player_cardUpdateManyWithWhereWithoutPlayerInput {
  data: Player_cardUpdateManyMutationInput!
  where: Player_cardScalarWhereInput!
}

input Player_cardUpdateManyWithoutCardNestedInput {
  connect: [Player_cardWhereUniqueInput!]
  connectOrCreate: [Player_cardCreateOrConnectWithoutCardInput!]
  create: [Player_cardCreateWithoutCardInput!]
  createMany: Player_cardCreateManyCardInputEnvelope
  delete: [Player_cardWhereUniqueInput!]
  deleteMany: [Player_cardScalarWhereInput!]
  disconnect: [Player_cardWhereUniqueInput!]
  set: [Player_cardWhereUniqueInput!]
  update: [Player_cardUpdateWithWhereUniqueWithoutCardInput!]
  updateMany: [Player_cardUpdateManyWithWhereWithoutCardInput!]
  upsert: [Player_cardUpsertWithWhereUniqueWithoutCardInput!]
}

input Player_cardUpdateManyWithoutPlayerNestedInput {
  connect: [Player_cardWhereUniqueInput!]
  connectOrCreate: [Player_cardCreateOrConnectWithoutPlayerInput!]
  create: [Player_cardCreateWithoutPlayerInput!]
  createMany: Player_cardCreateManyPlayerInputEnvelope
  delete: [Player_cardWhereUniqueInput!]
  deleteMany: [Player_cardScalarWhereInput!]
  disconnect: [Player_cardWhereUniqueInput!]
  set: [Player_cardWhereUniqueInput!]
  update: [Player_cardUpdateWithWhereUniqueWithoutPlayerInput!]
  updateMany: [Player_cardUpdateManyWithWhereWithoutPlayerInput!]
  upsert: [Player_cardUpsertWithWhereUniqueWithoutPlayerInput!]
}

input Player_cardUpdateWithWhereUniqueWithoutCardInput {
  data: Player_cardUpdateWithoutCardInput!
  where: Player_cardWhereUniqueInput!
}

input Player_cardUpdateWithWhereUniqueWithoutPlayerInput {
  data: Player_cardUpdateWithoutPlayerInput!
  where: Player_cardWhereUniqueInput!
}

input Player_cardUpdateWithoutCardInput {
  name: StringFieldUpdateOperationsInput
  player: PlayerUpdateOneRequiredWithoutPlayer_cardNestedInput
}

input Player_cardUpdateWithoutPlayerInput {
  card: CardUpdateOneRequiredWithoutPlayer_cardNestedInput
  name: StringFieldUpdateOperationsInput
}

input Player_cardUpsertWithWhereUniqueWithoutCardInput {
  create: Player_cardCreateWithoutCardInput!
  update: Player_cardUpdateWithoutCardInput!
  where: Player_cardWhereUniqueInput!
}

input Player_cardUpsertWithWhereUniqueWithoutPlayerInput {
  create: Player_cardCreateWithoutPlayerInput!
  update: Player_cardUpdateWithoutPlayerInput!
  where: Player_cardWhereUniqueInput!
}

input Player_cardWhereInput {
  AND: [Player_cardWhereInput!]
  NOT: [Player_cardWhereInput!]
  OR: [Player_cardWhereInput!]
  card: CardRelationFilter
  card_id: IntFilter
  id: IntFilter
  name: StringFilter
  player: PlayerRelationFilter
  player_id: IntFilter
}

input Player_cardWhereUniqueInput {
  id: Int
}

type Query {
  aggregateCard(cursor: CardWhereUniqueInput, orderBy: [CardOrderByWithRelationInput!], skip: Int, take: Int, where: CardWhereInput): AggregateCard!
  aggregateCard_rank(cursor: Card_rankWhereUniqueInput, orderBy: [Card_rankOrderByWithRelationInput!], skip: Int, take: Int, where: Card_rankWhereInput): AggregateCard_rank!
  aggregateCard_type(cursor: Card_typeWhereUniqueInput, orderBy: [Card_typeOrderByWithRelationInput!], skip: Int, take: Int, where: Card_typeWhereInput): AggregateCard_type!
  aggregateElement(cursor: ElementWhereUniqueInput, orderBy: [ElementOrderByWithRelationInput!], skip: Int, take: Int, where: ElementWhereInput): AggregateElement!
  aggregateElement_affinity(cursor: Element_affinityWhereUniqueInput, orderBy: [Element_affinityOrderByWithRelationInput!], skip: Int, take: Int, where: Element_affinityWhereInput): AggregateElement_affinity!
  aggregateElement_weakness(cursor: Element_weaknessWhereUniqueInput, orderBy: [Element_weaknessOrderByWithRelationInput!], skip: Int, take: Int, where: Element_weaknessWhereInput): AggregateElement_weakness!
  aggregatePlayer(cursor: PlayerWhereUniqueInput, orderBy: [PlayerOrderByWithRelationInput!], skip: Int, take: Int, where: PlayerWhereInput): AggregatePlayer!
  aggregatePlayer_card(cursor: Player_cardWhereUniqueInput, orderBy: [Player_cardOrderByWithRelationInput!], skip: Int, take: Int, where: Player_cardWhereInput): AggregatePlayer_card!
  card(where: CardWhereUniqueInput!): Card
  card_rank(where: Card_rankWhereUniqueInput!): Card_rank
  card_ranks(cursor: Card_rankWhereUniqueInput, distinct: [Card_rankScalarFieldEnum!], orderBy: [Card_rankOrderByWithRelationInput!], skip: Int, take: Int, where: Card_rankWhereInput): [Card_rank!]!
  card_type(where: Card_typeWhereUniqueInput!): Card_type
  card_types(cursor: Card_typeWhereUniqueInput, distinct: [Card_typeScalarFieldEnum!], orderBy: [Card_typeOrderByWithRelationInput!], skip: Int, take: Int, where: Card_typeWhereInput): [Card_type!]!
  cards(cursor: CardWhereUniqueInput, distinct: [CardScalarFieldEnum!], orderBy: [CardOrderByWithRelationInput!], skip: Int, take: Int, where: CardWhereInput): [Card!]!
  element(where: ElementWhereUniqueInput!): Element
  element_affinities(cursor: Element_affinityWhereUniqueInput, distinct: [Element_affinityScalarFieldEnum!], orderBy: [Element_affinityOrderByWithRelationInput!], skip: Int, take: Int, where: Element_affinityWhereInput): [Element_affinity!]!
  element_affinity(where: Element_affinityWhereUniqueInput!): Element_affinity
  element_weakness(where: Element_weaknessWhereUniqueInput!): Element_weakness
  element_weaknesses(cursor: Element_weaknessWhereUniqueInput, distinct: [Element_weaknessScalarFieldEnum!], orderBy: [Element_weaknessOrderByWithRelationInput!], skip: Int, take: Int, where: Element_weaknessWhereInput): [Element_weakness!]!
  elements(cursor: ElementWhereUniqueInput, distinct: [ElementScalarFieldEnum!], orderBy: [ElementOrderByWithRelationInput!], skip: Int, take: Int, where: ElementWhereInput): [Element!]!
  findFirstCard(cursor: CardWhereUniqueInput, distinct: [CardScalarFieldEnum!], orderBy: [CardOrderByWithRelationInput!], skip: Int, take: Int, where: CardWhereInput): Card
  findFirstCard_rank(cursor: Card_rankWhereUniqueInput, distinct: [Card_rankScalarFieldEnum!], orderBy: [Card_rankOrderByWithRelationInput!], skip: Int, take: Int, where: Card_rankWhereInput): Card_rank
  findFirstCard_type(cursor: Card_typeWhereUniqueInput, distinct: [Card_typeScalarFieldEnum!], orderBy: [Card_typeOrderByWithRelationInput!], skip: Int, take: Int, where: Card_typeWhereInput): Card_type
  findFirstElement(cursor: ElementWhereUniqueInput, distinct: [ElementScalarFieldEnum!], orderBy: [ElementOrderByWithRelationInput!], skip: Int, take: Int, where: ElementWhereInput): Element
  findFirstElement_affinity(cursor: Element_affinityWhereUniqueInput, distinct: [Element_affinityScalarFieldEnum!], orderBy: [Element_affinityOrderByWithRelationInput!], skip: Int, take: Int, where: Element_affinityWhereInput): Element_affinity
  findFirstElement_weakness(cursor: Element_weaknessWhereUniqueInput, distinct: [Element_weaknessScalarFieldEnum!], orderBy: [Element_weaknessOrderByWithRelationInput!], skip: Int, take: Int, where: Element_weaknessWhereInput): Element_weakness
  findFirstPlayer(cursor: PlayerWhereUniqueInput, distinct: [PlayerScalarFieldEnum!], orderBy: [PlayerOrderByWithRelationInput!], skip: Int, take: Int, where: PlayerWhereInput): Player
  findFirstPlayer_card(cursor: Player_cardWhereUniqueInput, distinct: [Player_cardScalarFieldEnum!], orderBy: [Player_cardOrderByWithRelationInput!], skip: Int, take: Int, where: Player_cardWhereInput): Player_card
  groupByCard(by: [CardScalarFieldEnum!]!, having: CardScalarWhereWithAggregatesInput, orderBy: [CardOrderByWithAggregationInput!], skip: Int, take: Int, where: CardWhereInput): [CardGroupBy!]!
  groupByCard_rank(by: [Card_rankScalarFieldEnum!]!, having: Card_rankScalarWhereWithAggregatesInput, orderBy: [Card_rankOrderByWithAggregationInput!], skip: Int, take: Int, where: Card_rankWhereInput): [Card_rankGroupBy!]!
  groupByCard_type(by: [Card_typeScalarFieldEnum!]!, having: Card_typeScalarWhereWithAggregatesInput, orderBy: [Card_typeOrderByWithAggregationInput!], skip: Int, take: Int, where: Card_typeWhereInput): [Card_typeGroupBy!]!
  groupByElement(by: [ElementScalarFieldEnum!]!, having: ElementScalarWhereWithAggregatesInput, orderBy: [ElementOrderByWithAggregationInput!], skip: Int, take: Int, where: ElementWhereInput): [ElementGroupBy!]!
  groupByElement_affinity(by: [Element_affinityScalarFieldEnum!]!, having: Element_affinityScalarWhereWithAggregatesInput, orderBy: [Element_affinityOrderByWithAggregationInput!], skip: Int, take: Int, where: Element_affinityWhereInput): [Element_affinityGroupBy!]!
  groupByElement_weakness(by: [Element_weaknessScalarFieldEnum!]!, having: Element_weaknessScalarWhereWithAggregatesInput, orderBy: [Element_weaknessOrderByWithAggregationInput!], skip: Int, take: Int, where: Element_weaknessWhereInput): [Element_weaknessGroupBy!]!
  groupByPlayer(by: [PlayerScalarFieldEnum!]!, having: PlayerScalarWhereWithAggregatesInput, orderBy: [PlayerOrderByWithAggregationInput!], skip: Int, take: Int, where: PlayerWhereInput): [PlayerGroupBy!]!
  groupByPlayer_card(by: [Player_cardScalarFieldEnum!]!, having: Player_cardScalarWhereWithAggregatesInput, orderBy: [Player_cardOrderByWithAggregationInput!], skip: Int, take: Int, where: Player_cardWhereInput): [Player_cardGroupBy!]!
  player(where: PlayerWhereUniqueInput!): Player
  player_card(where: Player_cardWhereUniqueInput!): Player_card
  player_cards(cursor: Player_cardWhereUniqueInput, distinct: [Player_cardScalarFieldEnum!], orderBy: [Player_cardOrderByWithRelationInput!], skip: Int, take: Int, where: Player_cardWhereInput): [Player_card!]!
  players(cursor: PlayerWhereUniqueInput, distinct: [PlayerScalarFieldEnum!], orderBy: [PlayerOrderByWithRelationInput!], skip: Int, take: Int, where: PlayerWhereInput): [Player!]!
}

enum SortOrder {
  asc
  desc
}

input StringFieldUpdateOperationsInput {
  set: String
}

input StringFilter {
  contains: String
  endsWith: String
  equals: String
  gt: String
  gte: String
  in: [String!]
  lt: String
  lte: String
  not: NestedStringFilter
  notIn: [String!]
  startsWith: String
}

input StringWithAggregatesFilter {
  _count: NestedIntFilter
  _max: NestedStringFilter
  _min: NestedStringFilter
  contains: String
  endsWith: String
  equals: String
  gt: String
  gte: String
  in: [String!]
  lt: String
  lte: String
  not: NestedStringWithAggregatesFilter
  notIn: [String!]
  startsWith: String
}

input element_affinityElement_idAffinity_elementCompoundUniqueInput {
  affinity_element: Int!
  element_id: Int!
}

input element_weaknessElement_idWeakness_element_idCompoundUniqueInput {
  element_id: Int!
  weakness_element_id: Int!
}