schema.gql

type Query {
  aggregateAddress(
    where: AddressWhereInput
    orderBy: [AddressOrderByWithRelationInput!]
    cursor: AddressWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateAddress!
  findFirstAddress(
    where: AddressWhereInput
    orderBy: [AddressOrderByWithRelationInput!]
    cursor: AddressWhereUniqueInput
    take: Int
    skip: Int
    distinct: [AddressScalarFieldEnum!]
  ): Address
  addresses(
    where: AddressWhereInput
    orderBy: [AddressOrderByWithRelationInput!]
    cursor: AddressWhereUniqueInput
    take: Int
    skip: Int
    distinct: [AddressScalarFieldEnum!]
  ): [Address!]!
  address(where: AddressWhereUniqueInput!): Address
  groupByAddress(
    where: AddressWhereInput
    orderBy: [AddressOrderByWithAggregationInput!]
    by: [AddressScalarFieldEnum!]!
    having: AddressScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [AddressGroupBy!]!
  aggregateClaim(
    where: ClaimWhereInput
    orderBy: [ClaimOrderByWithRelationInput!]
    cursor: ClaimWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateClaim!
  findFirstClaim(
    where: ClaimWhereInput
    orderBy: [ClaimOrderByWithRelationInput!]
    cursor: ClaimWhereUniqueInput
    take: Int
    skip: Int
    distinct: [ClaimScalarFieldEnum!]
  ): Claim
  claims(
    where: ClaimWhereInput
    orderBy: [ClaimOrderByWithRelationInput!]
    cursor: ClaimWhereUniqueInput
    take: Int
    skip: Int
    distinct: [ClaimScalarFieldEnum!]
  ): [Claim!]!
  claim(where: ClaimWhereUniqueInput!): Claim
  groupByClaim(
    where: ClaimWhereInput
    orderBy: [ClaimOrderByWithAggregationInput!]
    by: [ClaimScalarFieldEnum!]!
    having: ClaimScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [ClaimGroupBy!]!
  aggregateDiscordUser(
    where: DiscordUserWhereInput
    orderBy: [DiscordUserOrderByWithRelationInput!]
    cursor: DiscordUserWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateDiscordUser!
  findFirstDiscordUser(
    where: DiscordUserWhereInput
    orderBy: [DiscordUserOrderByWithRelationInput!]
    cursor: DiscordUserWhereUniqueInput
    take: Int
    skip: Int
    distinct: [DiscordUserScalarFieldEnum!]
  ): DiscordUser
  discordUsers(
    where: DiscordUserWhereInput
    orderBy: [DiscordUserOrderByWithRelationInput!]
    cursor: DiscordUserWhereUniqueInput
    take: Int
    skip: Int
    distinct: [DiscordUserScalarFieldEnum!]
  ): [DiscordUser!]!
  discordUser(where: DiscordUserWhereUniqueInput!): DiscordUser
  groupByDiscordUser(
    where: DiscordUserWhereInput
    orderBy: [DiscordUserOrderByWithAggregationInput!]
    by: [DiscordUserScalarFieldEnum!]!
    having: DiscordUserScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [DiscordUserGroupBy!]!
  aggregateEmail(
    where: EmailWhereInput
    orderBy: [EmailOrderByWithRelationInput!]
    cursor: EmailWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateEmail!
  aggregateFeaturedPOAP(
    where: FeaturedPOAPWhereInput
    orderBy: [FeaturedPOAPOrderByWithRelationInput!]
    cursor: FeaturedPOAPWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateFeaturedPOAP!
  findFirstFeaturedPOAP(
    where: FeaturedPOAPWhereInput
    orderBy: [FeaturedPOAPOrderByWithRelationInput!]
    cursor: FeaturedPOAPWhereUniqueInput
    take: Int
    skip: Int
    distinct: [FeaturedPOAPScalarFieldEnum!]
  ): FeaturedPOAP
  featuredPOAPS(
    where: FeaturedPOAPWhereInput
    orderBy: [FeaturedPOAPOrderByWithRelationInput!]
    cursor: FeaturedPOAPWhereUniqueInput
    take: Int
    skip: Int
    distinct: [FeaturedPOAPScalarFieldEnum!]
  ): [FeaturedPOAP!]!
  featuredPOAP(where: FeaturedPOAPWhereUniqueInput!): FeaturedPOAP
  groupByFeaturedPOAP(
    where: FeaturedPOAPWhereInput
    orderBy: [FeaturedPOAPOrderByWithAggregationInput!]
    by: [FeaturedPOAPScalarFieldEnum!]!
    having: FeaturedPOAPScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [FeaturedPOAPGroupBy!]!
  aggregateGitPOAP(
    where: GitPOAPWhereInput
    orderBy: [GitPOAPOrderByWithRelationInput!]
    cursor: GitPOAPWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateGitPOAP!
  findFirstGitPOAP(
    where: GitPOAPWhereInput
    orderBy: [GitPOAPOrderByWithRelationInput!]
    cursor: GitPOAPWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GitPOAPScalarFieldEnum!]
  ): GitPOAP
  gitPOAPS(
    where: GitPOAPWhereInput
    orderBy: [GitPOAPOrderByWithRelationInput!]
    cursor: GitPOAPWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GitPOAPScalarFieldEnum!]
  ): [GitPOAP!]!
  gitPOAP(where: GitPOAPWhereUniqueInput!): GitPOAP
  groupByGitPOAP(
    where: GitPOAPWhereInput
    orderBy: [GitPOAPOrderByWithAggregationInput!]
    by: [GitPOAPScalarFieldEnum!]!
    having: GitPOAPScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [GitPOAPGroupBy!]!
  aggregateGitPOAPRequest(
    where: GitPOAPRequestWhereInput
    orderBy: [GitPOAPRequestOrderByWithRelationInput!]
    cursor: GitPOAPRequestWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateGitPOAPRequest!
  findFirstGitPOAPRequest(
    where: GitPOAPRequestWhereInput
    orderBy: [GitPOAPRequestOrderByWithRelationInput!]
    cursor: GitPOAPRequestWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GitPOAPRequestScalarFieldEnum!]
  ): GitPOAPRequest
  gitPOAPRequests(
    where: GitPOAPRequestWhereInput
    orderBy: [GitPOAPRequestOrderByWithRelationInput!]
    cursor: GitPOAPRequestWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GitPOAPRequestScalarFieldEnum!]
  ): [GitPOAPRequest!]!
  gitPOAPRequest(where: GitPOAPRequestWhereUniqueInput!): GitPOAPRequest
  groupByGitPOAPRequest(
    where: GitPOAPRequestWhereInput
    orderBy: [GitPOAPRequestOrderByWithAggregationInput!]
    by: [GitPOAPRequestScalarFieldEnum!]!
    having: GitPOAPRequestScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [GitPOAPRequestGroupBy!]!
  aggregateGithubIssue(
    where: GithubIssueWhereInput
    orderBy: [GithubIssueOrderByWithRelationInput!]
    cursor: GithubIssueWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateGithubIssue!
  findFirstGithubIssue(
    where: GithubIssueWhereInput
    orderBy: [GithubIssueOrderByWithRelationInput!]
    cursor: GithubIssueWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubIssueScalarFieldEnum!]
  ): GithubIssue
  githubIssues(
    where: GithubIssueWhereInput
    orderBy: [GithubIssueOrderByWithRelationInput!]
    cursor: GithubIssueWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubIssueScalarFieldEnum!]
  ): [GithubIssue!]!
  githubIssue(where: GithubIssueWhereUniqueInput!): GithubIssue
  groupByGithubIssue(
    where: GithubIssueWhereInput
    orderBy: [GithubIssueOrderByWithAggregationInput!]
    by: [GithubIssueScalarFieldEnum!]!
    having: GithubIssueScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [GithubIssueGroupBy!]!
  aggregateGithubMention(
    where: GithubMentionWhereInput
    orderBy: [GithubMentionOrderByWithRelationInput!]
    cursor: GithubMentionWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateGithubMention!
  findFirstGithubMention(
    where: GithubMentionWhereInput
    orderBy: [GithubMentionOrderByWithRelationInput!]
    cursor: GithubMentionWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubMentionScalarFieldEnum!]
  ): GithubMention
  githubMentions(
    where: GithubMentionWhereInput
    orderBy: [GithubMentionOrderByWithRelationInput!]
    cursor: GithubMentionWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubMentionScalarFieldEnum!]
  ): [GithubMention!]!
  githubMention(where: GithubMentionWhereUniqueInput!): GithubMention
  groupByGithubMention(
    where: GithubMentionWhereInput
    orderBy: [GithubMentionOrderByWithAggregationInput!]
    by: [GithubMentionScalarFieldEnum!]!
    having: GithubMentionScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [GithubMentionGroupBy!]!
  aggregateGithubOrganization(
    where: GithubOrganizationWhereInput
    orderBy: [GithubOrganizationOrderByWithRelationInput!]
    cursor: GithubOrganizationWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateGithubOrganization!
  findFirstGithubOrganization(
    where: GithubOrganizationWhereInput
    orderBy: [GithubOrganizationOrderByWithRelationInput!]
    cursor: GithubOrganizationWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubOrganizationScalarFieldEnum!]
  ): GithubOrganization
  githubOrganizations(
    where: GithubOrganizationWhereInput
    orderBy: [GithubOrganizationOrderByWithRelationInput!]
    cursor: GithubOrganizationWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubOrganizationScalarFieldEnum!]
  ): [GithubOrganization!]!
  githubOrganization(
    where: GithubOrganizationWhereUniqueInput!
  ): GithubOrganization
  groupByGithubOrganization(
    where: GithubOrganizationWhereInput
    orderBy: [GithubOrganizationOrderByWithAggregationInput!]
    by: [GithubOrganizationScalarFieldEnum!]!
    having: GithubOrganizationScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [GithubOrganizationGroupBy!]!
  aggregateGithubPullRequest(
    where: GithubPullRequestWhereInput
    orderBy: [GithubPullRequestOrderByWithRelationInput!]
    cursor: GithubPullRequestWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateGithubPullRequest!
  findFirstGithubPullRequest(
    where: GithubPullRequestWhereInput
    orderBy: [GithubPullRequestOrderByWithRelationInput!]
    cursor: GithubPullRequestWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubPullRequestScalarFieldEnum!]
  ): GithubPullRequest
  githubPullRequests(
    where: GithubPullRequestWhereInput
    orderBy: [GithubPullRequestOrderByWithRelationInput!]
    cursor: GithubPullRequestWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubPullRequestScalarFieldEnum!]
  ): [GithubPullRequest!]!
  githubPullRequest(
    where: GithubPullRequestWhereUniqueInput!
  ): GithubPullRequest
  groupByGithubPullRequest(
    where: GithubPullRequestWhereInput
    orderBy: [GithubPullRequestOrderByWithAggregationInput!]
    by: [GithubPullRequestScalarFieldEnum!]!
    having: GithubPullRequestScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [GithubPullRequestGroupBy!]!
  aggregateGithubUser(
    where: GithubUserWhereInput
    orderBy: [GithubUserOrderByWithRelationInput!]
    cursor: GithubUserWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateGithubUser!
  findFirstGithubUser(
    where: GithubUserWhereInput
    orderBy: [GithubUserOrderByWithRelationInput!]
    cursor: GithubUserWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubUserScalarFieldEnum!]
  ): GithubUser
  githubUsers(
    where: GithubUserWhereInput
    orderBy: [GithubUserOrderByWithRelationInput!]
    cursor: GithubUserWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubUserScalarFieldEnum!]
  ): [GithubUser!]!
  githubUser(where: GithubUserWhereUniqueInput!): GithubUser
  groupByGithubUser(
    where: GithubUserWhereInput
    orderBy: [GithubUserOrderByWithAggregationInput!]
    by: [GithubUserScalarFieldEnum!]!
    having: GithubUserScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [GithubUserGroupBy!]!
  aggregateMembership(
    where: MembershipWhereInput
    orderBy: [MembershipOrderByWithRelationInput!]
    cursor: MembershipWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateMembership!
  findFirstMembership(
    where: MembershipWhereInput
    orderBy: [MembershipOrderByWithRelationInput!]
    cursor: MembershipWhereUniqueInput
    take: Int
    skip: Int
    distinct: [MembershipScalarFieldEnum!]
  ): Membership
  memberships(
    where: MembershipWhereInput
    orderBy: [MembershipOrderByWithRelationInput!]
    cursor: MembershipWhereUniqueInput
    take: Int
    skip: Int
    distinct: [MembershipScalarFieldEnum!]
  ): [Membership!]!
  membership(where: MembershipWhereUniqueInput!): Membership
  groupByMembership(
    where: MembershipWhereInput
    orderBy: [MembershipOrderByWithAggregationInput!]
    by: [MembershipScalarFieldEnum!]!
    having: MembershipScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [MembershipGroupBy!]!
  aggregateProfile(
    where: ProfileWhereInput
    orderBy: [ProfileOrderByWithRelationInput!]
    cursor: ProfileWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateProfile!
  findFirstProfile(
    where: ProfileWhereInput
    orderBy: [ProfileOrderByWithRelationInput!]
    cursor: ProfileWhereUniqueInput
    take: Int
    skip: Int
    distinct: [ProfileScalarFieldEnum!]
  ): Profile
  profiles(
    where: ProfileWhereInput
    orderBy: [ProfileOrderByWithRelationInput!]
    cursor: ProfileWhereUniqueInput
    take: Int
    skip: Int
    distinct: [ProfileScalarFieldEnum!]
  ): [Profile!]!
  profile(where: ProfileWhereUniqueInput!): Profile
  groupByProfile(
    where: ProfileWhereInput
    orderBy: [ProfileOrderByWithAggregationInput!]
    by: [ProfileScalarFieldEnum!]!
    having: ProfileScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [ProfileGroupBy!]!
  aggregateProject(
    where: ProjectWhereInput
    orderBy: [ProjectOrderByWithRelationInput!]
    cursor: ProjectWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateProject!
  findFirstProject(
    where: ProjectWhereInput
    orderBy: [ProjectOrderByWithRelationInput!]
    cursor: ProjectWhereUniqueInput
    take: Int
    skip: Int
    distinct: [ProjectScalarFieldEnum!]
  ): Project
  projects(
    where: ProjectWhereInput
    orderBy: [ProjectOrderByWithRelationInput!]
    cursor: ProjectWhereUniqueInput
    take: Int
    skip: Int
    distinct: [ProjectScalarFieldEnum!]
  ): [Project!]!
  project(where: ProjectWhereUniqueInput!): Project
  groupByProject(
    where: ProjectWhereInput
    orderBy: [ProjectOrderByWithAggregationInput!]
    by: [ProjectScalarFieldEnum!]!
    having: ProjectScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [ProjectGroupBy!]!
  aggregateRepo(
    where: RepoWhereInput
    orderBy: [RepoOrderByWithRelationInput!]
    cursor: RepoWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateRepo!
  findFirstRepo(
    where: RepoWhereInput
    orderBy: [RepoOrderByWithRelationInput!]
    cursor: RepoWhereUniqueInput
    take: Int
    skip: Int
    distinct: [RepoScalarFieldEnum!]
  ): Repo
  repos(
    where: RepoWhereInput
    orderBy: [RepoOrderByWithRelationInput!]
    cursor: RepoWhereUniqueInput
    take: Int
    skip: Int
    distinct: [RepoScalarFieldEnum!]
  ): [Repo!]!
  repo(where: RepoWhereUniqueInput!): Repo
  groupByRepo(
    where: RepoWhereInput
    orderBy: [RepoOrderByWithAggregationInput!]
    by: [RepoScalarFieldEnum!]!
    having: RepoScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [RepoGroupBy!]!
  aggregateTeam(
    where: TeamWhereInput
    orderBy: [TeamOrderByWithRelationInput!]
    cursor: TeamWhereUniqueInput
    take: Int
    skip: Int
  ): AggregateTeam!
  findFirstTeam(
    where: TeamWhereInput
    orderBy: [TeamOrderByWithRelationInput!]
    cursor: TeamWhereUniqueInput
    take: Int
    skip: Int
    distinct: [TeamScalarFieldEnum!]
  ): Team
  teams(
    where: TeamWhereInput
    orderBy: [TeamOrderByWithRelationInput!]
    cursor: TeamWhereUniqueInput
    take: Int
    skip: Int
    distinct: [TeamScalarFieldEnum!]
  ): [Team!]!
  team(where: TeamWhereUniqueInput!): Team
  groupByTeam(
    where: TeamWhereInput
    orderBy: [TeamOrderByWithAggregationInput!]
    by: [TeamScalarFieldEnum!]!
    having: TeamScalarWhereWithAggregatesInput
    take: Int
    skip: Int
  ): [TeamGroupBy!]!
  totalClaims: Float!
  lastMonthClaims: Float!
  userClaims: [FullClaimData!]
  totalGitPOAPs: Float!
  lastMonthGitPOAPs: Float!
  gitPOAPEvent(id: Float!): FullGitPOAPEventData
  userPOAPs(
    page: Float = null
    perPage: Float = null
    sort: String = "date"
    address: String!
  ): UserPOAPs
  repoGitPOAPs(
    page: Float = null
    perPage: Float = null
    sort: String = "date"
    repoId: Float!
  ): RepoGitPOAPs
  mostClaimedGitPOAPs(count: Float = 10): [GitPOAPWithClaimsCount!]
  profileFeaturedPOAPs(address: String!): UserFeaturedPOAPs
  gitPOAPHolders(
    page: Float = null
    perPage: Float = null
    sort: String = "claim-date"
    gitPOAPId: Float!
  ): Holders
  userMemberships: UserMemberships
  teamMemberships(
    page: Float = null
    perPage: Float = null
    sort: String = "date"
    teamId: Float!
  ): TeamMemberships
  repoData(
    repoName: String = null
    orgName: String = null
    repoId: Float = null
  ): RepoReturnData
  repoStarCount(repoId: Float!): Float!
  totalRepos: Float!
  lastMonthRepos: Float!
  recentlyAddedRepos(count: Float = 10): [Repo!]!
  allRepos(
    page: Float = null
    perPage: Float = null
    sort: String = "alphabetical"
  ): [RepoReturnData!]
  trendingRepos(numDays: Float = 3, count: Float = 10): [RepoReturnData!]
  organizationData(
    orgName: String = null
    orgId: Float = null
  ): OrganizationData
  allOrganizations(
    page: Float = null
    perPage: Float = null
    search: String = null
    sort: String = "alphabetical"
  ): [GithubOrganization!]
  organizationRepos(
    page: Float = null
    perPage: Float = null
    sort: String = "alphabetical"
    orgId: Float!
  ): [RepoReturnData!]
  userPermissions: Permissions!
  totalContributors: Float!
  lastMonthContributors: Float!
  profileData(address: String!): NullableProfile
  mostHonoredContributors(count: Float = 10): [ProfileWithClaimsCount!]!
  repoMostHonoredContributors(
    page: Float = 1
    perPage: Float = 6
    repoId: Float!
  ): [ProfileWithClaimsCount!]
  search(text: String!): SearchResults!
  teamData(teamId: Float!): Team!
  teamGitPOAPs(
    sort: String = null
    approvalStatus: String = null
    teamId: Float!
  ): [GitPOAP!]!
  teamGitPOAPRequests(
    sort: String = null
    approvalStatus: String = null
    teamId: Float!
  ): [GitPOAPRequest!]!
}

type AggregateAddress {
  _count: AddressCountAggregate
  _avg: AddressAvgAggregate
  _sum: AddressSumAggregate
  _min: AddressMinAggregate
  _max: AddressMaxAggregate
}

type AddressCountAggregate {
  id: Int!
  ethAddress: Int!
  createdAt: Int!
  updatedAt: Int!
  ensAvatarImageUrl: Int!
  ensName: Int!
  _all: Int!
}

type AddressAvgAggregate {
  id: Float
}

type AddressSumAggregate {
  id: Int
}

type AddressMinAggregate {
  id: Int
  ethAddress: String
  createdAt: DateTime
  updatedAt: DateTime
  ensAvatarImageUrl: String
  ensName: String
}

# The javascript `Date` as string. Type represents date and time as the ISO Date string.
scalar DateTime

type AddressMaxAggregate {
  id: Int
  ethAddress: String
  createdAt: DateTime
  updatedAt: DateTime
  ensAvatarImageUrl: String
  ensName: String
}

input AddressWhereInput {
  AND: [AddressWhereInput!]
  OR: [AddressWhereInput!]
  NOT: [AddressWhereInput!]
  id: IntFilter
  ethAddress: StringFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  ensAvatarImageUrl: StringNullableFilter
  ensName: StringNullableFilter
  memberships: MembershipListRelationFilter
  profile: ProfileRelationFilter
  issuedClaims: ClaimListRelationFilter
  mintedClaims: ClaimListRelationFilter
  gitPOAPRequests: GitPOAPRequestListRelationFilter
  createdGitPOAPs: GitPOAPListRelationFilter
  teams: TeamListRelationFilter
}

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

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

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

enum QueryMode {
  default
  insensitive
}

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

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

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

input StringNullableFilter {
  equals: String
  in: [String!]
  notIn: [String!]
  lt: String
  lte: String
  gt: String
  gte: String
  contains: String
  startsWith: String
  endsWith: String
  mode: QueryMode
  not: NestedStringNullableFilter
}

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

input MembershipListRelationFilter {
  every: MembershipWhereInput
  some: MembershipWhereInput
  none: MembershipWhereInput
}

input MembershipWhereInput {
  AND: [MembershipWhereInput!]
  OR: [MembershipWhereInput!]
  NOT: [MembershipWhereInput!]
  id: IntFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  teamId: IntFilter
  team: TeamRelationFilter
  addressId: IntFilter
  address: AddressRelationFilter
  role: EnumMembershipRoleFilter
  acceptanceStatus: EnumMembershipAcceptanceStatusFilter
  joinedOn: DateTimeNullableFilter
}

input TeamRelationFilter {
  is: TeamWhereInput
  isNot: TeamWhereInput
}

input TeamWhereInput {
  AND: [TeamWhereInput!]
  OR: [TeamWhereInput!]
  NOT: [TeamWhereInput!]
  id: IntFilter
  name: StringFilter
  ownerAddressId: IntFilter
  ownerAddress: AddressRelationFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  description: StringNullableFilter
  logoImageUrl: StringNullableFilter
  memberships: MembershipListRelationFilter
  gitPOAPs: GitPOAPListRelationFilter
  gitPOAPRequests: GitPOAPRequestListRelationFilter
  approvalStatus: EnumStaffApprovalStatusFilter
}

input AddressRelationFilter {
  is: AddressWhereInput
  isNot: AddressWhereInput
}

input GitPOAPListRelationFilter {
  every: GitPOAPWhereInput
  some: GitPOAPWhereInput
  none: GitPOAPWhereInput
}

input GitPOAPWhereInput {
  AND: [GitPOAPWhereInput!]
  OR: [GitPOAPWhereInput!]
  NOT: [GitPOAPWhereInput!]
  id: IntFilter
  type: EnumGitPOAPTypeFilter
  name: StringFilter
  imageUrl: StringFilter
  description: StringFilter
  year: IntFilter
  poapEventId: IntFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  projectId: IntNullableFilter
  project: ProjectRelationFilter
  teamId: IntNullableFilter
  team: TeamRelationFilter
  claims: ClaimListRelationFilter
  poapApprovalStatus: EnumGitPOAPStatusFilter
  canRequestMoreCodes: BoolFilter
  redeemCodes: RedeemCodeListRelationFilter
  eventId: IntNullableFilter
  event: EventRelationFilter
  level: IntFilter
  threshold: IntFilter
  isPRBased: BoolFilter
  isEnabled: BoolFilter
  creatorAddressId: IntNullableFilter
  creatorAddress: AddressRelationFilter
  creatorEmailId: IntNullableFilter
  creatorEmail: EmailRelationFilter
  gitPOAPRequestId: IntNullableFilter
  gitPOAPRequest: GitPOAPRequestRelationFilter
}

input EnumGitPOAPTypeFilter {
  equals: GitPOAPType
  in: [GitPOAPType!]
  notIn: [GitPOAPType!]
  not: NestedEnumGitPOAPTypeFilter
}

enum GitPOAPType {
  ANNUAL
  CUSTOM
}

input NestedEnumGitPOAPTypeFilter {
  equals: GitPOAPType
  in: [GitPOAPType!]
  notIn: [GitPOAPType!]
  not: NestedEnumGitPOAPTypeFilter
}

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

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

input ProjectRelationFilter {
  is: ProjectWhereInput
  isNot: ProjectWhereInput
}

input ProjectWhereInput {
  AND: [ProjectWhereInput!]
  OR: [ProjectWhereInput!]
  NOT: [ProjectWhereInput!]
  id: IntFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  repos: RepoListRelationFilter
  gitPOAPs: GitPOAPListRelationFilter
  gitPOAPRequests: GitPOAPRequestListRelationFilter
}

input RepoListRelationFilter {
  every: RepoWhereInput
  some: RepoWhereInput
  none: RepoWhereInput
}

input RepoWhereInput {
  AND: [RepoWhereInput!]
  OR: [RepoWhereInput!]
  NOT: [RepoWhereInput!]
  id: IntFilter
  name: StringFilter
  githubRepoId: IntFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  organizationId: IntFilter
  organization: GithubOrganizationRelationFilter
  projectId: IntFilter
  project: ProjectRelationFilter
  lastPRUpdatedAt: DateTimeFilter
  githubPullRequests: GithubPullRequestListRelationFilter
  githubIssues: GithubIssueListRelationFilter
  githubMentions: GithubMentionListRelationFilter
}

input GithubOrganizationRelationFilter {
  is: GithubOrganizationWhereInput
  isNot: GithubOrganizationWhereInput
}

input GithubOrganizationWhereInput {
  AND: [GithubOrganizationWhereInput!]
  OR: [GithubOrganizationWhereInput!]
  NOT: [GithubOrganizationWhereInput!]
  id: IntFilter
  githubOrgId: IntFilter
  name: StringFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  repos: RepoListRelationFilter
}

input GithubPullRequestListRelationFilter {
  every: GithubPullRequestWhereInput
  some: GithubPullRequestWhereInput
  none: GithubPullRequestWhereInput
}

input GithubPullRequestWhereInput {
  AND: [GithubPullRequestWhereInput!]
  OR: [GithubPullRequestWhereInput!]
  NOT: [GithubPullRequestWhereInput!]
  id: IntFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  githubPullNumber: IntFilter
  githubTitle: StringFilter
  githubCreatedAt: DateTimeFilter
  githubMergedAt: DateTimeNullableFilter
  githubMergeCommitSha: StringNullableFilter
  repoId: IntFilter
  repo: RepoRelationFilter
  githubUserId: IntFilter
  githubUser: GithubUserRelationFilter
  claims: ClaimListRelationFilter
  githubMentions: GithubMentionListRelationFilter
}

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

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

input RepoRelationFilter {
  is: RepoWhereInput
  isNot: RepoWhereInput
}

input GithubUserRelationFilter {
  is: GithubUserWhereInput
  isNot: GithubUserWhereInput
}

input GithubUserWhereInput {
  AND: [GithubUserWhereInput!]
  OR: [GithubUserWhereInput!]
  NOT: [GithubUserWhereInput!]
  id: IntFilter
  githubId: IntFilter
  githubHandle: StringFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  claims: ClaimListRelationFilter
  githubPullRequests: GithubPullRequestListRelationFilter
  githubIssues: GithubIssueListRelationFilter
  githubMentions: GithubMentionListRelationFilter
}

input ClaimListRelationFilter {
  every: ClaimWhereInput
  some: ClaimWhereInput
  none: ClaimWhereInput
}

input ClaimWhereInput {
  AND: [ClaimWhereInput!]
  OR: [ClaimWhereInput!]
  NOT: [ClaimWhereInput!]
  id: IntFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  mintedAt: DateTimeNullableFilter
  status: EnumClaimStatusFilter
  poapTokenId: StringNullableFilter
  mintedAddressId: IntNullableFilter
  mintedAddress: AddressRelationFilter
  gitPOAPId: IntFilter
  gitPOAP: GitPOAPRelationFilter
  githubUserId: IntNullableFilter
  githubUser: GithubUserRelationFilter
  emailId: IntNullableFilter
  email: EmailRelationFilter
  issuedAddressId: IntNullableFilter
  issuedAddress: AddressRelationFilter
  discordUserId: IntNullableFilter
  discordUser: DiscordUserRelationFilter
  pullRequestEarnedId: IntNullableFilter
  pullRequestEarned: GithubPullRequestRelationFilter
  mentionEarnedId: IntNullableFilter
  mentionEarned: GithubMentionRelationFilter
  needsRevalidation: BoolFilter
}

input EnumClaimStatusFilter {
  equals: ClaimStatus
  in: [ClaimStatus!]
  notIn: [ClaimStatus!]
  not: NestedEnumClaimStatusFilter
}

enum ClaimStatus {
  UNCLAIMED
  PENDING
  MINTING
  CLAIMED
}

input NestedEnumClaimStatusFilter {
  equals: ClaimStatus
  in: [ClaimStatus!]
  notIn: [ClaimStatus!]
  not: NestedEnumClaimStatusFilter
}

input GitPOAPRelationFilter {
  is: GitPOAPWhereInput
  isNot: GitPOAPWhereInput
}

input EmailRelationFilter {
  is: EmailWhereInput
  isNot: EmailWhereInput
}

input EmailWhereInput {
  AND: [EmailWhereInput!]
  OR: [EmailWhereInput!]
  NOT: [EmailWhereInput!]
  id: IntFilter
  emailAddress: StringFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  claims: ClaimListRelationFilter
  createdGitPOAPs: GitPOAPListRelationFilter
  createdGitPOAPRequests: GitPOAPRequestListRelationFilter
}

input GitPOAPRequestListRelationFilter {
  every: GitPOAPRequestWhereInput
  some: GitPOAPRequestWhereInput
  none: GitPOAPRequestWhereInput
}

input GitPOAPRequestWhereInput {
  AND: [GitPOAPRequestWhereInput!]
  OR: [GitPOAPRequestWhereInput!]
  NOT: [GitPOAPRequestWhereInput!]
  id: IntFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  startDate: DateTimeFilter
  endDate: DateTimeFilter
  creatorEmailId: IntFilter
  creatorEmail: EmailRelationFilter
  name: StringFilter
  numRequestedCodes: IntFilter
  imageUrl: StringFilter
  description: StringFilter
  projectId: IntNullableFilter
  project: ProjectRelationFilter
  team: TeamRelationFilter
  teamId: IntNullableFilter
  contributors: JsonFilter
  rejectionReason: StringNullableFilter
  staffApprovalStatus: EnumStaffApprovalStatusFilter
  addressId: IntFilter
  address: AddressRelationFilter
  gitPOAPId: IntNullableFilter
  gitPOAP: GitPOAPRelationFilter
}

input JsonFilter {
  equals: JSON
  path: [String!]
  string_contains: String
  string_starts_with: String
  string_ends_with: String
  array_contains: JSON
  array_starts_with: JSON
  array_ends_with: JSON
  lt: JSON
  lte: JSON
  gt: JSON
  gte: JSON
  not: JSON
}

# The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).
scalar JSON
  @specifiedBy(
    url: "http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf"
  )

input EnumStaffApprovalStatusFilter {
  equals: StaffApprovalStatus
  in: [StaffApprovalStatus!]
  notIn: [StaffApprovalStatus!]
  not: NestedEnumStaffApprovalStatusFilter
}

enum StaffApprovalStatus {
  APPROVED
  PENDING
  REJECTED
}

input NestedEnumStaffApprovalStatusFilter {
  equals: StaffApprovalStatus
  in: [StaffApprovalStatus!]
  notIn: [StaffApprovalStatus!]
  not: NestedEnumStaffApprovalStatusFilter
}

input DiscordUserRelationFilter {
  is: DiscordUserWhereInput
  isNot: DiscordUserWhereInput
}

input DiscordUserWhereInput {
  AND: [DiscordUserWhereInput!]
  OR: [DiscordUserWhereInput!]
  NOT: [DiscordUserWhereInput!]
  id: IntFilter
  discordId: StringFilter
  discordHandle: StringFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  claims: ClaimListRelationFilter
}

input GithubPullRequestRelationFilter {
  is: GithubPullRequestWhereInput
  isNot: GithubPullRequestWhereInput
}

input GithubMentionRelationFilter {
  is: GithubMentionWhereInput
  isNot: GithubMentionWhereInput
}

input GithubMentionWhereInput {
  AND: [GithubMentionWhereInput!]
  OR: [GithubMentionWhereInput!]
  NOT: [GithubMentionWhereInput!]
  id: IntFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  githubMentionedAt: DateTimeFilter
  repoId: IntFilter
  repo: RepoRelationFilter
  githubUserId: IntFilter
  githubUser: GithubUserRelationFilter
  pullRequestId: IntNullableFilter
  pullRequest: GithubPullRequestRelationFilter
  issueId: IntNullableFilter
  issue: GithubIssueRelationFilter
  claims: ClaimListRelationFilter
}

input GithubIssueRelationFilter {
  is: GithubIssueWhereInput
  isNot: GithubIssueWhereInput
}

input GithubIssueWhereInput {
  AND: [GithubIssueWhereInput!]
  OR: [GithubIssueWhereInput!]
  NOT: [GithubIssueWhereInput!]
  id: IntFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  githubIssueNumber: IntFilter
  githubTitle: StringFilter
  githubCreatedAt: DateTimeFilter
  githubClosedAt: DateTimeNullableFilter
  repoId: IntFilter
  repo: RepoRelationFilter
  githubUserId: IntFilter
  githubUser: GithubUserRelationFilter
  githubMentions: GithubMentionListRelationFilter
}

input GithubMentionListRelationFilter {
  every: GithubMentionWhereInput
  some: GithubMentionWhereInput
  none: GithubMentionWhereInput
}

input BoolFilter {
  equals: Boolean
  not: NestedBoolFilter
}

input NestedBoolFilter {
  equals: Boolean
  not: NestedBoolFilter
}

input GithubIssueListRelationFilter {
  every: GithubIssueWhereInput
  some: GithubIssueWhereInput
  none: GithubIssueWhereInput
}

input EnumGitPOAPStatusFilter {
  equals: GitPOAPStatus
  in: [GitPOAPStatus!]
  notIn: [GitPOAPStatus!]
  not: NestedEnumGitPOAPStatusFilter
}

enum GitPOAPStatus {
  UNAPPROVED
  APPROVED
  REDEEM_REQUEST_PENDING
  DEPRECATED
}

input NestedEnumGitPOAPStatusFilter {
  equals: GitPOAPStatus
  in: [GitPOAPStatus!]
  notIn: [GitPOAPStatus!]
  not: NestedEnumGitPOAPStatusFilter
}

input RedeemCodeListRelationFilter {
  every: RedeemCodeWhereInput
  some: RedeemCodeWhereInput
  none: RedeemCodeWhereInput
}

input RedeemCodeWhereInput {
  AND: [RedeemCodeWhereInput!]
  OR: [RedeemCodeWhereInput!]
  NOT: [RedeemCodeWhereInput!]
  id: IntFilter
  gitPOAPId: IntFilter
  gitPOAP: GitPOAPRelationFilter
  code: StringFilter
}

input EventRelationFilter {
  is: EventWhereInput
  isNot: EventWhereInput
}

input EventWhereInput {
  AND: [EventWhereInput!]
  OR: [EventWhereInput!]
  NOT: [EventWhereInput!]
  id: IntFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  startDate: DateTimeFilter
  endDate: DateTimeFilter
  name: StringFilter
  organization: StringFilter
  description: StringNullableFilter
  location: StringFilter
  imageUrl: StringNullableFilter
  githubHandle: StringNullableFilter
  twitterHandle: StringNullableFilter
  discordHandle: StringNullableFilter
  siteUrl: StringNullableFilter
  gitPOAPs: GitPOAPListRelationFilter
}

input GitPOAPRequestRelationFilter {
  is: GitPOAPRequestWhereInput
  isNot: GitPOAPRequestWhereInput
}

input EnumMembershipRoleFilter {
  equals: MembershipRole
  in: [MembershipRole!]
  notIn: [MembershipRole!]
  not: NestedEnumMembershipRoleFilter
}

enum MembershipRole {
  ADMIN
  OWNER
  MEMBER
}

input NestedEnumMembershipRoleFilter {
  equals: MembershipRole
  in: [MembershipRole!]
  notIn: [MembershipRole!]
  not: NestedEnumMembershipRoleFilter
}

input EnumMembershipAcceptanceStatusFilter {
  equals: MembershipAcceptanceStatus
  in: [MembershipAcceptanceStatus!]
  notIn: [MembershipAcceptanceStatus!]
  not: NestedEnumMembershipAcceptanceStatusFilter
}

enum MembershipAcceptanceStatus {
  ACCEPTED
  PENDING
}

input NestedEnumMembershipAcceptanceStatusFilter {
  equals: MembershipAcceptanceStatus
  in: [MembershipAcceptanceStatus!]
  notIn: [MembershipAcceptanceStatus!]
  not: NestedEnumMembershipAcceptanceStatusFilter
}

input ProfileRelationFilter {
  is: ProfileWhereInput
  isNot: ProfileWhereInput
}

input ProfileWhereInput {
  AND: [ProfileWhereInput!]
  OR: [ProfileWhereInput!]
  NOT: [ProfileWhereInput!]
  id: IntFilter
  addressId: IntFilter
  address: AddressRelationFilter
  createdAt: DateTimeFilter
  updatedAt: DateTimeFilter
  bio: StringNullableFilter
  bannerImageUrl: StringNullableFilter
  name: StringNullableFilter
  profileImageUrl: StringNullableFilter
  githubHandle: StringNullableFilter
  twitterHandle: StringNullableFilter
  discordHandle: StringNullableFilter
  personalSiteUrl: StringNullableFilter
  isVisibleOnLeaderboard: BoolFilter
  featuredPOAPs: FeaturedPOAPListRelationFilter
}

input FeaturedPOAPListRelationFilter {
  every: FeaturedPOAPWhereInput
  some: FeaturedPOAPWhereInput
  none: FeaturedPOAPWhereInput
}

input FeaturedPOAPWhereInput {
  AND: [FeaturedPOAPWhereInput!]
  OR: [FeaturedPOAPWhereInput!]
  NOT: [FeaturedPOAPWhereInput!]
  id: IntFilter
  poapTokenId: StringFilter
  profileId: IntFilter
  profile: ProfileRelationFilter
}

input TeamListRelationFilter {
  every: TeamWhereInput
  some: TeamWhereInput
  none: TeamWhereInput
}

input AddressOrderByWithRelationInput {
  id: SortOrder
  ethAddress: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  ensAvatarImageUrl: SortOrder
  ensName: SortOrder
  memberships: MembershipOrderByRelationAggregateInput
  profile: ProfileOrderByWithRelationInput
  issuedClaims: ClaimOrderByRelationAggregateInput
  mintedClaims: ClaimOrderByRelationAggregateInput
  gitPOAPRequests: GitPOAPRequestOrderByRelationAggregateInput
  createdGitPOAPs: GitPOAPOrderByRelationAggregateInput
  teams: TeamOrderByRelationAggregateInput
}

enum SortOrder {
  asc
  desc
}

input MembershipOrderByRelationAggregateInput {
  _count: SortOrder
}

input ProfileOrderByWithRelationInput {
  id: SortOrder
  addressId: SortOrder
  address: AddressOrderByWithRelationInput
  createdAt: SortOrder
  updatedAt: SortOrder
  bio: SortOrder
  bannerImageUrl: SortOrder
  name: SortOrder
  profileImageUrl: SortOrder
  githubHandle: SortOrder
  twitterHandle: SortOrder
  discordHandle: SortOrder
  personalSiteUrl: SortOrder
  isVisibleOnLeaderboard: SortOrder
  featuredPOAPs: FeaturedPOAPOrderByRelationAggregateInput
}

input FeaturedPOAPOrderByRelationAggregateInput {
  _count: SortOrder
}

input ClaimOrderByRelationAggregateInput {
  _count: SortOrder
}

input GitPOAPRequestOrderByRelationAggregateInput {
  _count: SortOrder
}

input GitPOAPOrderByRelationAggregateInput {
  _count: SortOrder
}

input TeamOrderByRelationAggregateInput {
  _count: SortOrder
}

input AddressWhereUniqueInput {
  id: Int
  ethAddress: String
}

type Address {
  id: Int!
  ethAddress: String!
  createdAt: DateTime!
  updatedAt: DateTime!
  ensAvatarImageUrl: String
  ensName: String
  _count: AddressCount
  memberships(
    where: MembershipWhereInput
    orderBy: [MembershipOrderByWithRelationInput!]
    cursor: MembershipWhereUniqueInput
    take: Int
    skip: Int
    distinct: [MembershipScalarFieldEnum!]
  ): [Membership!]!
  profile: Profile
  issuedClaims(
    where: ClaimWhereInput
    orderBy: [ClaimOrderByWithRelationInput!]
    cursor: ClaimWhereUniqueInput
    take: Int
    skip: Int
    distinct: [ClaimScalarFieldEnum!]
  ): [Claim!]!
  mintedClaims(
    where: ClaimWhereInput
    orderBy: [ClaimOrderByWithRelationInput!]
    cursor: ClaimWhereUniqueInput
    take: Int
    skip: Int
    distinct: [ClaimScalarFieldEnum!]
  ): [Claim!]!
  gitPOAPRequests(
    where: GitPOAPRequestWhereInput
    orderBy: [GitPOAPRequestOrderByWithRelationInput!]
    cursor: GitPOAPRequestWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GitPOAPRequestScalarFieldEnum!]
  ): [GitPOAPRequest!]!
  createdGitPOAPs(
    where: GitPOAPWhereInput
    orderBy: [GitPOAPOrderByWithRelationInput!]
    cursor: GitPOAPWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GitPOAPScalarFieldEnum!]
  ): [GitPOAP!]!
  teams(
    where: TeamWhereInput
    orderBy: [TeamOrderByWithRelationInput!]
    cursor: TeamWhereUniqueInput
    take: Int
    skip: Int
    distinct: [TeamScalarFieldEnum!]
  ): [Team!]!
}

type AddressCount {
  memberships: Int!
  issuedClaims: Int!
  mintedClaims: Int!
  gitPOAPRequests: Int!
  createdGitPOAPs: Int!
  teams: Int!
}

type Membership {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  teamId: Int!
  addressId: Int!
  role: MembershipRole!
  acceptanceStatus: MembershipAcceptanceStatus!
  joinedOn: DateTime
}

input MembershipOrderByWithRelationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  teamId: SortOrder
  team: TeamOrderByWithRelationInput
  addressId: SortOrder
  address: AddressOrderByWithRelationInput
  role: SortOrder
  acceptanceStatus: SortOrder
  joinedOn: SortOrder
}

input TeamOrderByWithRelationInput {
  id: SortOrder
  name: SortOrder
  ownerAddressId: SortOrder
  ownerAddress: AddressOrderByWithRelationInput
  createdAt: SortOrder
  updatedAt: SortOrder
  description: SortOrder
  logoImageUrl: SortOrder
  memberships: MembershipOrderByRelationAggregateInput
  gitPOAPs: GitPOAPOrderByRelationAggregateInput
  gitPOAPRequests: GitPOAPRequestOrderByRelationAggregateInput
  approvalStatus: SortOrder
}

input MembershipWhereUniqueInput {
  id: Int
  teamId_addressId: MembershipTeamIdAddressIdCompoundUniqueInput
}

input MembershipTeamIdAddressIdCompoundUniqueInput {
  teamId: Int!
  addressId: Int!
}

enum MembershipScalarFieldEnum {
  id
  createdAt
  updatedAt
  teamId
  addressId
  role
  acceptanceStatus
  joinedOn
}

type Profile {
  id: Int!
  addressId: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  bio: String
  bannerImageUrl: String
  name: String
  profileImageUrl: String
  githubHandle: String
  twitterHandle: String
  discordHandle: String
  personalSiteUrl: String
  isVisibleOnLeaderboard: Boolean!
  _count: ProfileCount
  address: Address!
  featuredPOAPs(
    where: FeaturedPOAPWhereInput
    orderBy: [FeaturedPOAPOrderByWithRelationInput!]
    cursor: FeaturedPOAPWhereUniqueInput
    take: Int
    skip: Int
    distinct: [FeaturedPOAPScalarFieldEnum!]
  ): [FeaturedPOAP!]!
}

type ProfileCount {
  featuredPOAPs: Int!
}

type FeaturedPOAP {
  id: Int!
  poapTokenId: String!
  profileId: Int!
  profile: Profile!
}

input FeaturedPOAPOrderByWithRelationInput {
  id: SortOrder
  poapTokenId: SortOrder
  profileId: SortOrder
  profile: ProfileOrderByWithRelationInput
}

input FeaturedPOAPWhereUniqueInput {
  id: Int
  poapTokenId: String
  poapTokenId_profileId: FeaturedPOAPPoapTokenIdProfileIdCompoundUniqueInput
}

input FeaturedPOAPPoapTokenIdProfileIdCompoundUniqueInput {
  poapTokenId: String!
  profileId: Int!
}

enum FeaturedPOAPScalarFieldEnum {
  id
  poapTokenId
  profileId
}

type Claim {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  mintedAt: DateTime
  status: ClaimStatus!
  poapTokenId: String
  mintedAddressId: Int
  gitPOAPId: Int!
  githubUserId: Int
  emailId: Int
  issuedAddressId: Int
  discordUserId: Int
  pullRequestEarnedId: Int
  mentionEarnedId: Int
  needsRevalidation: Boolean!
  mintedAddress: Address
  gitPOAP: GitPOAP!
  githubUser: GithubUser
  email: Email
  issuedAddress: Address
  discordUser: DiscordUser
  pullRequestEarned: GithubPullRequest
  mentionEarned: GithubMention
}

type GitPOAP {
  id: Int!
  type: GitPOAPType!
  name: String!
  imageUrl: String!
  description: String!
  year: Int!
  poapEventId: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  projectId: Int
  teamId: Int
  poapApprovalStatus: GitPOAPStatus!
  canRequestMoreCodes: Boolean!
  eventId: Int
  level: Int!
  threshold: Int!
  isPRBased: Boolean!
  isEnabled: Boolean!
  creatorAddressId: Int
  creatorEmailId: Int
  gitPOAPRequestId: Int
  _count: GitPOAPCount
  project: Project
  team: Team
  claims(
    where: ClaimWhereInput
    orderBy: [ClaimOrderByWithRelationInput!]
    cursor: ClaimWhereUniqueInput
    take: Int
    skip: Int
    distinct: [ClaimScalarFieldEnum!]
  ): [Claim!]!
  redeemCodes(
    where: RedeemCodeWhereInput
    orderBy: [RedeemCodeOrderByWithRelationInput!]
    cursor: RedeemCodeWhereUniqueInput
    take: Int
    skip: Int
    distinct: [RedeemCodeScalarFieldEnum!]
  ): [RedeemCode!]!
  event: Event
  creatorAddress: Address
  creatorEmail: Email
  gitPOAPRequest: GitPOAPRequest
}

type GitPOAPCount {
  claims: Int!
  redeemCodes: Int!
}

type Project {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  _count: ProjectCount
  repos(
    where: RepoWhereInput
    orderBy: [RepoOrderByWithRelationInput!]
    cursor: RepoWhereUniqueInput
    take: Int
    skip: Int
    distinct: [RepoScalarFieldEnum!]
  ): [Repo!]!
  gitPOAPs(
    where: GitPOAPWhereInput
    orderBy: [GitPOAPOrderByWithRelationInput!]
    cursor: GitPOAPWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GitPOAPScalarFieldEnum!]
  ): [GitPOAP!]!
  gitPOAPRequests(
    where: GitPOAPRequestWhereInput
    orderBy: [GitPOAPRequestOrderByWithRelationInput!]
    cursor: GitPOAPRequestWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GitPOAPRequestScalarFieldEnum!]
  ): [GitPOAPRequest!]!
}

type ProjectCount {
  repos: Int!
  gitPOAPs: Int!
  gitPOAPRequests: Int!
}

type Repo {
  id: Int!
  name: String!
  githubRepoId: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  organizationId: Int!
  projectId: Int!
  lastPRUpdatedAt: DateTime!
  _count: RepoCount
  organization: GithubOrganization!
  project: Project!
  githubPullRequests(
    where: GithubPullRequestWhereInput
    orderBy: [GithubPullRequestOrderByWithRelationInput!]
    cursor: GithubPullRequestWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubPullRequestScalarFieldEnum!]
  ): [GithubPullRequest!]!
  githubIssues(
    where: GithubIssueWhereInput
    orderBy: [GithubIssueOrderByWithRelationInput!]
    cursor: GithubIssueWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubIssueScalarFieldEnum!]
  ): [GithubIssue!]!
  githubMentions(
    where: GithubMentionWhereInput
    orderBy: [GithubMentionOrderByWithRelationInput!]
    cursor: GithubMentionWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubMentionScalarFieldEnum!]
  ): [GithubMention!]!
}

type RepoCount {
  githubPullRequests: Int!
  githubIssues: Int!
  githubMentions: Int!
}

type GithubOrganization {
  id: Int!
  githubOrgId: Int!
  name: String!
  createdAt: DateTime!
  updatedAt: DateTime!
  _count: GithubOrganizationCount
  repos(
    where: RepoWhereInput
    orderBy: [RepoOrderByWithRelationInput!]
    cursor: RepoWhereUniqueInput
    take: Int
    skip: Int
    distinct: [RepoScalarFieldEnum!]
  ): [Repo!]!
}

type GithubOrganizationCount {
  repos: Int!
}

input RepoOrderByWithRelationInput {
  id: SortOrder
  name: SortOrder
  githubRepoId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  organizationId: SortOrder
  organization: GithubOrganizationOrderByWithRelationInput
  projectId: SortOrder
  project: ProjectOrderByWithRelationInput
  lastPRUpdatedAt: SortOrder
  githubPullRequests: GithubPullRequestOrderByRelationAggregateInput
  githubIssues: GithubIssueOrderByRelationAggregateInput
  githubMentions: GithubMentionOrderByRelationAggregateInput
}

input GithubOrganizationOrderByWithRelationInput {
  id: SortOrder
  githubOrgId: SortOrder
  name: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  repos: RepoOrderByRelationAggregateInput
}

input RepoOrderByRelationAggregateInput {
  _count: SortOrder
}

input ProjectOrderByWithRelationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  repos: RepoOrderByRelationAggregateInput
  gitPOAPs: GitPOAPOrderByRelationAggregateInput
  gitPOAPRequests: GitPOAPRequestOrderByRelationAggregateInput
}

input GithubPullRequestOrderByRelationAggregateInput {
  _count: SortOrder
}

input GithubIssueOrderByRelationAggregateInput {
  _count: SortOrder
}

input GithubMentionOrderByRelationAggregateInput {
  _count: SortOrder
}

input RepoWhereUniqueInput {
  id: Int
  githubRepoId: Int
}

enum RepoScalarFieldEnum {
  id
  name
  githubRepoId
  createdAt
  updatedAt
  organizationId
  projectId
  lastPRUpdatedAt
}

type GithubPullRequest {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  githubPullNumber: Int!
  githubTitle: String!
  githubCreatedAt: DateTime!
  githubMergedAt: DateTime
  githubMergeCommitSha: String
  repoId: Int!
  githubUserId: Int!
  _count: GithubPullRequestCount
  repo: Repo!
  githubUser: GithubUser!
  claims(
    where: ClaimWhereInput
    orderBy: [ClaimOrderByWithRelationInput!]
    cursor: ClaimWhereUniqueInput
    take: Int
    skip: Int
    distinct: [ClaimScalarFieldEnum!]
  ): [Claim!]!
  githubMentions(
    where: GithubMentionWhereInput
    orderBy: [GithubMentionOrderByWithRelationInput!]
    cursor: GithubMentionWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubMentionScalarFieldEnum!]
  ): [GithubMention!]!
}

type GithubPullRequestCount {
  claims: Int!
  githubMentions: Int!
}

type GithubUser {
  id: Int!
  githubId: Int!
  githubHandle: String!
  createdAt: DateTime!
  updatedAt: DateTime!
  _count: GithubUserCount
  claims(
    where: ClaimWhereInput
    orderBy: [ClaimOrderByWithRelationInput!]
    cursor: ClaimWhereUniqueInput
    take: Int
    skip: Int
    distinct: [ClaimScalarFieldEnum!]
  ): [Claim!]!
  githubPullRequests(
    where: GithubPullRequestWhereInput
    orderBy: [GithubPullRequestOrderByWithRelationInput!]
    cursor: GithubPullRequestWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubPullRequestScalarFieldEnum!]
  ): [GithubPullRequest!]!
  githubIssues(
    where: GithubIssueWhereInput
    orderBy: [GithubIssueOrderByWithRelationInput!]
    cursor: GithubIssueWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubIssueScalarFieldEnum!]
  ): [GithubIssue!]!
  githubMentions(
    where: GithubMentionWhereInput
    orderBy: [GithubMentionOrderByWithRelationInput!]
    cursor: GithubMentionWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubMentionScalarFieldEnum!]
  ): [GithubMention!]!
}

type GithubUserCount {
  claims: Int!
  githubPullRequests: Int!
  githubIssues: Int!
  githubMentions: Int!
}

input ClaimOrderByWithRelationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  mintedAt: SortOrder
  status: SortOrder
  poapTokenId: SortOrder
  mintedAddressId: SortOrder
  mintedAddress: AddressOrderByWithRelationInput
  gitPOAPId: SortOrder
  gitPOAP: GitPOAPOrderByWithRelationInput
  githubUserId: SortOrder
  githubUser: GithubUserOrderByWithRelationInput
  emailId: SortOrder
  email: EmailOrderByWithRelationInput
  issuedAddressId: SortOrder
  issuedAddress: AddressOrderByWithRelationInput
  discordUserId: SortOrder
  discordUser: DiscordUserOrderByWithRelationInput
  pullRequestEarnedId: SortOrder
  pullRequestEarned: GithubPullRequestOrderByWithRelationInput
  mentionEarnedId: SortOrder
  mentionEarned: GithubMentionOrderByWithRelationInput
  needsRevalidation: SortOrder
}

input GitPOAPOrderByWithRelationInput {
  id: SortOrder
  type: SortOrder
  name: SortOrder
  imageUrl: SortOrder
  description: SortOrder
  year: SortOrder
  poapEventId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  projectId: SortOrder
  project: ProjectOrderByWithRelationInput
  teamId: SortOrder
  team: TeamOrderByWithRelationInput
  claims: ClaimOrderByRelationAggregateInput
  poapApprovalStatus: SortOrder
  canRequestMoreCodes: SortOrder
  redeemCodes: RedeemCodeOrderByRelationAggregateInput
  eventId: SortOrder
  event: EventOrderByWithRelationInput
  level: SortOrder
  threshold: SortOrder
  isPRBased: SortOrder
  isEnabled: SortOrder
  creatorAddressId: SortOrder
  creatorAddress: AddressOrderByWithRelationInput
  creatorEmailId: SortOrder
  creatorEmail: EmailOrderByWithRelationInput
  gitPOAPRequestId: SortOrder
  gitPOAPRequest: GitPOAPRequestOrderByWithRelationInput
}

input RedeemCodeOrderByRelationAggregateInput {
  _count: SortOrder
}

input EventOrderByWithRelationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  startDate: SortOrder
  endDate: SortOrder
  name: SortOrder
  organization: SortOrder
  description: SortOrder
  location: SortOrder
  imageUrl: SortOrder
  githubHandle: SortOrder
  twitterHandle: SortOrder
  discordHandle: SortOrder
  siteUrl: SortOrder
  gitPOAPs: GitPOAPOrderByRelationAggregateInput
}

input EmailOrderByWithRelationInput {
  id: SortOrder
  emailAddress: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  claims: ClaimOrderByRelationAggregateInput
  createdGitPOAPs: GitPOAPOrderByRelationAggregateInput
  createdGitPOAPRequests: GitPOAPRequestOrderByRelationAggregateInput
}

input GitPOAPRequestOrderByWithRelationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  startDate: SortOrder
  endDate: SortOrder
  creatorEmailId: SortOrder
  creatorEmail: EmailOrderByWithRelationInput
  name: SortOrder
  numRequestedCodes: SortOrder
  imageUrl: SortOrder
  description: SortOrder
  projectId: SortOrder
  project: ProjectOrderByWithRelationInput
  team: TeamOrderByWithRelationInput
  teamId: SortOrder
  contributors: SortOrder
  rejectionReason: SortOrder
  staffApprovalStatus: SortOrder
  addressId: SortOrder
  address: AddressOrderByWithRelationInput
  gitPOAPId: SortOrder
  gitPOAP: GitPOAPOrderByWithRelationInput
}

input GithubUserOrderByWithRelationInput {
  id: SortOrder
  githubId: SortOrder
  githubHandle: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  claims: ClaimOrderByRelationAggregateInput
  githubPullRequests: GithubPullRequestOrderByRelationAggregateInput
  githubIssues: GithubIssueOrderByRelationAggregateInput
  githubMentions: GithubMentionOrderByRelationAggregateInput
}

input DiscordUserOrderByWithRelationInput {
  id: SortOrder
  discordId: SortOrder
  discordHandle: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  claims: ClaimOrderByRelationAggregateInput
}

input GithubPullRequestOrderByWithRelationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubPullNumber: SortOrder
  githubTitle: SortOrder
  githubCreatedAt: SortOrder
  githubMergedAt: SortOrder
  githubMergeCommitSha: SortOrder
  repoId: SortOrder
  repo: RepoOrderByWithRelationInput
  githubUserId: SortOrder
  githubUser: GithubUserOrderByWithRelationInput
  claims: ClaimOrderByRelationAggregateInput
  githubMentions: GithubMentionOrderByRelationAggregateInput
}

input GithubMentionOrderByWithRelationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubMentionedAt: SortOrder
  repoId: SortOrder
  repo: RepoOrderByWithRelationInput
  githubUserId: SortOrder
  githubUser: GithubUserOrderByWithRelationInput
  pullRequestId: SortOrder
  pullRequest: GithubPullRequestOrderByWithRelationInput
  issueId: SortOrder
  issue: GithubIssueOrderByWithRelationInput
  claims: ClaimOrderByRelationAggregateInput
}

input GithubIssueOrderByWithRelationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubIssueNumber: SortOrder
  githubTitle: SortOrder
  githubCreatedAt: SortOrder
  githubClosedAt: SortOrder
  repoId: SortOrder
  repo: RepoOrderByWithRelationInput
  githubUserId: SortOrder
  githubUser: GithubUserOrderByWithRelationInput
  githubMentions: GithubMentionOrderByRelationAggregateInput
}

input ClaimWhereUniqueInput {
  id: Int
  poapTokenId: String
  gitPOAPId_githubUserId: ClaimGitPOAPIdGithubUserIdCompoundUniqueInput
  gitPOAPId_mintedAddressId: ClaimGitPOAPIdMintedAddressIdCompoundUniqueInput
  gitPOAPId_issuedAddressId: ClaimGitPOAPIdIssuedAddressIdCompoundUniqueInput
  gitPOAPId_emailId: ClaimGitPOAPIdEmailIdCompoundUniqueInput
}

