# ------------------------------------------------------
# THIS FILE WAS AUTOMATICALLY GENERATED (DO NOT MODIFY)
# ------------------------------------------------------

type Club {
  _count: ClubCount!
  clubName: String!
  createdAt: DateTime!
  games: [Game!]
  groups: [Group!]
  id: ID!
  owner: User!
  ownerId: String!
  phoneId: Int!
  players: [Player!]
  updatedAt: DateTime!
}

type ClubAvgAggregate {
  phoneId: Float
}

type ClubCount {
  games: Int!
  groups: Int!
  players: Int!
}

type ClubCountAggregate {
  _all: Int!
  clubName: Int!
  createdAt: Int!
  id: Int!
  ownerId: Int!
  phoneId: Int!
  updatedAt: Int!
}

input ClubCreateInput {
  clubName: String!
  createdAt: DateTime
  games: GameCreateNestedManyWithoutClubInput
  groups: GroupCreateNestedManyWithoutClubInput
  id: String
  owner: UserCreateNestedOneWithoutClubsInput!
  phoneId: Int!
  players: PlayerCreateNestedManyWithoutClubInput
  updatedAt: DateTime
}

input ClubCreateManyOwnerInput {
  clubName: String!
  createdAt: DateTime
  id: String
  phoneId: Int!
  updatedAt: DateTime
}

input ClubCreateManyOwnerInputEnvelope {
  data: [ClubCreateManyOwnerInput!]!
  skipDuplicates: Boolean
}

input ClubCreateNestedManyWithoutOwnerInput {
  connect: [ClubWhereUniqueInput!]
  connectOrCreate: [ClubCreateOrConnectWithoutOwnerInput!]
  create: [ClubCreateWithoutOwnerInput!]
  createMany: ClubCreateManyOwnerInputEnvelope
}

input ClubCreateNestedOneWithoutGamesInput {
  connect: ClubWhereUniqueInput
  connectOrCreate: ClubCreateOrConnectWithoutGamesInput
  create: ClubCreateWithoutGamesInput
}

input ClubCreateNestedOneWithoutGroupsInput {
  connect: ClubWhereUniqueInput
  connectOrCreate: ClubCreateOrConnectWithoutGroupsInput
  create: ClubCreateWithoutGroupsInput
}

input ClubCreateNestedOneWithoutPlayersInput {
  connect: ClubWhereUniqueInput
  connectOrCreate: ClubCreateOrConnectWithoutPlayersInput
  create: ClubCreateWithoutPlayersInput
}

input ClubCreateOrConnectWithoutGamesInput {
  create: ClubCreateWithoutGamesInput!
  where: ClubWhereUniqueInput!
}

input ClubCreateOrConnectWithoutGroupsInput {
  create: ClubCreateWithoutGroupsInput!
  where: ClubWhereUniqueInput!
}

input ClubCreateOrConnectWithoutOwnerInput {
  create: ClubCreateWithoutOwnerInput!
  where: ClubWhereUniqueInput!
}

input ClubCreateOrConnectWithoutPlayersInput {
  create: ClubCreateWithoutPlayersInput!
  where: ClubWhereUniqueInput!
}

input ClubCreateWithoutGamesInput {
  clubName: String!
  createdAt: DateTime
  groups: GroupCreateNestedManyWithoutClubInput
  id: String
  owner: UserCreateNestedOneWithoutClubsInput!
  phoneId: Int!
  players: PlayerCreateNestedManyWithoutClubInput
  updatedAt: DateTime
}

input ClubCreateWithoutGroupsInput {
  clubName: String!
  createdAt: DateTime
  games: GameCreateNestedManyWithoutClubInput
  id: String
  owner: UserCreateNestedOneWithoutClubsInput!
  phoneId: Int!
  players: PlayerCreateNestedManyWithoutClubInput
  updatedAt: DateTime
}

input ClubCreateWithoutOwnerInput {
  clubName: String!
  createdAt: DateTime
  games: GameCreateNestedManyWithoutClubInput
  groups: GroupCreateNestedManyWithoutClubInput
  id: String
  phoneId: Int!
  players: PlayerCreateNestedManyWithoutClubInput
  updatedAt: DateTime
}

input ClubCreateWithoutPlayersInput {
  clubName: String!
  createdAt: DateTime
  games: GameCreateNestedManyWithoutClubInput
  groups: GroupCreateNestedManyWithoutClubInput
  id: String
  owner: UserCreateNestedOneWithoutClubsInput!
  phoneId: Int!
  updatedAt: DateTime
}

input ClubListRelationFilter {
  every: ClubWhereInput
  none: ClubWhereInput
  some: ClubWhereInput
}

type ClubMaxAggregate {
  clubName: String
  createdAt: DateTime
  id: String
  ownerId: String
  phoneId: Int
  updatedAt: DateTime
}

type ClubMinAggregate {
  clubName: String
  createdAt: DateTime
  id: String
  ownerId: String
  phoneId: Int
  updatedAt: DateTime
}

input ClubRelationFilter {
  is: ClubWhereInput
  isNot: ClubWhereInput
}

input ClubScalarWhereInput {
  AND: [ClubScalarWhereInput!]
  NOT: [ClubScalarWhereInput!]
  OR: [ClubScalarWhereInput!]
  clubName: StringFilter
  createdAt: DateTimeFilter
  id: StringFilter
  ownerId: StringFilter
  phoneId: IntFilter
  updatedAt: DateTimeFilter
}

type ClubSumAggregate {
  phoneId: Int
}

