2023-08-26 17:43:01 -04:00
|
|
|
type Query {
|
|
|
|
"""
|
|
|
|
Returns the authenticated user
|
|
|
|
"""
|
|
|
|
currentUser: User
|
|
|
|
"""
|
|
|
|
Returns an entrant given its id
|
|
|
|
"""
|
|
|
|
entrant(id: ID!): Entrant
|
|
|
|
"""
|
|
|
|
Returns an event given its id or slug
|
|
|
|
"""
|
|
|
|
event(id: ID, slug: String): Event
|
|
|
|
"""
|
|
|
|
Returns a league given its id or slug
|
|
|
|
"""
|
|
|
|
league(id: ID, slug: String): League
|
|
|
|
"""
|
|
|
|
Paginated, filterable list of leagues
|
|
|
|
"""
|
|
|
|
leagues(query: LeagueQuery!): LeagueConnection
|
|
|
|
"""
|
|
|
|
Returns a participant given its id
|
|
|
|
"""
|
|
|
|
participant(id: ID!, isAdmin: Boolean): Participant
|
|
|
|
"""
|
|
|
|
Returns a phase given its id
|
|
|
|
"""
|
|
|
|
phase(id: ID): Phase
|
|
|
|
"""
|
|
|
|
Returns a phase group given its id
|
|
|
|
"""
|
|
|
|
phaseGroup(id: ID): PhaseGroup
|
|
|
|
"""
|
|
|
|
Returns a player given an id
|
|
|
|
"""
|
|
|
|
player(id: ID!): Player
|
|
|
|
"""
|
|
|
|
Returns a phase seed given its id
|
|
|
|
"""
|
|
|
|
seed(id: ID): Seed
|
|
|
|
"""
|
|
|
|
Returns a set given its id
|
|
|
|
"""
|
|
|
|
set(id: ID!): Set
|
|
|
|
"""
|
|
|
|
A shop entity
|
|
|
|
"""
|
|
|
|
shop(id: ID, slug: String): Shop
|
|
|
|
"""
|
|
|
|
Returns an stream given its id
|
|
|
|
"""
|
|
|
|
stream(id: ID!): Streams
|
|
|
|
"""
|
|
|
|
Returns all the stream queues for a given tournament
|
|
|
|
"""
|
|
|
|
streamQueue(tournamentId: ID!, includePlayerStreams: Boolean): [StreamQueue]
|
|
|
|
"""
|
|
|
|
Returns a team given its id
|
|
|
|
"""
|
|
|
|
team(id: ID, slug: String, inviteCode: String): Team
|
|
|
|
"""
|
|
|
|
Returns a tournament given its id or slug
|
|
|
|
"""
|
|
|
|
tournament(id: ID, slug: String): Tournament
|
|
|
|
"""
|
|
|
|
Paginated, filterable list of tournaments
|
|
|
|
"""
|
|
|
|
tournaments(query: TournamentQuery!): TournamentConnection
|
|
|
|
"""
|
|
|
|
Returns a user given a user slug of the form user/abc123, or id
|
|
|
|
"""
|
|
|
|
user(id: ID, slug: String): User
|
|
|
|
"""
|
|
|
|
Returns a videogame given its id
|
|
|
|
"""
|
|
|
|
videogame(id: ID, slug: String): Videogame
|
|
|
|
"""
|
|
|
|
Returns paginated list of videogames matching the search criteria.
|
|
|
|
"""
|
|
|
|
videogames(query: VideogameQuery!): VideogameConnection
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A user
|
|
|
|
"""
|
|
|
|
type User {
|
|
|
|
"""
|
|
|
|
Authorizations to external services (i.e. Twitch, Twitter)
|
|
|
|
"""
|
|
|
|
authorizations(types: [SocialConnectionType]): [ProfileAuthorization]
|
|
|
|
id: ID
|
|
|
|
bio: String
|
|
|
|
"""
|
|
|
|
Public facing user birthday that respects user publishing settings
|
|
|
|
"""
|
|
|
|
birthday: String
|
|
|
|
"""
|
|
|
|
Uniquely identifying token for user. Same as the hashed part of the slug
|
|
|
|
"""
|
|
|
|
discriminator: String
|
|
|
|
email: String
|
|
|
|
"""
|
|
|
|
Events this user has competed in
|
|
|
|
"""
|
|
|
|
events(query: UserEventsPaginationQuery): EventConnection
|
|
|
|
genderPronoun: String
|
|
|
|
images(type: String): [Image]
|
|
|
|
"""
|
|
|
|
Leagues this user has competed in
|
|
|
|
"""
|
|
|
|
leagues(query: UserLeaguesPaginationQuery): LeagueConnection
|
|
|
|
"""
|
|
|
|
Public location info for this user
|
|
|
|
"""
|
|
|
|
location: Address
|
|
|
|
"""
|
|
|
|
Public facing user name that respects user publishing settings
|
|
|
|
"""
|
|
|
|
name: String
|
|
|
|
"""
|
|
|
|
player for user
|
|
|
|
"""
|
|
|
|
player: Player
|
|
|
|
slug: String
|
|
|
|
"""
|
|
|
|
Tournaments this user is organizing or competing in
|
|
|
|
"""
|
|
|
|
tournaments(query: UserTournamentsPaginationQuery): TournamentConnection
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Represents the name of the third-party social service (e.g Twitter) for OAuth
|
|
|
|
"""
|
|
|
|
enum SocialConnectionType {
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
TWITTER
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
TWITCH
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
DISCORD
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
MIXER
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
XBOX
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
An OAuth ProfileAuthorization object
|
|
|
|
"""
|
|
|
|
type ProfileAuthorization {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
The id given by the external service
|
|
|
|
"""
|
|
|
|
externalId: String
|
|
|
|
"""
|
|
|
|
The username given by the external service (including discriminator if discord)
|
|
|
|
"""
|
|
|
|
externalUsername: String
|
|
|
|
stream: Stream
|
|
|
|
"""
|
|
|
|
The name of the external service providing this auth i.e. "twitch"
|
|
|
|
"""
|
|
|
|
type: AuthorizationType
|
|
|
|
url: String
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A Stream object
|
|
|
|
"""
|
|
|
|
type Stream {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
Whether the stream is currently live. May be slightly delayed.
|
|
|
|
"""
|
|
|
|
isOnline: Boolean
|
|
|
|
"""
|
|
|
|
The name of the stream
|
|
|
|
"""
|
|
|
|
name: String
|
|
|
|
"""
|
|
|
|
The name of the external service providing this auth i.e. "twitch"
|
|
|
|
"""
|
|
|
|
type: StreamType
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Represents the type of stream service
|
|
|
|
"""
|
|
|
|
enum StreamType {
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
TWITCH
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
MIXER
|
2024-08-14 20:44:08 -04:00
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
YOUTUBE
|
2023-08-26 17:43:01 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Represents the name of the third-party service (e.g Twitter) for OAuth
|
|
|
|
"""
|
|
|
|
enum AuthorizationType {
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
TWITTER
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
TWITCH
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
STEAM
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
DISCORD
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
XBOX
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
EPIC
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
BATTLENET
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
MIXER
|
|
|
|
}
|
|
|
|
|
|
|
|
input UserEventsPaginationQuery {
|
|
|
|
page: Int = 1
|
|
|
|
"""
|
|
|
|
How many nodes to return for the page. Maximum value of 500
|
|
|
|
"""
|
|
|
|
perPage: Int = 25
|
|
|
|
sortBy: String
|
|
|
|
filter: UserEventsPaginationFilter
|
|
|
|
}
|
|
|
|
|
|
|
|
input UserEventsPaginationFilter {
|
|
|
|
videogameId: [ID]
|
|
|
|
eventType: Int
|
|
|
|
minEntrantCount: Int
|
|
|
|
maxEntrantCount: Int
|
|
|
|
location: LocationFilterType
|
|
|
|
search: PaginationSearchType
|
|
|
|
}
|
|
|
|
|
|
|
|
input LocationFilterType {
|
|
|
|
countryCode: String
|
|
|
|
state: String
|
|
|
|
city: String
|
|
|
|
}
|
|
|
|
|
|
|
|
input PaginationSearchType {
|
|
|
|
fieldsToSearch: [String]
|
|
|
|
searchString: String
|
|
|
|
}
|
|
|
|
|
|
|
|
type EventConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [Event]
|
|
|
|
}
|
|
|
|
|
|
|
|
type PageInfo {
|
|
|
|
total: Int
|
|
|
|
totalPages: Int
|
|
|
|
page: Int
|
|
|
|
perPage: Int
|
|
|
|
sortBy: String
|
|
|
|
filter: 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
|
|
|
|
|
|
|
|
"""
|
|
|
|
An event in a tournament
|
|
|
|
"""
|
|
|
|
type Event {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
How long before the event start will the check-in end (in seconds)
|
|
|
|
"""
|
|
|
|
checkInBuffer: Int
|
|
|
|
"""
|
|
|
|
How long the event check-in will last (in seconds)
|
|
|
|
"""
|
|
|
|
checkInDuration: Int
|
|
|
|
"""
|
|
|
|
Whether check-in is enabled for this event
|
|
|
|
"""
|
|
|
|
checkInEnabled: Boolean
|
|
|
|
"""
|
|
|
|
Rough categorization of event tier, denoting relative importance in the competitive scene
|
|
|
|
"""
|
|
|
|
competitionTier: Int
|
|
|
|
"""
|
|
|
|
When the event was created (unix timestamp)
|
|
|
|
"""
|
|
|
|
createdAt: Timestamp
|
|
|
|
"""
|
|
|
|
Last date attendees are able to create teams for team events
|
|
|
|
"""
|
|
|
|
deckSubmissionDeadline: Timestamp
|
|
|
|
"""
|
2024-08-14 20:44:08 -04:00
|
|
|
Maximum number of participants each Entrant can have
|
|
|
|
"""
|
|
|
|
entrantSizeMax: Int @deprecated(reason: "Migrate to teamRosterSize")
|
|
|
|
"""
|
|
|
|
Minimum number of participants each Entrant can have
|
|
|
|
"""
|
|
|
|
entrantSizeMin: Int @deprecated(reason: "Migrate to teamRosterSize")
|
|
|
|
"""
|
2023-08-26 17:43:01 -04:00
|
|
|
The entrants that belong to an event, paginated by filter criteria
|
|
|
|
"""
|
|
|
|
entrants(query: EventEntrantPageQuery): EntrantConnection
|
|
|
|
"""
|
|
|
|
Whether the event has decks
|
|
|
|
"""
|
|
|
|
hasDecks: Boolean
|
|
|
|
"""
|
|
|
|
Are player tasks enabled for this event
|
|
|
|
"""
|
|
|
|
hasTasks: Boolean
|
|
|
|
images(type: String): [Image]
|
|
|
|
"""
|
|
|
|
Whether the event is an online event or not
|
|
|
|
"""
|
|
|
|
isOnline: Boolean
|
|
|
|
league: League
|
|
|
|
"""
|
|
|
|
Markdown field for match rules/instructions
|
|
|
|
"""
|
|
|
|
matchRulesMarkdown: String
|
|
|
|
"""
|
|
|
|
Title of event set by organizer
|
|
|
|
"""
|
|
|
|
name: String
|
|
|
|
"""
|
|
|
|
Gets the number of entrants in this event
|
|
|
|
"""
|
|
|
|
numEntrants: Int
|
|
|
|
"""
|
|
|
|
The phase groups that belong to an event.
|
|
|
|
"""
|
|
|
|
phaseGroups: [PhaseGroup]
|
|
|
|
"""
|
|
|
|
The phases that belong to an event.
|
|
|
|
"""
|
|
|
|
phases(
|
|
|
|
"""
|
|
|
|
Filter phases by state. If not specified will default to all phases
|
|
|
|
"""
|
|
|
|
state: ActivityState
|
|
|
|
"""
|
|
|
|
Optionally only return results for this phase
|
|
|
|
"""
|
|
|
|
phaseId: ID
|
|
|
|
): [Phase]
|
|
|
|
"""
|
|
|
|
TO settings for prizing
|
|
|
|
"""
|
|
|
|
prizingInfo: JSON
|
|
|
|
publishing: JSON
|
|
|
|
"""
|
|
|
|
Markdown field for event rules/instructions
|
|
|
|
"""
|
|
|
|
rulesMarkdown: String
|
|
|
|
"""
|
|
|
|
Id of the event ruleset
|
|
|
|
"""
|
|
|
|
rulesetId: Int
|
|
|
|
"""
|
2024-08-14 20:44:08 -04:00
|
|
|
Settings pulled from the event ruleset, if one exists
|
|
|
|
"""
|
|
|
|
rulesetSettings: JSON @deprecated(reason: "Use ruleset")
|
|
|
|
"""
|
2023-08-26 17:43:01 -04:00
|
|
|
Paginated sets for this Event
|
|
|
|
"""
|
|
|
|
sets(
|
|
|
|
page: Int
|
|
|
|
perPage: Int
|
|
|
|
"""
|
|
|
|
How to sort these sets
|
|
|
|
"""
|
|
|
|
sortType: SetSortType
|
|
|
|
"""
|
|
|
|
Supported filter options to filter down set results.
|
|
|
|
"""
|
|
|
|
filters: SetFilters
|
|
|
|
): SetConnection
|
|
|
|
slug: String
|
|
|
|
"""
|
|
|
|
Paginated list of standings
|
|
|
|
"""
|
|
|
|
standings(query: StandingPaginationQuery!): StandingConnection
|
|
|
|
"""
|
|
|
|
When does this event start?
|
|
|
|
"""
|
|
|
|
startAt: Timestamp
|
|
|
|
"""
|
|
|
|
The state of the Event.
|
|
|
|
"""
|
|
|
|
state: ActivityState
|
|
|
|
"""
|
|
|
|
Paginated stations on this event
|
|
|
|
"""
|
|
|
|
stations(query: StationFilter): StationsConnection
|
|
|
|
"""
|
|
|
|
Last date attendees are able to create teams for team events
|
|
|
|
"""
|
|
|
|
teamManagementDeadline: Timestamp
|
|
|
|
"""
|
|
|
|
If this is a teams event, returns whether or not teams can set custom names
|
|
|
|
"""
|
|
|
|
teamNameAllowed: Boolean
|
|
|
|
"""
|
|
|
|
Team roster size requirements
|
|
|
|
"""
|
|
|
|
teamRosterSize: TeamRosterSize
|
|
|
|
tournament: Tournament
|
|
|
|
"""
|
|
|
|
The type of the event, whether an entrant will have one participant or multiple
|
|
|
|
"""
|
|
|
|
type: Int
|
|
|
|
"""
|
|
|
|
When the event was last modified (unix timestamp)
|
|
|
|
"""
|
|
|
|
updatedAt: Timestamp
|
|
|
|
"""
|
|
|
|
Whether the event uses the new EventSeeds for seeding
|
|
|
|
"""
|
|
|
|
useEventSeeds: Boolean
|
|
|
|
"""
|
|
|
|
The entrant (if applicable) for a given user in this event
|
|
|
|
"""
|
|
|
|
userEntrant(
|
|
|
|
"""
|
|
|
|
User to get entrant for. Defaults to currently logged in user.
|
|
|
|
"""
|
|
|
|
userId: ID
|
|
|
|
): Entrant
|
|
|
|
videogame: Videogame
|
|
|
|
"""
|
|
|
|
The waves being used by the event
|
|
|
|
"""
|
|
|
|
waves(
|
|
|
|
"""
|
|
|
|
Waves filtered by phaseId, returns all if not set.
|
|
|
|
"""
|
|
|
|
phaseId: ID
|
|
|
|
): [Wave]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Represents a Unix Timestamp. Supports up to 53 bit int values,
|
|
|
|
as that is JavaScript's internal memory allocation for integer values.
|
|
|
|
"""
|
|
|
|
scalar Timestamp
|
|
|
|
|
|
|
|
input EventEntrantPageQuery {
|
|
|
|
page: Int
|
|
|
|
perPage: Int
|
|
|
|
sortBy: String
|
|
|
|
filter: EventEntrantPageQueryFilter
|
|
|
|
}
|
|
|
|
|
|
|
|
input EventEntrantPageQueryFilter {
|
|
|
|
name: String
|
|
|
|
}
|
|
|
|
|
|
|
|
type EntrantConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [Entrant]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
An entrant in an event
|
|
|
|
"""
|
|
|
|
type Entrant {
|
|
|
|
id: ID
|
|
|
|
event: Event
|
|
|
|
"""
|
|
|
|
Entrant's seed number in the first phase of the event.
|
|
|
|
"""
|
|
|
|
initialSeedNum: Int
|
|
|
|
isDisqualified: Boolean
|
|
|
|
"""
|
|
|
|
The entrant name as it appears in bracket: gamerTag of the participant or team name
|
|
|
|
"""
|
|
|
|
name: String
|
|
|
|
"""
|
|
|
|
Paginated sets for this entrant
|
|
|
|
"""
|
|
|
|
paginatedSets(
|
|
|
|
page: Int
|
|
|
|
perPage: Int
|
|
|
|
"""
|
|
|
|
How to sort these sets
|
|
|
|
"""
|
|
|
|
sortType: SetSortType
|
|
|
|
"""
|
|
|
|
Supported filter options to filter down set results.
|
|
|
|
"""
|
|
|
|
filters: SetFilters
|
|
|
|
): SetConnection
|
|
|
|
participants: [Participant]
|
|
|
|
seeds: [Seed]
|
|
|
|
skill: Int
|
|
|
|
"""
|
|
|
|
Standing for this entrant given an event. All entrants queried must be in the same event (for now).
|
|
|
|
"""
|
|
|
|
standing: Standing
|
2024-08-14 20:44:08 -04:00
|
|
|
stream: Streams @deprecated(reason: "DEPRECATED. Use streams instead, which supports multiple stream types and teams.")
|
2023-08-26 17:43:01 -04:00
|
|
|
streams: [Streams]
|
|
|
|
"""
|
|
|
|
Team linked to this entrant, if one exists
|
|
|
|
"""
|
|
|
|
team: Team
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Different sort type configurations used when displaying multiple sets
|
|
|
|
"""
|
|
|
|
enum SetSortType {
|
|
|
|
"""
|
|
|
|
Sets will not be sorted.
|
|
|
|
"""
|
|
|
|
NONE
|
|
|
|
"""
|
|
|
|
Sets are sorted in the suggested order that they be called to be played. The order of completed sets is reversed.
|
|
|
|
"""
|
|
|
|
CALL_ORDER
|
|
|
|
"""
|
|
|
|
Sets are sorted by relevancy dependent on the state and progress of the event.
|
|
|
|
"""
|
|
|
|
MAGIC
|
|
|
|
"""
|
|
|
|
Sets are sorted in the order that they were started.
|
|
|
|
"""
|
|
|
|
RECENT
|
|
|
|
"""
|
|
|
|
Deprecated. This is equivalent to CALL_ORDER
|
|
|
|
"""
|
|
|
|
STANDARD
|
|
|
|
"""
|
|
|
|
Sets sorted by round and identifier
|
|
|
|
"""
|
|
|
|
ROUND
|
|
|
|
}
|
|
|
|
|
|
|
|
input SetFilters {
|
|
|
|
"""
|
|
|
|
Only return Sets for these Entrants
|
|
|
|
"""
|
|
|
|
entrantIds: [ID]
|
|
|
|
"""
|
|
|
|
Only return Sets for this Entrant size. For example, to fetch 1v1 Sets only, filter by an entrantSize of 1
|
|
|
|
"""
|
|
|
|
entrantSize: [Int]
|
|
|
|
"""
|
|
|
|
Only return Sets that have an attached VOD
|
|
|
|
"""
|
|
|
|
hasVod: Boolean
|
|
|
|
"""
|
|
|
|
Do not return empty Sets. For example, set this to true to filter out sets that are waiting for progressions.
|
|
|
|
"""
|
|
|
|
hideEmpty: Boolean
|
|
|
|
"""
|
|
|
|
Return sets that contain a bye
|
|
|
|
"""
|
|
|
|
showByes: Boolean
|
|
|
|
"""
|
|
|
|
Only return Sets that are in an Online event. If omitted, Sets for both online and offline Events are returned
|
|
|
|
"""
|
|
|
|
isEventOnline: Boolean
|
|
|
|
"""
|
|
|
|
Only return Sets in certain geographical areas.
|
|
|
|
"""
|
|
|
|
location: SetFilterLocation
|
|
|
|
"""
|
|
|
|
Only return Sets for these Participants
|
|
|
|
"""
|
|
|
|
participantIds: [ID]
|
|
|
|
"""
|
|
|
|
Only return Sets in these PhaseGroups
|
|
|
|
"""
|
|
|
|
phaseGroupIds: [ID]
|
|
|
|
"""
|
|
|
|
Only return Sets in these Phases
|
|
|
|
"""
|
|
|
|
phaseIds: [ID]
|
|
|
|
"""
|
|
|
|
Only return Sets in these Events
|
|
|
|
"""
|
|
|
|
eventIds: [ID]
|
|
|
|
"""
|
|
|
|
Only return Sets in these Tournaments
|
|
|
|
"""
|
|
|
|
tournamentIds: [ID]
|
|
|
|
"""
|
|
|
|
Only return Sets for these Players
|
|
|
|
"""
|
|
|
|
playerIds: [ID]
|
|
|
|
"""
|
|
|
|
Only return Sets for these Rounds
|
|
|
|
"""
|
|
|
|
roundNumber: Int
|
|
|
|
"""
|
|
|
|
Only returns Sets that are in these states
|
|
|
|
"""
|
|
|
|
state: [Int]
|
|
|
|
"""
|
|
|
|
Only return Sets that are assigned to these Station IDs
|
|
|
|
"""
|
|
|
|
stationIds: [ID]
|
|
|
|
"""
|
|
|
|
Only return Sets that are assigned to these Station numbers
|
|
|
|
"""
|
|
|
|
stationNumbers: [Int]
|
|
|
|
"""
|
|
|
|
Only return sets created or updated since this timestamp
|
|
|
|
"""
|
|
|
|
updatedAfter: Timestamp
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Filter Sets by geographical constraints.
|
|
|
|
"""
|
|
|
|
input SetFilterLocation {
|
|
|
|
"""
|
|
|
|
Only return Sets in this state. Only applicable to US states
|
|
|
|
"""
|
|
|
|
state: String
|
|
|
|
"""
|
|
|
|
Only return Sets in this country. Expects a valid two-letter country code
|
|
|
|
"""
|
|
|
|
country: String
|
|
|
|
distanceFrom: SetFilterLocationDistanceFrom
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Only return Sets that are a certain distance away from a specified point
|
|
|
|
"""
|
|
|
|
input SetFilterLocationDistanceFrom {
|
|
|
|
"""
|
|
|
|
Point at which to perform distance calculation
|
|
|
|
"""
|
|
|
|
point: SetFilterLocationDistanceFromPoint
|
|
|
|
"""
|
|
|
|
Distance from the point to include results in
|
|
|
|
"""
|
|
|
|
radius: String
|
|
|
|
}
|
|
|
|
|
|
|
|
input SetFilterLocationDistanceFromPoint {
|
|
|
|
lat: Float
|
|
|
|
lon: Float
|
|
|
|
}
|
|
|
|
|
|
|
|
type SetConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [Set]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A set
|
|
|
|
"""
|
|
|
|
type Set {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
The time this set was marked as completed
|
|
|
|
"""
|
|
|
|
completedAt: Timestamp
|
|
|
|
"""
|
|
|
|
The time this set was created
|
|
|
|
"""
|
|
|
|
createdAt: Timestamp
|
|
|
|
displayScore(mainEntrantId: ID): String
|
|
|
|
"""
|
|
|
|
Event that this set belongs to.
|
|
|
|
"""
|
|
|
|
event: Event
|
|
|
|
"""
|
|
|
|
Full round text of this set.
|
|
|
|
"""
|
|
|
|
fullRoundText: String
|
|
|
|
game(orderNum: Int!): Game
|
|
|
|
games: [Game]
|
|
|
|
"""
|
|
|
|
Whether this set contains a placeholder entrant
|
|
|
|
"""
|
|
|
|
hasPlaceholder: Boolean
|
|
|
|
"""
|
|
|
|
The letters that describe a unique identifier within the pool. Eg. F, AT
|
|
|
|
"""
|
|
|
|
identifier: String
|
|
|
|
images(type: String): [Image]
|
|
|
|
lPlacement: Int
|
|
|
|
"""
|
|
|
|
Phase group that this Set belongs to.
|
|
|
|
"""
|
|
|
|
phaseGroup: PhaseGroup
|
|
|
|
"""
|
2024-08-14 20:44:08 -04:00
|
|
|
The sets that are affected from resetting this set
|
|
|
|
"""
|
|
|
|
resetAffectedData: ResetAffectedData
|
|
|
|
"""
|
2023-08-26 17:43:01 -04:00
|
|
|
The round number of the set. Negative numbers are losers bracket
|
|
|
|
"""
|
|
|
|
round: Int
|
|
|
|
"""
|
|
|
|
Indicates whether the set is in best of or total games mode. This instructs
|
|
|
|
which field is used to figure out how many games are in this set.
|
|
|
|
"""
|
|
|
|
setGamesType: Int
|
|
|
|
"""
|
|
|
|
A possible spot in a set. Use this to get all entrants in a set. Use this for all bracket types (FFA, elimination, etc)
|
|
|
|
"""
|
|
|
|
slots(includeByes: Boolean = false): [SetSlot]
|
|
|
|
"""
|
|
|
|
The start time of the Set. If there is no startAt time on the Set, will pull it from phaseGroup rounds configuration.
|
|
|
|
"""
|
|
|
|
startAt: Timestamp
|
|
|
|
startedAt: Timestamp
|
|
|
|
state: Int
|
|
|
|
"""
|
|
|
|
Tournament event station for a set
|
|
|
|
"""
|
|
|
|
station: Stations
|
|
|
|
"""
|
|
|
|
Tournament event stream for a set
|
|
|
|
"""
|
|
|
|
stream: Streams
|
|
|
|
"""
|
|
|
|
If setGamesType is in total games mode, this defined the number of games in the set.
|
|
|
|
"""
|
|
|
|
totalGames: Int
|
|
|
|
"""
|
|
|
|
Url of a VOD for this set
|
|
|
|
"""
|
|
|
|
vodUrl: String
|
|
|
|
wPlacement: Int
|
|
|
|
winnerId: Int
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A game represents a single game within a set.
|
|
|
|
"""
|
|
|
|
type Game {
|
|
|
|
id: ID
|
2024-08-14 20:44:08 -04:00
|
|
|
"""
|
|
|
|
Score of entrant 1. For smash, this is equivalent to stocks remaining.
|
|
|
|
"""
|
|
|
|
entrant1Score: Int
|
|
|
|
"""
|
|
|
|
Score of entrant 2. For smash, this is equivalent to stocks remaining.
|
|
|
|
"""
|
|
|
|
entrant2Score: Int
|
2023-08-26 17:43:01 -04:00
|
|
|
images(type: String): [Image]
|
|
|
|
orderNum: Int
|
|
|
|
"""
|
|
|
|
Selections for this game such as character, etc.
|
|
|
|
"""
|
|
|
|
selections: [GameSelection]
|
|
|
|
"""
|
|
|
|
The stage that this game was played on (if applicable)
|
|
|
|
"""
|
|
|
|
stage: Stage
|
|
|
|
state: Int
|
|
|
|
winnerId: Int
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
An image
|
|
|
|
"""
|
|
|
|
type Image {
|
|
|
|
id: ID
|
|
|
|
height: Float
|
|
|
|
ratio: Float
|
|
|
|
type: String
|
|
|
|
url: String
|
|
|
|
width: Float
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A selection for this game. i.e. character/stage selection, etc
|
|
|
|
"""
|
|
|
|
type GameSelection {
|
2024-08-14 20:44:08 -04:00
|
|
|
"""
|
|
|
|
If this is a character selection, returns the selected character.
|
|
|
|
"""
|
|
|
|
character: Character
|
2023-08-26 17:43:01 -04:00
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
The entrant who this selection is for
|
|
|
|
"""
|
|
|
|
entrant: Entrant
|
|
|
|
orderNum: Int
|
|
|
|
"""
|
|
|
|
The participant who this selection is for. This is only populated if there are
|
|
|
|
selections for multiple participants of a single entrant
|
|
|
|
"""
|
|
|
|
participant: Participant
|
|
|
|
selectionType: GameSelectionType
|
|
|
|
selectionValue: Int
|
|
|
|
}
|
|
|
|
|
2024-08-14 20:44:08 -04:00
|
|
|
"""
|
|
|
|
A character in a videogame
|
|
|
|
"""
|
|
|
|
type Character {
|
|
|
|
id: ID
|
|
|
|
images(type: String): [Image]
|
|
|
|
"""
|
|
|
|
Name of Character
|
|
|
|
"""
|
|
|
|
name: String
|
|
|
|
}
|
|
|
|
|
2023-08-26 17:43:01 -04:00
|
|
|
"""
|
|
|
|
A participant of a tournament; either a spectator or competitor
|
|
|
|
"""
|
|
|
|
type Participant {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
If this participant was checked-in by admin
|
|
|
|
"""
|
|
|
|
checkedIn: Boolean
|
|
|
|
"""
|
|
|
|
The time this participant was checked-in by admin
|
|
|
|
"""
|
|
|
|
checkedInAt: Timestamp
|
|
|
|
"""
|
|
|
|
Info for connected accounts to external services.
|
|
|
|
"""
|
|
|
|
connectedAccounts: JSON
|
|
|
|
"""
|
|
|
|
Contact Info selected during registration. Falls back to User.location and/or
|
|
|
|
User.name if necessary. These fields are for admin use only. If you are not a
|
|
|
|
tournament admin or the participant being queried, these fields will be null.
|
|
|
|
Do not display this information publicly.
|
|
|
|
"""
|
|
|
|
contactInfo: ContactInfo
|
|
|
|
"""
|
|
|
|
Email of the user, only available to admins within 18 months of tournament completion for tournament administrators.
|
|
|
|
"""
|
|
|
|
email: String
|
|
|
|
"""
|
|
|
|
Entrants associated with this Participant, if applicable
|
|
|
|
"""
|
|
|
|
entrants: [Entrant]
|
|
|
|
"""
|
|
|
|
The events this participant registered for within a Tournament.
|
|
|
|
"""
|
|
|
|
events: [Event]
|
|
|
|
"""
|
|
|
|
The tag that was used when the participant registered, e.g. Mang0
|
|
|
|
"""
|
|
|
|
gamerTag: String
|
|
|
|
images(type: String): [Image]
|
|
|
|
player: Player
|
|
|
|
"""
|
|
|
|
The prefix that the user set for this Tournament, e.g. C9
|
|
|
|
"""
|
|
|
|
prefix: String
|
|
|
|
"""
|
|
|
|
Tournament Admin viewable field. Shows details for required social connections
|
|
|
|
"""
|
|
|
|
requiredConnections: [ProfileAuthorization]
|
|
|
|
"""
|
|
|
|
The user this participant is associated to.
|
|
|
|
"""
|
|
|
|
user: User
|
|
|
|
"""
|
|
|
|
If this participant is verified as actually being in the tournament
|
|
|
|
"""
|
|
|
|
verified: Boolean
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Name, address, etc
|
|
|
|
"""
|
|
|
|
type ContactInfo {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
Participant City Name
|
|
|
|
"""
|
|
|
|
city: String
|
|
|
|
"""
|
|
|
|
Participant Country Name
|
|
|
|
"""
|
|
|
|
country: String
|
|
|
|
"""
|
|
|
|
Participant Country (region) id
|
|
|
|
"""
|
|
|
|
countryId: Int
|
|
|
|
name: String
|
|
|
|
"""
|
|
|
|
First Name
|
|
|
|
"""
|
|
|
|
nameFirst: String
|
|
|
|
"""
|
|
|
|
Last Name
|
|
|
|
"""
|
|
|
|
nameLast: String
|
|
|
|
"""
|
|
|
|
Participant State Name
|
|
|
|
"""
|
|
|
|
state: String
|
|
|
|
"""
|
|
|
|
Participant State (region) id
|
|
|
|
"""
|
|
|
|
stateId: Int
|
|
|
|
"""
|
|
|
|
Zip or Postal Code
|
|
|
|
"""
|
|
|
|
zipcode: String
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A player
|
|
|
|
"""
|
|
|
|
type Player {
|
|
|
|
id: ID
|
|
|
|
gamerTag: String
|
|
|
|
prefix: String
|
|
|
|
"""
|
|
|
|
Most recent active & published rankings
|
|
|
|
"""
|
|
|
|
rankings(limit: Int, videogameId: ID): [PlayerRank]
|
|
|
|
"""
|
2024-08-14 20:44:08 -04:00
|
|
|
Recent sets for this player.
|
|
|
|
"""
|
|
|
|
recentSets(
|
|
|
|
"""
|
|
|
|
Use this to get H2H history between two players
|
|
|
|
"""
|
|
|
|
opponentId: ID
|
|
|
|
): [Set] @deprecated(reason: "Use the sets field instead.")
|
|
|
|
"""
|
2023-08-26 17:43:01 -04:00
|
|
|
Recent standings
|
|
|
|
"""
|
|
|
|
recentStandings(
|
|
|
|
videogameId: ID
|
|
|
|
"""
|
|
|
|
Number of recent standings to fetch. Default value is 3. Maximum value is 20.
|
|
|
|
"""
|
|
|
|
limit: Int
|
|
|
|
): [Standing]
|
|
|
|
"""
|
|
|
|
Set history for this player.
|
|
|
|
"""
|
|
|
|
sets(
|
|
|
|
page: Int
|
|
|
|
perPage: Int
|
|
|
|
"""
|
|
|
|
Supported filter options to filter down set results.
|
|
|
|
"""
|
|
|
|
filters: SetFilters
|
|
|
|
): SetConnection
|
|
|
|
user: User
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A player's ranks
|
|
|
|
"""
|
|
|
|
type PlayerRank {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
The player's placement on the ranking
|
|
|
|
"""
|
|
|
|
rank: Int
|
|
|
|
title: String
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A standing indicates the placement of something within a container.
|
|
|
|
"""
|
|
|
|
type Standing {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
The containing entity that contextualizes this standing. Event standings, for
|
|
|
|
example, represent an entrant's standing in the entire event vs. Set standings
|
|
|
|
which is an entrant's standing in only a single set within an event.
|
|
|
|
"""
|
|
|
|
container: StandingContainer
|
|
|
|
"""
|
|
|
|
If the entity this standing is assigned to can be resolved into an entrant, this will provide the entrant.
|
|
|
|
"""
|
|
|
|
entrant: Entrant
|
|
|
|
isFinal: Boolean
|
|
|
|
"""
|
|
|
|
Metadata that goes along with this standing. Can take on different forms based on standing group type and settings.
|
|
|
|
"""
|
|
|
|
metadata: JSON
|
|
|
|
placement: Int
|
|
|
|
"""
|
|
|
|
The player(s) tied to this standing's entity
|
|
|
|
"""
|
|
|
|
player: Player
|
2024-08-14 20:44:08 -04:00
|
|
|
standing: Int @deprecated(reason: "The \"placement\" field is identical and will eventually replace \"standing\"")
|
2023-08-26 17:43:01 -04:00
|
|
|
stats: StandingStats
|
|
|
|
totalPoints: Float
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
The containing entity that this standing is for
|
|
|
|
"""
|
|
|
|
union StandingContainer = Tournament | Event | PhaseGroup | Set
|
|
|
|
|
|
|
|
"""
|
|
|
|
A tournament
|
|
|
|
"""
|
|
|
|
type Tournament {
|
|
|
|
id: ID
|
|
|
|
addrState: String
|
|
|
|
"""
|
|
|
|
Admin-only view of admins for this tournament
|
|
|
|
"""
|
|
|
|
admins(
|
|
|
|
"""
|
|
|
|
Which roles to show
|
|
|
|
"""
|
|
|
|
roles: [String]
|
|
|
|
): [User]
|
|
|
|
city: String
|
|
|
|
countryCode: String
|
|
|
|
"""
|
|
|
|
When the tournament was created (unix timestamp)
|
|
|
|
"""
|
|
|
|
createdAt: Timestamp
|
|
|
|
currency: String
|
|
|
|
"""
|
|
|
|
When the tournament ends
|
|
|
|
"""
|
|
|
|
endAt: Timestamp
|
|
|
|
"""
|
|
|
|
When does event registration close
|
|
|
|
"""
|
|
|
|
eventRegistrationClosesAt: Timestamp
|
|
|
|
events(limit: Int, filter: EventFilter): [Event]
|
|
|
|
"""
|
|
|
|
True if tournament has at least one offline event
|
|
|
|
"""
|
|
|
|
hasOfflineEvents: Boolean
|
|
|
|
hasOnlineEvents: Boolean
|
|
|
|
hashtag: String
|
|
|
|
images(type: String): [Image]
|
|
|
|
"""
|
|
|
|
True if tournament has at least one online event
|
|
|
|
"""
|
|
|
|
isOnline: Boolean
|
|
|
|
"""
|
|
|
|
Is tournament registration open
|
|
|
|
"""
|
|
|
|
isRegistrationOpen: Boolean
|
|
|
|
lat: Float
|
|
|
|
links: TournamentLinks
|
|
|
|
lng: Float
|
|
|
|
mapsPlaceId: String
|
|
|
|
"""
|
|
|
|
The tournament name
|
|
|
|
"""
|
|
|
|
name: String
|
|
|
|
"""
|
|
|
|
Number of attendees including spectators, if public
|
|
|
|
"""
|
|
|
|
numAttendees: Int
|
|
|
|
"""
|
|
|
|
The user who created the tournament
|
|
|
|
"""
|
|
|
|
owner: User
|
|
|
|
"""
|
|
|
|
Paginated, queryable list of participants
|
|
|
|
"""
|
|
|
|
participants(query: ParticipantPaginationQuery!, isAdmin: Boolean): ParticipantConnection
|
|
|
|
postalCode: String
|
|
|
|
primaryContact: String
|
|
|
|
primaryContactType: String
|
|
|
|
"""
|
|
|
|
Publishing settings for this tournament
|
|
|
|
"""
|
|
|
|
publishing: JSON
|
|
|
|
"""
|
|
|
|
When does registration for the tournament end
|
|
|
|
"""
|
|
|
|
registrationClosesAt: Timestamp
|
|
|
|
rules: String
|
|
|
|
"""
|
|
|
|
The short slug used to form the url
|
|
|
|
"""
|
|
|
|
shortSlug: String
|
|
|
|
"""
|
|
|
|
The slug used to form the url
|
|
|
|
"""
|
|
|
|
slug: String
|
|
|
|
"""
|
|
|
|
When the tournament Starts
|
|
|
|
"""
|
|
|
|
startAt: Timestamp
|
|
|
|
"""
|
|
|
|
State of the tournament, can be ActivityState::CREATED, ActivityState::ACTIVE, or ActivityState::COMPLETED
|
|
|
|
"""
|
|
|
|
state: Int
|
|
|
|
stations(page: Int, perPage: Int): StationsConnection
|
|
|
|
streamQueue: [StreamQueue]
|
|
|
|
streams: [Streams]
|
|
|
|
"""
|
|
|
|
When is the team creation deadline
|
|
|
|
"""
|
|
|
|
teamCreationClosesAt: Timestamp
|
|
|
|
"""
|
|
|
|
Paginated, queryable list of teams
|
|
|
|
"""
|
|
|
|
teams(query: TeamPaginationQuery!): TeamConnection
|
|
|
|
"""
|
|
|
|
The timezone of the tournament
|
|
|
|
"""
|
|
|
|
timezone: String
|
|
|
|
"""
|
|
|
|
The type of tournament from TournamentType
|
|
|
|
"""
|
|
|
|
tournamentType: Int
|
|
|
|
"""
|
|
|
|
When the tournament was last modified (unix timestamp)
|
|
|
|
"""
|
|
|
|
updatedAt: Timestamp
|
|
|
|
"""
|
|
|
|
Build Tournament URL
|
|
|
|
"""
|
|
|
|
url(
|
|
|
|
"""
|
|
|
|
Tournament tab to add to URL
|
|
|
|
"""
|
|
|
|
tab: String
|
|
|
|
"""
|
|
|
|
Generate a relative URL. Defaults to true. Setting to false will generate an absolute URL
|
|
|
|
"""
|
|
|
|
relative: Boolean = true
|
|
|
|
): String
|
|
|
|
venueAddress: String
|
|
|
|
venueName: String
|
|
|
|
"""
|
|
|
|
List of all waves in this tournament
|
|
|
|
"""
|
|
|
|
waves: [Wave]
|
|
|
|
}
|
|
|
|
|
|
|
|
input EventFilter {
|
|
|
|
videogameId: [ID]
|
|
|
|
type: [Int]
|
|
|
|
published: Boolean
|
|
|
|
id: ID
|
|
|
|
ids: [ID]
|
|
|
|
slug: String
|
|
|
|
fantasyEventId: ID
|
|
|
|
fantasyRosterHash: String
|
|
|
|
}
|
|
|
|
|
|
|
|
type TournamentLinks {
|
|
|
|
facebook: String
|
|
|
|
discord: String
|
|
|
|
}
|
|
|
|
|
|
|
|
input ParticipantPaginationQuery {
|
|
|
|
page: Int = 1
|
|
|
|
"""
|
|
|
|
How many nodes to return for the page. Maximum value of 500
|
|
|
|
"""
|
|
|
|
perPage: Int = 25
|
|
|
|
sortBy: String
|
|
|
|
filter: ParticipantPageFilter
|
|
|
|
}
|
|
|
|
|
|
|
|
input ParticipantPageFilter {
|
|
|
|
id: ID
|
|
|
|
ids: [ID]
|
|
|
|
eventIds: [ID]
|
|
|
|
search: PaginationSearchType
|
|
|
|
gamerTag: String
|
|
|
|
unpaid: Boolean
|
|
|
|
incompleteTeam: Boolean
|
|
|
|
missingDeck: Boolean
|
|
|
|
checkedIn: Boolean
|
|
|
|
notCheckedIn: Boolean
|
|
|
|
}
|
|
|
|
|
|
|
|
type ParticipantConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [Participant]
|
|
|
|
}
|
|
|
|
|
|
|
|
type StationsConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [Stations]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Stations, such as a stream setup, at an event
|
|
|
|
"""
|
|
|
|
type Stations {
|
|
|
|
id: ID
|
|
|
|
canAutoAssign: Boolean
|
|
|
|
clusterNumber: String
|
|
|
|
clusterPrefix: Int
|
|
|
|
enabled: Boolean
|
|
|
|
identifier: Int
|
|
|
|
numSetups: Int
|
|
|
|
number: Int
|
|
|
|
prefix: String
|
|
|
|
queue: JSON
|
|
|
|
queueDepth: Int
|
|
|
|
state: Int
|
|
|
|
updatedAt: Timestamp
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A Stream queue object
|
|
|
|
"""
|
|
|
|
type StreamQueue {
|
|
|
|
id: String
|
|
|
|
"""
|
|
|
|
The sets on the stream
|
|
|
|
"""
|
|
|
|
sets: [Set]
|
|
|
|
"""
|
|
|
|
The stream on the queue
|
|
|
|
"""
|
|
|
|
stream: Streams
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Tournament Stream
|
|
|
|
"""
|
|
|
|
type Streams {
|
|
|
|
id: ID
|
|
|
|
enabled: Boolean
|
|
|
|
followerCount: Int
|
|
|
|
isOnline: Boolean
|
|
|
|
numSetups: Int
|
|
|
|
parentStreamId: Int
|
|
|
|
streamGame: String
|
|
|
|
streamId: String
|
|
|
|
streamLogo: String
|
|
|
|
streamName: String
|
|
|
|
streamSource: StreamSource
|
|
|
|
streamStatus: String
|
|
|
|
streamType: Int
|
|
|
|
streamTypeId: Int
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Represents the source of a stream
|
|
|
|
"""
|
|
|
|
enum StreamSource {
|
|
|
|
"""
|
|
|
|
Stream is on twitch.tv channel
|
|
|
|
"""
|
|
|
|
TWITCH
|
|
|
|
"""
|
|
|
|
Stream is on smashcast.tv channel
|
|
|
|
"""
|
|
|
|
HITBOX
|
|
|
|
"""
|
|
|
|
Stream is on a stream.me channel
|
|
|
|
"""
|
|
|
|
STREAMME
|
|
|
|
"""
|
|
|
|
Stream is on a mixer.com channel
|
|
|
|
"""
|
|
|
|
MIXER
|
2024-08-14 20:44:08 -04:00
|
|
|
"""
|
|
|
|
Stream is on a youtube.com channel
|
|
|
|
"""
|
|
|
|
YOUTUBE
|
2023-08-26 17:43:01 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
input TeamPaginationQuery {
|
|
|
|
page: Int = 1
|
|
|
|
"""
|
|
|
|
How many nodes to return for the page. Maximum value of 500
|
|
|
|
"""
|
|
|
|
perPage: Int = 25
|
|
|
|
sortBy: String
|
|
|
|
filter: TeamPaginationFilter
|
|
|
|
}
|
|
|
|
|
|
|
|
input TeamPaginationFilter {
|
|
|
|
globalTeamId: ID
|
|
|
|
eventState: ActivityState
|
|
|
|
eventId: ID
|
|
|
|
eventIds: [ID]
|
|
|
|
minEntrantCount: Int
|
|
|
|
maxEntrantCount: Int
|
|
|
|
search: PaginationSearchType
|
|
|
|
type: Int
|
|
|
|
tournamentId: ID
|
|
|
|
memberStatus: [TeamMemberStatus]
|
|
|
|
videogameId: [ID]
|
|
|
|
isLeague: Boolean
|
|
|
|
upcoming: Boolean
|
|
|
|
past: Boolean
|
|
|
|
rosterComplete: Boolean
|
|
|
|
rosterIncomplete: Boolean
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Represents the state of an activity
|
|
|
|
"""
|
|
|
|
enum ActivityState {
|
|
|
|
"""
|
|
|
|
Activity is created
|
|
|
|
"""
|
|
|
|
CREATED
|
|
|
|
"""
|
|
|
|
Activity is active or in progress
|
|
|
|
"""
|
|
|
|
ACTIVE
|
|
|
|
"""
|
|
|
|
Activity is done
|
|
|
|
"""
|
|
|
|
COMPLETED
|
|
|
|
"""
|
|
|
|
Activity is ready to be started
|
|
|
|
"""
|
|
|
|
READY
|
|
|
|
"""
|
|
|
|
Activity is invalid
|
|
|
|
"""
|
|
|
|
INVALID
|
|
|
|
"""
|
|
|
|
Activity, like a set, has been called to start
|
|
|
|
"""
|
|
|
|
CALLED
|
|
|
|
"""
|
|
|
|
Activity is queued to run
|
|
|
|
"""
|
|
|
|
QUEUED
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Membership status of a team member
|
|
|
|
"""
|
|
|
|
enum TeamMemberStatus {
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
UNKNOWN
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
ACCEPTED
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
INVITED
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
REQUEST
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
ALUM
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
HIATUS
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
OPEN_SPOT
|
|
|
|
}
|
|
|
|
|
|
|
|
type TeamConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [Team]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A team, either at the global level or within the context of an event
|
|
|
|
"""
|
|
|
|
interface Team {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
Uniquely identifying token for team. Same as the hashed part of the slug
|
|
|
|
"""
|
|
|
|
discriminator: String
|
2024-08-14 20:44:08 -04:00
|
|
|
entrant: Entrant @deprecated(reason: "Use the entrant field off the EventTeam type")
|
|
|
|
event: Event @deprecated(reason: "Use the event field off the EventTeam type")
|
2023-08-26 17:43:01 -04:00
|
|
|
images(type: String): [Image]
|
|
|
|
members(status: [TeamMemberStatus]): [TeamMember]
|
|
|
|
name: String
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A member of a team
|
|
|
|
"""
|
|
|
|
type TeamMember {
|
|
|
|
id: ID
|
|
|
|
isAlternate: Boolean
|
|
|
|
isCaptain: Boolean
|
|
|
|
"""
|
|
|
|
The type of the team member
|
|
|
|
"""
|
|
|
|
memberType: TeamMemberType
|
|
|
|
participant: Participant
|
|
|
|
player: Player
|
|
|
|
"""
|
|
|
|
The status of the team member
|
|
|
|
"""
|
|
|
|
status: TeamMemberStatus
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Membership type of a team member
|
|
|
|
"""
|
|
|
|
enum TeamMemberType {
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
PLAYER
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
STAFF
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A wave in a tournament
|
|
|
|
"""
|
|
|
|
type Wave {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
The Wave Identifier
|
|
|
|
"""
|
|
|
|
identifier: String
|
|
|
|
"""
|
|
|
|
Unix time the wave is scheduled to start.
|
|
|
|
"""
|
|
|
|
startAt: Timestamp
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A group within a phase
|
|
|
|
"""
|
|
|
|
type PhaseGroup {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
The bracket type of this group's phase.
|
|
|
|
"""
|
|
|
|
bracketType: BracketType
|
|
|
|
"""
|
|
|
|
URL for this phase groups's bracket.
|
|
|
|
"""
|
|
|
|
bracketUrl: String
|
|
|
|
"""
|
|
|
|
Unique identifier for this group within the context of its phase
|
|
|
|
"""
|
|
|
|
displayIdentifier: String
|
|
|
|
"""
|
|
|
|
For the given phase group, this is the start time of the first round that occurs in the group.
|
|
|
|
"""
|
|
|
|
firstRoundTime: Timestamp
|
|
|
|
numRounds: Int
|
2024-08-14 20:44:08 -04:00
|
|
|
paginatedSeeds(query: SeedPaginationQuery!, eventId: ID): SeedConnection @deprecated(reason: "Please use 'seeds', which is now paginated")
|
|
|
|
"""
|
|
|
|
Paginated sets on this phaseGroup
|
|
|
|
"""
|
|
|
|
paginatedSets(
|
|
|
|
page: Int
|
|
|
|
perPage: Int
|
|
|
|
"""
|
|
|
|
How to sort these sets
|
|
|
|
"""
|
|
|
|
sortType: SetSortType
|
|
|
|
"""
|
|
|
|
Supported filter options to filter down set results.
|
|
|
|
"""
|
|
|
|
filters: SetFilters
|
|
|
|
): SetConnection @deprecated(reason: "Please use 'sets', which is now paginated")
|
2023-08-26 17:43:01 -04:00
|
|
|
"""
|
|
|
|
The phase associated with this phase group
|
|
|
|
"""
|
|
|
|
phase: Phase
|
|
|
|
"""
|
|
|
|
The progressions out of this phase group
|
|
|
|
"""
|
|
|
|
progressionsOut: [Progression]
|
|
|
|
rounds: [Round]
|
|
|
|
seedMap: JSON
|
|
|
|
"""
|
|
|
|
Paginated seeds for this phase group
|
|
|
|
"""
|
|
|
|
seeds(query: SeedPaginationQuery!, eventId: ID): SeedConnection
|
|
|
|
"""
|
|
|
|
Paginated sets on this phaseGroup
|
|
|
|
"""
|
|
|
|
sets(
|
|
|
|
page: Int
|
|
|
|
perPage: Int
|
|
|
|
"""
|
|
|
|
How to sort these sets
|
|
|
|
"""
|
|
|
|
sortType: SetSortType
|
|
|
|
"""
|
|
|
|
Supported filter options to filter down set results.
|
|
|
|
"""
|
|
|
|
filters: SetFilters
|
|
|
|
): SetConnection
|
|
|
|
"""
|
|
|
|
Paginated list of standings
|
|
|
|
"""
|
|
|
|
standings(query: StandingGroupStandingPageFilter): StandingConnection
|
|
|
|
"""
|
|
|
|
Unix time the group is scheduled to start. This info could also be on the wave instead.
|
|
|
|
"""
|
|
|
|
startAt: Timestamp
|
|
|
|
state: Int
|
|
|
|
tiebreakOrder: JSON
|
|
|
|
wave: Wave
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
The type of Bracket format that a Phase is configured with.
|
|
|
|
"""
|
|
|
|
enum BracketType {
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
SINGLE_ELIMINATION
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
DOUBLE_ELIMINATION
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
ROUND_ROBIN
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
SWISS
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
EXHIBITION
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
CUSTOM_SCHEDULE
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
MATCHMAKING
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
ELIMINATION_ROUNDS
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
RACE
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
CIRCUIT
|
|
|
|
}
|
|
|
|
|
|
|
|
input SeedPaginationQuery {
|
|
|
|
page: Int = 1
|
|
|
|
"""
|
|
|
|
How many nodes to return for the page. Maximum value of 500
|
|
|
|
"""
|
|
|
|
perPage: Int = 25
|
|
|
|
sortBy: String
|
|
|
|
filter: SeedPageFilter
|
|
|
|
}
|
|
|
|
|
|
|
|
input SeedPageFilter {
|
|
|
|
id: ID
|
|
|
|
entrantName: String
|
|
|
|
checkInState: [Int]
|
|
|
|
phaseGroupId: [ID]
|
|
|
|
eventCheckInGroupId: ID
|
|
|
|
phaseId: [ID]
|
|
|
|
eventId: ID
|
|
|
|
search: PaginationSearchType
|
|
|
|
}
|
|
|
|
|
|
|
|
type SeedConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [Seed]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A seed for an entrant
|
|
|
|
"""
|
|
|
|
type Seed {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
Map of Participant ID to checked in boolean
|
|
|
|
"""
|
|
|
|
checkedInParticipants: JSON
|
|
|
|
entrant: Entrant
|
|
|
|
groupSeedNum: Int
|
|
|
|
isBye: Boolean
|
|
|
|
phase: Phase
|
|
|
|
phaseGroup: PhaseGroup
|
|
|
|
placeholderName: String
|
|
|
|
placement: Int
|
|
|
|
"""
|
|
|
|
The player(s) associated with this seed's entrant
|
|
|
|
"""
|
|
|
|
players: [Player]
|
|
|
|
progressionSeedId: Int
|
|
|
|
"""
|
|
|
|
Source progression information
|
|
|
|
"""
|
|
|
|
progressionSource: Progression
|
|
|
|
seedNum: Int
|
|
|
|
"""
|
|
|
|
Entrant's win/loss record for this standing. Scores do not include byes.
|
|
|
|
"""
|
|
|
|
setRecordWithoutByes(phaseGroupId: ID!): JSON
|
|
|
|
standings(
|
|
|
|
"""
|
|
|
|
The container of the standing groups to get standings for. If null, will return all standings.
|
|
|
|
"""
|
|
|
|
containerType: String
|
|
|
|
): [Standing]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A phase in an event
|
|
|
|
"""
|
|
|
|
type Phase {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
The bracket type of this phase.
|
|
|
|
"""
|
|
|
|
bracketType: BracketType
|
|
|
|
"""
|
|
|
|
The Event that this phase belongs to
|
|
|
|
"""
|
|
|
|
event: Event
|
|
|
|
"""
|
|
|
|
Number of phase groups in this phase
|
|
|
|
"""
|
|
|
|
groupCount: Int
|
|
|
|
"""
|
|
|
|
Is the phase an exhibition or not.
|
|
|
|
"""
|
|
|
|
isExhibition: Boolean
|
|
|
|
"""
|
|
|
|
Name of phase e.g. Round 1 Pools
|
|
|
|
"""
|
|
|
|
name: String
|
|
|
|
"""
|
|
|
|
The number of seeds this phase contains.
|
|
|
|
"""
|
|
|
|
numSeeds: Int
|
2024-08-14 20:44:08 -04:00
|
|
|
paginatedSeeds(query: SeedPaginationQuery!, eventId: ID): SeedConnection @deprecated(reason: "Please use 'seeds' instead")
|
2023-08-26 17:43:01 -04:00
|
|
|
"""
|
|
|
|
Phase groups under this phase, paginated
|
|
|
|
"""
|
|
|
|
phaseGroups(query: PhaseGroupPageQuery): PhaseGroupConnection
|
|
|
|
"""
|
|
|
|
The relative order of this phase within an event
|
|
|
|
"""
|
|
|
|
phaseOrder: Int
|
|
|
|
"""
|
|
|
|
Paginated seeds for this phase
|
|
|
|
"""
|
|
|
|
seeds(query: SeedPaginationQuery!, eventId: ID): SeedConnection
|
|
|
|
"""
|
|
|
|
Paginated sets for this Phase
|
|
|
|
"""
|
|
|
|
sets(
|
|
|
|
page: Int
|
|
|
|
perPage: Int
|
|
|
|
"""
|
|
|
|
How to sort these sets
|
|
|
|
"""
|
|
|
|
sortType: SetSortType
|
|
|
|
"""
|
|
|
|
Supported filter options to filter down set results.
|
|
|
|
"""
|
|
|
|
filters: SetFilters
|
|
|
|
): SetConnection
|
|
|
|
"""
|
|
|
|
State of the phase
|
|
|
|
"""
|
|
|
|
state: ActivityState
|
|
|
|
waves: [Wave]
|
|
|
|
}
|
|
|
|
|
|
|
|
input PhaseGroupPageQuery {
|
|
|
|
page: Int
|
|
|
|
perPage: Int
|
|
|
|
sortBy: String
|
|
|
|
entrantIds: [ID]
|
|
|
|
filter: PhaseGroupPageQueryFilter
|
|
|
|
}
|
|
|
|
|
|
|
|
input PhaseGroupPageQueryFilter {
|
|
|
|
id: [ID]
|
|
|
|
waveId: ID
|
|
|
|
}
|
|
|
|
|
|
|
|
type PhaseGroupConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [PhaseGroup]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A connection between a placement in an origin phase group to a destination seed.
|
|
|
|
"""
|
|
|
|
type Progression {
|
|
|
|
id: ID
|
|
|
|
originOrder: Int
|
|
|
|
originPhase: Phase
|
|
|
|
originPhaseGroup: PhaseGroup
|
|
|
|
originPlacement: Int
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A round within a phase group
|
|
|
|
"""
|
|
|
|
type Round {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
If applicable, bestOf is the number of games
|
|
|
|
one must win a majority out of to win a set in this round
|
|
|
|
"""
|
|
|
|
bestOf: Int
|
|
|
|
"""
|
|
|
|
Indicates this round's order in the phase group
|
|
|
|
"""
|
|
|
|
number: Int
|
|
|
|
"""
|
|
|
|
The time that this round is scheduled to start at
|
|
|
|
"""
|
|
|
|
startAt: Timestamp
|
|
|
|
}
|
|
|
|
|
|
|
|
input StandingGroupStandingPageFilter {
|
|
|
|
page: Int
|
|
|
|
perPage: Int
|
|
|
|
sortBy: String
|
|
|
|
}
|
|
|
|
|
|
|
|
type StandingConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [Standing]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Any stats related to this standing. This type is experimental and very likely to change in the future.
|
|
|
|
"""
|
|
|
|
type StandingStats {
|
|
|
|
score: Score
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
The score that led to this standing being awarded. The meaning of this field can
|
|
|
|
vary by standing type and is not used for some standing types.
|
|
|
|
"""
|
|
|
|
type Score {
|
|
|
|
"""
|
|
|
|
The name of this score. e.g. "Kills" or "Stocks"
|
|
|
|
"""
|
|
|
|
label: String
|
|
|
|
"""
|
|
|
|
The raw score value
|
|
|
|
"""
|
|
|
|
value: Float
|
|
|
|
"""
|
|
|
|
Like value, but formatted for race format events. Formatted according to the race config for the front end to use.
|
|
|
|
"""
|
|
|
|
displayValue: String
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
The type of selection i.e. is it for a character or something else
|
|
|
|
"""
|
|
|
|
enum GameSelectionType {
|
|
|
|
"""
|
|
|
|
Character selection
|
|
|
|
"""
|
|
|
|
CHARACTER
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Video Stage
|
|
|
|
"""
|
|
|
|
type Stage {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
Stage name
|
|
|
|
"""
|
|
|
|
name: String
|
|
|
|
}
|
|
|
|
|
2024-08-14 20:44:08 -04:00
|
|
|
type ResetAffectedData {
|
|
|
|
affectedSetCount: Int
|
|
|
|
affectedSets: [Set]
|
|
|
|
affectedPhaseGroupCount: Int
|
|
|
|
}
|
|
|
|
|
2023-08-26 17:43:01 -04:00
|
|
|
"""
|
|
|
|
A slot in a set where a seed currently or will eventually exist in order to participate in the set.
|
|
|
|
"""
|
|
|
|
type SetSlot {
|
|
|
|
id: ID
|
|
|
|
entrant: Entrant
|
|
|
|
"""
|
|
|
|
Pairs with prereqType, is the ID of the prereq.
|
|
|
|
"""
|
|
|
|
prereqId: String
|
|
|
|
"""
|
|
|
|
Given a set prereq type, defines the placement required in the origin set to end up in this slot.
|
|
|
|
"""
|
|
|
|
prereqPlacement: Int
|
|
|
|
"""
|
|
|
|
Describes where the entity in this slot comes from.
|
|
|
|
"""
|
|
|
|
prereqType: String
|
|
|
|
seed: Seed
|
|
|
|
"""
|
|
|
|
The index of the slot. Unique per set.
|
|
|
|
"""
|
|
|
|
slotIndex: Int
|
|
|
|
"""
|
|
|
|
The standing within this set for the seed currently assigned to this slot.
|
|
|
|
"""
|
|
|
|
standing: Standing
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A league
|
|
|
|
"""
|
|
|
|
type League {
|
|
|
|
id: ID
|
|
|
|
addrState: String
|
|
|
|
city: String
|
|
|
|
countryCode: String
|
|
|
|
"""
|
|
|
|
When the tournament was created (unix timestamp)
|
|
|
|
"""
|
|
|
|
createdAt: Timestamp
|
|
|
|
currency: String
|
|
|
|
"""
|
|
|
|
When the tournament ends
|
|
|
|
"""
|
|
|
|
endAt: Timestamp
|
|
|
|
entrantCount: Int
|
|
|
|
eventOwners(query: EventOwnersQuery): EventOwnerConnection
|
|
|
|
"""
|
|
|
|
When does event registration close
|
|
|
|
"""
|
|
|
|
eventRegistrationClosesAt: Timestamp
|
|
|
|
"""
|
|
|
|
Paginated list of events in a league
|
|
|
|
"""
|
|
|
|
events(query: LeagueEventsQuery): EventConnection
|
|
|
|
"""
|
2024-08-14 20:44:08 -04:00
|
|
|
Hacked "progression" into this final event
|
|
|
|
"""
|
|
|
|
finalEventId: Int @deprecated(reason: "No longer used")
|
|
|
|
"""
|
2023-08-26 17:43:01 -04:00
|
|
|
True if tournament has at least one offline event
|
|
|
|
"""
|
|
|
|
hasOfflineEvents: Boolean
|
|
|
|
hasOnlineEvents: Boolean
|
|
|
|
hashtag: String
|
|
|
|
images(type: String): [Image]
|
|
|
|
"""
|
|
|
|
True if tournament has at least one online event
|
|
|
|
"""
|
|
|
|
isOnline: Boolean
|
|
|
|
lat: Float
|
|
|
|
links: TournamentLinks
|
|
|
|
lng: Float
|
|
|
|
mapsPlaceId: String
|
|
|
|
"""
|
|
|
|
The tournament name
|
|
|
|
"""
|
|
|
|
name: String
|
2024-08-14 20:44:08 -04:00
|
|
|
"""
|
|
|
|
Top X number of people in the standings who progress to final event
|
|
|
|
"""
|
|
|
|
numProgressingToFinalEvent: Int @deprecated(reason: "No longer used")
|
2023-08-26 17:43:01 -04:00
|
|
|
numUniquePlayers: Int
|
|
|
|
postalCode: String
|
|
|
|
primaryContact: String
|
|
|
|
primaryContactType: String
|
|
|
|
"""
|
|
|
|
Publishing settings for this tournament
|
|
|
|
"""
|
|
|
|
publishing: JSON
|
|
|
|
"""
|
|
|
|
When does registration for the tournament end
|
|
|
|
"""
|
|
|
|
registrationClosesAt: Timestamp
|
|
|
|
rules: String
|
|
|
|
"""
|
|
|
|
The short slug used to form the url
|
|
|
|
"""
|
|
|
|
shortSlug: String
|
|
|
|
"""
|
|
|
|
Whether standings for this league should be visible
|
|
|
|
"""
|
|
|
|
showStandings: Boolean
|
|
|
|
slug: String
|
|
|
|
"""
|
|
|
|
Paginated list of standings
|
|
|
|
"""
|
|
|
|
standings(query: StandingGroupStandingPageFilter): StandingConnection
|
|
|
|
"""
|
|
|
|
When the tournament Starts
|
|
|
|
"""
|
|
|
|
startAt: Timestamp
|
|
|
|
"""
|
|
|
|
State of the tournament, can be ActivityState::CREATED, ActivityState::ACTIVE, or ActivityState::COMPLETED
|
|
|
|
"""
|
|
|
|
state: Int
|
|
|
|
"""
|
|
|
|
When is the team creation deadline
|
|
|
|
"""
|
|
|
|
teamCreationClosesAt: Timestamp
|
|
|
|
tiers: [EventTier]
|
|
|
|
"""
|
|
|
|
The timezone of the tournament
|
|
|
|
"""
|
|
|
|
timezone: String
|
|
|
|
"""
|
|
|
|
The type of tournament from TournamentType
|
|
|
|
"""
|
|
|
|
tournamentType: Int
|
|
|
|
"""
|
|
|
|
When the tournament was last modified (unix timestamp)
|
|
|
|
"""
|
|
|
|
updatedAt: Timestamp
|
|
|
|
"""
|
|
|
|
Build Tournament URL
|
|
|
|
"""
|
|
|
|
url(
|
|
|
|
"""
|
|
|
|
Tournament tab to add to URL
|
|
|
|
"""
|
|
|
|
tab: String
|
|
|
|
"""
|
|
|
|
Generate a relative URL. Defaults to true. Setting to false will generate an absolute URL
|
|
|
|
"""
|
|
|
|
relative: Boolean = true
|
|
|
|
): String
|
|
|
|
venueAddress: String
|
|
|
|
venueName: String
|
|
|
|
videogames: [Videogame]
|
|
|
|
}
|
|
|
|
|
|
|
|
input EventOwnersQuery {
|
|
|
|
page: Int = 1
|
|
|
|
"""
|
|
|
|
How many nodes to return for the page. Maximum value of 500
|
|
|
|
"""
|
|
|
|
perPage: Int = 25
|
|
|
|
sortBy: String
|
|
|
|
}
|
|
|
|
|
|
|
|
type EventOwnerConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [EventOwner]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Name and Gamertag of the owner of an event in a league
|
|
|
|
"""
|
|
|
|
type EventOwner {
|
|
|
|
eventId: ID
|
|
|
|
email: String
|
|
|
|
gamerTag: String
|
|
|
|
fullName: String
|
|
|
|
}
|
|
|
|
|
|
|
|
input LeagueEventsQuery {
|
|
|
|
page: Int = 1
|
|
|
|
"""
|
|
|
|
How many nodes to return for the page. Maximum value of 500
|
|
|
|
"""
|
|
|
|
perPage: Int = 25
|
|
|
|
sortBy: String
|
|
|
|
filter: LeagueEventsFilter
|
|
|
|
}
|
|
|
|
|
|
|
|
input LeagueEventsFilter {
|
|
|
|
search: PaginationSearchType
|
|
|
|
pointMappingGroupIds: [ID]
|
|
|
|
tierIds: [ID]
|
|
|
|
userId: ID
|
|
|
|
upcoming: Boolean
|
|
|
|
leagueEntrantId: ID
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Used for league application tiers
|
|
|
|
"""
|
|
|
|
type EventTier {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
Name of this tier
|
|
|
|
"""
|
|
|
|
name: String
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A videogame
|
|
|
|
"""
|
|
|
|
type Videogame {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
All characters for this videogame
|
|
|
|
"""
|
|
|
|
characters: [Character]
|
|
|
|
displayName: String
|
|
|
|
images(type: String): [Image]
|
|
|
|
name: String
|
|
|
|
slug: String
|
|
|
|
"""
|
2024-08-14 20:44:08 -04:00
|
|
|
All stages for this videogame
|
2023-08-26 17:43:01 -04:00
|
|
|
"""
|
2024-08-14 20:44:08 -04:00
|
|
|
stages: [Stage]
|
2023-08-26 17:43:01 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
input StandingPaginationQuery {
|
|
|
|
page: Int = 1
|
|
|
|
"""
|
|
|
|
How many nodes to return for the page. Maximum value of 500
|
|
|
|
"""
|
|
|
|
perPage: Int = 25
|
|
|
|
sortBy: String
|
|
|
|
filter: StandingPageFilter
|
|
|
|
}
|
|
|
|
|
|
|
|
input StandingPageFilter {
|
|
|
|
id: ID
|
|
|
|
ids: [ID]
|
|
|
|
search: PaginationSearchType
|
|
|
|
}
|
|
|
|
|
|
|
|
input StationFilter {
|
|
|
|
page: Int
|
|
|
|
perPage: Int
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Team roster size requirements
|
|
|
|
"""
|
|
|
|
type TeamRosterSize {
|
|
|
|
maxAlternates: Int
|
|
|
|
maxPlayers: Int
|
|
|
|
minAlternates: Int
|
|
|
|
minPlayers: Int
|
|
|
|
}
|
|
|
|
|
|
|
|
input UserLeaguesPaginationQuery {
|
|
|
|
page: Int = 1
|
|
|
|
"""
|
|
|
|
How many nodes to return for the page. Maximum value of 500
|
|
|
|
"""
|
|
|
|
perPage: Int = 25
|
|
|
|
sortBy: String
|
|
|
|
filter: UserLeaguesPaginationFilter
|
|
|
|
}
|
|
|
|
|
|
|
|
input UserLeaguesPaginationFilter {
|
|
|
|
videogameId: [ID]
|
|
|
|
upcoming: Boolean
|
|
|
|
past: Boolean
|
|
|
|
search: PaginationSearchType
|
|
|
|
}
|
|
|
|
|
|
|
|
type LeagueConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [League]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A user's address
|
|
|
|
"""
|
|
|
|
type Address {
|
|
|
|
id: ID
|
|
|
|
city: String
|
|
|
|
country: String
|
|
|
|
countryId: Int
|
|
|
|
state: String
|
|
|
|
stateId: Int
|
|
|
|
}
|
|
|
|
|
|
|
|
input UserTournamentsPaginationQuery {
|
|
|
|
page: Int = 1
|
|
|
|
"""
|
|
|
|
How many nodes to return for the page. Maximum value of 500
|
|
|
|
"""
|
|
|
|
perPage: Int = 25
|
|
|
|
sortBy: String
|
|
|
|
filter: UserTournamentsPaginationFilter
|
|
|
|
}
|
|
|
|
|
|
|
|
input UserTournamentsPaginationFilter {
|
|
|
|
past: Boolean
|
|
|
|
upcoming: Boolean
|
|
|
|
search: PaginationSearchType
|
|
|
|
videogameId: [ID]
|
|
|
|
tournamentView: String
|
|
|
|
excludeId: [ID]
|
|
|
|
}
|
|
|
|
|
|
|
|
type TournamentConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [Tournament]
|
|
|
|
}
|
|
|
|
|
|
|
|
input LeagueQuery {
|
|
|
|
page: Int = 1
|
|
|
|
"""
|
|
|
|
How many nodes to return for the page. Maximum value of 500
|
|
|
|
"""
|
|
|
|
perPage: Int = 25
|
|
|
|
sortBy: String
|
|
|
|
filter: LeaguePageFilter
|
|
|
|
sort: TournamentPaginationSort
|
|
|
|
}
|
|
|
|
|
|
|
|
input LeaguePageFilter {
|
|
|
|
id: ID
|
|
|
|
ids: [ID]
|
|
|
|
"""
|
|
|
|
ID of the user that owns this league.
|
|
|
|
"""
|
|
|
|
ownerId: ID
|
|
|
|
afterDate: Timestamp
|
|
|
|
beforeDate: Timestamp
|
|
|
|
computedUpdatedAt: Timestamp
|
|
|
|
name: String
|
|
|
|
isFeatured: Boolean
|
|
|
|
hasBannerImages: Boolean
|
|
|
|
activeShops: Boolean
|
|
|
|
past: Boolean
|
|
|
|
published: Boolean
|
|
|
|
publiclySearchable: Boolean
|
|
|
|
upcoming: Boolean
|
|
|
|
videogameIds: [ID]
|
|
|
|
}
|
|
|
|
|
|
|
|
enum TournamentPaginationSort {
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
startAt
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
endAt
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
eventRegistrationClosesAt
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
computedUpdatedAt
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A shop
|
|
|
|
"""
|
|
|
|
type Shop {
|
|
|
|
id: ID
|
|
|
|
levels(query: ShopLevelsQuery): ShopLevelConnection
|
|
|
|
messages(query: ShopOrderMessagesQuery): ShopOrderMessageConnection
|
|
|
|
name: String
|
|
|
|
slug: String
|
|
|
|
url: String
|
|
|
|
}
|
|
|
|
|
|
|
|
input ShopLevelsQuery {
|
|
|
|
page: Int = 1
|
|
|
|
"""
|
|
|
|
How many nodes to return for the page. Maximum value of 500
|
|
|
|
"""
|
|
|
|
perPage: Int = 25
|
|
|
|
sortBy: String
|
|
|
|
}
|
|
|
|
|
|
|
|
type ShopLevelConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [ShopLevel]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A shop level
|
|
|
|
"""
|
|
|
|
type ShopLevel {
|
|
|
|
id: ID
|
|
|
|
currAmount: Float
|
|
|
|
description: String
|
|
|
|
goalAmount: Float
|
|
|
|
images(type: String): [Image]
|
|
|
|
name: String
|
|
|
|
}
|
|
|
|
|
|
|
|
input ShopOrderMessagesQuery {
|
|
|
|
page: Int = 1
|
|
|
|
"""
|
|
|
|
How many nodes to return for the page. Maximum value of 500
|
|
|
|
"""
|
|
|
|
perPage: Int = 25
|
|
|
|
sortBy: String
|
|
|
|
}
|
|
|
|
|
|
|
|
type ShopOrderMessageConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [ShopOrderMessage]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
The message and player info for a shop order
|
|
|
|
"""
|
|
|
|
type ShopOrderMessage {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
The player's gamertag. Returns null if anonymous message type
|
|
|
|
"""
|
|
|
|
gamertag: String
|
|
|
|
"""
|
|
|
|
The order message
|
|
|
|
"""
|
|
|
|
message: String
|
|
|
|
"""
|
|
|
|
The player's name. Returns null unless name & tag display is selected
|
|
|
|
"""
|
|
|
|
name: String
|
|
|
|
"""
|
|
|
|
The player who left the comment
|
|
|
|
"""
|
|
|
|
player: Player
|
|
|
|
"""
|
|
|
|
The total order amount
|
|
|
|
"""
|
|
|
|
total: Float
|
|
|
|
}
|
|
|
|
|
|
|
|
input TournamentQuery {
|
|
|
|
page: Int = 1
|
|
|
|
"""
|
|
|
|
How many nodes to return for the page. Maximum value of 500
|
|
|
|
"""
|
|
|
|
perPage: Int = 25
|
|
|
|
sortBy: String
|
|
|
|
filter: TournamentPageFilter
|
|
|
|
sort: TournamentPaginationSort
|
|
|
|
}
|
|
|
|
|
|
|
|
input TournamentPageFilter {
|
|
|
|
id: ID
|
|
|
|
ids: [ID]
|
|
|
|
"""
|
|
|
|
ID of the user that owns this tournament.
|
|
|
|
"""
|
|
|
|
ownerId: ID
|
|
|
|
"""
|
|
|
|
If true, filter to only tournaments the currently authed user is an admin of
|
|
|
|
"""
|
|
|
|
isCurrentUserAdmin: Boolean
|
|
|
|
countryCode: String
|
|
|
|
addrState: String
|
|
|
|
location: TournamentLocationFilter
|
|
|
|
afterDate: Timestamp
|
|
|
|
beforeDate: Timestamp
|
|
|
|
computedUpdatedAt: Timestamp
|
|
|
|
name: String
|
|
|
|
venueName: String
|
|
|
|
isFeatured: Boolean
|
|
|
|
isLeague: Boolean
|
|
|
|
hasBannerImages: Boolean
|
|
|
|
activeShops: Boolean
|
|
|
|
regOpen: Boolean
|
|
|
|
past: Boolean
|
|
|
|
published: Boolean
|
|
|
|
publiclySearchable: Boolean
|
|
|
|
staffPicks: Boolean
|
|
|
|
hasOnlineEvents: Boolean
|
|
|
|
topGames: TopGameFilter
|
|
|
|
upcoming: Boolean
|
|
|
|
videogameIds: [ID]
|
|
|
|
sortByScore: Boolean
|
|
|
|
}
|
|
|
|
|
|
|
|
input TournamentLocationFilter {
|
|
|
|
"""
|
|
|
|
Latitude, Longitude
|
|
|
|
"""
|
|
|
|
distanceFrom: String
|
|
|
|
"""
|
|
|
|
e.g. 50mi
|
|
|
|
"""
|
|
|
|
distance: String
|
|
|
|
}
|
|
|
|
|
|
|
|
input TopGameFilter {
|
|
|
|
"""
|
|
|
|
Array of which # top game you want to filter on.e.g. [2, 3] will filter on the 2nd and 3rd top games
|
|
|
|
"""
|
|
|
|
gameNums: [Int]
|
|
|
|
}
|
|
|
|
|
|
|
|
input VideogameQuery {
|
|
|
|
page: Int = 1
|
|
|
|
"""
|
|
|
|
How many nodes to return for the page. Maximum value of 500
|
|
|
|
"""
|
|
|
|
perPage: Int = 25
|
|
|
|
sortBy: String
|
|
|
|
filter: VideogamePageFilter
|
|
|
|
}
|
|
|
|
|
|
|
|
input VideogamePageFilter {
|
|
|
|
id: [ID]
|
|
|
|
name: String
|
|
|
|
forUser: ID
|
|
|
|
}
|
|
|
|
|
|
|
|
type VideogameConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [Videogame]
|
|
|
|
}
|
|
|
|
|
|
|
|
type Mutation {
|
|
|
|
"""
|
|
|
|
Delete a phase by id
|
|
|
|
"""
|
|
|
|
deletePhase(phaseId: ID!): Boolean
|
|
|
|
"""
|
|
|
|
Delete a station by id
|
|
|
|
"""
|
|
|
|
deleteStation(stationId: ID!): Boolean
|
|
|
|
"""
|
|
|
|
Delete a wave by id
|
|
|
|
"""
|
|
|
|
deleteWave(waveId: ID!): Boolean
|
|
|
|
"""
|
2024-08-14 20:44:08 -04:00
|
|
|
Generate tournament registration Token on behalf of user
|
|
|
|
"""
|
|
|
|
generateRegistrationToken(registration: TournamentRegistrationInput!, userId: ID!): String
|
|
|
|
"""
|
|
|
|
Update a set to called state
|
|
|
|
"""
|
|
|
|
markSetCalled(setId: ID!): Set
|
|
|
|
"""
|
|
|
|
Update a set to called state
|
|
|
|
"""
|
|
|
|
markSetInProgress(setId: ID!): Set
|
|
|
|
"""
|
|
|
|
Register for tournament
|
|
|
|
"""
|
|
|
|
registerForTournament(registration: TournamentRegistrationInput, registrationToken: String): Participant
|
|
|
|
"""
|
|
|
|
Report set winner or game stats for a H2H bracket set. If winnerId is
|
|
|
|
supplied, mark set as complete. gameData parameter will overwrite any existing
|
|
|
|
reported game data.
|
|
|
|
"""
|
|
|
|
reportBracketSet(setId: ID!, winnerId: ID, isDQ: Boolean, gameData: [BracketSetGameDataInput]): [Set]
|
|
|
|
"""
|
|
|
|
Resets set to initial state, can affect other sets and phase groups
|
|
|
|
"""
|
|
|
|
resetSet(setId: ID!, resetDependentSets: Boolean): Set
|
|
|
|
"""
|
2023-08-26 17:43:01 -04:00
|
|
|
Automatically attempt to resolve all schedule conflicts. Returns a list of changed seeds
|
|
|
|
"""
|
|
|
|
resolveScheduleConflicts(tournamentId: ID!, options: ResolveConflictsOptions): [Seed]
|
|
|
|
"""
|
|
|
|
Swap two seed ids in a phase
|
|
|
|
"""
|
|
|
|
swapSeeds(phaseId: ID!, seed1Id: ID!, seed2Id: ID!): [Seed]
|
|
|
|
"""
|
2024-08-14 20:44:08 -04:00
|
|
|
Update game stats for a H2H bracket set. Set winner cannot be changed with
|
|
|
|
this function, use the resetSet mutation instead.
|
|
|
|
"""
|
|
|
|
updateBracketSet(setId: ID!, winnerId: ID, isDQ: Boolean, gameData: [BracketSetGameDataInput]): Set
|
|
|
|
"""
|
2023-08-26 17:43:01 -04:00
|
|
|
Update set of phase groups in a phase
|
|
|
|
"""
|
|
|
|
updatePhaseGroups(groupConfigs: [PhaseGroupUpdateInput]!): [PhaseGroup]
|
|
|
|
"""
|
|
|
|
Update the seeding for a phase
|
|
|
|
"""
|
|
|
|
updatePhaseSeeding(phaseId: ID!, seedMapping: [UpdatePhaseSeedInfo]!, options: UpdatePhaseSeedingOptions): Phase
|
|
|
|
"""
|
|
|
|
Create or update a Phase
|
|
|
|
"""
|
|
|
|
upsertPhase(phaseId: ID, eventId: ID, payload: PhaseUpsertInput!): Phase
|
|
|
|
"""
|
|
|
|
Add or update a station by id
|
|
|
|
"""
|
|
|
|
upsertStation(stationId: ID, tournamentId: ID, fields: StationUpsertInput!): Stations
|
|
|
|
"""
|
|
|
|
Add or update a wave by id
|
|
|
|
"""
|
|
|
|
upsertWave(waveId: ID, tournamentId: ID, fields: WaveUpsertInput!): Wave
|
|
|
|
}
|
|
|
|
|
2024-08-14 20:44:08 -04:00
|
|
|
input TournamentRegistrationInput {
|
|
|
|
eventIds: [ID]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Game specific H2H set data such as character, stage, and stock info
|
|
|
|
"""
|
|
|
|
input BracketSetGameDataInput {
|
|
|
|
"""
|
|
|
|
Entrant ID of game winner
|
|
|
|
"""
|
|
|
|
winnerId: ID
|
|
|
|
"""
|
|
|
|
Game number
|
|
|
|
"""
|
|
|
|
gameNum: Int!
|
|
|
|
"""
|
|
|
|
Score for entrant 1 (if applicable). For smash, this is stocks remaining.
|
|
|
|
"""
|
|
|
|
entrant1Score: Int
|
|
|
|
"""
|
|
|
|
Score for entrant 2 (if applicable). For smash, this is stocks remaining.
|
|
|
|
"""
|
|
|
|
entrant2Score: Int
|
|
|
|
"""
|
|
|
|
ID of the stage that was played for this game (if applicable)
|
|
|
|
"""
|
|
|
|
stageId: ID
|
|
|
|
"""
|
|
|
|
List of selections for the game, typically character selections.
|
|
|
|
"""
|
|
|
|
selections: [BracketSetGameSelectionInput]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Game specific H2H selections made by the entrants, such as character info
|
|
|
|
"""
|
|
|
|
input BracketSetGameSelectionInput {
|
|
|
|
"""
|
|
|
|
Entrant ID that made selection
|
|
|
|
"""
|
|
|
|
entrantId: ID!
|
|
|
|
"""
|
|
|
|
Character selected by this entrant for this game.
|
|
|
|
"""
|
|
|
|
characterId: Int
|
|
|
|
}
|
|
|
|
|
2023-08-26 17:43:01 -04:00
|
|
|
input ResolveConflictsOptions {
|
|
|
|
lockedSeeds: [ResolveConflictsLockedSeedConfig]
|
|
|
|
}
|
|
|
|
|
|
|
|
input ResolveConflictsLockedSeedConfig {
|
|
|
|
eventId: ID!
|
|
|
|
numSeeds: Int!
|
|
|
|
}
|
|
|
|
|
|
|
|
input PhaseGroupUpdateInput {
|
|
|
|
phaseGroupId: ID!
|
|
|
|
stationId: ID
|
|
|
|
waveId: ID
|
|
|
|
}
|
|
|
|
|
|
|
|
input UpdatePhaseSeedInfo {
|
|
|
|
seedId: ID!
|
|
|
|
seedNum: ID!
|
|
|
|
phaseGroupId: ID
|
|
|
|
}
|
|
|
|
|
|
|
|
input UpdatePhaseSeedingOptions {
|
|
|
|
"""
|
|
|
|
Validate that seedMapping exactly accounts for all entrants in the phase
|
|
|
|
"""
|
|
|
|
strictMode: Boolean
|
|
|
|
}
|
|
|
|
|
|
|
|
input PhaseUpsertInput {
|
|
|
|
"""
|
|
|
|
The name of the Phase. For example, "Top 8" or "Pools"
|
|
|
|
"""
|
|
|
|
name: String
|
|
|
|
"""
|
|
|
|
The number of pools to configure for the Phase. Only applies to brackets that support pools
|
|
|
|
"""
|
|
|
|
groupCount: Int
|
|
|
|
bracketType: BracketType
|
|
|
|
}
|
|
|
|
|
|
|
|
input StationUpsertInput {
|
|
|
|
number: Int!
|
|
|
|
clusterId: ID
|
|
|
|
}
|
|
|
|
|
|
|
|
input WaveUpsertInput {
|
|
|
|
identifier: String!
|
|
|
|
startAt: Timestamp!
|
|
|
|
endAt: Timestamp!
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A set of actions available for an entity to take
|
|
|
|
"""
|
|
|
|
interface ActionSet {
|
|
|
|
id: ID
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Bracket-specific configuration
|
|
|
|
"""
|
|
|
|
interface BracketConfig {
|
|
|
|
id: ID
|
|
|
|
bracketType: BracketType
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Comparison operator
|
|
|
|
"""
|
|
|
|
enum Comparator {
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
GREATER_THAN
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
GREATER_THAN_OR_EQUAL
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
EQUAL
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
LESS_THAN_OR_EQUAL
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
LESS_THAN
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
An event-level Team, in the context of some competition
|
|
|
|
"""
|
|
|
|
type EventTeam implements Team {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
Uniquely identifying token for team. Same as the hashed part of the slug
|
|
|
|
"""
|
|
|
|
discriminator: String
|
2024-08-14 20:44:08 -04:00
|
|
|
entrant: Entrant @deprecated(reason: "Use the entrant field off the EventTeam type")
|
|
|
|
event: Event @deprecated(reason: "Use the event field off the EventTeam type")
|
2023-08-26 17:43:01 -04:00
|
|
|
globalTeam: GlobalTeam
|
|
|
|
images(type: String): [Image]
|
|
|
|
members(status: [TeamMemberStatus]): [TeamMember]
|
|
|
|
name: String
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Global Team
|
|
|
|
"""
|
|
|
|
type GlobalTeam implements Team {
|
|
|
|
id: ID
|
|
|
|
"""
|
|
|
|
Uniquely identifying token for team. Same as the hashed part of the slug
|
|
|
|
"""
|
|
|
|
discriminator: String
|
2024-08-14 20:44:08 -04:00
|
|
|
entrant: Entrant @deprecated(reason: "Use the entrant field off the EventTeam type")
|
|
|
|
event: Event @deprecated(reason: "Use the event field off the EventTeam type")
|
2023-08-26 17:43:01 -04:00
|
|
|
eventTeams(query: TeamPaginationQuery): EventTeamConnection
|
|
|
|
images(type: String): [Image]
|
|
|
|
"""
|
|
|
|
Leagues-level teams for leagues this team is competing in
|
|
|
|
"""
|
|
|
|
leagueTeams(query: TeamPaginationQuery): EventTeamConnection
|
|
|
|
members(status: [TeamMemberStatus]): [TeamMember]
|
|
|
|
name: String
|
|
|
|
}
|
|
|
|
|
|
|
|
type EventTeamConnection {
|
|
|
|
pageInfo: PageInfo
|
|
|
|
nodes: [EventTeam]
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Match-level configuration
|
|
|
|
"""
|
|
|
|
interface MatchConfig {
|
|
|
|
id: ID
|
|
|
|
bracketType: BracketType
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Different options available for verifying player-reported match results
|
|
|
|
"""
|
|
|
|
enum MatchConfigVerificationMethod {
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
TWITCH
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
STREAM_ME
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
ANY
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
MIXER
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
YOUTUBE
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Race specific bracket configuration
|
|
|
|
"""
|
|
|
|
type RaceBracketConfig implements BracketConfig {
|
|
|
|
automaticEndTime: Timestamp
|
|
|
|
id: ID
|
|
|
|
automaticStartTime: Timestamp
|
|
|
|
bracketType: BracketType
|
|
|
|
goalTargetComparator: Comparator
|
|
|
|
goalTargetValue: String
|
|
|
|
limitMode: RaceLimitMode
|
|
|
|
limitValue: Int
|
|
|
|
raceType: RaceType
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Enforces limits on the amount of allowable Race submissions
|
|
|
|
"""
|
|
|
|
enum RaceLimitMode {
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
BEST_ALL
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
FIRST_ALL
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
PLAYTIME
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Race type
|
|
|
|
"""
|
|
|
|
enum RaceType {
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
GOALS
|
|
|
|
"""
|
|
|
|
|
|
|
|
"""
|
|
|
|
TIMED
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
Race specific match configuration
|
|
|
|
"""
|
|
|
|
type RaceMatchConfig implements MatchConfig {
|
|
|
|
id: ID
|
|
|
|
bracketType: BracketType
|
|
|
|
"""
|
|
|
|
Can players report results?
|
|
|
|
"""
|
|
|
|
playerReportingEnabled: Boolean
|
|
|
|
"""
|
|
|
|
Accepted methods of verification that players can use
|
|
|
|
"""
|
|
|
|
verificationMethods: [MatchConfigVerificationMethod]
|
|
|
|
"""
|
|
|
|
Are players required to submit verification of their reported results?
|
|
|
|
"""
|
|
|
|
verificationRequired: Boolean
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A set of actions available for a team to take
|
|
|
|
"""
|
|
|
|
type TeamActionSet implements ActionSet {
|
|
|
|
id: ID
|
|
|
|
}
|
|
|
|
|