input ClaimGitPOAPIdGithubUserIdCompoundUniqueInput {
  gitPOAPId: Int!
  githubUserId: Int!
}

input ClaimGitPOAPIdMintedAddressIdCompoundUniqueInput {
  gitPOAPId: Int!
  mintedAddressId: Int!
}

input ClaimGitPOAPIdIssuedAddressIdCompoundUniqueInput {
  gitPOAPId: Int!
  issuedAddressId: Int!
}

input ClaimGitPOAPIdEmailIdCompoundUniqueInput {
  gitPOAPId: Int!
  emailId: Int!
}

enum ClaimScalarFieldEnum {
  id
  createdAt
  updatedAt
  mintedAt
  status
  qrHash
  poapTokenId
  mintedAddressId
  gitPOAPId
  githubUserId
  emailId
  issuedAddressId
  discordUserId
  pullRequestEarnedId
  mentionEarnedId
  needsRevalidation
}

input GithubPullRequestWhereUniqueInput {
  id: Int
  repoId_githubPullNumber: GithubPullRequestRepoIdGithubPullNumberCompoundUniqueInput
}

input GithubPullRequestRepoIdGithubPullNumberCompoundUniqueInput {
  repoId: Int!
  githubPullNumber: Int!
}

enum GithubPullRequestScalarFieldEnum {
  id
  createdAt
  updatedAt
  githubPullNumber
  githubTitle
  githubCreatedAt
  githubMergedAt
  githubMergeCommitSha
  repoId
  githubUserId
}