input ClubUpdateInput {
  clubName: StringFieldUpdateOperationsInput
  createdAt: DateTimeFieldUpdateOperationsInput
  games: GameUpdateManyWithoutClubInput
  groups: GroupUpdateManyWithoutClubInput
  id: StringFieldUpdateOperationsInput
  owner: UserUpdateOneRequiredWithoutClubsInput
  phoneId: IntFieldUpdateOperationsInput
  players: PlayerUpdateManyWithoutClubInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input ClubUpdateManyMutationInput {
  clubName: StringFieldUpdateOperationsInput
  createdAt: DateTimeFieldUpdateOperationsInput
  id: StringFieldUpdateOperationsInput
  phoneId: IntFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input ClubUpdateManyWithWhereWithoutOwnerInput {
  data: ClubUpdateManyMutationInput!
  where: ClubScalarWhereInput!
}

input ClubUpdateManyWithoutOwnerInput {
  connect: [ClubWhereUniqueInput!]
  connectOrCreate: [ClubCreateOrConnectWithoutOwnerInput!]
  create: [ClubCreateWithoutOwnerInput!]
  createMany: ClubCreateManyOwnerInputEnvelope
  delete: [ClubWhereUniqueInput!]
  deleteMany: [ClubScalarWhereInput!]
  disconnect: [ClubWhereUniqueInput!]
  set: [ClubWhereUniqueInput!]
  update: [ClubUpdateWithWhereUniqueWithoutOwnerInput!]
  updateMany: [ClubUpdateManyWithWhereWithoutOwnerInput!]
  upsert: [ClubUpsertWithWhereUniqueWithoutOwnerInput!]
}

input ClubUpdateOneRequiredWithoutGamesInput {
  connect: ClubWhereUniqueInput
  connectOrCreate: ClubCreateOrConnectWithoutGamesInput
  create: ClubCreateWithoutGamesInput
  update: ClubUpdateWithoutGamesInput
  upsert: ClubUpsertWithoutGamesInput
}

input ClubUpdateOneRequiredWithoutGroupsInput {
  connect: ClubWhereUniqueInput
  connectOrCreate: ClubCreateOrConnectWithoutGroupsInput
  create: ClubCreateWithoutGroupsInput
  update: ClubUpdateWithoutGroupsInput
  upsert: ClubUpsertWithoutGroupsInput
}

input ClubUpdateOneRequiredWithoutPlayersInput {
  connect: ClubWhereUniqueInput
  connectOrCreate: ClubCreateOrConnectWithoutPlayersInput
  create: ClubCreateWithoutPlayersInput
  update: ClubUpdateWithoutPlayersInput
  upsert: ClubUpsertWithoutPlayersInput
}

input ClubUpdateWithWhereUniqueWithoutOwnerInput {
  data: ClubUpdateWithoutOwnerInput!
  where: ClubWhereUniqueInput!
}

input ClubUpdateWithoutGamesInput {
  clubName: StringFieldUpdateOperationsInput
  createdAt: DateTimeFieldUpdateOperationsInput
  groups: GroupUpdateManyWithoutClubInput
  id: StringFieldUpdateOperationsInput
  owner: UserUpdateOneRequiredWithoutClubsInput
  phoneId: IntFieldUpdateOperationsInput
  players: PlayerUpdateManyWithoutClubInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input ClubUpdateWithoutGroupsInput {
  clubName: StringFieldUpdateOperationsInput
  createdAt: DateTimeFieldUpdateOperationsInput
  games: GameUpdateManyWithoutClubInput
  id: StringFieldUpdateOperationsInput
  owner: UserUpdateOneRequiredWithoutClubsInput
  phoneId: IntFieldUpdateOperationsInput
  players: PlayerUpdateManyWithoutClubInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input ClubUpdateWithoutOwnerInput {
  clubName: StringFieldUpdateOperationsInput
  createdAt: DateTimeFieldUpdateOperationsInput
  games: GameUpdateManyWithoutClubInput
  groups: GroupUpdateManyWithoutClubInput
  id: StringFieldUpdateOperationsInput
  phoneId: IntFieldUpdateOperationsInput
  players: PlayerUpdateManyWithoutClubInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input ClubUpdateWithoutPlayersInput {
  clubName: StringFieldUpdateOperationsInput
  createdAt: DateTimeFieldUpdateOperationsInput
  games: GameUpdateManyWithoutClubInput
  groups: GroupUpdateManyWithoutClubInput
  id: StringFieldUpdateOperationsInput
  owner: UserUpdateOneRequiredWithoutClubsInput
  phoneId: IntFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input ClubUpsertWithWhereUniqueWithoutOwnerInput {
  create: ClubCreateWithoutOwnerInput!
  update: ClubUpdateWithoutOwnerInput!
  where: ClubWhereUniqueInput!
}

input ClubUpsertWithoutGamesInput {
  create: ClubCreateWithoutGamesInput!
  update: ClubUpdateWithoutGamesInput!
}

input ClubUpsertWithoutGroupsInput {
  create: ClubCreateWithoutGroupsInput!
  update: ClubUpdateWithoutGroupsInput!
}

input ClubUpsertWithoutPlayersInput {
  create: ClubCreateWithoutPlayersInput!
  update: ClubUpdateWithoutPlayersInput!
}

input ClubWhereInput {
  AND: [ClubWhereInput!]
  NOT: [ClubWhereInput!]
  OR: [ClubWhereInput!]
  clubName: StringFilter
  createdAt: DateTimeFilter
  games: GameListRelationFilter
  groups: GroupListRelationFilter
  id: StringFilter
  owner: UserRelationFilter
  ownerId: StringFilter
  phoneId: IntFilter
  players: PlayerListRelationFilter
  updatedAt: DateTimeFilter
}

input ClubWhereUniqueInput {
  id: String
}

"""
A date-time string at UTC, such as 2019-12-03T09:54:33Z, compliant with the date-time format.
"""
scalar DateTime

input DateTimeFieldUpdateOperationsInput {
  set: DateTime
}

input DateTimeFilter {
  equals: DateTime
  gt: DateTime
  gte: DateTime
  in: [DateTime!]
  lt: DateTime
  lte: DateTime
  not: DateTimeFilter
  notIn: [DateTime!]
}

input EnumRoleFieldUpdateOperationsInput {
  set: Role
}

input EnumRoleFilter {
  equals: Role
  in: [Role!]
  not: EnumRoleFilter
  notIn: [Role!]
}

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: FloatFilter
  notIn: [Float!]
}

type Game {
  _count: GameCount!
  club: Club!
  clubId: String!
  createdAt: DateTime!
  delayTime: String
  gameData: GameData
  gameDescription: String
  gameMode: String
  gameTime: String
  gameType: String
  id: ID!
  name: String!
  notes: String!
  numPads: Int
  padLightUpTime: Float
  phoneId: Int!
  scheduledDate: DateTime
  sequence: String
  stations: [Station!]
  updatedAt: DateTime!
}

type GameAvgAggregate {
  numPads: Float
  padLightUpTime: Float
  phoneId: Float
}

type GameCount {
  stations: Int!
}

type GameCountAggregate {
  _all: Int!
  clubId: Int!
  createdAt: Int!
  delayTime: Int!
  gameDescription: Int!
  gameMode: Int!
  gameTime: Int!
  gameType: Int!
  id: Int!
  name: Int!
  notes: Int!
  numPads: Int!
  padLightUpTime: Int!
  phoneId: Int!
  scheduledDate: Int!
  sequence: Int!
  updatedAt: Int!
}

input GameCreateManyClubInput {
  createdAt: DateTime
  delayTime: String
  gameDescription: String
  gameMode: String
  gameTime: String
  gameType: String
  id: String
  name: String!
  notes: String!
  numPads: Int
  padLightUpTime: Float
  phoneId: Int!
  scheduledDate: DateTime
  sequence: String
  updatedAt: DateTime
}

input GameCreateManyClubInputEnvelope {
  data: [GameCreateManyClubInput!]!
  skipDuplicates: Boolean
}

input GameCreateNestedManyWithoutClubInput {
  connect: [GameWhereUniqueInput!]
  connectOrCreate: [GameCreateOrConnectWithoutClubInput!]
  create: [GameCreateWithoutClubInput!]
  createMany: GameCreateManyClubInputEnvelope
}

input GameCreateNestedOneWithoutGameDataInput {
  connect: GameWhereUniqueInput
  connectOrCreate: GameCreateOrConnectWithoutGameDataInput
  create: GameCreateWithoutGameDataInput
}

input GameCreateOrConnectWithoutClubInput {
  create: GameCreateWithoutClubInput!
  where: GameWhereUniqueInput!
}

input GameCreateOrConnectWithoutGameDataInput {
  create: GameCreateWithoutGameDataInput!
  where: GameWhereUniqueInput!
}

input GameCreateWithoutClubInput {
  createdAt: DateTime
  delayTime: String
  gameData: GameDataCreateNestedOneWithoutGameInput
  gameDescription: String
  gameMode: String
  gameTime: String
  gameType: String
  id: String
  name: String!
  notes: String!
  numPads: Int
  padLightUpTime: Float
  phoneId: Int!
  scheduledDate: DateTime
  sequence: String
  stations: StationCreateNestedManyWithoutGameInput
  updatedAt: DateTime
}

input GameCreateWithoutGameDataInput {
  club: ClubCreateNestedOneWithoutGamesInput!
  createdAt: DateTime
  delayTime: String
  gameDescription: String
  gameMode: String
  gameTime: String
  gameType: String
  id: String
  name: String!
  notes: String!
  numPads: Int
  padLightUpTime: Float
  phoneId: Int!
  scheduledDate: DateTime
  sequence: String
  stations: StationCreateNestedManyWithoutGameInput
  updatedAt: DateTime
}

type GameData {
  _count: GameDataCount!
  accuracy: Float!
  createdAt: DateTime!
  game: Game!
  gameId: String!
  hits: Int!
  id: ID!
  misses: Int!
  padArrangement: String
  players: [Player!]
  timeSequence: String!
  updatedAt: DateTime!
}

type GameDataAvgAggregate {
  accuracy: Float
  hits: Float
  misses: Float
}

type GameDataCount {
  players: Int!
}

type GameDataCountAggregate {
  _all: Int!
  accuracy: Int!
  createdAt: Int!
  gameId: Int!
  hits: Int!
  id: Int!
  misses: Int!
  padArrangement: Int!
  timeSequence: Int!
  updatedAt: Int!
}

input GameDataCreateNestedManyWithoutPlayersInput {
  connect: [GameDataWhereUniqueInput!]
  connectOrCreate: [GameDataCreateOrConnectWithoutPlayersInput!]
  create: [GameDataCreateWithoutPlayersInput!]
}

input GameDataCreateNestedOneWithoutGameInput {
  connect: GameDataWhereUniqueInput
  connectOrCreate: GameDataCreateOrConnectWithoutGameInput
  create: GameDataCreateWithoutGameInput
}

input GameDataCreateOrConnectWithoutGameInput {
  create: GameDataCreateWithoutGameInput!
  where: GameDataWhereUniqueInput!
}

input GameDataCreateOrConnectWithoutPlayersInput {
  create: GameDataCreateWithoutPlayersInput!
  where: GameDataWhereUniqueInput!
}

input GameDataCreateWithoutGameInput {
  accuracy: Float!
  createdAt: DateTime
  hits: Int!
  id: String
  misses: Int!
  padArrangement: String
  players: PlayerCreateNestedManyWithoutGameDataInput
  timeSequence: String!
  updatedAt: DateTime
}

input GameDataCreateWithoutPlayersInput {
  accuracy: Float!
  createdAt: DateTime
  game: GameCreateNestedOneWithoutGameDataInput!
  hits: Int!
  id: String
  misses: Int!
  padArrangement: String
  timeSequence: String!
  updatedAt: DateTime
}

input GameDataListRelationFilter {
  every: GameDataWhereInput
  none: GameDataWhereInput
  some: GameDataWhereInput
}

type GameDataMaxAggregate {
  accuracy: Float
  createdAt: DateTime
  gameId: String
  hits: Int
  id: String
  misses: Int
  padArrangement: String
  timeSequence: String
  updatedAt: DateTime
}

type GameDataMinAggregate {
  accuracy: Float
  createdAt: DateTime
  gameId: String
  hits: Int
  id: String
  misses: Int
  padArrangement: String
  timeSequence: String
  updatedAt: DateTime
}

input GameDataRelationFilter {
  is: GameDataWhereInput
  isNot: GameDataWhereInput
}

input GameDataScalarWhereInput {
  AND: [GameDataScalarWhereInput!]
  NOT: [GameDataScalarWhereInput!]
  OR: [GameDataScalarWhereInput!]
  accuracy: FloatFilter
  createdAt: DateTimeFilter
  gameId: StringFilter
  hits: IntFilter
  id: StringFilter
  misses: IntFilter
  padArrangement: StringFilter
  timeSequence: StringFilter
  updatedAt: DateTimeFilter
}

type GameDataSumAggregate {
  accuracy: Float
  hits: Int
  misses: Int
}

input GameDataUpdateManyMutationInput {
  accuracy: FloatFieldUpdateOperationsInput
  createdAt: DateTimeFieldUpdateOperationsInput
  hits: IntFieldUpdateOperationsInput
  id: StringFieldUpdateOperationsInput
  misses: IntFieldUpdateOperationsInput
  padArrangement: NullableStringFieldUpdateOperationsInput
  timeSequence: StringFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input GameDataUpdateManyWithWhereWithoutPlayersInput {
  data: GameDataUpdateManyMutationInput!
  where: GameDataScalarWhereInput!
}

input GameDataUpdateManyWithoutPlayersInput {
  connect: [GameDataWhereUniqueInput!]
  connectOrCreate: [GameDataCreateOrConnectWithoutPlayersInput!]
  create: [GameDataCreateWithoutPlayersInput!]
  delete: [GameDataWhereUniqueInput!]
  deleteMany: [GameDataScalarWhereInput!]
  disconnect: [GameDataWhereUniqueInput!]
  set: [GameDataWhereUniqueInput!]
  update: [GameDataUpdateWithWhereUniqueWithoutPlayersInput!]
  updateMany: [GameDataUpdateManyWithWhereWithoutPlayersInput!]
  upsert: [GameDataUpsertWithWhereUniqueWithoutPlayersInput!]
}

input GameDataUpdateOneWithoutGameInput {
  connect: GameDataWhereUniqueInput
  connectOrCreate: GameDataCreateOrConnectWithoutGameInput
  create: GameDataCreateWithoutGameInput
  delete: Boolean
  disconnect: Boolean
  update: GameDataUpdateWithoutGameInput
  upsert: GameDataUpsertWithoutGameInput
}

input GameDataUpdateWithWhereUniqueWithoutPlayersInput {
  data: GameDataUpdateWithoutPlayersInput!
  where: GameDataWhereUniqueInput!
}

input GameDataUpdateWithoutGameInput {
  accuracy: FloatFieldUpdateOperationsInput
  createdAt: DateTimeFieldUpdateOperationsInput
  hits: IntFieldUpdateOperationsInput
  id: StringFieldUpdateOperationsInput
  misses: IntFieldUpdateOperationsInput
  padArrangement: NullableStringFieldUpdateOperationsInput
  players: PlayerUpdateManyWithoutGameDataInput
  timeSequence: StringFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input GameDataUpdateWithoutPlayersInput {
  accuracy: FloatFieldUpdateOperationsInput
  createdAt: DateTimeFieldUpdateOperationsInput
  game: GameUpdateOneRequiredWithoutGameDataInput
  hits: IntFieldUpdateOperationsInput
  id: StringFieldUpdateOperationsInput
  misses: IntFieldUpdateOperationsInput
  padArrangement: NullableStringFieldUpdateOperationsInput
  timeSequence: StringFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input GameDataUpsertWithWhereUniqueWithoutPlayersInput {
  create: GameDataCreateWithoutPlayersInput!
  update: GameDataUpdateWithoutPlayersInput!
  where: GameDataWhereUniqueInput!
}

input GameDataUpsertWithoutGameInput {
  create: GameDataCreateWithoutGameInput!
  update: GameDataUpdateWithoutGameInput!
}

input GameDataWhereInput {
  AND: [GameDataWhereInput!]
  NOT: [GameDataWhereInput!]
  OR: [GameDataWhereInput!]
  accuracy: FloatFilter
  createdAt: DateTimeFilter
  game: GameRelationFilter
  gameId: StringFilter
  hits: IntFilter
  id: StringFilter
  misses: IntFilter
  padArrangement: StringFilter
  players: PlayerListRelationFilter
  timeSequence: StringFilter
  updatedAt: DateTimeFilter
}

input GameDataWhereUniqueInput {
  gameId: String
  id: String
}

input GameListRelationFilter {
  every: GameWhereInput
  none: GameWhereInput
  some: GameWhereInput
}

type GameMaxAggregate {
  clubId: String
  createdAt: DateTime
  delayTime: String
  gameDescription: String
  gameMode: String
  gameTime: String
  gameType: String
  id: String
  name: String
  notes: String
  numPads: Int
  padLightUpTime: Float
  phoneId: Int
  scheduledDate: DateTime
  sequence: String
  updatedAt: DateTime
}

type GameMinAggregate {
  clubId: String
  createdAt: DateTime
  delayTime: String
  gameDescription: String
  gameMode: String
  gameTime: String
  gameType: String
  id: String
  name: String
  notes: String
  numPads: Int
  padLightUpTime: Float
  phoneId: Int
  scheduledDate: DateTime
  sequence: String
  updatedAt: DateTime
}

input GameRelationFilter {
  is: GameWhereInput
  isNot: GameWhereInput
}

input GameScalarWhereInput {
  AND: [GameScalarWhereInput!]
  NOT: [GameScalarWhereInput!]
  OR: [GameScalarWhereInput!]
  clubId: StringFilter
  createdAt: DateTimeFilter
  delayTime: StringFilter
  gameDescription: StringFilter
  gameMode: StringFilter
  gameTime: StringFilter
  gameType: StringFilter
  id: StringFilter
  name: StringFilter
  notes: StringFilter
  numPads: IntFilter
  padLightUpTime: FloatFilter
  phoneId: IntFilter
  scheduledDate: DateTimeFilter
  sequence: StringFilter
  updatedAt: DateTimeFilter
}

type GameSumAggregate {
  numPads: Int
  padLightUpTime: Float
  phoneId: Int
}

input GameUpdateManyMutationInput {
  createdAt: DateTimeFieldUpdateOperationsInput
  delayTime: NullableStringFieldUpdateOperationsInput
  gameDescription: NullableStringFieldUpdateOperationsInput
  gameMode: NullableStringFieldUpdateOperationsInput
  gameTime: NullableStringFieldUpdateOperationsInput
  gameType: NullableStringFieldUpdateOperationsInput
  id: StringFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
  notes: StringFieldUpdateOperationsInput
  numPads: NullableIntFieldUpdateOperationsInput
  padLightUpTime: NullableFloatFieldUpdateOperationsInput
  phoneId: IntFieldUpdateOperationsInput
  scheduledDate: NullableDateTimeFieldUpdateOperationsInput
  sequence: NullableStringFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input GameUpdateManyWithWhereWithoutClubInput {
  data: GameUpdateManyMutationInput!
  where: GameScalarWhereInput!
}

input GameUpdateManyWithoutClubInput {
  connect: [GameWhereUniqueInput!]
  connectOrCreate: [GameCreateOrConnectWithoutClubInput!]
  create: [GameCreateWithoutClubInput!]
  createMany: GameCreateManyClubInputEnvelope
  delete: [GameWhereUniqueInput!]
  deleteMany: [GameScalarWhereInput!]
  disconnect: [GameWhereUniqueInput!]
  set: [GameWhereUniqueInput!]
  update: [GameUpdateWithWhereUniqueWithoutClubInput!]
  updateMany: [GameUpdateManyWithWhereWithoutClubInput!]
  upsert: [GameUpsertWithWhereUniqueWithoutClubInput!]
}

input GameUpdateOneRequiredWithoutGameDataInput {
  connect: GameWhereUniqueInput
  connectOrCreate: GameCreateOrConnectWithoutGameDataInput
  create: GameCreateWithoutGameDataInput
  update: GameUpdateWithoutGameDataInput
  upsert: GameUpsertWithoutGameDataInput
}

input GameUpdateWithWhereUniqueWithoutClubInput {
  data: GameUpdateWithoutClubInput!
  where: GameWhereUniqueInput!
}

input GameUpdateWithoutClubInput {
  createdAt: DateTimeFieldUpdateOperationsInput
  delayTime: NullableStringFieldUpdateOperationsInput
  gameData: GameDataUpdateOneWithoutGameInput
  gameDescription: NullableStringFieldUpdateOperationsInput
  gameMode: NullableStringFieldUpdateOperationsInput
  gameTime: NullableStringFieldUpdateOperationsInput
  gameType: NullableStringFieldUpdateOperationsInput
  id: StringFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
  notes: StringFieldUpdateOperationsInput
  numPads: NullableIntFieldUpdateOperationsInput
  padLightUpTime: NullableFloatFieldUpdateOperationsInput
  phoneId: IntFieldUpdateOperationsInput
  scheduledDate: NullableDateTimeFieldUpdateOperationsInput
  sequence: NullableStringFieldUpdateOperationsInput
  stations: StationUpdateManyWithoutGameInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input GameUpdateWithoutGameDataInput {
  club: ClubUpdateOneRequiredWithoutGamesInput
  createdAt: DateTimeFieldUpdateOperationsInput
  delayTime: NullableStringFieldUpdateOperationsInput
  gameDescription: NullableStringFieldUpdateOperationsInput
  gameMode: NullableStringFieldUpdateOperationsInput
  gameTime: NullableStringFieldUpdateOperationsInput
  gameType: NullableStringFieldUpdateOperationsInput
  id: StringFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
  notes: StringFieldUpdateOperationsInput
  numPads: NullableIntFieldUpdateOperationsInput
  padLightUpTime: NullableFloatFieldUpdateOperationsInput
  phoneId: IntFieldUpdateOperationsInput
  scheduledDate: NullableDateTimeFieldUpdateOperationsInput
  sequence: NullableStringFieldUpdateOperationsInput
  stations: StationUpdateManyWithoutGameInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input GameUpsertWithWhereUniqueWithoutClubInput {
  create: GameCreateWithoutClubInput!
  update: GameUpdateWithoutClubInput!
  where: GameWhereUniqueInput!
}

input GameUpsertWithoutGameDataInput {
  create: GameCreateWithoutGameDataInput!
  update: GameUpdateWithoutGameDataInput!
}

input GameWhereInput {
  AND: [GameWhereInput!]
  NOT: [GameWhereInput!]
  OR: [GameWhereInput!]
  club: ClubRelationFilter
  clubId: StringFilter
  createdAt: DateTimeFilter
  delayTime: StringFilter
  gameData: GameDataRelationFilter
  gameDescription: StringFilter
  gameMode: StringFilter
  gameTime: StringFilter
  gameType: StringFilter
  id: StringFilter
  name: StringFilter
  notes: StringFilter
  numPads: IntFilter
  padLightUpTime: FloatFilter
  phoneId: IntFilter
  scheduledDate: DateTimeFilter
  sequence: StringFilter
  stations: StationListRelationFilter
  updatedAt: DateTimeFilter
}

input GameWhereUniqueInput {
  id: String
}

type Group {
  _count: GroupCount!
  club: Club!
  clubId: String!
  createdAt: DateTime!
  description: String!
  id: ID!
  name: String!
  phoneId: Int!
  players: [Player!]
  updatedAt: DateTime!
}

type GroupAvgAggregate {
  phoneId: Float
}

type GroupCount {
  players: Int!
}

type GroupCountAggregate {
  _all: Int!
  clubId: Int!
  createdAt: Int!
  description: Int!
  id: Int!
  name: Int!
  phoneId: Int!
  updatedAt: Int!
}

input GroupCreateManyClubInput {
  createdAt: DateTime
  description: String!
  id: String
  name: String!
  phoneId: Int!
  updatedAt: DateTime
}

input GroupCreateManyClubInputEnvelope {
  data: [GroupCreateManyClubInput!]!
  skipDuplicates: Boolean
}

input GroupCreateNestedManyWithoutClubInput {
  connect: [GroupWhereUniqueInput!]
  connectOrCreate: [GroupCreateOrConnectWithoutClubInput!]
  create: [GroupCreateWithoutClubInput!]
  createMany: GroupCreateManyClubInputEnvelope
}

input GroupCreateNestedOneWithoutPlayersInput {
  connect: GroupWhereUniqueInput
  connectOrCreate: GroupCreateOrConnectWithoutPlayersInput
  create: GroupCreateWithoutPlayersInput
}

input GroupCreateOrConnectWithoutClubInput {
  create: GroupCreateWithoutClubInput!
  where: GroupWhereUniqueInput!
}

input GroupCreateOrConnectWithoutPlayersInput {
  create: GroupCreateWithoutPlayersInput!
  where: GroupWhereUniqueInput!
}

input GroupCreateWithoutClubInput {
  createdAt: DateTime
  description: String!
  id: String
  name: String!
  phoneId: Int!
  players: PlayerCreateNestedManyWithoutGroupInput
  updatedAt: DateTime
}

input GroupCreateWithoutPlayersInput {
  club: ClubCreateNestedOneWithoutGroupsInput!
  createdAt: DateTime
  description: String!
  id: String
  name: String!
  phoneId: Int!
  updatedAt: DateTime
}

input GroupListRelationFilter {
  every: GroupWhereInput
  none: GroupWhereInput
  some: GroupWhereInput
}

type GroupMaxAggregate {
  clubId: String
  createdAt: DateTime
  description: String
  id: String
  name: String
  phoneId: Int
  updatedAt: DateTime
}

type GroupMinAggregate {
  clubId: String
  createdAt: DateTime
  description: String
  id: String
  name: String
  phoneId: Int
  updatedAt: DateTime
}

input GroupRelationFilter {
  is: GroupWhereInput
  isNot: GroupWhereInput
}

input GroupScalarWhereInput {
  AND: [GroupScalarWhereInput!]
  NOT: [GroupScalarWhereInput!]
  OR: [GroupScalarWhereInput!]
  clubId: StringFilter
  createdAt: DateTimeFilter
  description: StringFilter
  id: StringFilter
  name: StringFilter
  phoneId: IntFilter
  updatedAt: DateTimeFilter
}

type GroupSumAggregate {
  phoneId: Int
}

input GroupUpdateManyMutationInput {
  createdAt: DateTimeFieldUpdateOperationsInput
  description: StringFieldUpdateOperationsInput
  id: StringFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
  phoneId: IntFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input GroupUpdateManyWithWhereWithoutClubInput {
  data: GroupUpdateManyMutationInput!
  where: GroupScalarWhereInput!
}

input GroupUpdateManyWithoutClubInput {
  connect: [GroupWhereUniqueInput!]
  connectOrCreate: [GroupCreateOrConnectWithoutClubInput!]
  create: [GroupCreateWithoutClubInput!]
  createMany: GroupCreateManyClubInputEnvelope
  delete: [GroupWhereUniqueInput!]
  deleteMany: [GroupScalarWhereInput!]
  disconnect: [GroupWhereUniqueInput!]
  set: [GroupWhereUniqueInput!]
  update: [GroupUpdateWithWhereUniqueWithoutClubInput!]
  updateMany: [GroupUpdateManyWithWhereWithoutClubInput!]
  upsert: [GroupUpsertWithWhereUniqueWithoutClubInput!]
}

input GroupUpdateOneWithoutPlayersInput {
  connect: GroupWhereUniqueInput
  connectOrCreate: GroupCreateOrConnectWithoutPlayersInput
  create: GroupCreateWithoutPlayersInput
  delete: Boolean
  disconnect: Boolean
  update: GroupUpdateWithoutPlayersInput
  upsert: GroupUpsertWithoutPlayersInput
}

input GroupUpdateWithWhereUniqueWithoutClubInput {
  data: GroupUpdateWithoutClubInput!
  where: GroupWhereUniqueInput!
}

input GroupUpdateWithoutClubInput {
  createdAt: DateTimeFieldUpdateOperationsInput
  description: StringFieldUpdateOperationsInput
  id: StringFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
  phoneId: IntFieldUpdateOperationsInput
  players: PlayerUpdateManyWithoutGroupInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input GroupUpdateWithoutPlayersInput {
  club: ClubUpdateOneRequiredWithoutGroupsInput
  createdAt: DateTimeFieldUpdateOperationsInput
  description: StringFieldUpdateOperationsInput
  id: StringFieldUpdateOperationsInput
  name: StringFieldUpdateOperationsInput
  phoneId: IntFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input GroupUpsertWithWhereUniqueWithoutClubInput {
  create: GroupCreateWithoutClubInput!
  update: GroupUpdateWithoutClubInput!
  where: GroupWhereUniqueInput!
}

input GroupUpsertWithoutPlayersInput {
  create: GroupCreateWithoutPlayersInput!
  update: GroupUpdateWithoutPlayersInput!
}

input GroupWhereInput {
  AND: [GroupWhereInput!]
  NOT: [GroupWhereInput!]
  OR: [GroupWhereInput!]
  club: ClubRelationFilter
  clubId: StringFilter
  createdAt: DateTimeFilter
  description: StringFilter
  id: StringFilter
  name: StringFilter
  phoneId: IntFilter
  players: PlayerListRelationFilter
  updatedAt: DateTimeFilter
}

input GroupWhereUniqueInput {
  id: String
}

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: IntFilter
  notIn: [Int!]
}

type Mutation {
  createClub(club: ClubCreateInput!): Club!
  createPlayer(data: PlayerCreateInput!): Player!
  updateClub(data: ClubUpdateInput!): Club!
  updatePlayer(data: PlayerUpdateInput!, id: String!): Player!
}

input NullableDateTimeFieldUpdateOperationsInput {
  set: DateTime
}

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

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

input NullableStringFieldUpdateOperationsInput {
  set: String
}

type PasswordResetCountAggregate {
  _all: Int!
  createdAt: Int!
  email: Int!
  id: Int!
  token: Int!
}

type PasswordResetMaxAggregate {
  createdAt: DateTime
  email: String
  id: String
  token: String
}

type PasswordResetMinAggregate {
  createdAt: DateTime
  email: String
  id: String
  token: String
}

type Player {
  _count: PlayerCount!
  avatarId: String
  club: Club!
  clubId: String!
  createdAt: DateTime!
  dateOfBirth: DateTime
  email: String!
  firstName: String
  gameData: [GameData!]
  group: Group
  groupId: String!
  id: ID!
  lastName: String
  owner: User!
  ownerId: String!
  phoneId: Int!
  phoneNumber: String
  rating: Float
  updatedAt: DateTime!
}

type PlayerAvgAggregate {
  phoneId: Float
  rating: Float
}

type PlayerCount {
  gameData: Int!
}

type PlayerCountAggregate {
  _all: Int!
  avatarId: Int!
  clubId: Int!
  createdAt: Int!
  dateOfBirth: Int!
  email: Int!
  firstName: Int!
  groupId: Int!
  id: Int!
  lastName: Int!
  ownerId: Int!
  phoneId: Int!
  phoneNumber: Int!
  rating: Int!
  updatedAt: Int!
}

input PlayerCreateInput {
  avatarId: String
  club: ClubCreateNestedOneWithoutPlayersInput!
  createdAt: DateTime
  dateOfBirth: DateTime
  email: String!
  firstName: String
  gameData: GameDataCreateNestedManyWithoutPlayersInput
  group: GroupCreateNestedOneWithoutPlayersInput
  id: String
  lastName: String
  owner: UserCreateNestedOneWithoutPlayersInput!
  phoneId: Int!
  phoneNumber: String
  rating: Float
  updatedAt: DateTime
}

input PlayerCreateManyClubInput {
  avatarId: String
  createdAt: DateTime
  dateOfBirth: DateTime
  email: String!
  firstName: String
  groupId: String!
  id: String
  lastName: String
  ownerId: String!
  phoneId: Int!
  phoneNumber: String
  rating: Float
  updatedAt: DateTime
}

input PlayerCreateManyClubInputEnvelope {
  data: [PlayerCreateManyClubInput!]!
  skipDuplicates: Boolean
}

input PlayerCreateManyGroupInput {
  avatarId: String
  clubId: String!
  createdAt: DateTime
  dateOfBirth: DateTime
  email: String!
  firstName: String
  id: String
  lastName: String
  ownerId: String!
  phoneId: Int!
  phoneNumber: String
  rating: Float
  updatedAt: DateTime
}

input PlayerCreateManyGroupInputEnvelope {
  data: [PlayerCreateManyGroupInput!]!
  skipDuplicates: Boolean
}

input PlayerCreateManyOwnerInput {
  avatarId: String
  clubId: String!
  createdAt: DateTime
  dateOfBirth: DateTime
  email: String!
  firstName: String
  groupId: String!
  id: String
  lastName: String
  phoneId: Int!
  phoneNumber: String
  rating: Float
  updatedAt: DateTime
}

input PlayerCreateManyOwnerInputEnvelope {
  data: [PlayerCreateManyOwnerInput!]!
  skipDuplicates: Boolean
}

input PlayerCreateNestedManyWithoutClubInput {
  connect: [PlayerWhereUniqueInput!]
  connectOrCreate: [PlayerCreateOrConnectWithoutClubInput!]
  create: [PlayerCreateWithoutClubInput!]
  createMany: PlayerCreateManyClubInputEnvelope
}

input PlayerCreateNestedManyWithoutGameDataInput {
  connect: [PlayerWhereUniqueInput!]
  connectOrCreate: [PlayerCreateOrConnectWithoutGameDataInput!]
  create: [PlayerCreateWithoutGameDataInput!]
}

input PlayerCreateNestedManyWithoutGroupInput {
  connect: [PlayerWhereUniqueInput!]
  connectOrCreate: [PlayerCreateOrConnectWithoutGroupInput!]
  create: [PlayerCreateWithoutGroupInput!]
  createMany: PlayerCreateManyGroupInputEnvelope
}

input PlayerCreateNestedManyWithoutOwnerInput {
  connect: [PlayerWhereUniqueInput!]
  connectOrCreate: [PlayerCreateOrConnectWithoutOwnerInput!]
  create: [PlayerCreateWithoutOwnerInput!]
  createMany: PlayerCreateManyOwnerInputEnvelope
}

input PlayerCreateOrConnectWithoutClubInput {
  create: PlayerCreateWithoutClubInput!
  where: PlayerWhereUniqueInput!
}

input PlayerCreateOrConnectWithoutGameDataInput {
  create: PlayerCreateWithoutGameDataInput!
  where: PlayerWhereUniqueInput!
}

input PlayerCreateOrConnectWithoutGroupInput {
  create: PlayerCreateWithoutGroupInput!
  where: PlayerWhereUniqueInput!
}

input PlayerCreateOrConnectWithoutOwnerInput {
  create: PlayerCreateWithoutOwnerInput!
  where: PlayerWhereUniqueInput!
}

input PlayerCreateWithoutClubInput {
  avatarId: String
  createdAt: DateTime
  dateOfBirth: DateTime
  email: String!
  firstName: String
  gameData: GameDataCreateNestedManyWithoutPlayersInput
  group: GroupCreateNestedOneWithoutPlayersInput
  id: String
  lastName: String
  owner: UserCreateNestedOneWithoutPlayersInput!
  phoneId: Int!
  phoneNumber: String
  rating: Float
  updatedAt: DateTime
}

input PlayerCreateWithoutGameDataInput {
  avatarId: String
  club: ClubCreateNestedOneWithoutPlayersInput!
  createdAt: DateTime
  dateOfBirth: DateTime
  email: String!
  firstName: String
  group: GroupCreateNestedOneWithoutPlayersInput
  id: String
  lastName: String
  owner: UserCreateNestedOneWithoutPlayersInput!
  phoneId: Int!
  phoneNumber: String
  rating: Float
  updatedAt: DateTime
}

input PlayerCreateWithoutGroupInput {
  avatarId: String
  club: ClubCreateNestedOneWithoutPlayersInput!
  createdAt: DateTime
  dateOfBirth: DateTime
  email: String!
  firstName: String
  gameData: GameDataCreateNestedManyWithoutPlayersInput
  id: String
  lastName: String
  owner: UserCreateNestedOneWithoutPlayersInput!
  phoneId: Int!
  phoneNumber: String
  rating: Float
  updatedAt: DateTime
}

input PlayerCreateWithoutOwnerInput {
  avatarId: String
  club: ClubCreateNestedOneWithoutPlayersInput!
  createdAt: DateTime
  dateOfBirth: DateTime
  email: String!
  firstName: String
  gameData: GameDataCreateNestedManyWithoutPlayersInput
  group: GroupCreateNestedOneWithoutPlayersInput
  id: String
  lastName: String
  phoneId: Int!
  phoneNumber: String
  rating: Float
  updatedAt: DateTime
}

input PlayerListRelationFilter {
  every: PlayerWhereInput
  none: PlayerWhereInput
  some: PlayerWhereInput
}

type PlayerMaxAggregate {
  avatarId: String
  clubId: String
  createdAt: DateTime
  dateOfBirth: DateTime
  email: String
  firstName: String
  groupId: String
  id: String
  lastName: String
  ownerId: String
  phoneId: Int
  phoneNumber: String
  rating: Float
  updatedAt: DateTime
}

type PlayerMinAggregate {
  avatarId: String
  clubId: String
  createdAt: DateTime
  dateOfBirth: DateTime
  email: String
  firstName: String
  groupId: String
  id: String
  lastName: String
  ownerId: String
  phoneId: Int
  phoneNumber: String
  rating: Float
  updatedAt: DateTime
}

input PlayerScalarWhereInput {
  AND: [PlayerScalarWhereInput!]
  NOT: [PlayerScalarWhereInput!]
  OR: [PlayerScalarWhereInput!]
  avatarId: StringFilter
  clubId: StringFilter
  createdAt: DateTimeFilter
  dateOfBirth: DateTimeFilter
  email: StringFilter
  firstName: StringFilter
  groupId: StringFilter
  id: StringFilter
  lastName: StringFilter
  ownerId: StringFilter
  phoneId: IntFilter
  phoneNumber: StringFilter
  rating: FloatFilter
  updatedAt: DateTimeFilter
}

type PlayerSumAggregate {
  phoneId: Int
  rating: Float
}

input PlayerUpdateInput {
  avatarId: NullableStringFieldUpdateOperationsInput
  club: ClubUpdateOneRequiredWithoutPlayersInput
  createdAt: DateTimeFieldUpdateOperationsInput
  dateOfBirth: NullableDateTimeFieldUpdateOperationsInput
  email: StringFieldUpdateOperationsInput
  firstName: NullableStringFieldUpdateOperationsInput
  gameData: GameDataUpdateManyWithoutPlayersInput
  group: GroupUpdateOneWithoutPlayersInput
  id: StringFieldUpdateOperationsInput
  lastName: NullableStringFieldUpdateOperationsInput
  owner: UserUpdateOneRequiredWithoutPlayersInput
  phoneId: IntFieldUpdateOperationsInput
  phoneNumber: NullableStringFieldUpdateOperationsInput
  rating: NullableFloatFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input PlayerUpdateManyMutationInput {
  avatarId: NullableStringFieldUpdateOperationsInput
  createdAt: DateTimeFieldUpdateOperationsInput
  dateOfBirth: NullableDateTimeFieldUpdateOperationsInput
  email: StringFieldUpdateOperationsInput
  firstName: NullableStringFieldUpdateOperationsInput
  id: StringFieldUpdateOperationsInput
  lastName: NullableStringFieldUpdateOperationsInput
  phoneId: IntFieldUpdateOperationsInput
  phoneNumber: NullableStringFieldUpdateOperationsInput
  rating: NullableFloatFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input PlayerUpdateManyWithWhereWithoutClubInput {
  data: PlayerUpdateManyMutationInput!
  where: PlayerScalarWhereInput!
}

input PlayerUpdateManyWithWhereWithoutGameDataInput {
  data: PlayerUpdateManyMutationInput!
  where: PlayerScalarWhereInput!
}

input PlayerUpdateManyWithWhereWithoutGroupInput {
  data: PlayerUpdateManyMutationInput!
  where: PlayerScalarWhereInput!
}

input PlayerUpdateManyWithWhereWithoutOwnerInput {
  data: PlayerUpdateManyMutationInput!
  where: PlayerScalarWhereInput!
}

input PlayerUpdateManyWithoutClubInput {
  connect: [PlayerWhereUniqueInput!]
  connectOrCreate: [PlayerCreateOrConnectWithoutClubInput!]
  create: [PlayerCreateWithoutClubInput!]
  createMany: PlayerCreateManyClubInputEnvelope
  delete: [PlayerWhereUniqueInput!]
  deleteMany: [PlayerScalarWhereInput!]
  disconnect: [PlayerWhereUniqueInput!]
  set: [PlayerWhereUniqueInput!]
  update: [PlayerUpdateWithWhereUniqueWithoutClubInput!]
  updateMany: [PlayerUpdateManyWithWhereWithoutClubInput!]
  upsert: [PlayerUpsertWithWhereUniqueWithoutClubInput!]
}

input PlayerUpdateManyWithoutGameDataInput {
  connect: [PlayerWhereUniqueInput!]
  connectOrCreate: [PlayerCreateOrConnectWithoutGameDataInput!]
  create: [PlayerCreateWithoutGameDataInput!]
  delete: [PlayerWhereUniqueInput!]
  deleteMany: [PlayerScalarWhereInput!]
  disconnect: [PlayerWhereUniqueInput!]
  set: [PlayerWhereUniqueInput!]
  update: [PlayerUpdateWithWhereUniqueWithoutGameDataInput!]
  updateMany: [PlayerUpdateManyWithWhereWithoutGameDataInput!]
  upsert: [PlayerUpsertWithWhereUniqueWithoutGameDataInput!]
}

input PlayerUpdateManyWithoutGroupInput {
  connect: [PlayerWhereUniqueInput!]
  connectOrCreate: [PlayerCreateOrConnectWithoutGroupInput!]
  create: [PlayerCreateWithoutGroupInput!]
  createMany: PlayerCreateManyGroupInputEnvelope
  delete: [PlayerWhereUniqueInput!]
  deleteMany: [PlayerScalarWhereInput!]
  disconnect: [PlayerWhereUniqueInput!]
  set: [PlayerWhereUniqueInput!]
  update: [PlayerUpdateWithWhereUniqueWithoutGroupInput!]
  updateMany: [PlayerUpdateManyWithWhereWithoutGroupInput!]
  upsert: [PlayerUpsertWithWhereUniqueWithoutGroupInput!]
}

input PlayerUpdateManyWithoutOwnerInput {
  connect: [PlayerWhereUniqueInput!]
  connectOrCreate: [PlayerCreateOrConnectWithoutOwnerInput!]
  create: [PlayerCreateWithoutOwnerInput!]
  createMany: PlayerCreateManyOwnerInputEnvelope
  delete: [PlayerWhereUniqueInput!]
  deleteMany: [PlayerScalarWhereInput!]
  disconnect: [PlayerWhereUniqueInput!]
  set: [PlayerWhereUniqueInput!]
  update: [PlayerUpdateWithWhereUniqueWithoutOwnerInput!]
  updateMany: [PlayerUpdateManyWithWhereWithoutOwnerInput!]
  upsert: [PlayerUpsertWithWhereUniqueWithoutOwnerInput!]
}

input PlayerUpdateWithWhereUniqueWithoutClubInput {
  data: PlayerUpdateWithoutClubInput!
  where: PlayerWhereUniqueInput!
}

input PlayerUpdateWithWhereUniqueWithoutGameDataInput {
  data: PlayerUpdateWithoutGameDataInput!
  where: PlayerWhereUniqueInput!
}

input PlayerUpdateWithWhereUniqueWithoutGroupInput {
  data: PlayerUpdateWithoutGroupInput!
  where: PlayerWhereUniqueInput!
}

input PlayerUpdateWithWhereUniqueWithoutOwnerInput {
  data: PlayerUpdateWithoutOwnerInput!
  where: PlayerWhereUniqueInput!
}

input PlayerUpdateWithoutClubInput {
  avatarId: NullableStringFieldUpdateOperationsInput
  createdAt: DateTimeFieldUpdateOperationsInput
  dateOfBirth: NullableDateTimeFieldUpdateOperationsInput
  email: StringFieldUpdateOperationsInput
  firstName: NullableStringFieldUpdateOperationsInput
  gameData: GameDataUpdateManyWithoutPlayersInput
  group: GroupUpdateOneWithoutPlayersInput
  id: StringFieldUpdateOperationsInput
  lastName: NullableStringFieldUpdateOperationsInput
  owner: UserUpdateOneRequiredWithoutPlayersInput
  phoneId: IntFieldUpdateOperationsInput
  phoneNumber: NullableStringFieldUpdateOperationsInput
  rating: NullableFloatFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input PlayerUpdateWithoutGameDataInput {
  avatarId: NullableStringFieldUpdateOperationsInput
  club: ClubUpdateOneRequiredWithoutPlayersInput
  createdAt: DateTimeFieldUpdateOperationsInput
  dateOfBirth: NullableDateTimeFieldUpdateOperationsInput
  email: StringFieldUpdateOperationsInput
  firstName: NullableStringFieldUpdateOperationsInput
  group: GroupUpdateOneWithoutPlayersInput
  id: StringFieldUpdateOperationsInput
  lastName: NullableStringFieldUpdateOperationsInput
  owner: UserUpdateOneRequiredWithoutPlayersInput
  phoneId: IntFieldUpdateOperationsInput
  phoneNumber: NullableStringFieldUpdateOperationsInput
  rating: NullableFloatFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input PlayerUpdateWithoutGroupInput {
  avatarId: NullableStringFieldUpdateOperationsInput
  club: ClubUpdateOneRequiredWithoutPlayersInput
  createdAt: DateTimeFieldUpdateOperationsInput
  dateOfBirth: NullableDateTimeFieldUpdateOperationsInput
  email: StringFieldUpdateOperationsInput
  firstName: NullableStringFieldUpdateOperationsInput
  gameData: GameDataUpdateManyWithoutPlayersInput
  id: StringFieldUpdateOperationsInput
  lastName: NullableStringFieldUpdateOperationsInput
  owner: UserUpdateOneRequiredWithoutPlayersInput
  phoneId: IntFieldUpdateOperationsInput
  phoneNumber: NullableStringFieldUpdateOperationsInput
  rating: NullableFloatFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input PlayerUpdateWithoutOwnerInput {
  avatarId: NullableStringFieldUpdateOperationsInput
  club: ClubUpdateOneRequiredWithoutPlayersInput
  createdAt: DateTimeFieldUpdateOperationsInput
  dateOfBirth: NullableDateTimeFieldUpdateOperationsInput
  email: StringFieldUpdateOperationsInput
  firstName: NullableStringFieldUpdateOperationsInput
  gameData: GameDataUpdateManyWithoutPlayersInput
  group: GroupUpdateOneWithoutPlayersInput
  id: StringFieldUpdateOperationsInput
  lastName: NullableStringFieldUpdateOperationsInput
  phoneId: IntFieldUpdateOperationsInput
  phoneNumber: NullableStringFieldUpdateOperationsInput
  rating: NullableFloatFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input PlayerUpsertWithWhereUniqueWithoutClubInput {
  create: PlayerCreateWithoutClubInput!
  update: PlayerUpdateWithoutClubInput!
  where: PlayerWhereUniqueInput!
}

input PlayerUpsertWithWhereUniqueWithoutGameDataInput {
  create: PlayerCreateWithoutGameDataInput!
  update: PlayerUpdateWithoutGameDataInput!
  where: PlayerWhereUniqueInput!
}

input PlayerUpsertWithWhereUniqueWithoutGroupInput {
  create: PlayerCreateWithoutGroupInput!
  update: PlayerUpdateWithoutGroupInput!
  where: PlayerWhereUniqueInput!
}

input PlayerUpsertWithWhereUniqueWithoutOwnerInput {
  create: PlayerCreateWithoutOwnerInput!
  update: PlayerUpdateWithoutOwnerInput!
  where: PlayerWhereUniqueInput!
}

input PlayerWhereInput {
  AND: [PlayerWhereInput!]
  NOT: [PlayerWhereInput!]
  OR: [PlayerWhereInput!]
  avatarId: StringFilter
  club: ClubRelationFilter
  clubId: StringFilter
  createdAt: DateTimeFilter
  dateOfBirth: DateTimeFilter
  email: StringFilter
  firstName: StringFilter
  gameData: GameDataListRelationFilter
  group: GroupRelationFilter
  groupId: StringFilter
  id: StringFilter
  lastName: StringFilter
  owner: UserRelationFilter
  ownerId: StringFilter
  phoneId: IntFilter
  phoneNumber: StringFilter
  rating: FloatFilter
  updatedAt: DateTimeFilter
}

input PlayerWhereUniqueInput {
  email: String
  id: String
}

type Query {
  clubById(id: String!): Club!
  clubs(filter: ClubWhereInput): [Club!]!
  clubsByOwner(filter: ClubWhereInput): [Club!]!
  player(id: String!): Player!
  user: User!
}

enum Role {
  Admin
  Guest
  User
}

type Station {
  game: Game!
  gameId: String!
  id: ID!
  numOfPads: Int
  padArrangementImage: String
  padArrangementName: String
  pads: String
  rectangleAttributes: String
  stationDescription: String
  stationName: String
}

type StationAvgAggregate {
  numOfPads: Float
}

type StationCountAggregate {
  _all: Int!
  gameId: Int!
  id: Int!
  numOfPads: Int!
  padArrangementImage: Int!
  padArrangementName: Int!
  pads: Int!
  rectangleAttributes: Int!
  stationDescription: Int!
  stationName: Int!
}

input StationCreateManyGameInput {
  id: String
  numOfPads: Int
  padArrangementImage: String
  padArrangementName: String
  pads: String
  rectangleAttributes: String
  stationDescription: String
  stationName: String
}

input StationCreateManyGameInputEnvelope {
  data: [StationCreateManyGameInput!]!
  skipDuplicates: Boolean
}

input StationCreateNestedManyWithoutGameInput {
  connect: [StationWhereUniqueInput!]
  connectOrCreate: [StationCreateOrConnectWithoutGameInput!]
  create: [StationCreateWithoutGameInput!]
  createMany: StationCreateManyGameInputEnvelope
}

input StationCreateOrConnectWithoutGameInput {
  create: StationCreateWithoutGameInput!
  where: StationWhereUniqueInput!
}

input StationCreateWithoutGameInput {
  id: String
  numOfPads: Int
  padArrangementImage: String
  padArrangementName: String
  pads: String
  rectangleAttributes: String
  stationDescription: String
  stationName: String
}

input StationListRelationFilter {
  every: StationWhereInput
  none: StationWhereInput
  some: StationWhereInput
}

type StationMaxAggregate {
  gameId: String
  id: String
  numOfPads: Int
  padArrangementImage: String
  padArrangementName: String
  pads: String
  rectangleAttributes: String
  stationDescription: String
  stationName: String
}

type StationMinAggregate {
  gameId: String
  id: String
  numOfPads: Int
  padArrangementImage: String
  padArrangementName: String
  pads: String
  rectangleAttributes: String
  stationDescription: String
  stationName: String
}

input StationScalarWhereInput {
  AND: [StationScalarWhereInput!]
  NOT: [StationScalarWhereInput!]
  OR: [StationScalarWhereInput!]
  gameId: StringFilter
  id: StringFilter
  numOfPads: IntFilter
  padArrangementImage: StringFilter
  padArrangementName: StringFilter
  pads: StringFilter
  rectangleAttributes: StringFilter
  stationDescription: StringFilter
  stationName: StringFilter
}

type StationSumAggregate {
  numOfPads: Int
}

input StationUpdateManyMutationInput {
  id: StringFieldUpdateOperationsInput
  numOfPads: NullableIntFieldUpdateOperationsInput
  padArrangementImage: NullableStringFieldUpdateOperationsInput
  padArrangementName: NullableStringFieldUpdateOperationsInput
  pads: NullableStringFieldUpdateOperationsInput
  rectangleAttributes: NullableStringFieldUpdateOperationsInput
  stationDescription: NullableStringFieldUpdateOperationsInput
  stationName: NullableStringFieldUpdateOperationsInput
}

input StationUpdateManyWithWhereWithoutGameInput {
  data: StationUpdateManyMutationInput!
  where: StationScalarWhereInput!
}

input StationUpdateManyWithoutGameInput {
  connect: [StationWhereUniqueInput!]
  connectOrCreate: [StationCreateOrConnectWithoutGameInput!]
  create: [StationCreateWithoutGameInput!]
  createMany: StationCreateManyGameInputEnvelope
  delete: [StationWhereUniqueInput!]
  deleteMany: [StationScalarWhereInput!]
  disconnect: [StationWhereUniqueInput!]
  set: [StationWhereUniqueInput!]
  update: [StationUpdateWithWhereUniqueWithoutGameInput!]
  updateMany: [StationUpdateManyWithWhereWithoutGameInput!]
  upsert: [StationUpsertWithWhereUniqueWithoutGameInput!]
}

input StationUpdateWithWhereUniqueWithoutGameInput {
  data: StationUpdateWithoutGameInput!
  where: StationWhereUniqueInput!
}

input StationUpdateWithoutGameInput {
  id: StringFieldUpdateOperationsInput
  numOfPads: NullableIntFieldUpdateOperationsInput
  padArrangementImage: NullableStringFieldUpdateOperationsInput
  padArrangementName: NullableStringFieldUpdateOperationsInput
  pads: NullableStringFieldUpdateOperationsInput
  rectangleAttributes: NullableStringFieldUpdateOperationsInput
  stationDescription: NullableStringFieldUpdateOperationsInput
  stationName: NullableStringFieldUpdateOperationsInput
}

input StationUpsertWithWhereUniqueWithoutGameInput {
  create: StationCreateWithoutGameInput!
  update: StationUpdateWithoutGameInput!
  where: StationWhereUniqueInput!
}

input StationWhereInput {
  AND: [StationWhereInput!]
  NOT: [StationWhereInput!]
  OR: [StationWhereInput!]
  game: GameRelationFilter
  gameId: StringFilter
  id: StringFilter
  numOfPads: IntFilter
  padArrangementImage: StringFilter
  padArrangementName: StringFilter
  pads: StringFilter
  rectangleAttributes: StringFilter
  stationDescription: StringFilter
  stationName: StringFilter
}

input StationWhereUniqueInput {
  id: String
}

input StringFieldUpdateOperationsInput {
  set: String
}

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

type User {
  _count: UserCount!
  avatar: String
  biography: String
  clubs: [Club!]
  createdAt: DateTime!
  email: String!
  emailVerifiedAt: DateTime
  firstName: String!
  id: ID!
  lastLoginAt: DateTime
  lastName: String!
  phoneNumber: String!
  players: [Player!]
  role: Role!
  updatedAt: DateTime!
}

type UserCount {
  clubs: Int!
  players: Int!
}

type UserCountAggregate {
  _all: Int!
  avatar: Int!
  biography: Int!
  createdAt: Int!
  email: Int!
  emailVerifiedAt: Int!
  firstName: Int!
  id: Int!
  lastLoginAt: Int!
  lastName: Int!
  phoneNumber: Int!
  role: Int!
  updatedAt: Int!
}

input UserCreateNestedOneWithoutClubsInput {
  connect: UserWhereUniqueInput
  connectOrCreate: UserCreateOrConnectWithoutClubsInput
  create: UserCreateWithoutClubsInput
}

input UserCreateNestedOneWithoutPlayersInput {
  connect: UserWhereUniqueInput
  connectOrCreate: UserCreateOrConnectWithoutPlayersInput
  create: UserCreateWithoutPlayersInput
}

input UserCreateOrConnectWithoutClubsInput {
  create: UserCreateWithoutClubsInput!
  where: UserWhereUniqueInput!
}

input UserCreateOrConnectWithoutPlayersInput {
  create: UserCreateWithoutPlayersInput!
  where: UserWhereUniqueInput!
}

input UserCreateWithoutClubsInput {
  avatar: String
  biography: String
  createdAt: DateTime
  email: String!
  emailVerifiedAt: DateTime
  firstName: String!
  id: String
  lastLoginAt: DateTime
  lastName: String!
  passwordHash: String!
  phoneNumber: String!
  players: PlayerCreateNestedManyWithoutOwnerInput
  role: Role!
  updatedAt: DateTime
}

input UserCreateWithoutPlayersInput {
  avatar: String
  biography: String
  clubs: ClubCreateNestedManyWithoutOwnerInput
  createdAt: DateTime
  email: String!
  emailVerifiedAt: DateTime
  firstName: String!
  id: String
  lastLoginAt: DateTime
  lastName: String!
  passwordHash: String!
  phoneNumber: String!
  role: Role!
  updatedAt: DateTime
}

type UserMaxAggregate {
  avatar: String
  biography: String
  createdAt: DateTime
  email: String
  emailVerifiedAt: DateTime
  firstName: String
  id: String
  lastLoginAt: DateTime
  lastName: String
  phoneNumber: String
  role: Role
  updatedAt: DateTime
}

type UserMinAggregate {
  avatar: String
  biography: String
  createdAt: DateTime
  email: String
  emailVerifiedAt: DateTime
  firstName: String
  id: String
  lastLoginAt: DateTime
  lastName: String
  phoneNumber: String
  role: Role
  updatedAt: DateTime
}

input UserRelationFilter {
  is: UserWhereInput
  isNot: UserWhereInput
}

input UserUpdateOneRequiredWithoutClubsInput {
  connect: UserWhereUniqueInput
  connectOrCreate: UserCreateOrConnectWithoutClubsInput
  create: UserCreateWithoutClubsInput
  update: UserUpdateWithoutClubsInput
  upsert: UserUpsertWithoutClubsInput
}

input UserUpdateOneRequiredWithoutPlayersInput {
  connect: UserWhereUniqueInput
  connectOrCreate: UserCreateOrConnectWithoutPlayersInput
  create: UserCreateWithoutPlayersInput
  update: UserUpdateWithoutPlayersInput
  upsert: UserUpsertWithoutPlayersInput
}

input UserUpdateWithoutClubsInput {
  avatar: NullableStringFieldUpdateOperationsInput
  biography: NullableStringFieldUpdateOperationsInput
  createdAt: DateTimeFieldUpdateOperationsInput
  email: StringFieldUpdateOperationsInput
  emailVerifiedAt: NullableDateTimeFieldUpdateOperationsInput
  firstName: StringFieldUpdateOperationsInput
  id: StringFieldUpdateOperationsInput
  lastLoginAt: NullableDateTimeFieldUpdateOperationsInput
  lastName: StringFieldUpdateOperationsInput
  passwordHash: StringFieldUpdateOperationsInput
  phoneNumber: StringFieldUpdateOperationsInput
  players: PlayerUpdateManyWithoutOwnerInput
  role: EnumRoleFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input UserUpdateWithoutPlayersInput {
  avatar: NullableStringFieldUpdateOperationsInput
  biography: NullableStringFieldUpdateOperationsInput
  clubs: ClubUpdateManyWithoutOwnerInput
  createdAt: DateTimeFieldUpdateOperationsInput
  email: StringFieldUpdateOperationsInput
  emailVerifiedAt: NullableDateTimeFieldUpdateOperationsInput
  firstName: StringFieldUpdateOperationsInput
  id: StringFieldUpdateOperationsInput
  lastLoginAt: NullableDateTimeFieldUpdateOperationsInput
  lastName: StringFieldUpdateOperationsInput
  passwordHash: StringFieldUpdateOperationsInput
  phoneNumber: StringFieldUpdateOperationsInput
  role: EnumRoleFieldUpdateOperationsInput
  updatedAt: DateTimeFieldUpdateOperationsInput
}

input UserUpsertWithoutClubsInput {
  create: UserCreateWithoutClubsInput!
  update: UserUpdateWithoutClubsInput!
}

input UserUpsertWithoutPlayersInput {
  create: UserCreateWithoutPlayersInput!
  update: UserUpdateWithoutPlayersInput!
}

input UserWhereInput {
  AND: [UserWhereInput!]
  NOT: [UserWhereInput!]
  OR: [UserWhereInput!]
  avatar: StringFilter
  biography: StringFilter
  clubs: ClubListRelationFilter
  createdAt: DateTimeFilter
  email: StringFilter
  emailVerifiedAt: DateTimeFilter
  firstName: StringFilter
  id: StringFilter
  lastLoginAt: DateTimeFilter
  lastName: StringFilter
  passwordHash: StringFilter
  phoneNumber: StringFilter
  players: PlayerListRelationFilter
  role: EnumRoleFilter
  updatedAt: DateTimeFilter
}

input UserWhereUniqueInput {
  email: String
  id: String
  phoneNumber: String
}