type GithubIssue {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  githubIssueNumber: Int!
  githubTitle: String!
  githubCreatedAt: DateTime!
  githubClosedAt: DateTime
  repoId: Int!
  githubUserId: Int!
  _count: GithubIssueCount
}

type GithubIssueCount {
  githubMentions: Int!
}

input GithubIssueWhereUniqueInput {
  id: Int
  repoId_githubIssueNumber: GithubIssueRepoIdGithubIssueNumberCompoundUniqueInput
}

input GithubIssueRepoIdGithubIssueNumberCompoundUniqueInput {
  repoId: Int!
  githubIssueNumber: Int!
}

enum GithubIssueScalarFieldEnum {
  id
  createdAt
  updatedAt
  githubIssueNumber
  githubTitle
  githubCreatedAt
  githubClosedAt
  repoId
  githubUserId
}

type GithubMention {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  githubMentionedAt: DateTime!
  repoId: Int!
  githubUserId: Int!
  pullRequestId: Int
  issueId: Int
  _count: GithubMentionCount
}

type GithubMentionCount {
  claims: Int!
}

input GithubMentionWhereUniqueInput {
  id: Int
  repoId_githubUserId_pullRequestId: GithubMentionRepoIdGithubUserIdPullRequestIdCompoundUniqueInput
  repoId_githubUserId_issueId: GithubMentionRepoIdGithubUserIdIssueIdCompoundUniqueInput
}

input GithubMentionRepoIdGithubUserIdPullRequestIdCompoundUniqueInput {
  repoId: Int!
  githubUserId: Int!
  pullRequestId: Int!
}

input GithubMentionRepoIdGithubUserIdIssueIdCompoundUniqueInput {
  repoId: Int!
  githubUserId: Int!
  issueId: Int!
}

enum GithubMentionScalarFieldEnum {
  id
  createdAt
  updatedAt
  githubMentionedAt
  repoId
  githubUserId
  pullRequestId
  issueId
}

input GitPOAPWhereUniqueInput {
  id: Int
  poapEventId: Int
  gitPOAPRequestId: Int
}

enum GitPOAPScalarFieldEnum {
  id
  type
  name
  imageUrl
  description
  year
  poapEventId
  createdAt
  updatedAt
  projectId
  teamId
  poapSecret
  poapApprovalStatus
  canRequestMoreCodes
  eventId
  level
  threshold
  isPRBased
  isEnabled
  creatorAddressId
  creatorEmailId
  gitPOAPRequestId
}

type GitPOAPRequest {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  startDate: DateTime!
  endDate: DateTime!
  creatorEmailId: Int!
  name: String!
  numRequestedCodes: Int!
  imageUrl: String!
  description: String!
  projectId: Int
  teamId: Int
  contributors: JSON!
  rejectionReason: String
  staffApprovalStatus: StaffApprovalStatus!
  addressId: Int!
  gitPOAPId: Int
  creatorEmail: Email!
  project: Project
  team: Team
  address: Address!
  gitPOAP: GitPOAP
}

type Email {
  id: Int!
  emailAddress: String!
  createdAt: DateTime!
  updatedAt: DateTime!
  _count: EmailCount
}

type EmailCount {
  claims: Int!
  createdGitPOAPs: Int!
  createdGitPOAPRequests: Int!
}

type Team {
  id: Int!
  name: String!
  ownerAddressId: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  description: String
  logoImageUrl: String
  approvalStatus: StaffApprovalStatus!
  _count: TeamCount
}

type TeamCount {
  memberships: Int!
  gitPOAPs: Int!
  gitPOAPRequests: Int!
}

input GitPOAPRequestWhereUniqueInput {
  id: Int
  gitPOAPId: Int
}

enum GitPOAPRequestScalarFieldEnum {
  id
  createdAt
  updatedAt
  startDate
  endDate
  creatorEmailId
  name
  numRequestedCodes
  imageUrl
  description
  projectId
  teamId
  contributors
  rejectionReason
  staffApprovalStatus
  addressId
  gitPOAPId
}

type RedeemCode {
  id: Int!
  gitPOAPId: Int!
  code: String!
}

input RedeemCodeOrderByWithRelationInput {
  id: SortOrder
  gitPOAPId: SortOrder
  gitPOAP: GitPOAPOrderByWithRelationInput
  code: SortOrder
}

input RedeemCodeWhereUniqueInput {
  id: Int
  gitPOAPId_code: RedeemCodeGitPOAPIdCodeCompoundUniqueInput
}

input RedeemCodeGitPOAPIdCodeCompoundUniqueInput {
  gitPOAPId: Int!
  code: String!
}

enum RedeemCodeScalarFieldEnum {
  id
  gitPOAPId
  code
}

type Event {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  startDate: DateTime!
  endDate: DateTime!
  name: String!
  organization: String!
  description: String
  location: String!
  imageUrl: String
  githubHandle: String
  twitterHandle: String
  discordHandle: String
  siteUrl: String
  _count: EventCount
}

type EventCount {
  gitPOAPs: Int!
}

type DiscordUser {
  id: Int!
  discordId: String!
  discordHandle: String!
  createdAt: DateTime!
  updatedAt: DateTime!
  _count: DiscordUserCount
  claims(
    where: ClaimWhereInput
    orderBy: [ClaimOrderByWithRelationInput!]
    cursor: ClaimWhereUniqueInput
    take: Int
    skip: Int
    distinct: [ClaimScalarFieldEnum!]
  ): [Claim!]!
}

type DiscordUserCount {
  claims: Int!
}

input TeamWhereUniqueInput {
  id: Int
}

enum TeamScalarFieldEnum {
  id
  name
  ownerAddressId
  createdAt
  updatedAt
  description
  logoImageUrl
  approvalStatus
}

enum AddressScalarFieldEnum {
  id
  ethAddress
  createdAt
  updatedAt
  ensAvatarImageUrl
  ensName
}

type AddressGroupBy {
  id: Int!
  ethAddress: String!
  createdAt: DateTime!
  updatedAt: DateTime!
  ensAvatarImageUrl: String
  ensName: String
  _count: AddressCountAggregate
  _avg: AddressAvgAggregate
  _sum: AddressSumAggregate
  _min: AddressMinAggregate
  _max: AddressMaxAggregate
}

input AddressOrderByWithAggregationInput {
  id: SortOrder
  ethAddress: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  ensAvatarImageUrl: SortOrder
  ensName: SortOrder
  _count: AddressCountOrderByAggregateInput
  _avg: AddressAvgOrderByAggregateInput
  _max: AddressMaxOrderByAggregateInput
  _min: AddressMinOrderByAggregateInput
  _sum: AddressSumOrderByAggregateInput
}

input AddressCountOrderByAggregateInput {
  id: SortOrder
  ethAddress: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  ensAvatarImageUrl: SortOrder
  ensName: SortOrder
}

input AddressAvgOrderByAggregateInput {
  id: SortOrder
}

input AddressMaxOrderByAggregateInput {
  id: SortOrder
  ethAddress: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  ensAvatarImageUrl: SortOrder
  ensName: SortOrder
}

input AddressMinOrderByAggregateInput {
  id: SortOrder
  ethAddress: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  ensAvatarImageUrl: SortOrder
  ensName: SortOrder
}

input AddressSumOrderByAggregateInput {
  id: SortOrder
}

input AddressScalarWhereWithAggregatesInput {
  AND: [AddressScalarWhereWithAggregatesInput!]
  OR: [AddressScalarWhereWithAggregatesInput!]
  NOT: [AddressScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  ethAddress: StringWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
  ensAvatarImageUrl: StringNullableWithAggregatesFilter
  ensName: StringNullableWithAggregatesFilter
}

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

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

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

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

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

input DateTimeWithAggregatesFilter {
  equals: DateTime
  in: [DateTime!]
  notIn: [DateTime!]
  lt: DateTime
  lte: DateTime
  gt: DateTime
  gte: DateTime
  not: NestedDateTimeWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedDateTimeFilter
  _max: NestedDateTimeFilter
}

input NestedDateTimeWithAggregatesFilter {
  equals: DateTime
  in: [DateTime!]
  notIn: [DateTime!]
  lt: DateTime
  lte: DateTime
  gt: DateTime
  gte: DateTime
  not: NestedDateTimeWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedDateTimeFilter
  _max: NestedDateTimeFilter
}

input StringNullableWithAggregatesFilter {
  equals: String
  in: [String!]
  notIn: [String!]
  lt: String
  lte: String
  gt: String
  gte: String
  contains: String
  startsWith: String
  endsWith: String
  mode: QueryMode
  not: NestedStringNullableWithAggregatesFilter
  _count: NestedIntNullableFilter
  _min: NestedStringNullableFilter
  _max: NestedStringNullableFilter
}

input NestedStringNullableWithAggregatesFilter {
  equals: String
  in: [String!]
  notIn: [String!]
  lt: String
  lte: String
  gt: String
  gte: String
  contains: String
  startsWith: String
  endsWith: String
  not: NestedStringNullableWithAggregatesFilter
  _count: NestedIntNullableFilter
  _min: NestedStringNullableFilter
  _max: NestedStringNullableFilter
}

type AggregateClaim {
  _count: ClaimCountAggregate
  _avg: ClaimAvgAggregate
  _sum: ClaimSumAggregate
  _min: ClaimMinAggregate
  _max: ClaimMaxAggregate
}

type ClaimCountAggregate {
  id: Int!
  createdAt: Int!
  updatedAt: Int!
  mintedAt: Int!
  status: Int!
  qrHash: Int!
  poapTokenId: Int!
  mintedAddressId: Int!
  gitPOAPId: Int!
  githubUserId: Int!
  emailId: Int!
  issuedAddressId: Int!
  discordUserId: Int!
  pullRequestEarnedId: Int!
  mentionEarnedId: Int!
  needsRevalidation: Int!
  _all: Int!
}

type ClaimAvgAggregate {
  id: Float
  mintedAddressId: Float
  gitPOAPId: Float
  githubUserId: Float
  emailId: Float
  issuedAddressId: Float
  discordUserId: Float
  pullRequestEarnedId: Float
  mentionEarnedId: Float
}

type ClaimSumAggregate {
  id: Int
  mintedAddressId: Int
  gitPOAPId: Int
  githubUserId: Int
  emailId: Int
  issuedAddressId: Int
  discordUserId: Int
  pullRequestEarnedId: Int
  mentionEarnedId: Int
}

type ClaimMinAggregate {
  id: Int
  createdAt: DateTime
  updatedAt: DateTime
  mintedAt: DateTime
  status: ClaimStatus
  qrHash: String
  poapTokenId: String
  mintedAddressId: Int
  gitPOAPId: Int
  githubUserId: Int
  emailId: Int
  issuedAddressId: Int
  discordUserId: Int
  pullRequestEarnedId: Int
  mentionEarnedId: Int
  needsRevalidation: Boolean
}

type ClaimMaxAggregate {
  id: Int
  createdAt: DateTime
  updatedAt: DateTime
  mintedAt: DateTime
  status: ClaimStatus
  qrHash: String
  poapTokenId: String
  mintedAddressId: Int
  gitPOAPId: Int
  githubUserId: Int
  emailId: Int
  issuedAddressId: Int
  discordUserId: Int
  pullRequestEarnedId: Int
  mentionEarnedId: Int
  needsRevalidation: Boolean
}

type ClaimGroupBy {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  mintedAt: DateTime
  status: ClaimStatus!
  qrHash: String
  poapTokenId: String
  mintedAddressId: Int
  gitPOAPId: Int!
  githubUserId: Int
  emailId: Int
  issuedAddressId: Int
  discordUserId: Int
  pullRequestEarnedId: Int
  mentionEarnedId: Int
  needsRevalidation: Boolean!
  _count: ClaimCountAggregate
  _avg: ClaimAvgAggregate
  _sum: ClaimSumAggregate
  _min: ClaimMinAggregate
  _max: ClaimMaxAggregate
}

input ClaimOrderByWithAggregationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  mintedAt: SortOrder
  status: SortOrder
  poapTokenId: SortOrder
  mintedAddressId: SortOrder
  gitPOAPId: SortOrder
  githubUserId: SortOrder
  emailId: SortOrder
  issuedAddressId: SortOrder
  discordUserId: SortOrder
  pullRequestEarnedId: SortOrder
  mentionEarnedId: SortOrder
  needsRevalidation: SortOrder
  _count: ClaimCountOrderByAggregateInput
  _avg: ClaimAvgOrderByAggregateInput
  _max: ClaimMaxOrderByAggregateInput
  _min: ClaimMinOrderByAggregateInput
  _sum: ClaimSumOrderByAggregateInput
}

input ClaimCountOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  mintedAt: SortOrder
  status: SortOrder
  poapTokenId: SortOrder
  mintedAddressId: SortOrder
  gitPOAPId: SortOrder
  githubUserId: SortOrder
  emailId: SortOrder
  issuedAddressId: SortOrder
  discordUserId: SortOrder
  pullRequestEarnedId: SortOrder
  mentionEarnedId: SortOrder
  needsRevalidation: SortOrder
}

input ClaimAvgOrderByAggregateInput {
  id: SortOrder
  mintedAddressId: SortOrder
  gitPOAPId: SortOrder
  githubUserId: SortOrder
  emailId: SortOrder
  issuedAddressId: SortOrder
  discordUserId: SortOrder
  pullRequestEarnedId: SortOrder
  mentionEarnedId: SortOrder
}

input ClaimMaxOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  mintedAt: SortOrder
  status: SortOrder
  poapTokenId: SortOrder
  mintedAddressId: SortOrder
  gitPOAPId: SortOrder
  githubUserId: SortOrder
  emailId: SortOrder
  issuedAddressId: SortOrder
  discordUserId: SortOrder
  pullRequestEarnedId: SortOrder
  mentionEarnedId: SortOrder
  needsRevalidation: SortOrder
}

input ClaimMinOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  mintedAt: SortOrder
  status: SortOrder
  poapTokenId: SortOrder
  mintedAddressId: SortOrder
  gitPOAPId: SortOrder
  githubUserId: SortOrder
  emailId: SortOrder
  issuedAddressId: SortOrder
  discordUserId: SortOrder
  pullRequestEarnedId: SortOrder
  mentionEarnedId: SortOrder
  needsRevalidation: SortOrder
}

input ClaimSumOrderByAggregateInput {
  id: SortOrder
  mintedAddressId: SortOrder
  gitPOAPId: SortOrder
  githubUserId: SortOrder
  emailId: SortOrder
  issuedAddressId: SortOrder
  discordUserId: SortOrder
  pullRequestEarnedId: SortOrder
  mentionEarnedId: SortOrder
}

input ClaimScalarWhereWithAggregatesInput {
  AND: [ClaimScalarWhereWithAggregatesInput!]
  OR: [ClaimScalarWhereWithAggregatesInput!]
  NOT: [ClaimScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
  mintedAt: DateTimeNullableWithAggregatesFilter
  status: EnumClaimStatusWithAggregatesFilter
  poapTokenId: StringNullableWithAggregatesFilter
  mintedAddressId: IntNullableWithAggregatesFilter
  gitPOAPId: IntWithAggregatesFilter
  githubUserId: IntNullableWithAggregatesFilter
  emailId: IntNullableWithAggregatesFilter
  issuedAddressId: IntNullableWithAggregatesFilter
  discordUserId: IntNullableWithAggregatesFilter
  pullRequestEarnedId: IntNullableWithAggregatesFilter
  mentionEarnedId: IntNullableWithAggregatesFilter
  needsRevalidation: BoolWithAggregatesFilter
}

input DateTimeNullableWithAggregatesFilter {
  equals: DateTime
  in: [DateTime!]
  notIn: [DateTime!]
  lt: DateTime
  lte: DateTime
  gt: DateTime
  gte: DateTime
  not: NestedDateTimeNullableWithAggregatesFilter
  _count: NestedIntNullableFilter
  _min: NestedDateTimeNullableFilter
  _max: NestedDateTimeNullableFilter
}

input NestedDateTimeNullableWithAggregatesFilter {
  equals: DateTime
  in: [DateTime!]
  notIn: [DateTime!]
  lt: DateTime
  lte: DateTime
  gt: DateTime
  gte: DateTime
  not: NestedDateTimeNullableWithAggregatesFilter
  _count: NestedIntNullableFilter
  _min: NestedDateTimeNullableFilter
  _max: NestedDateTimeNullableFilter
}

input EnumClaimStatusWithAggregatesFilter {
  equals: ClaimStatus
  in: [ClaimStatus!]
  notIn: [ClaimStatus!]
  not: NestedEnumClaimStatusWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedEnumClaimStatusFilter
  _max: NestedEnumClaimStatusFilter
}

input NestedEnumClaimStatusWithAggregatesFilter {
  equals: ClaimStatus
  in: [ClaimStatus!]
  notIn: [ClaimStatus!]
  not: NestedEnumClaimStatusWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedEnumClaimStatusFilter
  _max: NestedEnumClaimStatusFilter
}

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

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

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

input BoolWithAggregatesFilter {
  equals: Boolean
  not: NestedBoolWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedBoolFilter
  _max: NestedBoolFilter
}

input NestedBoolWithAggregatesFilter {
  equals: Boolean
  not: NestedBoolWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedBoolFilter
  _max: NestedBoolFilter
}

type AggregateDiscordUser {
  _count: DiscordUserCountAggregate
  _avg: DiscordUserAvgAggregate
  _sum: DiscordUserSumAggregate
  _min: DiscordUserMinAggregate
  _max: DiscordUserMaxAggregate
}

type DiscordUserCountAggregate {
  id: Int!
  discordId: Int!
  discordHandle: Int!
  createdAt: Int!
  updatedAt: Int!
  _all: Int!
}

type DiscordUserAvgAggregate {
  id: Float
}

type DiscordUserSumAggregate {
  id: Int
}

type DiscordUserMinAggregate {
  id: Int
  discordId: String
  discordHandle: String
  createdAt: DateTime
  updatedAt: DateTime
}

type DiscordUserMaxAggregate {
  id: Int
  discordId: String
  discordHandle: String
  createdAt: DateTime
  updatedAt: DateTime
}

input DiscordUserWhereUniqueInput {
  id: Int
  discordId: String
}

enum DiscordUserScalarFieldEnum {
  id
  discordId
  discordHandle
  createdAt
  updatedAt
}

type DiscordUserGroupBy {
  id: Int!
  discordId: String!
  discordHandle: String!
  createdAt: DateTime!
  updatedAt: DateTime!
  _count: DiscordUserCountAggregate
  _avg: DiscordUserAvgAggregate
  _sum: DiscordUserSumAggregate
  _min: DiscordUserMinAggregate
  _max: DiscordUserMaxAggregate
}

input DiscordUserOrderByWithAggregationInput {
  id: SortOrder
  discordId: SortOrder
  discordHandle: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  _count: DiscordUserCountOrderByAggregateInput
  _avg: DiscordUserAvgOrderByAggregateInput
  _max: DiscordUserMaxOrderByAggregateInput
  _min: DiscordUserMinOrderByAggregateInput
  _sum: DiscordUserSumOrderByAggregateInput
}

input DiscordUserCountOrderByAggregateInput {
  id: SortOrder
  discordId: SortOrder
  discordHandle: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
}

input DiscordUserAvgOrderByAggregateInput {
  id: SortOrder
}

input DiscordUserMaxOrderByAggregateInput {
  id: SortOrder
  discordId: SortOrder
  discordHandle: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
}

input DiscordUserMinOrderByAggregateInput {
  id: SortOrder
  discordId: SortOrder
  discordHandle: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
}

input DiscordUserSumOrderByAggregateInput {
  id: SortOrder
}

input DiscordUserScalarWhereWithAggregatesInput {
  AND: [DiscordUserScalarWhereWithAggregatesInput!]
  OR: [DiscordUserScalarWhereWithAggregatesInput!]
  NOT: [DiscordUserScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  discordId: StringWithAggregatesFilter
  discordHandle: StringWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
}

type AggregateEmail {
  _count: EmailCountAggregate
  _avg: EmailAvgAggregate
  _sum: EmailSumAggregate
  _min: EmailMinAggregate
  _max: EmailMaxAggregate
}

type EmailCountAggregate {
  id: Int!
  emailAddress: Int!
  createdAt: Int!
  updatedAt: Int!
  _all: Int!
}

type EmailAvgAggregate {
  id: Float
}

type EmailSumAggregate {
  id: Int
}

type EmailMinAggregate {
  id: Int
  emailAddress: String
  createdAt: DateTime
  updatedAt: DateTime
}

type EmailMaxAggregate {
  id: Int
  emailAddress: String
  createdAt: DateTime
  updatedAt: DateTime
}

input EmailWhereUniqueInput {
  id: Int
  emailAddress: String
}

type AggregateFeaturedPOAP {
  _count: FeaturedPOAPCountAggregate
  _avg: FeaturedPOAPAvgAggregate
  _sum: FeaturedPOAPSumAggregate
  _min: FeaturedPOAPMinAggregate
  _max: FeaturedPOAPMaxAggregate
}

type FeaturedPOAPCountAggregate {
  id: Int!
  poapTokenId: Int!
  profileId: Int!
  _all: Int!
}

type FeaturedPOAPAvgAggregate {
  id: Float
  profileId: Float
}

type FeaturedPOAPSumAggregate {
  id: Int
  profileId: Int
}

type FeaturedPOAPMinAggregate {
  id: Int
  poapTokenId: String
  profileId: Int
}

type FeaturedPOAPMaxAggregate {
  id: Int
  poapTokenId: String
  profileId: Int
}

type FeaturedPOAPGroupBy {
  id: Int!
  poapTokenId: String!
  profileId: Int!
  _count: FeaturedPOAPCountAggregate
  _avg: FeaturedPOAPAvgAggregate
  _sum: FeaturedPOAPSumAggregate
  _min: FeaturedPOAPMinAggregate
  _max: FeaturedPOAPMaxAggregate
}

input FeaturedPOAPOrderByWithAggregationInput {
  id: SortOrder
  poapTokenId: SortOrder
  profileId: SortOrder
  _count: FeaturedPOAPCountOrderByAggregateInput
  _avg: FeaturedPOAPAvgOrderByAggregateInput
  _max: FeaturedPOAPMaxOrderByAggregateInput
  _min: FeaturedPOAPMinOrderByAggregateInput
  _sum: FeaturedPOAPSumOrderByAggregateInput
}

input FeaturedPOAPCountOrderByAggregateInput {
  id: SortOrder
  poapTokenId: SortOrder
  profileId: SortOrder
}

input FeaturedPOAPAvgOrderByAggregateInput {
  id: SortOrder
  profileId: SortOrder
}

input FeaturedPOAPMaxOrderByAggregateInput {
  id: SortOrder
  poapTokenId: SortOrder
  profileId: SortOrder
}

input FeaturedPOAPMinOrderByAggregateInput {
  id: SortOrder
  poapTokenId: SortOrder
  profileId: SortOrder
}

input FeaturedPOAPSumOrderByAggregateInput {
  id: SortOrder
  profileId: SortOrder
}

input FeaturedPOAPScalarWhereWithAggregatesInput {
  AND: [FeaturedPOAPScalarWhereWithAggregatesInput!]
  OR: [FeaturedPOAPScalarWhereWithAggregatesInput!]
  NOT: [FeaturedPOAPScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  poapTokenId: StringWithAggregatesFilter
  profileId: IntWithAggregatesFilter
}

type AggregateGitPOAP {
  _count: GitPOAPCountAggregate
  _avg: GitPOAPAvgAggregate
  _sum: GitPOAPSumAggregate
  _min: GitPOAPMinAggregate
  _max: GitPOAPMaxAggregate
}

type GitPOAPCountAggregate {
  id: Int!
  type: Int!
  name: Int!
  imageUrl: Int!
  description: Int!
  year: Int!
  poapEventId: Int!
  createdAt: Int!
  updatedAt: Int!
  projectId: Int!
  teamId: Int!
  poapSecret: Int!
  poapApprovalStatus: Int!
  canRequestMoreCodes: Int!
  eventId: Int!
  level: Int!
  threshold: Int!
  isPRBased: Int!
  isEnabled: Int!
  creatorAddressId: Int!
  creatorEmailId: Int!
  gitPOAPRequestId: Int!
  _all: Int!
}

type GitPOAPAvgAggregate {
  id: Float
  year: Float
  poapEventId: Float
  projectId: Float
  teamId: Float
  eventId: Float
  level: Float
  threshold: Float
  creatorAddressId: Float
  creatorEmailId: Float
  gitPOAPRequestId: Float
}

type GitPOAPSumAggregate {
  id: Int
  year: Int
  poapEventId: Int
  projectId: Int
  teamId: Int
  eventId: Int
  level: Int
  threshold: Int
  creatorAddressId: Int
  creatorEmailId: Int
  gitPOAPRequestId: Int
}

type GitPOAPMinAggregate {
  id: Int
  type: GitPOAPType
  name: String
  imageUrl: String
  description: String
  year: Int
  poapEventId: Int
  createdAt: DateTime
  updatedAt: DateTime
  projectId: Int
  teamId: Int
  poapSecret: String
  poapApprovalStatus: GitPOAPStatus
  canRequestMoreCodes: Boolean
  eventId: Int
  level: Int
  threshold: Int
  isPRBased: Boolean
  isEnabled: Boolean
  creatorAddressId: Int
  creatorEmailId: Int
  gitPOAPRequestId: Int
}

type GitPOAPMaxAggregate {
  id: Int
  type: GitPOAPType
  name: String
  imageUrl: String
  description: String
  year: Int
  poapEventId: Int
  createdAt: DateTime
  updatedAt: DateTime
  projectId: Int
  teamId: Int
  poapSecret: String
  poapApprovalStatus: GitPOAPStatus
  canRequestMoreCodes: Boolean
  eventId: Int
  level: Int
  threshold: Int
  isPRBased: Boolean
  isEnabled: Boolean
  creatorAddressId: Int
  creatorEmailId: Int
  gitPOAPRequestId: Int
}

type GitPOAPGroupBy {
  id: Int!
  type: GitPOAPType!
  name: String!
  imageUrl: String!
  description: String!
  year: Int!
  poapEventId: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  projectId: Int
  teamId: Int
  poapSecret: String!
  poapApprovalStatus: GitPOAPStatus!
  canRequestMoreCodes: Boolean!
  eventId: Int
  level: Int!
  threshold: Int!
  isPRBased: Boolean!
  isEnabled: Boolean!
  creatorAddressId: Int
  creatorEmailId: Int
  gitPOAPRequestId: Int
  _count: GitPOAPCountAggregate
  _avg: GitPOAPAvgAggregate
  _sum: GitPOAPSumAggregate
  _min: GitPOAPMinAggregate
  _max: GitPOAPMaxAggregate
}

input GitPOAPOrderByWithAggregationInput {
  id: SortOrder
  type: SortOrder
  name: SortOrder
  imageUrl: SortOrder
  description: SortOrder
  year: SortOrder
  poapEventId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  projectId: SortOrder
  teamId: SortOrder
  poapApprovalStatus: SortOrder
  canRequestMoreCodes: SortOrder
  eventId: SortOrder
  level: SortOrder
  threshold: SortOrder
  isPRBased: SortOrder
  isEnabled: SortOrder
  creatorAddressId: SortOrder
  creatorEmailId: SortOrder
  gitPOAPRequestId: SortOrder
  _count: GitPOAPCountOrderByAggregateInput
  _avg: GitPOAPAvgOrderByAggregateInput
  _max: GitPOAPMaxOrderByAggregateInput
  _min: GitPOAPMinOrderByAggregateInput
  _sum: GitPOAPSumOrderByAggregateInput
}

input GitPOAPCountOrderByAggregateInput {
  id: SortOrder
  type: SortOrder
  name: SortOrder
  imageUrl: SortOrder
  description: SortOrder
  year: SortOrder
  poapEventId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  projectId: SortOrder
  teamId: SortOrder
  poapApprovalStatus: SortOrder
  canRequestMoreCodes: SortOrder
  eventId: SortOrder
  level: SortOrder
  threshold: SortOrder
  isPRBased: SortOrder
  isEnabled: SortOrder
  creatorAddressId: SortOrder
  creatorEmailId: SortOrder
  gitPOAPRequestId: SortOrder
}

input GitPOAPAvgOrderByAggregateInput {
  id: SortOrder
  year: SortOrder
  poapEventId: SortOrder
  projectId: SortOrder
  teamId: SortOrder
  eventId: SortOrder
  level: SortOrder
  threshold: SortOrder
  creatorAddressId: SortOrder
  creatorEmailId: SortOrder
  gitPOAPRequestId: SortOrder
}

input GitPOAPMaxOrderByAggregateInput {
  id: SortOrder
  type: SortOrder
  name: SortOrder
  imageUrl: SortOrder
  description: SortOrder
  year: SortOrder
  poapEventId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  projectId: SortOrder
  teamId: SortOrder
  poapApprovalStatus: SortOrder
  canRequestMoreCodes: SortOrder
  eventId: SortOrder
  level: SortOrder
  threshold: SortOrder
  isPRBased: SortOrder
  isEnabled: SortOrder
  creatorAddressId: SortOrder
  creatorEmailId: SortOrder
  gitPOAPRequestId: SortOrder
}

input GitPOAPMinOrderByAggregateInput {
  id: SortOrder
  type: SortOrder
  name: SortOrder
  imageUrl: SortOrder
  description: SortOrder
  year: SortOrder
  poapEventId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  projectId: SortOrder
  teamId: SortOrder
  poapApprovalStatus: SortOrder
  canRequestMoreCodes: SortOrder
  eventId: SortOrder
  level: SortOrder
  threshold: SortOrder
  isPRBased: SortOrder
  isEnabled: SortOrder
  creatorAddressId: SortOrder
  creatorEmailId: SortOrder
  gitPOAPRequestId: SortOrder
}

input GitPOAPSumOrderByAggregateInput {
  id: SortOrder
  year: SortOrder
  poapEventId: SortOrder
  projectId: SortOrder
  teamId: SortOrder
  eventId: SortOrder
  level: SortOrder
  threshold: SortOrder
  creatorAddressId: SortOrder
  creatorEmailId: SortOrder
  gitPOAPRequestId: SortOrder
}

input GitPOAPScalarWhereWithAggregatesInput {
  AND: [GitPOAPScalarWhereWithAggregatesInput!]
  OR: [GitPOAPScalarWhereWithAggregatesInput!]
  NOT: [GitPOAPScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  type: EnumGitPOAPTypeWithAggregatesFilter
  name: StringWithAggregatesFilter
  imageUrl: StringWithAggregatesFilter
  description: StringWithAggregatesFilter
  year: IntWithAggregatesFilter
  poapEventId: IntWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
  projectId: IntNullableWithAggregatesFilter
  teamId: IntNullableWithAggregatesFilter
  poapApprovalStatus: EnumGitPOAPStatusWithAggregatesFilter
  canRequestMoreCodes: BoolWithAggregatesFilter
  eventId: IntNullableWithAggregatesFilter
  level: IntWithAggregatesFilter
  threshold: IntWithAggregatesFilter
  isPRBased: BoolWithAggregatesFilter
  isEnabled: BoolWithAggregatesFilter
  creatorAddressId: IntNullableWithAggregatesFilter
  creatorEmailId: IntNullableWithAggregatesFilter
  gitPOAPRequestId: IntNullableWithAggregatesFilter
}

input EnumGitPOAPTypeWithAggregatesFilter {
  equals: GitPOAPType
  in: [GitPOAPType!]
  notIn: [GitPOAPType!]
  not: NestedEnumGitPOAPTypeWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedEnumGitPOAPTypeFilter
  _max: NestedEnumGitPOAPTypeFilter
}

input NestedEnumGitPOAPTypeWithAggregatesFilter {
  equals: GitPOAPType
  in: [GitPOAPType!]
  notIn: [GitPOAPType!]
  not: NestedEnumGitPOAPTypeWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedEnumGitPOAPTypeFilter
  _max: NestedEnumGitPOAPTypeFilter
}

input EnumGitPOAPStatusWithAggregatesFilter {
  equals: GitPOAPStatus
  in: [GitPOAPStatus!]
  notIn: [GitPOAPStatus!]
  not: NestedEnumGitPOAPStatusWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedEnumGitPOAPStatusFilter
  _max: NestedEnumGitPOAPStatusFilter
}

input NestedEnumGitPOAPStatusWithAggregatesFilter {
  equals: GitPOAPStatus
  in: [GitPOAPStatus!]
  notIn: [GitPOAPStatus!]
  not: NestedEnumGitPOAPStatusWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedEnumGitPOAPStatusFilter
  _max: NestedEnumGitPOAPStatusFilter
}

type AggregateGitPOAPRequest {
  _count: GitPOAPRequestCountAggregate
  _avg: GitPOAPRequestAvgAggregate
  _sum: GitPOAPRequestSumAggregate
  _min: GitPOAPRequestMinAggregate
  _max: GitPOAPRequestMaxAggregate
}

type GitPOAPRequestCountAggregate {
  id: Int!
  createdAt: Int!
  updatedAt: Int!
  startDate: Int!
  endDate: Int!
  creatorEmailId: Int!
  name: Int!
  numRequestedCodes: Int!
  imageUrl: Int!
  description: Int!
  projectId: Int!
  teamId: Int!
  contributors: Int!
  rejectionReason: Int!
  staffApprovalStatus: Int!
  addressId: Int!
  gitPOAPId: Int!
  _all: Int!
}

type GitPOAPRequestAvgAggregate {
  id: Float
  creatorEmailId: Float
  numRequestedCodes: Float
  projectId: Float
  teamId: Float
  addressId: Float
  gitPOAPId: Float
}

type GitPOAPRequestSumAggregate {
  id: Int
  creatorEmailId: Int
  numRequestedCodes: Int
  projectId: Int
  teamId: Int
  addressId: Int
  gitPOAPId: Int
}

type GitPOAPRequestMinAggregate {
  id: Int
  createdAt: DateTime
  updatedAt: DateTime
  startDate: DateTime
  endDate: DateTime
  creatorEmailId: Int
  name: String
  numRequestedCodes: Int
  imageUrl: String
  description: String
  projectId: Int
  teamId: Int
  rejectionReason: String
  staffApprovalStatus: StaffApprovalStatus
  addressId: Int
  gitPOAPId: Int
}

type GitPOAPRequestMaxAggregate {
  id: Int
  createdAt: DateTime
  updatedAt: DateTime
  startDate: DateTime
  endDate: DateTime
  creatorEmailId: Int
  name: String
  numRequestedCodes: Int
  imageUrl: String
  description: String
  projectId: Int
  teamId: Int
  rejectionReason: String
  staffApprovalStatus: StaffApprovalStatus
  addressId: Int
  gitPOAPId: Int
}

type GitPOAPRequestGroupBy {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  startDate: DateTime!
  endDate: DateTime!
  creatorEmailId: Int!
  name: String!
  numRequestedCodes: Int!
  imageUrl: String!
  description: String!
  projectId: Int
  teamId: Int
  contributors: JSON!
  rejectionReason: String
  staffApprovalStatus: StaffApprovalStatus!
  addressId: Int!
  gitPOAPId: Int
  _count: GitPOAPRequestCountAggregate
  _avg: GitPOAPRequestAvgAggregate
  _sum: GitPOAPRequestSumAggregate
  _min: GitPOAPRequestMinAggregate
  _max: GitPOAPRequestMaxAggregate
}

input GitPOAPRequestOrderByWithAggregationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  startDate: SortOrder
  endDate: SortOrder
  creatorEmailId: SortOrder
  name: SortOrder
  numRequestedCodes: SortOrder
  imageUrl: SortOrder
  description: SortOrder
  projectId: SortOrder
  teamId: SortOrder
  contributors: SortOrder
  rejectionReason: SortOrder
  staffApprovalStatus: SortOrder
  addressId: SortOrder
  gitPOAPId: SortOrder
  _count: GitPOAPRequestCountOrderByAggregateInput
  _avg: GitPOAPRequestAvgOrderByAggregateInput
  _max: GitPOAPRequestMaxOrderByAggregateInput
  _min: GitPOAPRequestMinOrderByAggregateInput
  _sum: GitPOAPRequestSumOrderByAggregateInput
}

input GitPOAPRequestCountOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  startDate: SortOrder
  endDate: SortOrder
  creatorEmailId: SortOrder
  name: SortOrder
  numRequestedCodes: SortOrder
  imageUrl: SortOrder
  description: SortOrder
  projectId: SortOrder
  teamId: SortOrder
  contributors: SortOrder
  rejectionReason: SortOrder
  staffApprovalStatus: SortOrder
  addressId: SortOrder
  gitPOAPId: SortOrder
}

input GitPOAPRequestAvgOrderByAggregateInput {
  id: SortOrder
  creatorEmailId: SortOrder
  numRequestedCodes: SortOrder
  projectId: SortOrder
  teamId: SortOrder
  addressId: SortOrder
  gitPOAPId: SortOrder
}

input GitPOAPRequestMaxOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  startDate: SortOrder
  endDate: SortOrder
  creatorEmailId: SortOrder
  name: SortOrder
  numRequestedCodes: SortOrder
  imageUrl: SortOrder
  description: SortOrder
  projectId: SortOrder
  teamId: SortOrder
  rejectionReason: SortOrder
  staffApprovalStatus: SortOrder
  addressId: SortOrder
  gitPOAPId: SortOrder
}

input GitPOAPRequestMinOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  startDate: SortOrder
  endDate: SortOrder
  creatorEmailId: SortOrder
  name: SortOrder
  numRequestedCodes: SortOrder
  imageUrl: SortOrder
  description: SortOrder
  projectId: SortOrder
  teamId: SortOrder
  rejectionReason: SortOrder
  staffApprovalStatus: SortOrder
  addressId: SortOrder
  gitPOAPId: SortOrder
}

input GitPOAPRequestSumOrderByAggregateInput {
  id: SortOrder
  creatorEmailId: SortOrder
  numRequestedCodes: SortOrder
  projectId: SortOrder
  teamId: SortOrder
  addressId: SortOrder
  gitPOAPId: SortOrder
}

input GitPOAPRequestScalarWhereWithAggregatesInput {
  AND: [GitPOAPRequestScalarWhereWithAggregatesInput!]
  OR: [GitPOAPRequestScalarWhereWithAggregatesInput!]
  NOT: [GitPOAPRequestScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
  startDate: DateTimeWithAggregatesFilter
  endDate: DateTimeWithAggregatesFilter
  creatorEmailId: IntWithAggregatesFilter
  name: StringWithAggregatesFilter
  numRequestedCodes: IntWithAggregatesFilter
  imageUrl: StringWithAggregatesFilter
  description: StringWithAggregatesFilter
  projectId: IntNullableWithAggregatesFilter
  teamId: IntNullableWithAggregatesFilter
  contributors: JsonWithAggregatesFilter
  rejectionReason: StringNullableWithAggregatesFilter
  staffApprovalStatus: EnumStaffApprovalStatusWithAggregatesFilter
  addressId: IntWithAggregatesFilter
  gitPOAPId: IntNullableWithAggregatesFilter
}

input JsonWithAggregatesFilter {
  equals: JSON
  path: [String!]
  string_contains: String
  string_starts_with: String
  string_ends_with: String
  array_contains: JSON
  array_starts_with: JSON
  array_ends_with: JSON
  lt: JSON
  lte: JSON
  gt: JSON
  gte: JSON
  not: JSON
  _count: NestedIntFilter
  _min: NestedJsonFilter
  _max: NestedJsonFilter
}

input NestedJsonFilter {
  equals: JSON
  path: [String!]
  string_contains: String
  string_starts_with: String
  string_ends_with: String
  array_contains: JSON
  array_starts_with: JSON
  array_ends_with: JSON
  lt: JSON
  lte: JSON
  gt: JSON
  gte: JSON
  not: JSON
}

input EnumStaffApprovalStatusWithAggregatesFilter {
  equals: StaffApprovalStatus
  in: [StaffApprovalStatus!]
  notIn: [StaffApprovalStatus!]
  not: NestedEnumStaffApprovalStatusWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedEnumStaffApprovalStatusFilter
  _max: NestedEnumStaffApprovalStatusFilter
}

input NestedEnumStaffApprovalStatusWithAggregatesFilter {
  equals: StaffApprovalStatus
  in: [StaffApprovalStatus!]
  notIn: [StaffApprovalStatus!]
  not: NestedEnumStaffApprovalStatusWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedEnumStaffApprovalStatusFilter
  _max: NestedEnumStaffApprovalStatusFilter
}

type AggregateGithubIssue {
  _count: GithubIssueCountAggregate
  _avg: GithubIssueAvgAggregate
  _sum: GithubIssueSumAggregate
  _min: GithubIssueMinAggregate
  _max: GithubIssueMaxAggregate
}

type GithubIssueCountAggregate {
  id: Int!
  createdAt: Int!
  updatedAt: Int!
  githubIssueNumber: Int!
  githubTitle: Int!
  githubCreatedAt: Int!
  githubClosedAt: Int!
  repoId: Int!
  githubUserId: Int!
  _all: Int!
}

type GithubIssueAvgAggregate {
  id: Float
  githubIssueNumber: Float
  repoId: Float
  githubUserId: Float
}

type GithubIssueSumAggregate {
  id: Int
  githubIssueNumber: Int
  repoId: Int
  githubUserId: Int
}

type GithubIssueMinAggregate {
  id: Int
  createdAt: DateTime
  updatedAt: DateTime
  githubIssueNumber: Int
  githubTitle: String
  githubCreatedAt: DateTime
  githubClosedAt: DateTime
  repoId: Int
  githubUserId: Int
}

type GithubIssueMaxAggregate {
  id: Int
  createdAt: DateTime
  updatedAt: DateTime
  githubIssueNumber: Int
  githubTitle: String
  githubCreatedAt: DateTime
  githubClosedAt: DateTime
  repoId: Int
  githubUserId: Int
}

type GithubIssueGroupBy {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  githubIssueNumber: Int!
  githubTitle: String!
  githubCreatedAt: DateTime!
  githubClosedAt: DateTime
  repoId: Int!
  githubUserId: Int!
  _count: GithubIssueCountAggregate
  _avg: GithubIssueAvgAggregate
  _sum: GithubIssueSumAggregate
  _min: GithubIssueMinAggregate
  _max: GithubIssueMaxAggregate
}

input GithubIssueOrderByWithAggregationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubIssueNumber: SortOrder
  githubTitle: SortOrder
  githubCreatedAt: SortOrder
  githubClosedAt: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
  _count: GithubIssueCountOrderByAggregateInput
  _avg: GithubIssueAvgOrderByAggregateInput
  _max: GithubIssueMaxOrderByAggregateInput
  _min: GithubIssueMinOrderByAggregateInput
  _sum: GithubIssueSumOrderByAggregateInput
}

input GithubIssueCountOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubIssueNumber: SortOrder
  githubTitle: SortOrder
  githubCreatedAt: SortOrder
  githubClosedAt: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
}

input GithubIssueAvgOrderByAggregateInput {
  id: SortOrder
  githubIssueNumber: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
}

input GithubIssueMaxOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubIssueNumber: SortOrder
  githubTitle: SortOrder
  githubCreatedAt: SortOrder
  githubClosedAt: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
}

input GithubIssueMinOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubIssueNumber: SortOrder
  githubTitle: SortOrder
  githubCreatedAt: SortOrder
  githubClosedAt: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
}

input GithubIssueSumOrderByAggregateInput {
  id: SortOrder
  githubIssueNumber: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
}

input GithubIssueScalarWhereWithAggregatesInput {
  AND: [GithubIssueScalarWhereWithAggregatesInput!]
  OR: [GithubIssueScalarWhereWithAggregatesInput!]
  NOT: [GithubIssueScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
  githubIssueNumber: IntWithAggregatesFilter
  githubTitle: StringWithAggregatesFilter
  githubCreatedAt: DateTimeWithAggregatesFilter
  githubClosedAt: DateTimeNullableWithAggregatesFilter
  repoId: IntWithAggregatesFilter
  githubUserId: IntWithAggregatesFilter
}

type AggregateGithubMention {
  _count: GithubMentionCountAggregate
  _avg: GithubMentionAvgAggregate
  _sum: GithubMentionSumAggregate
  _min: GithubMentionMinAggregate
  _max: GithubMentionMaxAggregate
}

type GithubMentionCountAggregate {
  id: Int!
  createdAt: Int!
  updatedAt: Int!
  githubMentionedAt: Int!
  repoId: Int!
  githubUserId: Int!
  pullRequestId: Int!
  issueId: Int!
  _all: Int!
}

type GithubMentionAvgAggregate {
  id: Float
  repoId: Float
  githubUserId: Float
  pullRequestId: Float
  issueId: Float
}

type GithubMentionSumAggregate {
  id: Int
  repoId: Int
  githubUserId: Int
  pullRequestId: Int
  issueId: Int
}

type GithubMentionMinAggregate {
  id: Int
  createdAt: DateTime
  updatedAt: DateTime
  githubMentionedAt: DateTime
  repoId: Int
  githubUserId: Int
  pullRequestId: Int
  issueId: Int
}

type GithubMentionMaxAggregate {
  id: Int
  createdAt: DateTime
  updatedAt: DateTime
  githubMentionedAt: DateTime
  repoId: Int
  githubUserId: Int
  pullRequestId: Int
  issueId: Int
}

type GithubMentionGroupBy {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  githubMentionedAt: DateTime!
  repoId: Int!
  githubUserId: Int!
  pullRequestId: Int
  issueId: Int
  _count: GithubMentionCountAggregate
  _avg: GithubMentionAvgAggregate
  _sum: GithubMentionSumAggregate
  _min: GithubMentionMinAggregate
  _max: GithubMentionMaxAggregate
}

input GithubMentionOrderByWithAggregationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubMentionedAt: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
  pullRequestId: SortOrder
  issueId: SortOrder
  _count: GithubMentionCountOrderByAggregateInput
  _avg: GithubMentionAvgOrderByAggregateInput
  _max: GithubMentionMaxOrderByAggregateInput
  _min: GithubMentionMinOrderByAggregateInput
  _sum: GithubMentionSumOrderByAggregateInput
}

input GithubMentionCountOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubMentionedAt: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
  pullRequestId: SortOrder
  issueId: SortOrder
}

input GithubMentionAvgOrderByAggregateInput {
  id: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
  pullRequestId: SortOrder
  issueId: SortOrder
}

input GithubMentionMaxOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubMentionedAt: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
  pullRequestId: SortOrder
  issueId: SortOrder
}

input GithubMentionMinOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubMentionedAt: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
  pullRequestId: SortOrder
  issueId: SortOrder
}

input GithubMentionSumOrderByAggregateInput {
  id: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
  pullRequestId: SortOrder
  issueId: SortOrder
}

input GithubMentionScalarWhereWithAggregatesInput {
  AND: [GithubMentionScalarWhereWithAggregatesInput!]
  OR: [GithubMentionScalarWhereWithAggregatesInput!]
  NOT: [GithubMentionScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
  githubMentionedAt: DateTimeWithAggregatesFilter
  repoId: IntWithAggregatesFilter
  githubUserId: IntWithAggregatesFilter
  pullRequestId: IntNullableWithAggregatesFilter
  issueId: IntNullableWithAggregatesFilter
}

type AggregateGithubOrganization {
  _count: GithubOrganizationCountAggregate
  _avg: GithubOrganizationAvgAggregate
  _sum: GithubOrganizationSumAggregate
  _min: GithubOrganizationMinAggregate
  _max: GithubOrganizationMaxAggregate
}

type GithubOrganizationCountAggregate {
  id: Int!
  githubOrgId: Int!
  name: Int!
  createdAt: Int!
  updatedAt: Int!
  _all: Int!
}

type GithubOrganizationAvgAggregate {
  id: Float
  githubOrgId: Float
}

type GithubOrganizationSumAggregate {
  id: Int
  githubOrgId: Int
}

type GithubOrganizationMinAggregate {
  id: Int
  githubOrgId: Int
  name: String
  createdAt: DateTime
  updatedAt: DateTime
}

type GithubOrganizationMaxAggregate {
  id: Int
  githubOrgId: Int
  name: String
  createdAt: DateTime
  updatedAt: DateTime
}

input GithubOrganizationWhereUniqueInput {
  id: Int
  githubOrgId: Int
}

enum GithubOrganizationScalarFieldEnum {
  id
  githubOrgId
  name
  createdAt
  updatedAt
}

type GithubOrganizationGroupBy {
  id: Int!
  githubOrgId: Int!
  name: String!
  createdAt: DateTime!
  updatedAt: DateTime!
  _count: GithubOrganizationCountAggregate
  _avg: GithubOrganizationAvgAggregate
  _sum: GithubOrganizationSumAggregate
  _min: GithubOrganizationMinAggregate
  _max: GithubOrganizationMaxAggregate
}

input GithubOrganizationOrderByWithAggregationInput {
  id: SortOrder
  githubOrgId: SortOrder
  name: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  _count: GithubOrganizationCountOrderByAggregateInput
  _avg: GithubOrganizationAvgOrderByAggregateInput
  _max: GithubOrganizationMaxOrderByAggregateInput
  _min: GithubOrganizationMinOrderByAggregateInput
  _sum: GithubOrganizationSumOrderByAggregateInput
}

input GithubOrganizationCountOrderByAggregateInput {
  id: SortOrder
  githubOrgId: SortOrder
  name: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
}

input GithubOrganizationAvgOrderByAggregateInput {
  id: SortOrder
  githubOrgId: SortOrder
}

input GithubOrganizationMaxOrderByAggregateInput {
  id: SortOrder
  githubOrgId: SortOrder
  name: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
}

input GithubOrganizationMinOrderByAggregateInput {
  id: SortOrder
  githubOrgId: SortOrder
  name: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
}

input GithubOrganizationSumOrderByAggregateInput {
  id: SortOrder
  githubOrgId: SortOrder
}

input GithubOrganizationScalarWhereWithAggregatesInput {
  AND: [GithubOrganizationScalarWhereWithAggregatesInput!]
  OR: [GithubOrganizationScalarWhereWithAggregatesInput!]
  NOT: [GithubOrganizationScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  githubOrgId: IntWithAggregatesFilter
  name: StringWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
}

type AggregateGithubPullRequest {
  _count: GithubPullRequestCountAggregate
  _avg: GithubPullRequestAvgAggregate
  _sum: GithubPullRequestSumAggregate
  _min: GithubPullRequestMinAggregate
  _max: GithubPullRequestMaxAggregate
}

type GithubPullRequestCountAggregate {
  id: Int!
  createdAt: Int!
  updatedAt: Int!
  githubPullNumber: Int!
  githubTitle: Int!
  githubCreatedAt: Int!
  githubMergedAt: Int!
  githubMergeCommitSha: Int!
  repoId: Int!
  githubUserId: Int!
  _all: Int!
}

type GithubPullRequestAvgAggregate {
  id: Float
  githubPullNumber: Float
  repoId: Float
  githubUserId: Float
}

type GithubPullRequestSumAggregate {
  id: Int
  githubPullNumber: Int
  repoId: Int
  githubUserId: Int
}

type GithubPullRequestMinAggregate {
  id: Int
  createdAt: DateTime
  updatedAt: DateTime
  githubPullNumber: Int
  githubTitle: String
  githubCreatedAt: DateTime
  githubMergedAt: DateTime
  githubMergeCommitSha: String
  repoId: Int
  githubUserId: Int
}

type GithubPullRequestMaxAggregate {
  id: Int
  createdAt: DateTime
  updatedAt: DateTime
  githubPullNumber: Int
  githubTitle: String
  githubCreatedAt: DateTime
  githubMergedAt: DateTime
  githubMergeCommitSha: String
  repoId: Int
  githubUserId: Int
}

type GithubPullRequestGroupBy {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  githubPullNumber: Int!
  githubTitle: String!
  githubCreatedAt: DateTime!
  githubMergedAt: DateTime
  githubMergeCommitSha: String
  repoId: Int!
  githubUserId: Int!
  _count: GithubPullRequestCountAggregate
  _avg: GithubPullRequestAvgAggregate
  _sum: GithubPullRequestSumAggregate
  _min: GithubPullRequestMinAggregate
  _max: GithubPullRequestMaxAggregate
}

input GithubPullRequestOrderByWithAggregationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubPullNumber: SortOrder
  githubTitle: SortOrder
  githubCreatedAt: SortOrder
  githubMergedAt: SortOrder
  githubMergeCommitSha: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
  _count: GithubPullRequestCountOrderByAggregateInput
  _avg: GithubPullRequestAvgOrderByAggregateInput
  _max: GithubPullRequestMaxOrderByAggregateInput
  _min: GithubPullRequestMinOrderByAggregateInput
  _sum: GithubPullRequestSumOrderByAggregateInput
}

input GithubPullRequestCountOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubPullNumber: SortOrder
  githubTitle: SortOrder
  githubCreatedAt: SortOrder
  githubMergedAt: SortOrder
  githubMergeCommitSha: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
}

input GithubPullRequestAvgOrderByAggregateInput {
  id: SortOrder
  githubPullNumber: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
}

input GithubPullRequestMaxOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubPullNumber: SortOrder
  githubTitle: SortOrder
  githubCreatedAt: SortOrder
  githubMergedAt: SortOrder
  githubMergeCommitSha: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
}

input GithubPullRequestMinOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  githubPullNumber: SortOrder
  githubTitle: SortOrder
  githubCreatedAt: SortOrder
  githubMergedAt: SortOrder
  githubMergeCommitSha: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
}

input GithubPullRequestSumOrderByAggregateInput {
  id: SortOrder
  githubPullNumber: SortOrder
  repoId: SortOrder
  githubUserId: SortOrder
}

input GithubPullRequestScalarWhereWithAggregatesInput {
  AND: [GithubPullRequestScalarWhereWithAggregatesInput!]
  OR: [GithubPullRequestScalarWhereWithAggregatesInput!]
  NOT: [GithubPullRequestScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
  githubPullNumber: IntWithAggregatesFilter
  githubTitle: StringWithAggregatesFilter
  githubCreatedAt: DateTimeWithAggregatesFilter
  githubMergedAt: DateTimeNullableWithAggregatesFilter
  githubMergeCommitSha: StringNullableWithAggregatesFilter
  repoId: IntWithAggregatesFilter
  githubUserId: IntWithAggregatesFilter
}

type AggregateGithubUser {
  _count: GithubUserCountAggregate
  _avg: GithubUserAvgAggregate
  _sum: GithubUserSumAggregate
  _min: GithubUserMinAggregate
  _max: GithubUserMaxAggregate
}

type GithubUserCountAggregate {
  id: Int!
  githubId: Int!
  githubHandle: Int!
  createdAt: Int!
  updatedAt: Int!
  _all: Int!
}

type GithubUserAvgAggregate {
  id: Float
  githubId: Float
}

type GithubUserSumAggregate {
  id: Int
  githubId: Int
}

type GithubUserMinAggregate {
  id: Int
  githubId: Int
  githubHandle: String
  createdAt: DateTime
  updatedAt: DateTime
}

type GithubUserMaxAggregate {
  id: Int
  githubId: Int
  githubHandle: String
  createdAt: DateTime
  updatedAt: DateTime
}

input GithubUserWhereUniqueInput {
  id: Int
  githubId: Int
}

enum GithubUserScalarFieldEnum {
  id
  githubId
  githubHandle
  createdAt
  updatedAt
}

type GithubUserGroupBy {
  id: Int!
  githubId: Int!
  githubHandle: String!
  createdAt: DateTime!
  updatedAt: DateTime!
  _count: GithubUserCountAggregate
  _avg: GithubUserAvgAggregate
  _sum: GithubUserSumAggregate
  _min: GithubUserMinAggregate
  _max: GithubUserMaxAggregate
}

input GithubUserOrderByWithAggregationInput {
  id: SortOrder
  githubId: SortOrder
  githubHandle: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  _count: GithubUserCountOrderByAggregateInput
  _avg: GithubUserAvgOrderByAggregateInput
  _max: GithubUserMaxOrderByAggregateInput
  _min: GithubUserMinOrderByAggregateInput
  _sum: GithubUserSumOrderByAggregateInput
}

input GithubUserCountOrderByAggregateInput {
  id: SortOrder
  githubId: SortOrder
  githubHandle: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
}

input GithubUserAvgOrderByAggregateInput {
  id: SortOrder
  githubId: SortOrder
}

input GithubUserMaxOrderByAggregateInput {
  id: SortOrder
  githubId: SortOrder
  githubHandle: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
}

input GithubUserMinOrderByAggregateInput {
  id: SortOrder
  githubId: SortOrder
  githubHandle: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
}

input GithubUserSumOrderByAggregateInput {
  id: SortOrder
  githubId: SortOrder
}

input GithubUserScalarWhereWithAggregatesInput {
  AND: [GithubUserScalarWhereWithAggregatesInput!]
  OR: [GithubUserScalarWhereWithAggregatesInput!]
  NOT: [GithubUserScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  githubId: IntWithAggregatesFilter
  githubHandle: StringWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
}

type AggregateMembership {
  _count: MembershipCountAggregate
  _avg: MembershipAvgAggregate
  _sum: MembershipSumAggregate
  _min: MembershipMinAggregate
  _max: MembershipMaxAggregate
}

type MembershipCountAggregate {
  id: Int!
  createdAt: Int!
  updatedAt: Int!
  teamId: Int!
  addressId: Int!
  role: Int!
  acceptanceStatus: Int!
  joinedOn: Int!
  _all: Int!
}

type MembershipAvgAggregate {
  id: Float
  teamId: Float
  addressId: Float
}

type MembershipSumAggregate {
  id: Int
  teamId: Int
  addressId: Int
}

type MembershipMinAggregate {
  id: Int
  createdAt: DateTime
  updatedAt: DateTime
  teamId: Int
  addressId: Int
  role: MembershipRole
  acceptanceStatus: MembershipAcceptanceStatus
  joinedOn: DateTime
}

type MembershipMaxAggregate {
  id: Int
  createdAt: DateTime
  updatedAt: DateTime
  teamId: Int
  addressId: Int
  role: MembershipRole
  acceptanceStatus: MembershipAcceptanceStatus
  joinedOn: DateTime
}

type MembershipGroupBy {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  teamId: Int!
  addressId: Int!
  role: MembershipRole!
  acceptanceStatus: MembershipAcceptanceStatus!
  joinedOn: DateTime
  _count: MembershipCountAggregate
  _avg: MembershipAvgAggregate
  _sum: MembershipSumAggregate
  _min: MembershipMinAggregate
  _max: MembershipMaxAggregate
}

input MembershipOrderByWithAggregationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  teamId: SortOrder
  addressId: SortOrder
  role: SortOrder
  acceptanceStatus: SortOrder
  joinedOn: SortOrder
  _count: MembershipCountOrderByAggregateInput
  _avg: MembershipAvgOrderByAggregateInput
  _max: MembershipMaxOrderByAggregateInput
  _min: MembershipMinOrderByAggregateInput
  _sum: MembershipSumOrderByAggregateInput
}

input MembershipCountOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  teamId: SortOrder
  addressId: SortOrder
  role: SortOrder
  acceptanceStatus: SortOrder
  joinedOn: SortOrder
}

input MembershipAvgOrderByAggregateInput {
  id: SortOrder
  teamId: SortOrder
  addressId: SortOrder
}

input MembershipMaxOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  teamId: SortOrder
  addressId: SortOrder
  role: SortOrder
  acceptanceStatus: SortOrder
  joinedOn: SortOrder
}

input MembershipMinOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  teamId: SortOrder
  addressId: SortOrder
  role: SortOrder
  acceptanceStatus: SortOrder
  joinedOn: SortOrder
}

input MembershipSumOrderByAggregateInput {
  id: SortOrder
  teamId: SortOrder
  addressId: SortOrder
}

input MembershipScalarWhereWithAggregatesInput {
  AND: [MembershipScalarWhereWithAggregatesInput!]
  OR: [MembershipScalarWhereWithAggregatesInput!]
  NOT: [MembershipScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
  teamId: IntWithAggregatesFilter
  addressId: IntWithAggregatesFilter
  role: EnumMembershipRoleWithAggregatesFilter
  acceptanceStatus: EnumMembershipAcceptanceStatusWithAggregatesFilter
  joinedOn: DateTimeNullableWithAggregatesFilter
}

input EnumMembershipRoleWithAggregatesFilter {
  equals: MembershipRole
  in: [MembershipRole!]
  notIn: [MembershipRole!]
  not: NestedEnumMembershipRoleWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedEnumMembershipRoleFilter
  _max: NestedEnumMembershipRoleFilter
}

input NestedEnumMembershipRoleWithAggregatesFilter {
  equals: MembershipRole
  in: [MembershipRole!]
  notIn: [MembershipRole!]
  not: NestedEnumMembershipRoleWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedEnumMembershipRoleFilter
  _max: NestedEnumMembershipRoleFilter
}

input EnumMembershipAcceptanceStatusWithAggregatesFilter {
  equals: MembershipAcceptanceStatus
  in: [MembershipAcceptanceStatus!]
  notIn: [MembershipAcceptanceStatus!]
  not: NestedEnumMembershipAcceptanceStatusWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedEnumMembershipAcceptanceStatusFilter
  _max: NestedEnumMembershipAcceptanceStatusFilter
}

input NestedEnumMembershipAcceptanceStatusWithAggregatesFilter {
  equals: MembershipAcceptanceStatus
  in: [MembershipAcceptanceStatus!]
  notIn: [MembershipAcceptanceStatus!]
  not: NestedEnumMembershipAcceptanceStatusWithAggregatesFilter
  _count: NestedIntFilter
  _min: NestedEnumMembershipAcceptanceStatusFilter
  _max: NestedEnumMembershipAcceptanceStatusFilter
}

type AggregateProfile {
  _count: ProfileCountAggregate
  _avg: ProfileAvgAggregate
  _sum: ProfileSumAggregate
  _min: ProfileMinAggregate
  _max: ProfileMaxAggregate
}

type ProfileCountAggregate {
  id: Int!
  addressId: Int!
  createdAt: Int!
  updatedAt: Int!
  bio: Int!
  bannerImageUrl: Int!
  name: Int!
  profileImageUrl: Int!
  githubHandle: Int!
  twitterHandle: Int!
  discordHandle: Int!
  personalSiteUrl: Int!
  isVisibleOnLeaderboard: Int!
  _all: Int!
}

type ProfileAvgAggregate {
  id: Float
  addressId: Float
}

type ProfileSumAggregate {
  id: Int
  addressId: Int
}

type ProfileMinAggregate {
  id: Int
  addressId: Int
  createdAt: DateTime
  updatedAt: DateTime
  bio: String
  bannerImageUrl: String
  name: String
  profileImageUrl: String
  githubHandle: String
  twitterHandle: String
  discordHandle: String
  personalSiteUrl: String
  isVisibleOnLeaderboard: Boolean
}

type ProfileMaxAggregate {
  id: Int
  addressId: Int
  createdAt: DateTime
  updatedAt: DateTime
  bio: String
  bannerImageUrl: String
  name: String
  profileImageUrl: String
  githubHandle: String
  twitterHandle: String
  discordHandle: String
  personalSiteUrl: String
  isVisibleOnLeaderboard: Boolean
}

input ProfileWhereUniqueInput {
  id: Int
  addressId: Int
}

enum ProfileScalarFieldEnum {
  id
  addressId
  createdAt
  updatedAt
  bio
  bannerImageUrl
  name
  profileImageUrl
  githubHandle
  twitterHandle
  discordHandle
  personalSiteUrl
  isVisibleOnLeaderboard
}

type ProfileGroupBy {
  id: Int!
  addressId: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  bio: String
  bannerImageUrl: String
  name: String
  profileImageUrl: String
  githubHandle: String
  twitterHandle: String
  discordHandle: String
  personalSiteUrl: String
  isVisibleOnLeaderboard: Boolean!
  _count: ProfileCountAggregate
  _avg: ProfileAvgAggregate
  _sum: ProfileSumAggregate
  _min: ProfileMinAggregate
  _max: ProfileMaxAggregate
}

input ProfileOrderByWithAggregationInput {
  id: SortOrder
  addressId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  bio: SortOrder
  bannerImageUrl: SortOrder
  name: SortOrder
  profileImageUrl: SortOrder
  githubHandle: SortOrder
  twitterHandle: SortOrder
  discordHandle: SortOrder
  personalSiteUrl: SortOrder
  isVisibleOnLeaderboard: SortOrder
  _count: ProfileCountOrderByAggregateInput
  _avg: ProfileAvgOrderByAggregateInput
  _max: ProfileMaxOrderByAggregateInput
  _min: ProfileMinOrderByAggregateInput
  _sum: ProfileSumOrderByAggregateInput
}

input ProfileCountOrderByAggregateInput {
  id: SortOrder
  addressId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  bio: SortOrder
  bannerImageUrl: SortOrder
  name: SortOrder
  profileImageUrl: SortOrder
  githubHandle: SortOrder
  twitterHandle: SortOrder
  discordHandle: SortOrder
  personalSiteUrl: SortOrder
  isVisibleOnLeaderboard: SortOrder
}

input ProfileAvgOrderByAggregateInput {
  id: SortOrder
  addressId: SortOrder
}

input ProfileMaxOrderByAggregateInput {
  id: SortOrder
  addressId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  bio: SortOrder
  bannerImageUrl: SortOrder
  name: SortOrder
  profileImageUrl: SortOrder
  githubHandle: SortOrder
  twitterHandle: SortOrder
  discordHandle: SortOrder
  personalSiteUrl: SortOrder
  isVisibleOnLeaderboard: SortOrder
}

input ProfileMinOrderByAggregateInput {
  id: SortOrder
  addressId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  bio: SortOrder
  bannerImageUrl: SortOrder
  name: SortOrder
  profileImageUrl: SortOrder
  githubHandle: SortOrder
  twitterHandle: SortOrder
  discordHandle: SortOrder
  personalSiteUrl: SortOrder
  isVisibleOnLeaderboard: SortOrder
}

input ProfileSumOrderByAggregateInput {
  id: SortOrder
  addressId: SortOrder
}

input ProfileScalarWhereWithAggregatesInput {
  AND: [ProfileScalarWhereWithAggregatesInput!]
  OR: [ProfileScalarWhereWithAggregatesInput!]
  NOT: [ProfileScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  addressId: IntWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
  bio: StringNullableWithAggregatesFilter
  bannerImageUrl: StringNullableWithAggregatesFilter
  name: StringNullableWithAggregatesFilter
  profileImageUrl: StringNullableWithAggregatesFilter
  githubHandle: StringNullableWithAggregatesFilter
  twitterHandle: StringNullableWithAggregatesFilter
  discordHandle: StringNullableWithAggregatesFilter
  personalSiteUrl: StringNullableWithAggregatesFilter
  isVisibleOnLeaderboard: BoolWithAggregatesFilter
}

type AggregateProject {
  _count: ProjectCountAggregate
  _avg: ProjectAvgAggregate
  _sum: ProjectSumAggregate
  _min: ProjectMinAggregate
  _max: ProjectMaxAggregate
}

type ProjectCountAggregate {
  id: Int!
  createdAt: Int!
  updatedAt: Int!
  _all: Int!
}

type ProjectAvgAggregate {
  id: Float
}

type ProjectSumAggregate {
  id: Int
}

type ProjectMinAggregate {
  id: Int
  createdAt: DateTime
  updatedAt: DateTime
}

type ProjectMaxAggregate {
  id: Int
  createdAt: DateTime
  updatedAt: DateTime
}

input ProjectWhereUniqueInput {
  id: Int
}

enum ProjectScalarFieldEnum {
  id
  createdAt
  updatedAt
}

type ProjectGroupBy {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  _count: ProjectCountAggregate
  _avg: ProjectAvgAggregate
  _sum: ProjectSumAggregate
  _min: ProjectMinAggregate
  _max: ProjectMaxAggregate
}

input ProjectOrderByWithAggregationInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  _count: ProjectCountOrderByAggregateInput
  _avg: ProjectAvgOrderByAggregateInput
  _max: ProjectMaxOrderByAggregateInput
  _min: ProjectMinOrderByAggregateInput
  _sum: ProjectSumOrderByAggregateInput
}

input ProjectCountOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
}

input ProjectAvgOrderByAggregateInput {
  id: SortOrder
}

input ProjectMaxOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
}

input ProjectMinOrderByAggregateInput {
  id: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
}

input ProjectSumOrderByAggregateInput {
  id: SortOrder
}

input ProjectScalarWhereWithAggregatesInput {
  AND: [ProjectScalarWhereWithAggregatesInput!]
  OR: [ProjectScalarWhereWithAggregatesInput!]
  NOT: [ProjectScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
}

type AggregateRepo {
  _count: RepoCountAggregate
  _avg: RepoAvgAggregate
  _sum: RepoSumAggregate
  _min: RepoMinAggregate
  _max: RepoMaxAggregate
}

type RepoCountAggregate {
  id: Int!
  name: Int!
  githubRepoId: Int!
  createdAt: Int!
  updatedAt: Int!
  organizationId: Int!
  projectId: Int!
  lastPRUpdatedAt: Int!
  _all: Int!
}

type RepoAvgAggregate {
  id: Float
  githubRepoId: Float
  organizationId: Float
  projectId: Float
}

type RepoSumAggregate {
  id: Int
  githubRepoId: Int
  organizationId: Int
  projectId: Int
}

type RepoMinAggregate {
  id: Int
  name: String
  githubRepoId: Int
  createdAt: DateTime
  updatedAt: DateTime
  organizationId: Int
  projectId: Int
  lastPRUpdatedAt: DateTime
}

type RepoMaxAggregate {
  id: Int
  name: String
  githubRepoId: Int
  createdAt: DateTime
  updatedAt: DateTime
  organizationId: Int
  projectId: Int
  lastPRUpdatedAt: DateTime
}

type RepoGroupBy {
  id: Int!
  name: String!
  githubRepoId: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  organizationId: Int!
  projectId: Int!
  lastPRUpdatedAt: DateTime!
  _count: RepoCountAggregate
  _avg: RepoAvgAggregate
  _sum: RepoSumAggregate
  _min: RepoMinAggregate
  _max: RepoMaxAggregate
}

input RepoOrderByWithAggregationInput {
  id: SortOrder
  name: SortOrder
  githubRepoId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  organizationId: SortOrder
  projectId: SortOrder
  lastPRUpdatedAt: SortOrder
  _count: RepoCountOrderByAggregateInput
  _avg: RepoAvgOrderByAggregateInput
  _max: RepoMaxOrderByAggregateInput
  _min: RepoMinOrderByAggregateInput
  _sum: RepoSumOrderByAggregateInput
}

input RepoCountOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
  githubRepoId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  organizationId: SortOrder
  projectId: SortOrder
  lastPRUpdatedAt: SortOrder
}

input RepoAvgOrderByAggregateInput {
  id: SortOrder
  githubRepoId: SortOrder
  organizationId: SortOrder
  projectId: SortOrder
}

input RepoMaxOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
  githubRepoId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  organizationId: SortOrder
  projectId: SortOrder
  lastPRUpdatedAt: SortOrder
}

input RepoMinOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
  githubRepoId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  organizationId: SortOrder
  projectId: SortOrder
  lastPRUpdatedAt: SortOrder
}

input RepoSumOrderByAggregateInput {
  id: SortOrder
  githubRepoId: SortOrder
  organizationId: SortOrder
  projectId: SortOrder
}

input RepoScalarWhereWithAggregatesInput {
  AND: [RepoScalarWhereWithAggregatesInput!]
  OR: [RepoScalarWhereWithAggregatesInput!]
  NOT: [RepoScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  name: StringWithAggregatesFilter
  githubRepoId: IntWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
  organizationId: IntWithAggregatesFilter
  projectId: IntWithAggregatesFilter
  lastPRUpdatedAt: DateTimeWithAggregatesFilter
}

type AggregateTeam {
  _count: TeamCountAggregate
  _avg: TeamAvgAggregate
  _sum: TeamSumAggregate
  _min: TeamMinAggregate
  _max: TeamMaxAggregate
}

type TeamCountAggregate {
  id: Int!
  name: Int!
  ownerAddressId: Int!
  createdAt: Int!
  updatedAt: Int!
  description: Int!
  logoImageUrl: Int!
  approvalStatus: Int!
  _all: Int!
}

type TeamAvgAggregate {
  id: Float
  ownerAddressId: Float
}

type TeamSumAggregate {
  id: Int
  ownerAddressId: Int
}

type TeamMinAggregate {
  id: Int
  name: String
  ownerAddressId: Int
  createdAt: DateTime
  updatedAt: DateTime
  description: String
  logoImageUrl: String
  approvalStatus: StaffApprovalStatus
}

type TeamMaxAggregate {
  id: Int
  name: String
  ownerAddressId: Int
  createdAt: DateTime
  updatedAt: DateTime
  description: String
  logoImageUrl: String
  approvalStatus: StaffApprovalStatus
}

type TeamGroupBy {
  id: Int!
  name: String!
  ownerAddressId: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  description: String
  logoImageUrl: String
  approvalStatus: StaffApprovalStatus!
  _count: TeamCountAggregate
  _avg: TeamAvgAggregate
  _sum: TeamSumAggregate
  _min: TeamMinAggregate
  _max: TeamMaxAggregate
}

input TeamOrderByWithAggregationInput {
  id: SortOrder
  name: SortOrder
  ownerAddressId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  description: SortOrder
  logoImageUrl: SortOrder
  approvalStatus: SortOrder
  _count: TeamCountOrderByAggregateInput
  _avg: TeamAvgOrderByAggregateInput
  _max: TeamMaxOrderByAggregateInput
  _min: TeamMinOrderByAggregateInput
  _sum: TeamSumOrderByAggregateInput
}

input TeamCountOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
  ownerAddressId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  description: SortOrder
  logoImageUrl: SortOrder
  approvalStatus: SortOrder
}

input TeamAvgOrderByAggregateInput {
  id: SortOrder
  ownerAddressId: SortOrder
}

input TeamMaxOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
  ownerAddressId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  description: SortOrder
  logoImageUrl: SortOrder
  approvalStatus: SortOrder
}

input TeamMinOrderByAggregateInput {
  id: SortOrder
  name: SortOrder
  ownerAddressId: SortOrder
  createdAt: SortOrder
  updatedAt: SortOrder
  description: SortOrder
  logoImageUrl: SortOrder
  approvalStatus: SortOrder
}

input TeamSumOrderByAggregateInput {
  id: SortOrder
  ownerAddressId: SortOrder
}

input TeamScalarWhereWithAggregatesInput {
  AND: [TeamScalarWhereWithAggregatesInput!]
  OR: [TeamScalarWhereWithAggregatesInput!]
  NOT: [TeamScalarWhereWithAggregatesInput!]
  id: IntWithAggregatesFilter
  name: StringWithAggregatesFilter
  ownerAddressId: IntWithAggregatesFilter
  createdAt: DateTimeWithAggregatesFilter
  updatedAt: DateTimeWithAggregatesFilter
  description: StringNullableWithAggregatesFilter
  logoImageUrl: StringNullableWithAggregatesFilter
  approvalStatus: EnumStaffApprovalStatusWithAggregatesFilter
}

type FullClaimData {
  claim: Claim!
  event: POAPEvent!
}

type POAPEvent {
  id: Float!
  fancy_id: String!
  name: String!
  event_url: String!
  image_url: String!
  country: String!
  city: String!
  description: String!
  year: Float!
  start_date: String!
  end_date: String!
  expiry_date: String!
  supply: Float!
}

type FullGitPOAPEventData {
  gitPOAP: GitPOAP!
  event: POAPEvent!
}

type UserPOAPs {
  totalGitPOAPs: Float!
  totalPOAPs: Float!
  gitPOAPs: [UserGitPOAPData!]!
  poaps: [POAPToken!]!
}

type UserGitPOAPData {
  claim: Claim!
  event: POAPEvent!
  contributionCount: Float!
}

type POAPToken {
  event: POAPEvent!
  tokenId: String!
  owner: String!
  chain: String!
  created: String!
}

type RepoGitPOAPs {
  totalGitPOAPs: Float!
  gitPOAPs: [FullGitPOAPEventData!]!
}

type GitPOAPWithClaimsCount {
  gitPOAP: GitPOAP!
  event: POAPEvent!
  claimsCount: Float!
}

type UserFeaturedPOAPs {
  gitPOAPs: [UserFeaturedGitPOAPData!]!
  poaps: [POAPToken!]!
}

type UserFeaturedGitPOAPData {
  claim: Claim!
  poap: POAPToken!
}

type Holders {
  totalHolders: Float!
  holders: [Holder!]!
}

type Holder {
  profileId: Float!
  address: String!
  bio: String
  profileImageUrl: String
  twitterHandle: String
  personalSiteUrl: String
  ensName: String
  ensAvatarImageUrl: String
  githubHandle: String
  gitPOAPCount: Float!
}

type UserMemberships {
  memberships: [MembershipWithTeam!]!
}

type MembershipWithTeam {
  id: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  teamId: Int!
  addressId: Int!
  role: MembershipRole!
  acceptanceStatus: MembershipAcceptanceStatus!
  joinedOn: DateTime
  team: Team!
  address: Address!
}

type TeamMemberships {
  total: Float!
  memberships: [MembershipWithTeam!]!
}

type RepoReturnData {
  id: Int!
  name: String!
  githubRepoId: Int!
  createdAt: DateTime!
  updatedAt: DateTime!
  organizationId: Int!
  projectId: Int!
  lastPRUpdatedAt: DateTime!
  _count: RepoCount
  organization: GithubOrganization!
  project: Project!
  githubPullRequests(
    where: GithubPullRequestWhereInput
    orderBy: [GithubPullRequestOrderByWithRelationInput!]
    cursor: GithubPullRequestWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubPullRequestScalarFieldEnum!]
  ): [GithubPullRequest!]!
  githubIssues(
    where: GithubIssueWhereInput
    orderBy: [GithubIssueOrderByWithRelationInput!]
    cursor: GithubIssueWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubIssueScalarFieldEnum!]
  ): [GithubIssue!]!
  githubMentions(
    where: GithubMentionWhereInput
    orderBy: [GithubMentionOrderByWithRelationInput!]
    cursor: GithubMentionWhereUniqueInput
    take: Int
    skip: Int
    distinct: [GithubMentionScalarFieldEnum!]
  ): [GithubMention!]!
  contributorCount: Float!
  gitPOAPCount: Float!
  mintedGitPOAPCount: Float!
}

type OrganizationData {
  id: Int!
  githubOrgId: Int!
  name: String!
  createdAt: DateTime!
  updatedAt: DateTime!
  _count: GithubOrganizationCount
  repos(
    where: RepoWhereInput
    orderBy: [RepoOrderByWithRelationInput!]
    cursor: RepoWhereUniqueInput
    take: Int
    skip: Int
    distinct: [RepoScalarFieldEnum!]
  ): [Repo!]!
  contributorCount: Float!
  gitPOAPCount: Float!
  mintedGitPOAPCount: Float!
  repoCount: Float!
}

type Permissions {
  canCreateCGs: Boolean!
  isStaff: Boolean!
}

type NullableProfile {
  id: Float
  address: String!
  ensName: String
  createdAt: DateTime
  updatedAt: DateTime
  bio: String
  bannerImageUrl: String
  name: String
  profileImageUrl: String
  githubHandle: String
  twitterHandle: String
  personalSiteUrl: String
  isVisibleOnLeaderboard: Boolean!
  ensAvatarImageUrl: String
  featuredPOAPs: [FeaturedPOAP!]!
}

type ProfileWithClaimsCount {
  profile: Profile!
  claimsCount: Float!
}

type SearchResults {
  githubUsers: [GithubUser!]!
  profiles: [Profile!]!
}

type Mutation {
  addNewMembership(address: String!, teamId: Float!): MembershipMutationPayload!
  removeMembership(membershipId: Float!): MembershipMutationPayload!
  acceptMembership(teamId: Float!): MembershipMutationPayload!
  updateTeam(input: TeamUpdateInput!, teamId: Float!): TeamUpdatePayload!
}

type MembershipMutationPayload {
  membership: MembershipWithTeam
}

type TeamUpdatePayload {
  name: String!
  description: String
}

input TeamUpdateInput {
  name: StringFieldUpdateOperationsInput
  description: NullableStringFieldUpdateOperationsInput
}

input StringFieldUpdateOperationsInput {
  set: String
}

input NullableStringFieldUpdateOperationsInput {
  set: String
}