WTN GraphQL API

The ITF World Tennis Number APIs allow external systems to manage and exercise functionality within WTN platform. The API is based on GraphQL. If you are not familiar with GraphQL there are many external resources to help you get started.

Contact

API Support
support@example.com

API Endpoints

GraphQL endpoint:
https://prd-itf-kube.clubspark.pro/tods-gw-api/graphql

Queries

`accountPerson`

Returns an AccountPersonDetail

Example

Query

query accountPerson {
  accountPerson {
    id
    tennisId
    registrationToken
    nativeGivenName
    nativeFamilyName
    standardGivenName
    standardFamilyName
    sex
    birthDate
    birthYear
    nationalityCode
    countryOfResidenceCode
    alreadyItfCustomer
    alreadyRegisteredForService
    isSexUpdateable
    isNativeGivenNameUpdateable
    isNativeFamilyNameUpdateable
    isBirthDateUpdateable
    isNationalityUpdateable
    isCountryOfResidenceUpdateable
    biographicalInformation {
      ...BiographicalInformationFragment
    }
    hasBirthDate
    hasNationality
    hasSex
    hasCountryOfResidence
  }
}

Response

{
  "data": {
    "accountPerson": {
      "id": "xyz789",
      "tennisId": "xyz789",
      "registrationToken": "abc123",
      "nativeGivenName": "xyz789",
      "nativeFamilyName": "abc123",
      "standardGivenName": "abc123",
      "standardFamilyName": "xyz789",
      "sex": SexEnum,
      "birthDate": "2026-03-31T14:07:52.371Z",
      "birthYear": 123,
      "nationalityCode": "xyz789",
      "countryOfResidenceCode": "xyz789",
      "alreadyItfCustomer": true,
      "alreadyRegisteredForService": true,
      "isSexUpdateable": true,
      "isNativeGivenNameUpdateable": false,
      "isNativeFamilyNameUpdateable": false,
      "isBirthDateUpdateable": true,
      "isNationalityUpdateable": true,
      "isCountryOfResidenceUpdateable": true,
      "biographicalInformation": BiographicalInformation,
      "hasBirthDate": true,
      "hasNationality": false,
      "hasSex": false,
      "hasCountryOfResidence": true
    }
  }
}

Queries

`checkMergePerson`

Returns if a players can be merged depending if they have shared matches, eg, true if players didn't play in the same matches

Returns a Boolean

Name	Description
`targetPersonID` - `PersonIDInput!`
`additionalPersonID` - `PersonIDInput!`

Example

Query

query checkMergePerson($targetPersonID: PersonIDInput!, $additionalPersonID: PersonIDInput!) {
  checkMergePerson(targetPersonID: $targetPersonID, additionalPersonID: $additionalPersonID)
}

Variables

{
  "targetPersonID": PersonIDInput,
  "additionalPersonID": PersonIDInput
}

Response

{"data": {"checkMergePerson": true}}

Queries

`checkRemovePerson`

Returns if a player can be removed depending if he has any matches, eg, true if player doesn't have any matches

Returns a Boolean

Name	Description
`id` - `PersonIDInput!`

Example

Query

query checkRemovePerson($id: PersonIDInput!) {
  checkRemovePerson(id: $id)
}

Variables

{"id": PersonIDInput}

Response

{"data": {"checkRemovePerson": false}}

Queries

`club`

Returns a Club

Name	Description
`id` - `ID!`

Example

Query

query club($id: ID!) {
  club(id: $id) {
    id
    name
    members {
      ...PersonListFragment
    }
    myRole
  }
}

Variables

{"id": ID}

Response

{
  "data": {
    "club": {
      "id": ID,
      "name": "abc123",
      "members": PersonList,
      "myRole": ClubMemberRole
    }
  }
}

Queries

`clubs`

Returns a ClubList

Name	Description
`filter` - `ClubFilterOptions`
`pageArgs` - `PaginationArgs`
`sort` - `SortOrder`

Example

Query

query clubs($filter: ClubFilterOptions, $pageArgs: PaginationArgs, $sort: SortOrder) {
  clubs(filter: $filter, pageArgs: $pageArgs, sort: $sort) {
    totalItems
    items {
      ...ClubFragment
    }
  }
}

Variables

{
  "filter": ClubFilterOptions,
  "pageArgs": PaginationArgs,
  "sort": SortOrder
}

Response

{"data": {"clubs": {"totalItems": 987, "items": [Club]}}}

Queries

`fastTrackInviteLinks`

Returns [InviteLink]

Name	Description
`tennisIds` - `[String!]!`

Example

Query

query fastTrackInviteLinks($tennisIds: [String!]!) {
  fastTrackInviteLinks(tennisIds: $tennisIds) {
    tennisId
    url
    errorCode
    errorMessage
  }
}

Variables

{"tennisIds": ["abc123"]}

Response

{
  "data": {
    "fastTrackInviteLinks": [
      {
        "tennisId": "abc123",
        "url": "xyz789",
        "errorCode": "xyz789",
        "errorMessage": "xyz789"
      }
    ]
  }
}

Queries

`features`

Returns a Features

Example

Query

query features {
  features {
    walkUpRegistration
  }
}

Response

{
  "data": {
    "features": {"walkUpRegistration": FeatureStatusEnum}
  }
}

Queries

`matchUp`

Returns a MatchUp

Name	Description
`id` - `ID!`

Example

Query

query matchUp($id: ID!) {
  matchUp(id: $id) {
    id
    score {
      ...ScoreFragment
    }
    sides {
      ...SideFragment
    }
    winningSide
    providerMatchId
    ageCategoryCode
    surfaceCategory
    indoorOutdoor
    type
    matchUpFormat
    grade
    start
    end
    circuit
    roundNumber
    roundPosition
    roundName
    humidity
    duration
    status
    statusCodes
    extensions {
      ...ExtensionFragment
    }
    createdAt
    updatedAt
    competitiveness
    state
    divisionType
    drawStructure
    drawType
    tieMatchUpId
    courtId
    surfaceType
    tournamentLevel
    pace
    gender
    drawId
    drawName
    venueId
    selfSubmittedResult
    ballType
    deleted
    collectionPosition
    wtnId
    wtnErrors
    isTied
    tournament {
      ...TournamentFragment
    }
    court {
      ...CourtFragment
    }
    venue {
      ...VenueFragment
    }
    provider {
      ...ProviderFragment
    }
    ownerId
    reviewedBy {
      ...PersonFragment
    }
    submissionState
    reviewedAt
    worldTennisNumbers {
      ...MatchUpWorldTennisNumberFragment
    }
  }
}

Variables

{"id": ID}

Response

{
  "data": {
    "matchUp": {
      "id": ID,
      "score": Score,
      "sides": [Side],
      "winningSide": SideEnum,
      "providerMatchId": ID,
      "ageCategoryCode": "abc123",
      "surfaceCategory": SurfaceCategoryEnum,
      "indoorOutdoor": IndoorOutdoorEnum,
      "type": MatchUpTypeEnum,
      "matchUpFormat": "xyz789",
      "grade": "abc123",
      "start": DateTime,
      "end": DateTime,
      "circuit": CircuitEnum,
      "roundNumber": 987,
      "roundPosition": 123,
      "roundName": "xyz789",
      "humidity": 123.45,
      "duration": 987.65,
      "status": MatchUpStatusEnum,
      "statusCodes": ["xyz789"],
      "extensions": [Extension],
      "createdAt": DateTime,
      "updatedAt": DateTime,
      "competitiveness": 123.45,
      "state": StateEnum,
      "divisionType": "abc123",
      "drawStructure": DrawStructureEnum,
      "drawType": "xyz789",
      "tieMatchUpId": ID,
      "courtId": ID,
      "surfaceType": SurfaceTypeEnum,
      "tournamentLevel": StandardGradeEnum,
      "pace": PaceEnum,
      "gender": MatchUpGenderEnum,
      "drawId": ID,
      "drawName": "xyz789",
      "venueId": ID,
      "selfSubmittedResult": false,
      "ballType": BallTypeEnum,
      "deleted": false,
      "collectionPosition": 123,
      "wtnId": ID,
      "wtnErrors": ["abc123"],
      "isTied": false,
      "tournament": Tournament,
      "court": Court,
      "venue": Venue,
      "provider": Provider,
      "ownerId": ID,
      "reviewedBy": Person,
      "submissionState": MatchUpSubmissionStateEnum,
      "reviewedAt": DateTime,
      "worldTennisNumbers": [MatchUpWorldTennisNumber]
    }
  }
}

Queries

`matchUpAggregatedCount`

Returns an AggregatedMatchUpCount

Name	Description
`filter` - `MatchUpAggregateFilterOptions!`

Example

Query

query matchUpAggregatedCount($filter: MatchUpAggregateFilterOptions!) {
  matchUpAggregatedCount(filter: $filter) {
    totalMatches
    tournamentMatches
    notTournamentMatches
    matchesWon
    matchesLost
    matchesTied
    uniqueOpponents {
      ...UniqueOpponentsFragment
    }
    walkovers
    decisive
    routine
    competitive
  }
}

Variables

{"filter": MatchUpAggregateFilterOptions}

Response

{
  "data": {
    "matchUpAggregatedCount": {
      "totalMatches": 987,
      "tournamentMatches": 987,
      "notTournamentMatches": 123,
      "matchesWon": 123,
      "matchesLost": 987,
      "matchesTied": 123,
      "uniqueOpponents": UniqueOpponents,
      "walkovers": 987,
      "decisive": 123,
      "routine": 123,
      "competitive": 123
    }
  }
}

Queries

`matchUpBucketedStats`

Returns a BucketedMatchUpStats

Name	Description
`filter` - `BucketedMatchUpFilterOptions!`

Example

Query

query matchUpBucketedStats($filter: BucketedMatchUpFilterOptions!) {
  matchUpBucketedStats(filter: $filter) {
    bucketsMeta {
      ...BucketMetaFragment
    }
  }
}

Variables

{"filter": BucketedMatchUpFilterOptions}

Response

{
  "data": {
    "matchUpBucketedStats": {"bucketsMeta": [BucketMeta]}
  }
}

Queries

`matchUpCount`

Returns an Int

Name	Description
`filter` - `MatchUpFilterOptions`

Example

Query

query matchUpCount($filter: MatchUpFilterOptions) {
  matchUpCount(filter: $filter)
}

Variables

{"filter": MatchUpFilterOptions}

Response

{"data": {"matchUpCount": 123}}

Queries

`matchUps`

Returns a MatchUpList

Name	Description
`pageArgs` - `PaginationArgs`
`filter` - `MatchUpFilterOptions`
`matchUpFilter` - `[MatchUpFilterOptions]`
`personFilter` - `[PersonFilterOptions]`
`tournamentFilter` - `[TournamentFilterOptions]`
`sort` - `SortOrder`

Example

Query

query matchUps($pageArgs: PaginationArgs, $filter: MatchUpFilterOptions, $matchUpFilter: [MatchUpFilterOptions], $personFilter: [PersonFilterOptions], $tournamentFilter: [TournamentFilterOptions], $sort: SortOrder) {
  matchUps(pageArgs: $pageArgs, filter: $filter, matchUpFilter: $matchUpFilter, personFilter: $personFilter, tournamentFilter: $tournamentFilter, sort: $sort) {
    items {
      ...MatchUpFragment
    }
    totalItems
  }
}

Variables

{
  "pageArgs": PaginationArgs,
  "filter": MatchUpFilterOptions,
  "matchUpFilter": [MatchUpFilterOptions],
  "personFilter": [PersonFilterOptions],
  "tournamentFilter": [TournamentFilterOptions],
  "sort": SortOrder
}

Response

{
  "data": {
    "matchUps": {"items": [MatchUp], "totalItems": 123}
  }
}

Queries

`matchUpsInternational`

Returns a MatchUpList

Name	Description
`pageArgs` - `PaginationArgs`
`filter` - `MatchUpFilterOptions`
`sort` - `SortOrder`

Example

Query

query matchUpsInternational($pageArgs: PaginationArgs, $filter: MatchUpFilterOptions, $sort: SortOrder) {
  matchUpsInternational(pageArgs: $pageArgs, filter: $filter, sort: $sort) {
    items {
      ...MatchUpFragment
    }
    totalItems
  }
}

Variables

{
  "pageArgs": PaginationArgs,
  "filter": MatchUpFilterOptions,
  "sort": SortOrder
}

Response

{
  "data": {
    "matchUpsInternational": {
      "items": [MatchUp],
      "totalItems": 987
    }
  }
}

Queries

`matchUpStatistics`

Returns a MatchUpVsStatistics

Name	Description
`filter` - `MatchUpStatisticsFilterOptions!`

Example

Query

query matchUpStatistics($filter: MatchUpStatisticsFilterOptions!) {
  matchUpStatistics(filter: $filter) {
    matchUpVsStatisticsCount {
      ...MatchUpWinLossCountFragment
    }
    matchUps {
      ...MatchUpListFragment
    }
    commonCompetitorIds
    commonCompetitors {
      ...PersonFragment
    }
    winLikelihood
  }
}

Variables

{"filter": MatchUpStatisticsFilterOptions}

Response

{
  "data": {
    "matchUpStatistics": {
      "matchUpVsStatisticsCount": MatchUpWinLossCount,
      "matchUps": MatchUpList,
      "commonCompetitorIds": [ID],
      "commonCompetitors": [Person],
      "winLikelihood": 123
    }
  }
}

Queries

`person`

Retrieve a single person record by known identifiers

Returns a Person

Name	Description
`id` - `PersonIDInput!`

Example

Query

query person($id: PersonIDInput!) {
  person(id: $id) {
    registrationInvite {
      ...InviteLinkFragment
    }
    clubs {
      ...ClubFragment
    }
    clubStatus
    id
    clubsparkId
    externalID
    tennisID
    nationalID
    personID
    biographicalInformation {
      ...BiographicalInformationFragment
    }
    extensions {
      ...ExtensionFragment
    }
    nationalityCode
    nativeFamilyName
    nativeGivenName
    nationalRating
    notes
    standardGivenName
    standardFamilyName
    birthDate
    isDeceased
    sex
    age
    birthYear
    worldTennisNumbers {
      ...WorldTennisNumberFragment
    }
    addresses {
      ...AddressFragment
    }
    createdAt
    updatedAt
    belongsToRequestingProvider
    lastPlayedSingles
    lastPlayedDoubles
    optedOutOfPublicDataConsent
    owningProviderId
    school {
      ...SchoolInfoFragment
    }
    isRanked
    rankedSingles
    rankedDoubles
    eligibleForSelfSubmission
    eligibleForPsq
    isRegistered
    section {
      ...SectionFragment
    }
    hasSubmittedResult
    tournaments {
      ...TournamentListFragment
    }
    matchUpIntervals {
      ...MatchUpIntervalsFragment
    }
    matchUpVsStatisticsCount {
      ...MatchUpVsStatisticsWinLossCountFragment
    }
    matchUps {
      ...MatchUpListFragment
    }
    demographicStats {
      ...DemographicStatFragment
    }
    ratingBounds {
      ...RatingBoundsFragment
    }
  }
}

Variables

{"id": PersonIDInput}

Response

{
  "data": {
    "person": {
      "registrationInvite": InviteLink,
      "clubs": [Club],
      "clubStatus": PersonClubStatus,
      "id": ID,
      "clubsparkId": ID,
      "externalID": ID,
      "tennisID": ID,
      "nationalID": ID,
      "personID": ID,
      "biographicalInformation": BiographicalInformation,
      "extensions": [Extension],
      "nationalityCode": "abc123",
      "nativeFamilyName": "xyz789",
      "nativeGivenName": "xyz789",
      "nationalRating": "xyz789",
      "notes": "abc123",
      "standardGivenName": "abc123",
      "standardFamilyName": "xyz789",
      "birthDate": "2025-10-01T14:07:52.371Z",
      "isDeceased": true,
      "sex": SexEnum,
      "age": 123,
      "birthYear": 987,
      "worldTennisNumbers": [WorldTennisNumber],
      "addresses": [Address],
      "createdAt": DateTime,
      "updatedAt": DateTime,
      "belongsToRequestingProvider": true,
      "lastPlayedSingles": DateTime,
      "lastPlayedDoubles": DateTime,
      "optedOutOfPublicDataConsent": true,
      "owningProviderId": ID,
      "school": [SchoolInfo],
      "isRanked": false,
      "rankedSingles": true,
      "rankedDoubles": false,
      "eligibleForSelfSubmission": false,
      "eligibleForPsq": true,
      "isRegistered": true,
      "section": Section,
      "hasSubmittedResult": false,
      "tournaments": TournamentList,
      "matchUpIntervals": MatchUpIntervals,
      "matchUpVsStatisticsCount": MatchUpVsStatisticsWinLossCount,
      "matchUps": MatchUpList,
      "demographicStats": [DemographicStat],
      "ratingBounds": RatingBounds
    }
  }
}

Queries

`personCount`

Returns a count of the Person records matching the provided filter, or all records if filter is omitted

Returns an Int

Name	Description
`filter` - `PersonFilterOptions`

Example

Query

query personCount($filter: PersonFilterOptions) {
  personCount(filter: $filter)
}

Variables

{"filter": PersonFilterOptions}

Response

{"data": {"personCount": 123}}

Queries

`personMerges`

Returns a PersonMergesList

Name	Description
`pageArgs` - `PaginationArgs`
`from` - `DateTime`

Example

Query

query personMerges($pageArgs: PaginationArgs, $from: DateTime) {
  personMerges(pageArgs: $pageArgs, from: $from) {
    items {
      ...PersonMergeFragment
    }
    totalItems
  }
}

Variables

{
  "pageArgs": PaginationArgs,
  "from": DateTime
}

Response

{
  "data": {
    "personMerges": {
      "items": [PersonMerge],
      "totalItems": 987
    }
  }
}

Queries

`persons`

Returns an array of Person records. Allows paging, filtering and sorting

Returns a PersonList

Name	Description
`pageArgs` - `PaginationArgs`
`filter` - `PersonFilterOptions`
`sort` - `SortOrder`

Example

Query

query persons($pageArgs: PaginationArgs, $filter: PersonFilterOptions, $sort: SortOrder) {
  persons(pageArgs: $pageArgs, filter: $filter, sort: $sort) {
    items {
      ...PersonFragment
    }
    totalItems
  }
}

Variables

{
  "pageArgs": PaginationArgs,
  "filter": PersonFilterOptions,
  "sort": SortOrder
}

Response

{
  "data": {
    "persons": {"items": [Person], "totalItems": 987}
  }
}

Queries

`providerNames`

Returns a ProviderNameList

Name	Description
`filter` - `ProviderFilterOptions`
`sort` - `SortOrder`

Example

Query

query providerNames($filter: ProviderFilterOptions, $sort: SortOrder) {
  providerNames(filter: $filter, sort: $sort) {
    items {
      ...ProviderNameFragment
    }
    totalItems
  }
}

Variables

{
  "filter": ProviderFilterOptions,
  "sort": SortOrder
}

Response

{
  "data": {
    "providerNames": {
      "items": [ProviderName],
      "totalItems": 123
    }
  }
}

Queries

`publicPersons`

Returns an array of Public Person records. Allows paging, filtering and sorting

Returns a PersonList

Name	Description
`pageArgs` - `PaginationArgs`
`filter` - `PublicPersonFilterOptions`
`sort` - `SortOrder`

Example

Query

query publicPersons($pageArgs: PaginationArgs, $filter: PublicPersonFilterOptions, $sort: SortOrder) {
  publicPersons(pageArgs: $pageArgs, filter: $filter, sort: $sort) {
    items {
      ...PersonFragment
    }
    totalItems
  }
}

Variables

{
  "pageArgs": PaginationArgs,
  "filter": PublicPersonFilterOptions,
  "sort": SortOrder
}

Response

{
  "data": {
    "publicPersons": {
      "items": [Person],
      "totalItems": 123
    }
  }
}

Queries

`rmg`

Returns [WorldTennisNumber]

Name	Description
`input` - `PersonPSQInput!`

Example

Query

query rmg($input: PersonPSQInput!) {
  rmg(input: $input) {
    confidence
    ratingDate
    tennisNumber
    prevTennisNumber
    type
    gameZoneUpper
    gameZoneLower
    source
    isRanked
  }
}

Variables

{"input": PersonPSQInput}

Response

{
  "data": {
    "rmg": [
      {
        "confidence": 123.45,
        "ratingDate": DateTime,
        "tennisNumber": 123.45,
        "prevTennisNumber": 123.45,
        "type": WorldTennisNumberTypeEnum,
        "gameZoneUpper": 123.45,
        "gameZoneLower": 123.45,
        "source": RatingSourceEnum,
        "isRanked": true
      }
    ]
  }
}

Queries

`selfSubmittedMatchUps`

Returns a SelfSubmittedMatchUpList

Name	Description
`pageArgs` - `PaginationArgs`
`states` - `[MatchUpSubmissionStateEnum]`
`sort` - `SortOrder`

Example

Query

query selfSubmittedMatchUps($pageArgs: PaginationArgs, $states: [MatchUpSubmissionStateEnum], $sort: SortOrder) {
  selfSubmittedMatchUps(pageArgs: $pageArgs, states: $states, sort: $sort) {
    items {
      ...MatchUpFragment
    }
    pendingItems
    rejectedItems
    approvedItems
    totalItems
  }
}

Variables

{
  "pageArgs": PaginationArgs,
  "states": [MatchUpSubmissionStateEnum],
  "sort": SortOrder
}

Response

{
  "data": {
    "selfSubmittedMatchUps": {
      "items": [MatchUp],
      "pendingItems": 987,
      "rejectedItems": 123,
      "approvedItems": 987,
      "totalItems": 987
    }
  }
}

Queries

`tournament`

Returns a Tournament

Name	Description
`id` - `ID!`

Example

Query

query tournament($id: ID!) {
  tournament(id: $id) {
    id
    end
    start
    entriesClose
    entriesOpen
    extensions {
      ...ExtensionFragment
    }
    formalName
    hostCountryCode
    indoorOutdoor
    localTimeZone
    notes
    promotionalName
    season
    surfaceCategory
    providerTournamentId
    unifiedTournamentId
    level
    name
    updatedAt
    createdAt
    withdrawalDeadline
    belongsToRequestingProvider
    subCategory
    persons {
      ...PersonListFragment
    }
    matchUps {
      ...MatchUpListFragment
    }
    provider {
      ...ProviderFragment
    }
  }
}

Variables

{"id": ID}

Response

{
  "data": {
    "tournament": {
      "id": ID,
      "end": DateTime,
      "start": DateTime,
      "entriesClose": DateTime,
      "entriesOpen": DateTime,
      "extensions": [Extension],
      "formalName": "abc123",
      "hostCountryCode": CountryCode,
      "indoorOutdoor": IndoorOutdoorEnum,
      "localTimeZone": "xyz789",
      "notes": "xyz789",
      "promotionalName": "abc123",
      "season": "xyz789",
      "surfaceCategory": SurfaceCategoryEnum,
      "providerTournamentId": "abc123",
      "unifiedTournamentId": "xyz789",
      "level": "xyz789",
      "name": "abc123",
      "updatedAt": DateTime,
      "createdAt": DateTime,
      "withdrawalDeadline": DateTime,
      "belongsToRequestingProvider": false,
      "subCategory": TournamentSubCategoryEnum,
      "persons": PersonList,
      "matchUps": MatchUpList,
      "provider": Provider
    }
  }
}

Queries

`tournamentCount`

Returns an Int

Name	Description
`filter` - `TournamentFilterOptions`

Example

Query

query tournamentCount($filter: TournamentFilterOptions) {
  tournamentCount(filter: $filter)
}

Variables

{"filter": TournamentFilterOptions}

Response

{"data": {"tournamentCount": 987}}

Queries

`tournaments`

Returns a TournamentList

Name	Description
`pageArgs` - `PaginationArgs`
`filter` - `TournamentFilterOptions`
`sort` - `SortOrder`

Example

Query

query tournaments($pageArgs: PaginationArgs, $filter: TournamentFilterOptions, $sort: SortOrder) {
  tournaments(pageArgs: $pageArgs, filter: $filter, sort: $sort) {
    items {
      ...TournamentFragment
    }
    totalItems
  }
}

Variables

{
  "pageArgs": PaginationArgs,
  "filter": TournamentFilterOptions,
  "sort": SortOrder
}

Response

{
  "data": {
    "tournaments": {
      "items": [Tournament],
      "totalItems": 123
    }
  }
}

Queries

`venue`

Returns a Venue

Name	Description
`id` - `ID!`

Example

Query

query venue($id: ID!) {
  venue(id: $id) {
    id
    name
    type
    courts {
      ...CourtFragment
    }
    notes
    addresses {
      ...AddressFragment
    }
    extensions {
      ...ExtensionFragment
    }
    providerVenueId
    updatedAt
    createdAt
  }
}

Variables

{"id": ID}

Response

{
  "data": {
    "venue": {
      "id": ID,
      "name": "xyz789",
      "type": "xyz789",
      "courts": [Court],
      "notes": "xyz789",
      "addresses": [Address],
      "extensions": [Extension],
      "providerVenueId": ID,
      "updatedAt": DateTime,
      "createdAt": DateTime
    }
  }
}

Queries

`venueCount`

Returns an Int

Name	Description
`filter` - `VenueFilterOptions`

Example

Query

query venueCount($filter: VenueFilterOptions) {
  venueCount(filter: $filter)
}

Variables

{"filter": VenueFilterOptions}

Response

{"data": {"venueCount": 123}}

Queries

`venues`

Returns a VenueList

Name	Description
`pageArgs` - `PaginationArgs`
`filter` - `VenueFilterOptions`
`sort` - `SortOrder`

Example

Query

query venues($pageArgs: PaginationArgs, $filter: VenueFilterOptions, $sort: SortOrder) {
  venues(pageArgs: $pageArgs, filter: $filter, sort: $sort) {
    items {
      ...VenueFragment
    }
    totalItems
  }
}

Variables

{
  "pageArgs": PaginationArgs,
  "filter": VenueFilterOptions,
  "sort": SortOrder
}

Response

{
  "data": {
    "venues": {"items": [Venue], "totalItems": 123}
  }
}

Queries

`watchlist`

Returns a Watchlist

Name	Description
`id` - `ID!`

Example

Query

query watchlist($id: ID!) {
  watchlist(id: $id) {
    ownerId
    id
    personIds
    name
    persons {
      ...PersonFragment
    }
    watchlistStats {
      ...WatchlistStatsFragment
    }
  }
}

Variables

{"id": ID}

Response

{
  "data": {
    "watchlist": {
      "ownerId": ID,
      "id": ID,
      "personIds": [ID],
      "name": "abc123",
      "persons": [Person],
      "watchlistStats": WatchlistStats
    }
  }
}

Queries

`watchlistIdsForPlayer`

Returns [ID!]!

Name	Description
`id` - `ID!`

Example

Query

query watchlistIdsForPlayer($id: ID!) {
  watchlistIdsForPlayer(id: $id)
}

Variables

{"id": ID}

Response

{"data": {"watchlistIdsForPlayer": [ID]}}

Queries

`watchlists`

Returns a WatchlistList

Example

Query

query watchlists {
  watchlists {
    items {
      ...WatchlistFragment
    }
    totalItems
  }
}

Response

{
  "data": {
    "watchlists": {
      "items": [Watchlist],
      "totalItems": 123
    }
  }
}

Queries

`worldTennisNumber`

Retrieves the current WorldTennisNumber for the specified person by TennisID

Returns [WorldTennisNumber]

Name	Description
`tennisID` - `ID!`

Example

Query

query worldTennisNumber($tennisID: ID!) {
  worldTennisNumber(tennisID: $tennisID) {
    confidence
    ratingDate
    tennisNumber
    prevTennisNumber
    type
    gameZoneUpper
    gameZoneLower
    source
    isRanked
  }
}

Variables

{"tennisID": ID}

Response

{
  "data": {
    "worldTennisNumber": [
      {
        "confidence": 987.65,
        "ratingDate": DateTime,
        "tennisNumber": 123.45,
        "prevTennisNumber": 123.45,
        "type": WorldTennisNumberTypeEnum,
        "gameZoneUpper": 987.65,
        "gameZoneLower": 987.65,
        "source": RatingSourceEnum,
        "isRanked": false
      }
    ]
  }
}

Queries

`worldTennisNumberHistory`

Retrieves the WorldTennisNumber history for the specified person

Returns a WorldTennisNumberList

Name	Description
`id` - `PersonIDInput!`
`pageArgs` - `PaginationArgs`
`filter` - `WorldTennisNumberFilterInput`
`sort` - `SortOrder`

Example

Query

query worldTennisNumberHistory($id: PersonIDInput!, $pageArgs: PaginationArgs, $filter: WorldTennisNumberFilterInput, $sort: SortOrder) {
  worldTennisNumberHistory(id: $id, pageArgs: $pageArgs, filter: $filter, sort: $sort) {
    items {
      ...WorldTennisNumberFragment
    }
    totalItems
  }
}

Variables

{
  "id": PersonIDInput,
  "pageArgs": PaginationArgs,
  "filter": WorldTennisNumberFilterInput,
  "sort": SortOrder
}

Response

{
  "data": {
    "worldTennisNumberHistory": {
      "items": [WorldTennisNumber],
      "totalItems": 987
    }
  }
}

Queries

`wtnLastYear`

Retrieves the WorldTennisNumber history for the previous year

Returns [WorldTennisNumber]

Name	Description
`tennisID` - `ID!`

Example

Query

query wtnLastYear($tennisID: ID!) {
  wtnLastYear(tennisID: $tennisID) {
    confidence
    ratingDate
    tennisNumber
    prevTennisNumber
    type
    gameZoneUpper
    gameZoneLower
    source
    isRanked
  }
}

Variables

{"tennisID": ID}

Response

{
  "data": {
    "wtnLastYear": [
      {
        "confidence": 987.65,
        "ratingDate": DateTime,
        "tennisNumber": 987.65,
        "prevTennisNumber": 123.45,
        "type": WorldTennisNumberTypeEnum,
        "gameZoneUpper": 123.45,
        "gameZoneLower": 987.65,
        "source": RatingSourceEnum,
        "isRanked": true
      }
    ]
  }
}

Queries

`wtnPast`

Retrieves the WorldTennisNumber history for the period between the specified dates

Returns [WorldTennisNumber]

Name	Description
`tennisID` - `ID!`
`startDate` - `String`
`endDate` - `String`

Example

Query

query wtnPast($tennisID: ID!, $startDate: String, $endDate: String) {
  wtnPast(tennisID: $tennisID, startDate: $startDate, endDate: $endDate) {
    confidence
    ratingDate
    tennisNumber
    prevTennisNumber
    type
    gameZoneUpper
    gameZoneLower
    source
    isRanked
  }
}

Variables

{
  "tennisID": ID,
  "startDate": "xyz789",
  "endDate": "xyz789"
}

Response

{
  "data": {
    "wtnPast": [
      {
        "confidence": 123.45,
        "ratingDate": DateTime,
        "tennisNumber": 987.65,
        "prevTennisNumber": 123.45,
        "type": WorldTennisNumberTypeEnum,
        "gameZoneUpper": 123.45,
        "gameZoneLower": 123.45,
        "source": RatingSourceEnum,
        "isRanked": false
      }
    ]
  }
}

Mutations

`addAccountPerson`

Returns an AddAccountPerson

Name	Description
`personInput` - `AddAccountPersonInput!`
`recaptchaInput` - `RecaptchaInput!`

Example

Query

mutation addAccountPerson($personInput: AddAccountPersonInput!, $recaptchaInput: RecaptchaInput!) {
  addAccountPerson(personInput: $personInput, recaptchaInput: $recaptchaInput) {
    id
    tennisId
    registrationToken
    nativeGivenName
    nativeFamilyName
    standardGivenName
    standardFamilyName
    sex
    birthDate
    birthYear
    nationalityCode
    countryOfResidenceCode
    alreadyItfCustomer
    alreadyRegisteredForService
    biographicalInformation {
      ...BiographicalInformationFragment
    }
    signUpType
  }
}

Variables

{
  "personInput": AddAccountPersonInput,
  "recaptchaInput": RecaptchaInput
}

Response

{
  "data": {
    "addAccountPerson": {
      "id": "xyz789",
      "tennisId": "xyz789",
      "registrationToken": "abc123",
      "nativeGivenName": "abc123",
      "nativeFamilyName": "abc123",
      "standardGivenName": "xyz789",
      "standardFamilyName": "abc123",
      "sex": SexEnum,
      "birthDate": "2026-03-31T14:07:52.371Z",
      "birthYear": 123,
      "nationalityCode": "abc123",
      "countryOfResidenceCode": "xyz789",
      "alreadyItfCustomer": false,
      "alreadyRegisteredForService": true,
      "biographicalInformation": BiographicalInformation,
      "signUpType": SignUpTypeEnum
    }
  }
}

Mutations

`addBatchMatchUps`

Use upsertBatchMatchUps instead.

Returns [MatchUp]

Name	Description
`input` - `[MatchUpInput!]!`

Example

Query

mutation addBatchMatchUps($input: [MatchUpInput!]!) {
  addBatchMatchUps(input: $input) {
    id
    score {
      ...ScoreFragment
    }
    sides {
      ...SideFragment
    }
    winningSide
    providerMatchId
    ageCategoryCode
    surfaceCategory
    indoorOutdoor
    type
    matchUpFormat
    grade
    start
    end
    circuit
    roundNumber
    roundPosition
    roundName
    humidity
    duration
    status
    statusCodes
    extensions {
      ...ExtensionFragment
    }
    createdAt
    updatedAt
    competitiveness
    state
    divisionType
    drawStructure
    drawType
    tieMatchUpId
    courtId
    surfaceType
    tournamentLevel
    pace
    gender
    drawId
    drawName
    venueId
    selfSubmittedResult
    ballType
    deleted
    collectionPosition
    wtnId
    wtnErrors
    isTied
    tournament {
      ...TournamentFragment
    }
    court {
      ...CourtFragment
    }
    venue {
      ...VenueFragment
    }
    provider {
      ...ProviderFragment
    }
    ownerId
    reviewedBy {
      ...PersonFragment
    }
    submissionState
    reviewedAt
    worldTennisNumbers {
      ...MatchUpWorldTennisNumberFragment
    }
  }
}

Variables

{"input": [MatchUpInput]}

Response

{
  "data": {
    "addBatchMatchUps": [
      {
        "id": ID,
        "score": Score,
        "sides": [Side],
        "winningSide": SideEnum,
        "providerMatchId": ID,
        "ageCategoryCode": "abc123",
        "surfaceCategory": SurfaceCategoryEnum,
        "indoorOutdoor": IndoorOutdoorEnum,
        "type": MatchUpTypeEnum,
        "matchUpFormat": "abc123",
        "grade": "xyz789",
        "start": DateTime,
        "end": DateTime,
        "circuit": CircuitEnum,
        "roundNumber": 123,
        "roundPosition": 987,
        "roundName": "xyz789",
        "humidity": 987.65,
        "duration": 987.65,
        "status": MatchUpStatusEnum,
        "statusCodes": ["abc123"],
        "extensions": [Extension],
        "createdAt": DateTime,
        "updatedAt": DateTime,
        "competitiveness": 987.65,
        "state": StateEnum,
        "divisionType": "xyz789",
        "drawStructure": DrawStructureEnum,
        "drawType": "abc123",
        "tieMatchUpId": ID,
        "courtId": ID,
        "surfaceType": SurfaceTypeEnum,
        "tournamentLevel": StandardGradeEnum,
        "pace": PaceEnum,
        "gender": MatchUpGenderEnum,
        "drawId": ID,
        "drawName": "xyz789",
        "venueId": ID,
        "selfSubmittedResult": true,
        "ballType": BallTypeEnum,
        "deleted": true,
        "collectionPosition": 123,
        "wtnId": ID,
        "wtnErrors": ["xyz789"],
        "isTied": true,
        "tournament": Tournament,
        "court": Court,
        "venue": Venue,
        "provider": Provider,
        "ownerId": ID,
        "reviewedBy": Person,
        "submissionState": MatchUpSubmissionStateEnum,
        "reviewedAt": DateTime,
        "worldTennisNumbers": [MatchUpWorldTennisNumber]
      }
    ]
  }
}

Mutations

`addBatchPersons`

Use createBatchPersons instead.

Returns [Person]

Name	Description
`input` - `[PersonInput!]!`

Example

Query

mutation addBatchPersons($input: [PersonInput!]!) {
  addBatchPersons(input: $input) {
    registrationInvite {
      ...InviteLinkFragment
    }
    clubs {
      ...ClubFragment
    }
    clubStatus
    id
    clubsparkId
    externalID
    tennisID
    nationalID
    personID
    biographicalInformation {
      ...BiographicalInformationFragment
    }
    extensions {
      ...ExtensionFragment
    }
    nationalityCode
    nativeFamilyName
    nativeGivenName
    nationalRating
    notes
    standardGivenName
    standardFamilyName
    birthDate
    isDeceased
    sex
    age
    birthYear
    worldTennisNumbers {
      ...WorldTennisNumberFragment
    }
    addresses {
      ...AddressFragment
    }
    createdAt
    updatedAt
    belongsToRequestingProvider
    lastPlayedSingles
    lastPlayedDoubles
    optedOutOfPublicDataConsent
    owningProviderId
    school {
      ...SchoolInfoFragment
    }
    isRanked
    rankedSingles
    rankedDoubles
    eligibleForSelfSubmission
    eligibleForPsq
    isRegistered
    section {
      ...SectionFragment
    }
    hasSubmittedResult
    tournaments {
      ...TournamentListFragment
    }
    matchUpIntervals {
      ...MatchUpIntervalsFragment
    }
    matchUpVsStatisticsCount {
      ...MatchUpVsStatisticsWinLossCountFragment
    }
    matchUps {
      ...MatchUpListFragment
    }
    demographicStats {
      ...DemographicStatFragment
    }
    ratingBounds {
      ...RatingBoundsFragment
    }
  }
}

Variables

{"input": [PersonInput]}

Response

{
  "data": {
    "addBatchPersons": [
      {
        "registrationInvite": InviteLink,
        "clubs": [Club],
        "clubStatus": PersonClubStatus,
        "id": ID,
        "clubsparkId": ID,
        "externalID": ID,
        "tennisID": ID,
        "nationalID": ID,
        "personID": ID,
        "biographicalInformation": BiographicalInformation,
        "extensions": [Extension],
        "nationalityCode": "xyz789",
        "nativeFamilyName": "xyz789",
        "nativeGivenName": "xyz789",
        "nationalRating": "xyz789",
        "notes": "abc123",
        "standardGivenName": "xyz789",
        "standardFamilyName": "xyz789",
        "birthDate": "2025-10-01T14:07:52.371Z",
        "isDeceased": true,
        "sex": SexEnum,
        "age": 123,
        "birthYear": 987,
        "worldTennisNumbers": [WorldTennisNumber],
        "addresses": [Address],
        "createdAt": DateTime,
        "updatedAt": DateTime,
        "belongsToRequestingProvider": true,
        "lastPlayedSingles": DateTime,
        "lastPlayedDoubles": DateTime,
        "optedOutOfPublicDataConsent": false,
        "owningProviderId": ID,
        "school": [SchoolInfo],
        "isRanked": true,
        "rankedSingles": false,
        "rankedDoubles": false,
        "eligibleForSelfSubmission": true,
        "eligibleForPsq": true,
        "isRegistered": false,
        "section": Section,
        "hasSubmittedResult": false,
        "tournaments": TournamentList,
        "matchUpIntervals": MatchUpIntervals,
        "matchUpVsStatisticsCount": MatchUpVsStatisticsWinLossCount,
        "matchUps": MatchUpList,
        "demographicStats": [DemographicStat],
        "ratingBounds": RatingBounds
      }
    ]
  }
}

Mutations

`addBatchTournaments`

Use upsertBatchTournaments instead.

Returns [Tournament]

Name	Description
`input` - `[TournamentInput!]!`

Example

Query

mutation addBatchTournaments($input: [TournamentInput!]!) {
  addBatchTournaments(input: $input) {
    id
    end
    start
    entriesClose
    entriesOpen
    extensions {
      ...ExtensionFragment
    }
    formalName
    hostCountryCode
    indoorOutdoor
    localTimeZone
    notes
    promotionalName
    season
    surfaceCategory
    providerTournamentId
    unifiedTournamentId
    level
    name
    updatedAt
    createdAt
    withdrawalDeadline
    belongsToRequestingProvider
    subCategory
    persons {
      ...PersonListFragment
    }
    matchUps {
      ...MatchUpListFragment
    }
    provider {
      ...ProviderFragment
    }
  }
}

Variables

{"input": [TournamentInput]}

Response

{
  "data": {
    "addBatchTournaments": [
      {
        "id": ID,
        "end": DateTime,
        "start": DateTime,
        "entriesClose": DateTime,
        "entriesOpen": DateTime,
        "extensions": [Extension],
        "formalName": "abc123",
        "hostCountryCode": CountryCode,
        "indoorOutdoor": IndoorOutdoorEnum,
        "localTimeZone": "xyz789",
        "notes": "abc123",
        "promotionalName": "abc123",
        "season": "xyz789",
        "surfaceCategory": SurfaceCategoryEnum,
        "providerTournamentId": "xyz789",
        "unifiedTournamentId": "abc123",
        "level": "xyz789",
        "name": "xyz789",
        "updatedAt": DateTime,
        "createdAt": DateTime,
        "withdrawalDeadline": DateTime,
        "belongsToRequestingProvider": true,
        "subCategory": TournamentSubCategoryEnum,
        "persons": PersonList,
        "matchUps": MatchUpList,
        "provider": Provider
      }
    ]
  }
}

Mutations

`addBatchVenues`

Returns [Venue]

Name	Description
`input` - `[VenueInput!]!`

Example

Query

mutation addBatchVenues($input: [VenueInput!]!) {
  addBatchVenues(input: $input) {
    id
    name
    type
    courts {
      ...CourtFragment
    }
    notes
    addresses {
      ...AddressFragment
    }
    extensions {
      ...ExtensionFragment
    }
    providerVenueId
    updatedAt
    createdAt
  }
}

Variables

{"input": [VenueInput]}

Response

{
  "data": {
    "addBatchVenues": [
      {
        "id": ID,
        "name": "xyz789",
        "type": "abc123",
        "courts": [Court],
        "notes": "xyz789",
        "addresses": [Address],
        "extensions": [Extension],
        "providerVenueId": ID,
        "updatedAt": DateTime,
        "createdAt": DateTime
      }
    ]
  }
}

Mutations

`addMatchUp`

Returns a MatchUp

Name	Description
`input` - `MatchUpInput!`

Example

Query

mutation addMatchUp($input: MatchUpInput!) {
  addMatchUp(input: $input) {
    id
    score {
      ...ScoreFragment
    }
    sides {
      ...SideFragment
    }
    winningSide
    providerMatchId
    ageCategoryCode
    surfaceCategory
    indoorOutdoor
    type
    matchUpFormat
    grade
    start
    end
    circuit
    roundNumber
    roundPosition
    roundName
    humidity
    duration
    status
    statusCodes
    extensions {
      ...ExtensionFragment
    }
    createdAt
    updatedAt
    competitiveness
    state
    divisionType
    drawStructure
    drawType
    tieMatchUpId
    courtId
    surfaceType
    tournamentLevel
    pace
    gender
    drawId
    drawName
    venueId
    selfSubmittedResult
    ballType
    deleted
    collectionPosition
    wtnId
    wtnErrors
    isTied
    tournament {
      ...TournamentFragment
    }
    court {
      ...CourtFragment
    }
    venue {
      ...VenueFragment
    }
    provider {
      ...ProviderFragment
    }
    ownerId
    reviewedBy {
      ...PersonFragment
    }
    submissionState
    reviewedAt
    worldTennisNumbers {
      ...MatchUpWorldTennisNumberFragment
    }
  }
}

Variables

{"input": MatchUpInput}

Response

{
  "data": {
    "addMatchUp": {
      "id": ID,
      "score": Score,
      "sides": [Side],
      "winningSide": SideEnum,
      "providerMatchId": ID,
      "ageCategoryCode": "xyz789",
      "surfaceCategory": SurfaceCategoryEnum,
      "indoorOutdoor": IndoorOutdoorEnum,
      "type": MatchUpTypeEnum,
      "matchUpFormat": "abc123",
      "grade": "abc123",
      "start": DateTime,
      "end": DateTime,
      "circuit": CircuitEnum,
      "roundNumber": 987,
      "roundPosition": 987,
      "roundName": "abc123",
      "humidity": 123.45,
      "duration": 123.45,
      "status": MatchUpStatusEnum,
      "statusCodes": ["xyz789"],
      "extensions": [Extension],
      "createdAt": DateTime,
      "updatedAt": DateTime,
      "competitiveness": 987.65,
      "state": StateEnum,
      "divisionType": "xyz789",
      "drawStructure": DrawStructureEnum,
      "drawType": "xyz789",
      "tieMatchUpId": ID,
      "courtId": ID,
      "surfaceType": SurfaceTypeEnum,
      "tournamentLevel": StandardGradeEnum,
      "pace": PaceEnum,
      "gender": MatchUpGenderEnum,
      "drawId": ID,
      "drawName": "abc123",
      "venueId": ID,
      "selfSubmittedResult": false,
      "ballType": BallTypeEnum,
      "deleted": true,
      "collectionPosition": 987,
      "wtnId": ID,
      "wtnErrors": ["abc123"],
      "isTied": true,
      "tournament": Tournament,
      "court": Court,
      "venue": Venue,
      "provider": Provider,
      "ownerId": ID,
      "reviewedBy": Person,
      "submissionState": MatchUpSubmissionStateEnum,
      "reviewedAt": DateTime,
      "worldTennisNumbers": [MatchUpWorldTennisNumber]
    }
  }
}

Mutations

`addPerson`

Returns a Person

Name	Description
`input` - `PersonInput!`

Example

Query

mutation addPerson($input: PersonInput!) {
  addPerson(input: $input) {
    registrationInvite {
      ...InviteLinkFragment
    }
    clubs {
      ...ClubFragment
    }
    clubStatus
    id
    clubsparkId
    externalID
    tennisID
    nationalID
    personID
    biographicalInformation {
      ...BiographicalInformationFragment
    }
    extensions {
      ...ExtensionFragment
    }
    nationalityCode
    nativeFamilyName
    nativeGivenName
    nationalRating
    notes
    standardGivenName
    standardFamilyName
    birthDate
    isDeceased
    sex
    age
    birthYear
    worldTennisNumbers {
      ...WorldTennisNumberFragment
    }
    addresses {
      ...AddressFragment
    }
    createdAt
    updatedAt
    belongsToRequestingProvider
    lastPlayedSingles
    lastPlayedDoubles
    optedOutOfPublicDataConsent
    owningProviderId
    school {
      ...SchoolInfoFragment
    }
    isRanked
    rankedSingles
    rankedDoubles
    eligibleForSelfSubmission
    eligibleForPsq
    isRegistered
    section {
      ...SectionFragment
    }
    hasSubmittedResult
    tournaments {
      ...TournamentListFragment
    }
    matchUpIntervals {
      ...MatchUpIntervalsFragment
    }
    matchUpVsStatisticsCount {
      ...MatchUpVsStatisticsWinLossCountFragment
    }
    matchUps {
      ...MatchUpListFragment
    }
    demographicStats {
      ...DemographicStatFragment
    }
    ratingBounds {
      ...RatingBoundsFragment
    }
  }
}

Variables

{"input": PersonInput}

Response

{
  "data": {
    "addPerson": {
      "registrationInvite": InviteLink,
      "clubs": [Club],
      "clubStatus": PersonClubStatus,
      "id": ID,
      "clubsparkId": ID,
      "externalID": ID,
      "tennisID": ID,
      "nationalID": ID,
      "personID": ID,
      "biographicalInformation": BiographicalInformation,
      "extensions": [Extension],
      "nationalityCode": "xyz789",
      "nativeFamilyName": "abc123",
      "nativeGivenName": "abc123",
      "nationalRating": "xyz789",
      "notes": "abc123",
      "standardGivenName": "abc123",
      "standardFamilyName": "abc123",
      "birthDate": "2025-10-01T14:07:52.371Z",
      "isDeceased": true,
      "sex": SexEnum,
      "age": 987,
      "birthYear": 987,
      "worldTennisNumbers": [WorldTennisNumber],
      "addresses": [Address],
      "createdAt": DateTime,
      "updatedAt": DateTime,
      "belongsToRequestingProvider": false,
      "lastPlayedSingles": DateTime,
      "lastPlayedDoubles": DateTime,
      "optedOutOfPublicDataConsent": true,
      "owningProviderId": ID,
      "school": [SchoolInfo],
      "isRanked": true,
      "rankedSingles": false,
      "rankedDoubles": true,
      "eligibleForSelfSubmission": true,
      "eligibleForPsq": false,
      "isRegistered": true,
      "section": Section,
      "hasSubmittedResult": true,
      "tournaments": TournamentList,
      "matchUpIntervals": MatchUpIntervals,
      "matchUpVsStatisticsCount": MatchUpVsStatisticsWinLossCount,
      "matchUps": MatchUpList,
      "demographicStats": [DemographicStat],
      "ratingBounds": RatingBounds
    }
  }
}

Mutations

`addPersonsToWatchlists`

Returns a WatchlistList

Name	Description
`watchlistIds` - `[ID!]!`
`personIds` - `[ID!]!`

Example

Query

mutation addPersonsToWatchlists($watchlistIds: [ID!]!, $personIds: [ID!]!) {
  addPersonsToWatchlists(watchlistIds: $watchlistIds, personIds: $personIds) {
    items {
      ...WatchlistFragment
    }
    totalItems
  }
}

Variables

{
  "watchlistIds": [ID],
  "personIds": [ID]
}

Response

{
  "data": {
    "addPersonsToWatchlists": {
      "items": [Watchlist],
      "totalItems": 987
    }
  }
}

Mutations

`addPersonToClub`

Returns a Boolean

Name	Description
`personId` - `ID!`
`clubId` - `ID!`
`role` - `ClubMemberRole`

Example

Query

mutation addPersonToClub($personId: ID!, $clubId: ID!, $role: ClubMemberRole) {
  addPersonToClub(personId: $personId, clubId: $clubId, role: $role)
}

Variables

{
  "personId": ID,
  "clubId": ID,
  "role": ClubMemberRole
}

Response

{"data": {"addPersonToClub": true}}

Mutations

`addSelfSubmittedMatchUp`

Returns a MatchUp

Name	Description
`input` - `SelfSubmittedMatchUpInput!`

Example

Query

mutation addSelfSubmittedMatchUp($input: SelfSubmittedMatchUpInput!) {
  addSelfSubmittedMatchUp(input: $input) {
    id
    score {
      ...ScoreFragment
    }
    sides {
      ...SideFragment
    }
    winningSide
    providerMatchId
    ageCategoryCode
    surfaceCategory
    indoorOutdoor
    type
    matchUpFormat
    grade
    start
    end
    circuit
    roundNumber
    roundPosition
    roundName
    humidity
    duration
    status
    statusCodes
    extensions {
      ...ExtensionFragment
    }
    createdAt
    updatedAt
    competitiveness
    state
    divisionType
    drawStructure
    drawType
    tieMatchUpId
    courtId
    surfaceType
    tournamentLevel
    pace
    gender
    drawId
    drawName
    venueId
    selfSubmittedResult
    ballType
    deleted
    collectionPosition
    wtnId
    wtnErrors
    isTied
    tournament {
      ...TournamentFragment
    }
    court {
      ...CourtFragment
    }
    venue {
      ...VenueFragment
    }
    provider {
      ...ProviderFragment
    }
    ownerId
    reviewedBy {
      ...PersonFragment
    }
    submissionState
    reviewedAt
    worldTennisNumbers {
      ...MatchUpWorldTennisNumberFragment
    }
  }
}

Variables

{"input": SelfSubmittedMatchUpInput}

Response

{
  "data": {
    "addSelfSubmittedMatchUp": {
      "id": ID,
      "score": Score,
      "sides": [Side],
      "winningSide": SideEnum,
      "providerMatchId": ID,
      "ageCategoryCode": "abc123",
      "surfaceCategory": SurfaceCategoryEnum,
      "indoorOutdoor": IndoorOutdoorEnum,
      "type": MatchUpTypeEnum,
      "matchUpFormat": "abc123",
      "grade": "xyz789",
      "start": DateTime,
      "end": DateTime,
      "circuit": CircuitEnum,
      "roundNumber": 987,
      "roundPosition": 987,
      "roundName": "xyz789",
      "humidity": 987.65,
      "duration": 123.45,
      "status": MatchUpStatusEnum,
      "statusCodes": ["xyz789"],
      "extensions": [Extension],
      "createdAt": DateTime,
      "updatedAt": DateTime,
      "competitiveness": 123.45,
      "state": StateEnum,
      "divisionType": "xyz789",
      "drawStructure": DrawStructureEnum,
      "drawType": "abc123",
      "tieMatchUpId": ID,
      "courtId": ID,
      "surfaceType": SurfaceTypeEnum,
      "tournamentLevel": StandardGradeEnum,
      "pace": PaceEnum,
      "gender": MatchUpGenderEnum,
      "drawId": ID,
      "drawName": "abc123",
      "venueId": ID,
      "selfSubmittedResult": true,
      "ballType": BallTypeEnum,
      "deleted": true,
      "collectionPosition": 987,
      "wtnId": ID,
      "wtnErrors": ["xyz789"],
      "isTied": false,
      "tournament": Tournament,
      "court": Court,
      "venue": Venue,
      "provider": Provider,
      "ownerId": ID,
      "reviewedBy": Person,
      "submissionState": MatchUpSubmissionStateEnum,
      "reviewedAt": DateTime,
      "worldTennisNumbers": [MatchUpWorldTennisNumber]
    }
  }
}

Mutations

`addTournament`

Returns a Tournament

Name	Description
`input` - `TournamentInput!`

Example

Query

mutation addTournament($input: TournamentInput!) {
  addTournament(input: $input) {
    id
    end
    start
    entriesClose
    entriesOpen
    extensions {
      ...ExtensionFragment
    }
    formalName
    hostCountryCode
    indoorOutdoor
    localTimeZone
    notes
    promotionalName
    season
    surfaceCategory
    providerTournamentId
    unifiedTournamentId
    level
    name
    updatedAt
    createdAt
    withdrawalDeadline
    belongsToRequestingProvider
    subCategory
    persons {
      ...PersonListFragment
    }
    matchUps {
      ...MatchUpListFragment
    }
    provider {
      ...ProviderFragment
    }
  }
}

Variables

{"input": TournamentInput}

Response

{
  "data": {
    "addTournament": {
      "id": ID,
      "end": DateTime,
      "start": DateTime,
      "entriesClose": DateTime,
      "entriesOpen": DateTime,
      "extensions": [Extension],
      "formalName": "xyz789",
      "hostCountryCode": CountryCode,
      "indoorOutdoor": IndoorOutdoorEnum,
      "localTimeZone": "abc123",
      "notes": "abc123",
      "promotionalName": "abc123",
      "season": "abc123",
      "surfaceCategory": SurfaceCategoryEnum,
      "providerTournamentId": "abc123",
      "unifiedTournamentId": "xyz789",
      "level": "xyz789",
      "name": "xyz789",
      "updatedAt": DateTime,
      "createdAt": DateTime,
      "withdrawalDeadline": DateTime,
      "belongsToRequestingProvider": true,
      "subCategory": TournamentSubCategoryEnum,
      "persons": PersonList,
      "matchUps": MatchUpList,
      "provider": Provider
    }
  }
}

Mutations

`addVenue`

Returns a Venue

Name	Description
`input` - `VenueInput!`

Example

Query

mutation addVenue($input: VenueInput!) {
  addVenue(input: $input) {
    id
    name
    type
    courts {
      ...CourtFragment
    }
    notes
    addresses {
      ...AddressFragment
    }
    extensions {
      ...ExtensionFragment
    }
    providerVenueId
    updatedAt
    createdAt
  }
}

Variables

{"input": VenueInput}

Response

{
  "data": {
    "addVenue": {
      "id": ID,
      "name": "xyz789",
      "type": "xyz789",
      "courts": [Court],
      "notes": "xyz789",
      "addresses": [Address],
      "extensions": [Extension],
      "providerVenueId": ID,
      "updatedAt": DateTime,
      "createdAt": DateTime
    }
  }
}

Mutations

`addWatchlist`

Returns a Watchlist

Name	Description
`input` - `WatchlistInput`

Example

Query

mutation addWatchlist($input: WatchlistInput) {
  addWatchlist(input: $input) {
    ownerId
    id
    personIds
    name
    persons {
      ...PersonFragment
    }
    watchlistStats {
      ...WatchlistStatsFragment
    }
  }
}

Variables

{"input": WatchlistInput}

Response

{
  "data": {
    "addWatchlist": {
      "ownerId": ID,
      "id": ID,
      "personIds": [ID],
      "name": "xyz789",
      "persons": [Person],
      "watchlistStats": WatchlistStats
    }
  }
}

Mutations

`approveSelfSubmittedMatchUp`

Returns a MatchUp

Name	Description
`id` - `ID!`

Example

Query

mutation approveSelfSubmittedMatchUp($id: ID!) {
  approveSelfSubmittedMatchUp(id: $id) {
    id
    score {
      ...ScoreFragment
    }
    sides {
      ...SideFragment
    }
    winningSide
    providerMatchId
    ageCategoryCode
    surfaceCategory
    indoorOutdoor
    type
    matchUpFormat
    grade
    start
    end
    circuit
    roundNumber
    roundPosition
    roundName
    humidity
    duration
    status
    statusCodes
    extensions {
      ...ExtensionFragment
    }
    createdAt
    updatedAt
    competitiveness
    state
    divisionType
    drawStructure
    drawType
    tieMatchUpId
    courtId
    surfaceType
    tournamentLevel
    pace
    gender
    drawId
    drawName
    venueId
    selfSubmittedResult
    ballType
    deleted
    collectionPosition
    wtnId
    wtnErrors
    isTied
    tournament {
      ...TournamentFragment
    }
    court {
      ...CourtFragment
    }
    venue {
      ...VenueFragment
    }
    provider {
      ...ProviderFragment
    }
    ownerId
    reviewedBy {
      ...PersonFragment
    }
    submissionState
    reviewedAt
    worldTennisNumbers {
      ...MatchUpWorldTennisNumberFragment
    }
  }
}

Variables

{"id": ID}

Response

{
  "data": {
    "approveSelfSubmittedMatchUp": {
      "id": ID,
      "score": Score,
      "sides": [Side],
      "winningSide": SideEnum,
      "providerMatchId": ID,
      "ageCategoryCode": "xyz789",
      "surfaceCategory": SurfaceCategoryEnum,
      "indoorOutdoor": IndoorOutdoorEnum,
      "type": MatchUpTypeEnum,
      "matchUpFormat": "abc123",
      "grade": "abc123",
      "start": DateTime,
      "end": DateTime,
      "circuit": CircuitEnum,
      "roundNumber": 987,
      "roundPosition": 987,
      "roundName": "abc123",
      "humidity": 987.65,
      "duration": 123.45,
      "status": MatchUpStatusEnum,
      "statusCodes": ["abc123"],
      "extensions": [Extension],
      "createdAt": DateTime,
      "updatedAt": DateTime,
      "competitiveness": 987.65,
      "state": StateEnum,
      "divisionType": "xyz789",
      "drawStructure": DrawStructureEnum,
      "drawType": "abc123",
      "tieMatchUpId": ID,
      "courtId": ID,
      "surfaceType": SurfaceTypeEnum,
      "tournamentLevel": StandardGradeEnum,
      "pace": PaceEnum,
      "gender": MatchUpGenderEnum,
      "drawId": ID,
      "drawName": "xyz789",
      "venueId": ID,
      "selfSubmittedResult": true,
      "ballType": BallTypeEnum,
      "deleted": true,
      "collectionPosition": 123,
      "wtnId": ID,
      "wtnErrors": ["abc123"],
      "isTied": true,
      "tournament": Tournament,
      "court": Court,
      "venue": Venue,
      "provider": Provider,
      "ownerId": ID,
      "reviewedBy": Person,
      "submissionState": MatchUpSubmissionStateEnum,
      "reviewedAt": DateTime,
      "worldTennisNumbers": [MatchUpWorldTennisNumber]
    }
  }
}

Mutations

`createBatchPersons`

Returns a CreateBatchPersonsResult

Name	Description
`input` - `[PersonInput!]!`

Example

Query

mutation createBatchPersons($input: [PersonInput!]!) {
  createBatchPersons(input: $input) {
    items {
      ...PersonFragment
    }
    totalItems
    batchErrors
    totalBatchErrors
  }
}

Variables

{"input": [PersonInput]}

Response

{
  "data": {
    "createBatchPersons": {
      "items": [Person],
      "totalItems": 123,
      "batchErrors": ["abc123"],
      "totalBatchErrors": 123
    }
  }
}

Mutations

`mergePerson`

Returns a PersonMergeResult

Name	Description
`targetPersonID` - `PersonIDInput!`
`additionalPersonID` - `PersonIDInput!`

Example

Query

mutation mergePerson($targetPersonID: PersonIDInput!, $additionalPersonID: PersonIDInput!) {
  mergePerson(targetPersonID: $targetPersonID, additionalPersonID: $additionalPersonID) {
    code
    reason
    person {
      ...PersonFragment
    }
  }
}

Variables

{
  "targetPersonID": PersonIDInput,
  "additionalPersonID": PersonIDInput
}

Response

{
  "data": {
    "mergePerson": {
      "code": 123,
      "reason": "xyz789",
      "person": Person
    }
  }
}

Mutations

`personSubmitPSQ`

Returns [WorldTennisNumber]

Name	Description
`id` - `PersonIDInput!`
`input` - `PersonPSQInput!`
`type` - `WorldTennisNumberTypeEnum`

Example

Query

mutation personSubmitPSQ($id: PersonIDInput!, $input: PersonPSQInput!, $type: WorldTennisNumberTypeEnum) {
  personSubmitPSQ(id: $id, input: $input, type: $type) {
    confidence
    ratingDate
    tennisNumber
    prevTennisNumber
    type
    gameZoneUpper
    gameZoneLower
    source
    isRanked
  }
}

Variables

{
  "id": PersonIDInput,
  "input": PersonPSQInput,
  "type": WorldTennisNumberTypeEnum
}

Response

{
  "data": {
    "personSubmitPSQ": [
      {
        "confidence": 123.45,
        "ratingDate": DateTime,
        "tennisNumber": 123.45,
        "prevTennisNumber": 123.45,
        "type": WorldTennisNumberTypeEnum,
        "gameZoneUpper": 987.65,
        "gameZoneLower": 987.65,
        "source": RatingSourceEnum,
        "isRanked": false
      }
    ]
  }
}

Mutations

`rejectSelfSubmittedMatchUp`

Returns a MatchUp

Name	Description
`id` - `ID!`

Example

Query

mutation rejectSelfSubmittedMatchUp($id: ID!) {
  rejectSelfSubmittedMatchUp(id: $id) {
    id
    score {
      ...ScoreFragment
    }
    sides {
      ...SideFragment
    }
    winningSide
    providerMatchId
    ageCategoryCode
    surfaceCategory
    indoorOutdoor
    type
    matchUpFormat
    grade
    start
    end
    circuit
    roundNumber
    roundPosition
    roundName
    humidity
    duration
    status
    statusCodes
    extensions {
      ...ExtensionFragment
    }
    createdAt
    updatedAt
    competitiveness
    state
    divisionType
    drawStructure
    drawType
    tieMatchUpId
    courtId
    surfaceType
    tournamentLevel
    pace
    gender
    drawId
    drawName
    venueId
    selfSubmittedResult
    ballType
    deleted
    collectionPosition
    wtnId
    wtnErrors
    isTied
    tournament {
      ...TournamentFragment
    }
    court {
      ...CourtFragment
    }
    venue {
      ...VenueFragment
    }
    provider {
      ...ProviderFragment
    }
    ownerId
    reviewedBy {
      ...PersonFragment
    }
    submissionState
    reviewedAt
    worldTennisNumbers {
      ...MatchUpWorldTennisNumberFragment
    }
  }
}

Variables

{"id": ID}

Response

{
  "data": {
    "rejectSelfSubmittedMatchUp": {
      "id": ID,
      "score": Score,
      "sides": [Side],
      "winningSide": SideEnum,
      "providerMatchId": ID,
      "ageCategoryCode": "abc123",
      "surfaceCategory": SurfaceCategoryEnum,
      "indoorOutdoor": IndoorOutdoorEnum,
      "type": MatchUpTypeEnum,
      "matchUpFormat": "xyz789",
      "grade": "abc123",
      "start": DateTime,
      "end": DateTime,
      "circuit": CircuitEnum,
      "roundNumber": 987,
      "roundPosition": 123,
      "roundName": "xyz789",
      "humidity": 987.65,
      "duration": 987.65,
      "status": MatchUpStatusEnum,
      "statusCodes": ["abc123"],
      "extensions": [Extension],
      "createdAt": DateTime,
      "updatedAt": DateTime,
      "competitiveness": 987.65,
      "state": StateEnum,
      "divisionType": "abc123",
      "drawStructure": DrawStructureEnum,
      "drawType": "abc123",
      "tieMatchUpId": ID,
      "courtId": ID,
      "surfaceType": SurfaceTypeEnum,
      "tournamentLevel": StandardGradeEnum,
      "pace": PaceEnum,
      "gender": MatchUpGenderEnum,
      "drawId": ID,
      "drawName": "abc123",
      "venueId": ID,
      "selfSubmittedResult": false,
      "ballType": BallTypeEnum,
      "deleted": false,
      "collectionPosition": 123,
      "wtnId": ID,
      "wtnErrors": ["abc123"],
      "isTied": true,
      "tournament": Tournament,
      "court": Court,
      "venue": Venue,
      "provider": Provider,
      "ownerId": ID,
      "reviewedBy": Person,
      "submissionState": MatchUpSubmissionStateEnum,
      "reviewedAt": DateTime,
      "worldTennisNumbers": [MatchUpWorldTennisNumber]
    }
  }
}

Mutations

`removeMatchUp`

Returns a MatchUp

Name	Description
`id` - `ID!`

Example

Query

mutation removeMatchUp($id: ID!) {
  removeMatchUp(id: $id) {
    id
    score {
      ...ScoreFragment
    }
    sides {
      ...SideFragment
    }
    winningSide
    providerMatchId
    ageCategoryCode
    surfaceCategory
    indoorOutdoor
    type
    matchUpFormat
    grade
    start
    end
    circuit
    roundNumber
    roundPosition
    roundName
    humidity
    duration
    status
    statusCodes
    extensions {
      ...ExtensionFragment
    }
    createdAt
    updatedAt
    competitiveness
    state
    divisionType
    drawStructure
    drawType
    tieMatchUpId
    courtId
    surfaceType
    tournamentLevel
    pace
    gender
    drawId
    drawName
    venueId
    selfSubmittedResult
    ballType
    deleted
    collectionPosition
    wtnId
    wtnErrors
    isTied
    tournament {
      ...TournamentFragment
    }
    court {
      ...CourtFragment
    }
    venue {
      ...VenueFragment
    }
    provider {
      ...ProviderFragment
    }
    ownerId
    reviewedBy {
      ...PersonFragment
    }
    submissionState
    reviewedAt
    worldTennisNumbers {
      ...MatchUpWorldTennisNumberFragment
    }
  }
}

Variables

{"id": ID}

Response

{
  "data": {
    "removeMatchUp": {
      "id": ID,
      "score": Score,
      "sides": [Side],
      "winningSide": SideEnum,
      "providerMatchId": ID,
      "ageCategoryCode": "xyz789",
      "surfaceCategory": SurfaceCategoryEnum,
      "indoorOutdoor": IndoorOutdoorEnum,
      "type": MatchUpTypeEnum,
      "matchUpFormat": "abc123",
      "grade": "xyz789",
      "start": DateTime,
      "end": DateTime,
      "circuit": CircuitEnum,
      "roundNumber": 987,
      "roundPosition": 987,
      "roundName": "abc123",
      "humidity": 987.65,
      "duration": 123.45,
      "status": MatchUpStatusEnum,
      "statusCodes": ["xyz789"],
      "extensions": [Extension],
      "createdAt": DateTime,
      "updatedAt": DateTime,
      "competitiveness": 123.45,
      "state": StateEnum,
      "divisionType": "xyz789",
      "drawStructure": DrawStructureEnum,
      "drawType": "xyz789",
      "tieMatchUpId": ID,
      "courtId": ID,
      "surfaceType": SurfaceTypeEnum,
      "tournamentLevel": StandardGradeEnum,
      "pace": PaceEnum,
      "gender": MatchUpGenderEnum,
      "drawId": ID,
      "drawName": "abc123",
      "venueId": ID,
      "selfSubmittedResult": false,
      "ballType": BallTypeEnum,
      "deleted": true,
      "collectionPosition": 987,
      "wtnId": ID,
      "wtnErrors": ["abc123"],
      "isTied": true,
      "tournament": Tournament,
      "court": Court,
      "venue": Venue,
      "provider": Provider,
      "ownerId": ID,
      "reviewedBy": Person,
      "submissionState": MatchUpSubmissionStateEnum,
      "reviewedAt": DateTime,
      "worldTennisNumbers": [MatchUpWorldTennisNumber]
    }
  }
}

Mutations

`removeMatchUps`

Returns [MatchUp]

Name	Description
`filter` - `MatchUpRemoveOptions!`

Example

Query

mutation removeMatchUps($filter: MatchUpRemoveOptions!) {
  removeMatchUps(filter: $filter) {
    id
    score {
      ...ScoreFragment
    }
    sides {
      ...SideFragment
    }
    winningSide
    providerMatchId
    ageCategoryCode
    surfaceCategory
    indoorOutdoor
    type
    matchUpFormat
    grade
    start
    end
    circuit
    roundNumber
    roundPosition
    roundName
    humidity
    duration
    status
    statusCodes
    extensions {
      ...ExtensionFragment
    }
    createdAt
    updatedAt
    competitiveness
    state
    divisionType
    drawStructure
    drawType
    tieMatchUpId
    courtId
    surfaceType
    tournamentLevel
    pace
    gender
    drawId
    drawName
    venueId
    selfSubmittedResult
    ballType
    deleted
    collectionPosition
    wtnId
    wtnErrors
    isTied
    tournament {
      ...TournamentFragment
    }
    court {
      ...CourtFragment
    }
    venue {
      ...VenueFragment
    }
    provider {
      ...ProviderFragment
    }
    ownerId
    reviewedBy {
      ...PersonFragment
    }
    submissionState
    reviewedAt
    worldTennisNumbers {
      ...MatchUpWorldTennisNumberFragment
    }
  }
}

Variables

{"filter": MatchUpRemoveOptions}

Response

{
  "data": {
    "removeMatchUps": [
      {
        "id": ID,
        "score": Score,
        "sides": [Side],
        "winningSide": SideEnum,
        "providerMatchId": ID,
        "ageCategoryCode": "xyz789",
        "surfaceCategory": SurfaceCategoryEnum,
        "indoorOutdoor": IndoorOutdoorEnum,
        "type": MatchUpTypeEnum,
        "matchUpFormat": "abc123",
        "grade": "xyz789",
        "start": DateTime,
        "end": DateTime,
        "circuit": CircuitEnum,
        "roundNumber": 123,
        "roundPosition": 987,
        "roundName": "xyz789",
        "humidity": 987.65,
        "duration": 987.65,
        "status": MatchUpStatusEnum,
        "statusCodes": ["abc123"],
        "extensions": [Extension],
        "createdAt": DateTime,
        "updatedAt": DateTime,
        "competitiveness": 987.65,
        "state": StateEnum,
        "divisionType": "abc123",
        "drawStructure": DrawStructureEnum,
        "drawType": "abc123",
        "tieMatchUpId": ID,
        "courtId": ID,
        "surfaceType": SurfaceTypeEnum,
        "tournamentLevel": StandardGradeEnum,
        "pace": PaceEnum,
        "gender": MatchUpGenderEnum,
        "drawId": ID,
        "drawName": "xyz789",
        "venueId": ID,
        "selfSubmittedResult": true,
        "ballType": BallTypeEnum,
        "deleted": true,
        "collectionPosition": 987,
        "wtnId": ID,
        "wtnErrors": ["abc123"],
        "isTied": true,
        "tournament": Tournament,
        "court": Court,
        "venue": Venue,
        "provider": Provider,
        "ownerId": ID,
        "reviewedBy": Person,
        "submissionState": MatchUpSubmissionStateEnum,
        "reviewedAt": DateTime,
        "worldTennisNumbers": [MatchUpWorldTennisNumber]
      }
    ]
  }
}

Mutations

`removePerson`

Returns a Person

Name	Description
`id` - `PersonIDInput!`

Example

Query

mutation removePerson($id: PersonIDInput!) {
  removePerson(id: $id) {
    registrationInvite {
      ...InviteLinkFragment
    }
    clubs {
      ...ClubFragment
    }
    clubStatus
    id
    clubsparkId
    externalID
    tennisID
    nationalID
    personID
    biographicalInformation {
      ...BiographicalInformationFragment
    }
    extensions {
      ...ExtensionFragment
    }
    nationalityCode
    nativeFamilyName
    nativeGivenName
    nationalRating
    notes
    standardGivenName
    standardFamilyName
    birthDate
    isDeceased
    sex
    age
    birthYear
    worldTennisNumbers {
      ...WorldTennisNumberFragment
    }
    addresses {
      ...AddressFragment
    }
    createdAt
    updatedAt
    belongsToRequestingProvider
    lastPlayedSingles
    lastPlayedDoubles
    optedOutOfPublicDataConsent
    owningProviderId
    school {
      ...SchoolInfoFragment
    }
    isRanked
    rankedSingles
    rankedDoubles
    eligibleForSelfSubmission
    eligibleForPsq
    isRegistered
    section {
      ...SectionFragment
    }
    hasSubmittedResult
    tournaments {
      ...TournamentListFragment
    }
    matchUpIntervals {
      ...MatchUpIntervalsFragment
    }
    matchUpVsStatisticsCount {
      ...MatchUpVsStatisticsWinLossCountFragment
    }
    matchUps {
      ...MatchUpListFragment
    }
    demographicStats {
      ...DemographicStatFragment
    }
    ratingBounds {
      ...RatingBoundsFragment
    }
  }
}

Variables

{"id": PersonIDInput}

Response

{
  "data": {
    "removePerson": {
      "registrationInvite": InviteLink,
      "clubs": [Club],
      "clubStatus": PersonClubStatus,
      "id": ID,
      "clubsparkId": ID,
      "externalID": ID,
      "tennisID": ID,
      "nationalID": ID,
      "personID": ID,
      "biographicalInformation": BiographicalInformation,
      "extensions": [Extension],
      "nationalityCode": "xyz789",
      "nativeFamilyName": "xyz789",
      "nativeGivenName": "abc123",
      "nationalRating": "abc123",
      "notes": "xyz789",
      "standardGivenName": "xyz789",
      "standardFamilyName": "xyz789",
      "birthDate": "2025-10-01T14:07:52.371Z",
      "isDeceased": true,
      "sex": SexEnum,
      "age": 987,
      "birthYear": 987,
      "worldTennisNumbers": [WorldTennisNumber],
      "addresses": [Address],
      "createdAt": DateTime,
      "updatedAt": DateTime,
      "belongsToRequestingProvider": true,
      "lastPlayedSingles": DateTime,
      "lastPlayedDoubles": DateTime,
      "optedOutOfPublicDataConsent": true,
      "owningProviderId": ID,
      "school": [SchoolInfo],
      "isRanked": false,
      "rankedSingles": false,
      "rankedDoubles": false,
      "eligibleForSelfSubmission": true,
      "eligibleForPsq": false,
      "isRegistered": false,
      "section": Section,
      "hasSubmittedResult": true,
      "tournaments": TournamentList,
      "matchUpIntervals": MatchUpIntervals,
      "matchUpVsStatisticsCount": MatchUpVsStatisticsWinLossCount,
      "matchUps": MatchUpList,
      "demographicStats": [DemographicStat],
      "ratingBounds": RatingBounds
    }
  }
}

Mutations

`removePersonFromClub`

Returns a Boolean

Name	Description
`personId` - `ID!`
`clubId` - `ID!`
`role` - `ClubMemberRole`

Example

Query

mutation removePersonFromClub($personId: ID!, $clubId: ID!, $role: ClubMemberRole) {
  removePersonFromClub(personId: $personId, clubId: $clubId, role: $role)
}

Variables

{
  "personId": ID,
  "clubId": ID,
  "role": ClubMemberRole
}

Response

{"data": {"removePersonFromClub": true}}

Mutations

`removePersonsFromWatchlists`

Returns a WatchlistList

Name	Description
`watchlistIds` - `[ID!]!`
`personIds` - `[ID!]!`

Example

Query

mutation removePersonsFromWatchlists($watchlistIds: [ID!]!, $personIds: [ID!]!) {
  removePersonsFromWatchlists(watchlistIds: $watchlistIds, personIds: $personIds) {
    items {
      ...WatchlistFragment
    }
    totalItems
  }
}

Variables

{
  "watchlistIds": [ID],
  "personIds": [ID]
}

Response

{
  "data": {
    "removePersonsFromWatchlists": {
      "items": [Watchlist],
      "totalItems": 123
    }
  }
}

Mutations

`removeSelfSubmittedMatchUp`

Returns a MatchUp

Name	Description
`id` - `ID!`

Example

Query

mutation removeSelfSubmittedMatchUp($id: ID!) {
  removeSelfSubmittedMatchUp(id: $id) {
    id
    score {
      ...ScoreFragment
    }
    sides {
      ...SideFragment
    }
    winningSide
    providerMatchId
    ageCategoryCode
    surfaceCategory
    indoorOutdoor
    type
    matchUpFormat
    grade
    start
    end
    circuit
    roundNumber
    roundPosition
    roundName
    humidity
    duration
    status
    statusCodes
    extensions {
      ...ExtensionFragment
    }
    createdAt
    updatedAt
    competitiveness
    state
    divisionType
    drawStructure
    drawType
    tieMatchUpId
    courtId
    surfaceType
    tournamentLevel
    pace
    gender
    drawId
    drawName
    venueId
    selfSubmittedResult
    ballType
    deleted
    collectionPosition
    wtnId
    wtnErrors
    isTied
    tournament {
      ...TournamentFragment
    }
    court {
      ...CourtFragment
    }
    venue {
      ...VenueFragment
    }
    provider {
      ...ProviderFragment
    }
    ownerId
    reviewedBy {
      ...PersonFragment
    }
    submissionState
    reviewedAt
    worldTennisNumbers {
      ...MatchUpWorldTennisNumberFragment
    }
  }
}

Variables

{"id": ID}

Response

{
  "data": {
    "removeSelfSubmittedMatchUp": {
      "id": ID,
      "score": Score,
      "sides": [Side],
      "winningSide": SideEnum,
      "providerMatchId": ID,
      "ageCategoryCode": "abc123",
      "surfaceCategory": SurfaceCategoryEnum,
      "indoorOutdoor": IndoorOutdoorEnum,
      "type": MatchUpTypeEnum,
      "matchUpFormat": "abc123",
      "grade": "abc123",
      "start": DateTime,
      "end": DateTime,
      "circuit": CircuitEnum,
      "roundNumber": 123,
      "roundPosition": 987,
      "roundName": "xyz789",
      "humidity": 123.45,
      "duration": 987.65,
      "status": MatchUpStatusEnum,
      "statusCodes": ["abc123"],
      "extensions": [Extension],
      "createdAt": DateTime,
      "updatedAt": DateTime,
      "competitiveness": 987.65,
      "state": StateEnum,
      "divisionType": "abc123",
      "drawStructure": DrawStructureEnum,
      "drawType": "xyz789",
      "tieMatchUpId": ID,
      "courtId": ID,
      "surfaceType": SurfaceTypeEnum,
      "tournamentLevel": StandardGradeEnum,
      "pace": PaceEnum,
      "gender": MatchUpGenderEnum,
      "drawId": ID,
      "drawName": "abc123",
      "venueId": ID,
      "selfSubmittedResult": true,
      "ballType": BallTypeEnum,
      "deleted": true,
      "collectionPosition": 987,
      "wtnId": ID,
      "wtnErrors": ["abc123"],
      "isTied": true,
      "tournament": Tournament,
      "court": Court,
      "venue": Venue,
      "provider": Provider,
      "ownerId": ID,
      "reviewedBy": Person,
      "submissionState": MatchUpSubmissionStateEnum,
      "reviewedAt": DateTime,
      "worldTennisNumbers": [MatchUpWorldTennisNumber]
    }
  }
}

Mutations

`removeTournament`

Returns a Tournament

Name	Description
`id` - `ID!`

Example

Query

mutation removeTournament($id: ID!) {
  removeTournament(id: $id) {
    id
    end
    start
    entriesClose
    entriesOpen
    extensions {
      ...ExtensionFragment
    }
    formalName
    hostCountryCode
    indoorOutdoor
    localTimeZone
    notes
    promotionalName
    season
    surfaceCategory
    providerTournamentId
    unifiedTournamentId
    level
    name
    updatedAt
    createdAt
    withdrawalDeadline
    belongsToRequestingProvider
    subCategory
    persons {
      ...PersonListFragment
    }
    matchUps {
      ...MatchUpListFragment
    }
    provider {
      ...ProviderFragment
    }
  }
}

Variables

{"id": ID}

Response

{
  "data": {
    "removeTournament": {
      "id": ID,
      "end": DateTime,
      "start": DateTime,
      "entriesClose": DateTime,
      "entriesOpen": DateTime,
      "extensions": [Extension],
      "formalName": "abc123",
      "hostCountryCode": CountryCode,
      "indoorOutdoor": IndoorOutdoorEnum,
      "localTimeZone": "xyz789",
      "notes": "abc123",
      "promotionalName": "abc123",
      "season": "abc123",
      "surfaceCategory": SurfaceCategoryEnum,
      "providerTournamentId": "xyz789",
      "unifiedTournamentId": "abc123",
      "level": "abc123",
      "name": "xyz789",
      "updatedAt": DateTime,
      "createdAt": DateTime,
      "withdrawalDeadline": DateTime,
      "belongsToRequestingProvider": true,
      "subCategory": TournamentSubCategoryEnum,
      "persons": PersonList,
      "matchUps": MatchUpList,
      "provider": Provider
    }
  }
}

Mutations

`removeVenue`

Returns a Venue

Name	Description
`id` - `ID!`

Example

Query

mutation removeVenue($id: ID!) {
  removeVenue(id: $id) {
    id
    name
    type
    courts {
      ...CourtFragment
    }
    notes
    addresses {
      ...AddressFragment
    }
    extensions {
      ...ExtensionFragment
    }
    providerVenueId
    updatedAt
    createdAt
  }
}

Variables

{"id": ID}

Response

{
  "data": {
    "removeVenue": {
      "id": ID,
      "name": "abc123",
      "type": "xyz789",
      "courts": [Court],
      "notes": "abc123",
      "addresses": [Address],
      "extensions": [Extension],
      "providerVenueId": ID,
      "updatedAt": DateTime,
      "createdAt": DateTime
    }
  }
}

Mutations

`removeWatchlist`

Returns a Watchlist

Name	Description
`id` - `ID!`

Example

Query

mutation removeWatchlist($id: ID!) {
  removeWatchlist(id: $id) {
    ownerId
    id
    personIds
    name
    persons {
      ...PersonFragment
    }
    watchlistStats {
      ...WatchlistStatsFragment
    }
  }
}

Variables

{"id": ID}

Response

{
  "data": {
    "removeWatchlist": {
      "ownerId": ID,
      "id": ID,
      "personIds": [ID],
      "name": "abc123",
      "persons": [Person],
      "watchlistStats": WatchlistStats
    }
  }
}

Mutations

`renameWatchlist`

Returns a Watchlist

Name	Description
`id` - `ID!`
`name` - `String!`

Example

Query

mutation renameWatchlist($id: ID!, $name: String!) {
  renameWatchlist(id: $id, name: $name) {
    ownerId
    id
    personIds
    name
    persons {
      ...PersonFragment
    }
    watchlistStats {
      ...WatchlistStatsFragment
    }
  }
}

Variables

{"id": ID, "name": "xyz789"}

Response

{
  "data": {
    "renameWatchlist": {
      "ownerId": ID,
      "id": ID,
      "personIds": [ID],
      "name": "xyz789",
      "persons": [Person],
      "watchlistStats": WatchlistStats
    }
  }
}

Mutations

`setPersonClubStatus`

Returns a Boolean

Name	Description
`personId` - `ID!`
`clubStatus` - `PersonClubStatus!`

Example

Query

mutation setPersonClubStatus($personId: ID!, $clubStatus: PersonClubStatus!) {
  setPersonClubStatus(personId: $personId, clubStatus: $clubStatus)
}

Variables

{
  "personId": ID,
  "clubStatus": PersonClubStatus
}

Response

{"data": {"setPersonClubStatus": true}}

Mutations

`setPersonExclusiveClub`

Returns a Boolean

Name	Description
`personId` - `ID!`
`clubId` - `ID!`

Example

Query

mutation setPersonExclusiveClub($personId: ID!, $clubId: ID!) {
  setPersonExclusiveClub(personId: $personId, clubId: $clubId)
}

Variables

{"personId": ID, "clubId": ID}

Response

{"data": {"setPersonExclusiveClub": false}}

Mutations

`updateAccountPerson`

Returns an AccountPerson

Name	Description
`personInput` - `UpdateAccountPersonInput!`

Example

Query

mutation updateAccountPerson($personInput: UpdateAccountPersonInput!) {
  updateAccountPerson(personInput: $personInput) {
    id
    tennisId
    registrationToken
    nativeGivenName
    nativeFamilyName
    standardGivenName
    standardFamilyName
    sex
    birthDate
    birthYear
    nationalityCode
    countryOfResidenceCode
    biographicalInformation {
      ...BiographicalInformationFragment
    }
  }
}

Variables

{"personInput": UpdateAccountPersonInput}

Response

{
  "data": {
    "updateAccountPerson": {
      "id": "abc123",
      "tennisId": "abc123",
      "registrationToken": "abc123",
      "nativeGivenName": "abc123",
      "nativeFamilyName": "xyz789",
      "standardGivenName": "xyz789",
      "standardFamilyName": "xyz789",
      "sex": SexEnum,
      "birthDate": "2026-03-31T14:07:52.371Z",
      "birthYear": 987,
      "nationalityCode": "xyz789",
      "countryOfResidenceCode": "abc123",
      "biographicalInformation": BiographicalInformation
    }
  }
}

Mutations

`updateMatchUp`

Returns a MatchUp

Name	Description
`id` - `ID!`
`input` - `MatchUpUpdateInput!`

Example

Query

mutation updateMatchUp($id: ID!, $input: MatchUpUpdateInput!) {
  updateMatchUp(id: $id, input: $input) {
    id
    score {
      ...ScoreFragment
    }
    sides {
      ...SideFragment
    }
    winningSide
    providerMatchId
    ageCategoryCode
    surfaceCategory
    indoorOutdoor
    type
    matchUpFormat
    grade
    start
    end
    circuit
    roundNumber
    roundPosition
    roundName
    humidity
    duration
    status
    statusCodes
    extensions {
      ...ExtensionFragment
    }
    createdAt
    updatedAt
    competitiveness
    state
    divisionType
    drawStructure
    drawType
    tieMatchUpId
    courtId
    surfaceType
    tournamentLevel
    pace
    gender
    drawId
    drawName
    venueId
    selfSubmittedResult
    ballType
    deleted
    collectionPosition
    wtnId
    wtnErrors
    isTied
    tournament {
      ...TournamentFragment
    }
    court {
      ...CourtFragment
    }
    venue {
      ...VenueFragment
    }
    provider {
      ...ProviderFragment
    }
    ownerId
    reviewedBy {
      ...PersonFragment
    }
    submissionState
    reviewedAt
    worldTennisNumbers {
      ...MatchUpWorldTennisNumberFragment
    }
  }
}

Variables

{
  "id": ID,
  "input": MatchUpUpdateInput
}

Response

{
  "data": {
    "updateMatchUp": {
      "id": ID,
      "score": Score,
      "sides": [Side],
      "winningSide": SideEnum,
      "providerMatchId": ID,
      "ageCategoryCode": "xyz789",
      "surfaceCategory": SurfaceCategoryEnum,
      "indoorOutdoor": IndoorOutdoorEnum,
      "type": MatchUpTypeEnum,
      "matchUpFormat": "xyz789",
      "grade": "xyz789",
      "start": DateTime,
      "end": DateTime,
      "circuit": CircuitEnum,
      "roundNumber": 987,
      "roundPosition": 123,
      "roundName": "xyz789",
      "humidity": 123.45,
      "duration": 123.45,
      "status": MatchUpStatusEnum,
      "statusCodes": ["xyz789"],
      "extensions": [Extension],
      "createdAt": DateTime,
      "updatedAt": DateTime,
      "competitiveness": 123.45,
      "state": StateEnum,
      "divisionType": "abc123",
      "drawStructure": DrawStructureEnum,
      "drawType": "xyz789",
      "tieMatchUpId": ID,
      "courtId": ID,
      "surfaceType": SurfaceTypeEnum,
      "tournamentLevel": StandardGradeEnum,
      "pace": PaceEnum,
      "gender": MatchUpGenderEnum,
      "drawId": ID,
      "drawName": "abc123",
      "venueId": ID,
      "selfSubmittedResult": true,
      "ballType": BallTypeEnum,
      "deleted": false,
      "collectionPosition": 987,
      "wtnId": ID,
      "wtnErrors": ["abc123"],
      "isTied": false,
      "tournament": Tournament,
      "court": Court,
      "venue": Venue,
      "provider": Provider,
      "ownerId": ID,
      "reviewedBy": Person,
      "submissionState": MatchUpSubmissionStateEnum,
      "reviewedAt": DateTime,
      "worldTennisNumbers": [MatchUpWorldTennisNumber]
    }
  }
}

Mutations

`updatePerson`

Returns a Person

Name	Description
`id` - `PersonIDInput!`
`input` - `PersonUpdateInput!`

Example

Query

mutation updatePerson($id: PersonIDInput!, $input: PersonUpdateInput!) {
  updatePerson(id: $id, input: $input) {
    registrationInvite {
      ...InviteLinkFragment
    }
    clubs {
      ...ClubFragment
    }
    clubStatus
    id
    clubsparkId
    externalID
    tennisID
    nationalID
    personID
    biographicalInformation {
      ...BiographicalInformationFragment
    }
    extensions {
      ...ExtensionFragment
    }
    nationalityCode
    nativeFamilyName
    nativeGivenName
    nationalRating
    notes
    standardGivenName
    standardFamilyName
    birthDate
    isDeceased
    sex
    age
    birthYear
    worldTennisNumbers {
      ...WorldTennisNumberFragment
    }
    addresses {
      ...AddressFragment
    }
    createdAt
    updatedAt
    belongsToRequestingProvider
    lastPlayedSingles
    lastPlayedDoubles
    optedOutOfPublicDataConsent
    owningProviderId
    school {
      ...SchoolInfoFragment
    }
    isRanked
    rankedSingles
    rankedDoubles
    eligibleForSelfSubmission
    eligibleForPsq
    isRegistered
    section {
      ...SectionFragment
    }
    hasSubmittedResult
    tournaments {
      ...TournamentListFragment
    }
    matchUpIntervals {
      ...MatchUpIntervalsFragment
    }
    matchUpVsStatisticsCount {
      ...MatchUpVsStatisticsWinLossCountFragment
    }
    matchUps {
      ...MatchUpListFragment
    }
    demographicStats {
      ...DemographicStatFragment
    }
    ratingBounds {
      ...RatingBoundsFragment
    }
  }
}

Variables

{
  "id": PersonIDInput,
  "input": PersonUpdateInput
}

Response

{
  "data": {
    "updatePerson": {
      "registrationInvite": InviteLink,
      "clubs": [Club],
      "clubStatus": PersonClubStatus,
      "id": ID,
      "clubsparkId": ID,
      "externalID": ID,
      "tennisID": ID,
      "nationalID": ID,
      "personID": ID,
      "biographicalInformation": BiographicalInformation,
      "extensions": [Extension],
      "nationalityCode": "abc123",
      "nativeFamilyName": "abc123",
      "nativeGivenName": "xyz789",
      "nationalRating": "abc123",
      "notes": "abc123",
      "standardGivenName": "xyz789",
      "standardFamilyName": "abc123",
      "birthDate": "2026-03-31T14:07:52.371Z",
      "isDeceased": false,
      "sex": SexEnum,
      "age": 123,
      "birthYear": 987,
      "worldTennisNumbers": [WorldTennisNumber],
      "addresses": [Address],
      "createdAt": DateTime,
      "updatedAt": DateTime,
      "belongsToRequestingProvider": true,
      "lastPlayedSingles": DateTime,
      "lastPlayedDoubles": DateTime,
      "optedOutOfPublicDataConsent": true,
      "owningProviderId": ID,
      "school": [SchoolInfo],
      "isRanked": true,
      "rankedSingles": false,
      "rankedDoubles": false,
      "eligibleForSelfSubmission": false,
      "eligibleForPsq": true,
      "isRegistered": true,
      "section": Section,
      "hasSubmittedResult": true,
      "tournaments": TournamentList,
      "matchUpIntervals": MatchUpIntervals,
      "matchUpVsStatisticsCount": MatchUpVsStatisticsWinLossCount,
      "matchUps": MatchUpList,
      "demographicStats": [DemographicStat],
      "ratingBounds": RatingBounds
    }
  }
}

Mutations

`updateTournament`

Returns a Tournament

Name	Description
`id` - `ID!`
`input` - `TournamentUpdateInput!`

Example

Query

mutation updateTournament($id: ID!, $input: TournamentUpdateInput!) {
  updateTournament(id: $id, input: $input) {
    id
    end
    start
    entriesClose
    entriesOpen
    extensions {
      ...ExtensionFragment
    }
    formalName
    hostCountryCode
    indoorOutdoor
    localTimeZone
    notes
    promotionalName
    season
    surfaceCategory
    providerTournamentId
    unifiedTournamentId
    level
    name
    updatedAt
    createdAt
    withdrawalDeadline
    belongsToRequestingProvider
    subCategory
    persons {
      ...PersonListFragment
    }
    matchUps {
      ...MatchUpListFragment
    }
    provider {
      ...ProviderFragment
    }
  }
}

Variables

{
  "id": ID,
  "input": TournamentUpdateInput
}

Response

{
  "data": {
    "updateTournament": {
      "id": ID,
      "end": DateTime,
      "start": DateTime,
      "entriesClose": DateTime,
      "entriesOpen": DateTime,
      "extensions": [Extension],
      "formalName": "xyz789",
      "hostCountryCode": CountryCode,
      "indoorOutdoor": IndoorOutdoorEnum,
      "localTimeZone": "abc123",
      "notes": "abc123",
      "promotionalName": "xyz789",
      "season": "xyz789",
      "surfaceCategory": SurfaceCategoryEnum,
      "providerTournamentId": "abc123",
      "unifiedTournamentId": "xyz789",
      "level": "abc123",
      "name": "abc123",
      "updatedAt": DateTime,
      "createdAt": DateTime,
      "withdrawalDeadline": DateTime,
      "belongsToRequestingProvider": true,
      "subCategory": TournamentSubCategoryEnum,
      "persons": PersonList,
      "matchUps": MatchUpList,
      "provider": Provider
    }
  }
}

Mutations

`updateVenue`

Returns a Venue

Name	Description
`id` - `ID!`
`input` - `VenueInput!`

Example

Query

mutation updateVenue($id: ID!, $input: VenueInput!) {
  updateVenue(id: $id, input: $input) {
    id
    name
    type
    courts {
      ...CourtFragment
    }
    notes
    addresses {
      ...AddressFragment
    }
    extensions {
      ...ExtensionFragment
    }
    providerVenueId
    updatedAt
    createdAt
  }
}

Variables

{"id": ID, "input": VenueInput}

Response

{
  "data": {
    "updateVenue": {
      "id": ID,
      "name": "abc123",
      "type": "xyz789",
      "courts": [Court],
      "notes": "xyz789",
      "addresses": [Address],
      "extensions": [Extension],
      "providerVenueId": ID,
      "updatedAt": DateTime,
      "createdAt": DateTime
    }
  }
}

Mutations

`upsertBatchMatchUps`

Returns an UpsertBatchMatchUpsResult

Name	Description
`input` - `[MatchUpInput!]!`

Example

Query

mutation upsertBatchMatchUps($input: [MatchUpInput!]!) {
  upsertBatchMatchUps(input: $input) {
    items {
      ...MatchUpFragment
    }
    totalItems
    batchErrors
    totalBatchErrors
  }
}

Variables

{"input": [MatchUpInput]}

Response

{
  "data": {
    "upsertBatchMatchUps": {
      "items": [MatchUp],
      "totalItems": 123,
      "batchErrors": ["xyz789"],
      "totalBatchErrors": 987
    }
  }
}

Mutations

`upsertBatchTournaments`

Returns an UpsertBatchTournamentsResult

Name	Description
`input` - `[TournamentInput!]!`

Example

Query

mutation upsertBatchTournaments($input: [TournamentInput!]!) {
  upsertBatchTournaments(input: $input) {
    items {
      ...TournamentFragment
    }
    totalItems
    batchErrors
    totalBatchErrors
  }
}

Variables

{"input": [TournamentInput]}

Response

{
  "data": {
    "upsertBatchTournaments": {
      "items": [Tournament],
      "totalItems": 123,
      "batchErrors": ["abc123"],
      "totalBatchErrors": 987
    }
  }
}

Types

`AccountPerson`

Field Name	Description
`id` - `String`
`tennisId` - `String`
`registrationToken` - `String`
`nativeGivenName` - `String`
`nativeFamilyName` - `String`
`standardGivenName` - `String`
`standardFamilyName` - `String`
`sex` - `SexEnum`
`birthDate` - `Date`
`birthYear` - `Int`
`nationalityCode` - `String`
`countryOfResidenceCode` - `String`
`biographicalInformation` - `BiographicalInformation`

Example

{
  "id": "abc123",
  "tennisId": "xyz789",
  "registrationToken": "abc123",
  "nativeGivenName": "abc123",
  "nativeFamilyName": "abc123",
  "standardGivenName": "xyz789",
  "standardFamilyName": "xyz789",
  "sex": SexEnum,
  "birthDate": "2025-10-01T14:07:52.371Z",
  "birthYear": 123,
  "nationalityCode": "abc123",
  "countryOfResidenceCode": "abc123",
  "biographicalInformation": BiographicalInformation
}

Types

`AccountPersonDetail`

Field Name	Description
`id` - `String`
`tennisId` - `String`
`registrationToken` - `String`
`nativeGivenName` - `String`
`nativeFamilyName` - `String`
`standardGivenName` - `String`
`standardFamilyName` - `String`
`sex` - `SexEnum`
`birthDate` - `Date`
`birthYear` - `Int`
`nationalityCode` - `String`
`countryOfResidenceCode` - `String`
`alreadyItfCustomer` - `Boolean`
`alreadyRegisteredForService` - `Boolean`
`isSexUpdateable` - `Boolean`
`isNativeGivenNameUpdateable` - `Boolean`
`isNativeFamilyNameUpdateable` - `Boolean`
`isBirthDateUpdateable` - `Boolean`
`isNationalityUpdateable` - `Boolean`
`isCountryOfResidenceUpdateable` - `Boolean`
`biographicalInformation` - `BiographicalInformation`
`hasBirthDate` - `Boolean`
`hasNationality` - `Boolean`
`hasSex` - `Boolean`
`hasCountryOfResidence` - `Boolean`

Example

{
  "id": "abc123",
  "tennisId": "abc123",
  "registrationToken": "abc123",
  "nativeGivenName": "abc123",
  "nativeFamilyName": "xyz789",
  "standardGivenName": "xyz789",
  "standardFamilyName": "xyz789",
  "sex": SexEnum,
  "birthDate": "2026-03-31T14:07:52.371Z",
  "birthYear": 123,
  "nationalityCode": "abc123",
  "countryOfResidenceCode": "abc123",
  "alreadyItfCustomer": false,
  "alreadyRegisteredForService": false,
  "isSexUpdateable": true,
  "isNativeGivenNameUpdateable": true,
  "isNativeFamilyNameUpdateable": true,
  "isBirthDateUpdateable": true,
  "isNationalityUpdateable": true,
  "isCountryOfResidenceUpdateable": true,
  "biographicalInformation": BiographicalInformation,
  "hasBirthDate": false,
  "hasNationality": true,
  "hasSex": true,
  "hasCountryOfResidence": true
}

Types

`AddAccountPerson`

Field Name	Description
`id` - `String`
`tennisId` - `String`
`registrationToken` - `String`
`nativeGivenName` - `String`
`nativeFamilyName` - `String`
`standardGivenName` - `String`
`standardFamilyName` - `String`
`sex` - `SexEnum`
`birthDate` - `Date`
`birthYear` - `Int`
`nationalityCode` - `String`
`countryOfResidenceCode` - `String`
`alreadyItfCustomer` - `Boolean`
`alreadyRegisteredForService` - `Boolean`
`biographicalInformation` - `BiographicalInformation`
`signUpType` - `SignUpTypeEnum`

Example

{
  "id": "abc123",
  "tennisId": "abc123",
  "registrationToken": "abc123",
  "nativeGivenName": "xyz789",
  "nativeFamilyName": "xyz789",
  "standardGivenName": "abc123",
  "standardFamilyName": "abc123",
  "sex": SexEnum,
  "birthDate": "2026-03-31T14:07:52.371Z",
  "birthYear": 123,
  "nationalityCode": "abc123",
  "countryOfResidenceCode": "xyz789",
  "alreadyItfCustomer": false,
  "alreadyRegisteredForService": true,
  "biographicalInformation": BiographicalInformation,
  "signUpType": SignUpTypeEnum
}

Types

`AddAccountPersonInput`

Input Field	Description
`emailAddress` - `String`
`nativeGivenName` - `String!`
`nativeFamilyName` - `String!`
`sex` - `SexEnum`
`birthDate` - `Date`
`nationalityCode` - `String`
`countryOfResidenceCode` - `String`
`biographicalInformation` - `BiographicalInformationInput`
`signUpType` - `SignUpTypeEnum`
`parentEmailAddress` - `String`
`parentFullName` - `String`
`personaType` - `PersonaTypeEnum`
`personaDetail` - `String`
`whereDidYouHearAboutUs` - `WhereDidYouHearEnum`
`whereDidYouHearDetail` - `String`
`whereDidYouHearNa` - `String`

Example

{
  "emailAddress": "xyz789",
  "nativeGivenName": "abc123",
  "nativeFamilyName": "xyz789",
  "sex": SexEnum,
  "birthDate": "2026-03-31T14:07:52.371Z",
  "nationalityCode": "abc123",
  "countryOfResidenceCode": "xyz789",
  "biographicalInformation": BiographicalInformationInput,
  "signUpType": SignUpTypeEnum,
  "parentEmailAddress": "xyz789",
  "parentFullName": "xyz789",
  "personaType": PersonaTypeEnum,
  "personaDetail": "abc123",
  "whereDidYouHearAboutUs": WhereDidYouHearEnum,
  "whereDidYouHearDetail": "abc123",
  "whereDidYouHearNa": "abc123"
}

Types

`AddTeamMembersInput`

Input Field	Description
`teamId` - `ID!`
`members` - `[PersonInput!]!`

Example

{
  "teamId": ID,
  "members": [PersonInput]
}

Types

`AdditionalFieldsByMatchId`

Field Name	Description
`matchUpId` - `Int`
`additionalMatchFields` - `AdditionalMatchFields`

Example

{
  "matchUpId": 123,
  "additionalMatchFields": AdditionalMatchFields
}

Types

`AdditionalMatchFields`

Field Name	Description
`drawId` - `String`
`drawName` - `String`
`drawStructure` - `String`
`roundNumber` - `Int`
`roundPosition` - `Int`
`ageCategoryCode` - `String`
`eventId` - `String`
`side1Players` - `[PlayerOnSide]`
`side2Players` - `[PlayerOnSide]`

Example

{
  "drawId": "xyz789",
  "drawName": "abc123",
  "drawStructure": "abc123",
  "roundNumber": 123,
  "roundPosition": 987,
  "ageCategoryCode": "xyz789",
  "eventId": "xyz789",
  "side1Players": [PlayerOnSide],
  "side2Players": [PlayerOnSide]
}

Types

`Address`

Field Name	Description
`addressLine1` - `String`
`addressLine2` - `String`
`addressLine3` - `String`
`addressType` - `AddressTypeEnum`
`city` - `String`
`countryCode` - `CountryCode`
`latitude` - `Float`
`longitude` - `Float`
`postalCode` - `String`
`state` - `String`

Example

{
  "addressLine1": "abc123",
  "addressLine2": "abc123",
  "addressLine3": "abc123",
  "addressType": AddressTypeEnum,
  "city": "abc123",
  "countryCode": CountryCode,
  "latitude": 987.65,
  "longitude": 987.65,
  "postalCode": "abc123",
  "state": "abc123"
}

Types

`AddressInput`

Input Field	Description
`addressLine1` - `String`
`addressLine2` - `String`
`addressLine3` - `String`
`addressType` - `AddressTypeEnum`
`city` - `String`
`countryCode` - `CountryCode`
`latitude` - `Float`
`longitude` - `Float`
`postalCode` - `String`
`state` - `String`

Example

{
  "addressLine1": "abc123",
  "addressLine2": "abc123",
  "addressLine3": "abc123",
  "addressType": AddressTypeEnum,
  "city": "abc123",
  "countryCode": CountryCode,
  "latitude": 123.45,
  "longitude": 987.65,
  "postalCode": "abc123",
  "state": "xyz789"
}

Types

`AddressTypeEnum`

Enum Value	Description
`HOME`
`WORK`
`MAIL`
`RESIDENTIAL`
`VENUE`
`UNKNOWN`

Types

`AggregatedMatchUpCount`

Field Name	Description
`totalMatches` - `Int`
`tournamentMatches` - `Int`
`notTournamentMatches` - `Int`
`matchesWon` - `Int`
`matchesLost` - `Int`
`matchesTied` - `Int`
`uniqueOpponents` - `UniqueOpponents`
`walkovers` - `Int`
`decisive` - `Int`
`routine` - `Int`
`competitive` - `Int`

Example

{
  "totalMatches": 987,
  "tournamentMatches": 123,
  "notTournamentMatches": 123,
  "matchesWon": 987,
  "matchesLost": 123,
  "matchesTied": 987,
  "uniqueOpponents": UniqueOpponents,
  "walkovers": 987,
  "decisive": 123,
  "routine": 123,
  "competitive": 123
}

Types

`AggregatedPersonCount`

Field Name	Description
`id` - `String!`
`count` - `Int!`

Example

{"id": "abc123", "count": 123}

Types

`AuditError`

Field Name	Description
`error` - `String`

Example

{"error": "abc123"}

Types

`BackhandEnum`

Enum Value	Description
`UNKNOWN`
`SINGLE`
`DOUBLE`

Types

`BallTypeEnum`

Enum Value	Description
`HIGH_ALTITUDE`
`STAGE1GREEN`
`STAGE2ORANGE`
`STAGE3RED`
`T2STANDARD_PRESSURELESS`
`T2STANDARD_PRESSURISED`
`TYPE1FAST`
`TYPE3SLOW`

Types

`BiographicalInformation`

Field Name	Description
`ageBeganTennis` - `Int`	Age in years that the player started playing tennis
`ageTurnedPro` - `Int`	Age in years that the player became a professional
`birthCountryCode` - `String`	ISO-3166-1 alpha-3 country code assigned to player at birth
`coach` - `Person`	Person record of the coach of this person
`doublePlayingHand` - `PlayingDoubleHandEnumType`
`heightInMeters` - `Float`
`placeOfResidence` - `String`
`playingHand` - `PlayingHandEnumType`
`favouriteShot` - `FavouriteShotEnum`
`avatarUrl` - `String`
`residenceCountryCode` - `String`
`weightInKgs` - `Float`

Example

{
  "ageBeganTennis": 987,
  "ageTurnedPro": 987,
  "birthCountryCode": "abc123",
  "coach": Person,
  "doublePlayingHand": PlayingDoubleHandEnumType,
  "heightInMeters": 123.45,
  "placeOfResidence": "abc123",
  "playingHand": PlayingHandEnumType,
  "favouriteShot": FavouriteShotEnum,
  "avatarUrl": "abc123",
  "residenceCountryCode": "abc123",
  "weightInKgs": 123.45
}

Types

`BiographicalInformationInput`

Input Field	Description
`ageBeganTennis` - `Int`
`ageTurnedPro` - `Int`
`birthCountryCode` - `String`
`coachID` - `ID`
`doublePlayingHand` - `PlayingDoubleHandEnumType`
`heightInMeters` - `Float`
`placeOfResidence` - `String`
`playingHand` - `PlayingHandEnumType`
`favouriteShot` - `FavouriteShotEnum`
`avatarUrl` - `String`
`residenceCountryCode` - `ResidenceCountryCode`
`weightInKgs` - `Float`

Example

{
  "ageBeganTennis": 987,
  "ageTurnedPro": 987,
  "birthCountryCode": "xyz789",
  "coachID": ID,
  "doublePlayingHand": PlayingDoubleHandEnumType,
  "heightInMeters": 123.45,
  "placeOfResidence": "abc123",
  "playingHand": PlayingHandEnumType,
  "favouriteShot": FavouriteShotEnum,
  "avatarUrl": "abc123",
  "residenceCountryCode": ResidenceCountryCode,
  "weightInKgs": 987.65
}

Types

`Boolean`

The Boolean scalar type represents true or false.

Example

true

Types

`BooleanOperators`

Input Field	Description
`eq` - `Boolean`

Example

{"eq": false}

Types

`BucketMeta`

Field Name	Description
`type` - `MatchUpTypeEnum`
`matchUpStatsBuckets` - `[StatBucket]`

Example

{
  "type": MatchUpTypeEnum,
  "matchUpStatsBuckets": [StatBucket]
}

Types

`BucketedMatchUpFilterOptions`

Field Name	Description
`personId` - `PersonIDInput!`
`type` - `[MatchUpTypeEnum!]!`
`start` - `DateOperators!`
`statuses` - `[MatchUpStatusEnum]`

Example

{
  "personId": PersonIDInput,
  "type": [MatchUpTypeEnum],
  "start": DateOperators,
  "statuses": [MatchUpStatusEnum]
}

Types

`BucketedMatchUpStats`

Field Name	Description
`bucketsMeta` - `[BucketMeta]`

Example

{"bucketsMeta": [BucketMeta]}

Types

`Championship`

Field Name	Description
`cpType` - `String`
`cpYear` - `DateTime`

Example

{"cpType": "abc123", "cpYear": DateTime}

Types

`ChampionshipInput`

Input Field	Description
`cpType` - `String!`
`cpYear` - `DateTime!`

Example

{"cpType": "xyz789", "cpYear": DateTime}

Types

`CircuitEnum`

Enum Value	Description
`M`	Mens
`W`	Women
`J`	Junior
`S`	Senior
`WC`	Wheelchair
`U`	Unknown

Types

`Club`

Field Name	Description
`id` - `ID`
`name` - `String`
`members` - `PersonList`
Arguments `pageArgs` - `PaginationArgs` `filter` - `PersonFilterOptions` `sort` - `SortOrder`
`myRole` - `ClubMemberRole`

Example

{
  "id": ID,
  "name": "xyz789",
  "members": PersonList,
  "myRole": ClubMemberRole
}

Types

`ClubFilterOptions`

Input Field	Description
`search` - `SearchFilterOptions`

Example

{"search": SearchFilterOptions}

Types

`ClubInput`

Input Field	Description
`name` - `String!`
`allowedCountryOfResidences` - `[String!]`

Example

{"name": "abc123", "allowedCountryOfResidences": ["abc123"]}

Types

`ClubList`

Field Name	Description
`totalItems` - `Int`
`items` - `[Club]`

Example

{"totalItems": 987, "items": [Club]}

Types

`ClubMemberRole`

Enum Value	Description
`NONE`
`MEMBER`

Types

`ClubUpdateInput`

Input Field	Description
`name` - `String`
`allowedCountryOfResidences` - `[String!]`

Example

{"name": "abc123", "allowedCountryOfResidences": ["abc123"]}

Types

`ContemporaryRating`

Field Name	Description
`rating` - `Float`
`ratingType` - `RatingTypeEnum`
`confidence` - `Float`
`personId` - `ID`

Example

{
  "rating": 987.65,
  "ratingType": RatingTypeEnum,
  "confidence": 123.45,
  "personId": ID
}

Types

`CountryCode`

Example

object

Types

`Court`

Field Name	Description
`id` - `ID!`
`extensions` - `[Extension]`
`notes` - `String`
`name` - `String`
`pace` - `String`
`surfaceCategory` - `SurfaceCategoryEnum`
`surfaceType` - `String`
`surfacedDate` - `DateTime`
`latitude` - `Float`
`longitude` - `Float`
`altitude` - `Float`
`courtDimensions` - `String`
`providerCourtId` - `ID`

Example

{
  "id": ID,
  "extensions": [Extension],
  "notes": "abc123",
  "name": "xyz789",
  "pace": "xyz789",
  "surfaceCategory": SurfaceCategoryEnum,
  "surfaceType": "xyz789",
  "surfacedDate": DateTime,
  "latitude": 123.45,
  "longitude": 123.45,
  "altitude": 987.65,
  "courtDimensions": "xyz789",
  "providerCourtId": ID
}

Types

`CourtInput`

Field Name	Description
`notes` - `String`
`name` - `String`
`pace` - `String`
`surfaceCategory` - `SurfaceCategoryEnum`
`surfaceType` - `String`
`surfacedDate` - `DateTime`
`latitude` - `Float`
`longitude` - `Float`
`extensions` - `[ExtensionInput]`
`altitude` - `Float`
`courtDimensions` - `String`
`providerCourtId` - `ID`

Example

{
  "notes": "abc123",
  "name": "xyz789",
  "pace": "abc123",
  "surfaceCategory": SurfaceCategoryEnum,
  "surfaceType": "xyz789",
  "surfacedDate": DateTime,
  "latitude": 123.45,
  "longitude": 123.45,
  "extensions": [ExtensionInput],
  "altitude": 123.45,
  "courtDimensions": "xyz789",
  "providerCourtId": ID
}

Types

`CreateBatchPersonsResult`

Field Name	Description
`items` - `[Person]`
`totalItems` - `Int`
`batchErrors` - `[String]`
`totalBatchErrors` - `Int`

Example

{
  "items": [Person],
  "totalItems": 987,
  "batchErrors": ["xyz789"],
  "totalBatchErrors": 123
}

Types

`CreateTeamInput`

Field Name	Description
`providerId` - `ID!`
`extensions` - `[ExtensionInput]`
`gender` - `GenderEnum`
`name` - `String!`
`nativeTeamName` - `String`
`notes` - `String`
`color` - `TeamColor` default = `"NONE"`
`logoUrl` - `String`

Example

{
  "providerId": ID,
  "extensions": [ExtensionInput],
  "gender": GenderEnum,
  "name": "abc123",
  "nativeTeamName": "abc123",
  "notes": "abc123",
  "color": "NONE",
  "logoUrl": "xyz789"
}

Types

`Date`

Example

2026-03-31T14:07:52.371Z

Types

`DateFilter`

Input Field	Description
`to` - `DateTime`
`from` - `DateTime`

Example

{"to": DateTime, "from": DateTime}

Types

`DateOperators`

Input Field	Description
`eq` - `DateTime`
`before` - `DateTime`
`after` - `DateTime`
`between` - `DateRange`

Example

{
  "eq": DateTime,
  "before": DateTime,
  "after": DateTime,
  "between": DateRange
}

Types

`DateRange`

Input Field	Description
`start` - `DateTime!`
`end` - `DateTime!`

Example

{"start": DateTime, "end": DateTime}

Types

`DateTime`

Example

object

Types

`DemographicAttributeEnum`

Enum Value	Description
`Age`
`Sex`
`Country`

Types

`DemographicStat`

Field Name	Description
`type` - `StatTypeEnum`
`strata` - `[StrataDetail]`
`percentileBounds` - `[Float]`
`stratumSize` - `Int`

Example

{
  "type": StatTypeEnum,
  "strata": [StrataDetail],
  "percentileBounds": [123.45],
  "stratumSize": 123
}

Types

`DirectionEnum`

Enum Value	Description
`ASC`
`DESC`

Types

`District`

Field Name	Description
`code` - `String`
`name` - `String`

Example

{"code": "abc123", "name": "xyz789"}

Types

`DistrictInput`

Input Field	Description
`code` - `String`
`name` - `String`

Example

{"code": "xyz789", "name": "xyz789"}

Types

`DrawStructureEnum`

Enum Value	Description
`KO`	Knock-out structure
`RR`	Round Robin structure
`FI`	Feed-in structure
`OT`	Other structure

Types

`DrawTypeEnum`

Enum Value	Description
`ELIMINATION`
`DUAL_MATCH`
`TOURNAMENT`
`UNKNOWN`

Types

`Extension`

Field Name	Description
`description` - `String`
`name` - `String!`
`value` - `String!`

Example

{"description": "abc123", "name": "abc123", "value": "abc123"}

Types

`ExtensionInput`

Input Field	Description
`description` - `String`
`name` - `String!`
`value` - `String!`

Example

{"description": "xyz789", "name": "abc123", "value": "xyz789"}

Types

`FavouriteShotEnum`

Enum Value	Description
`Forehand`
`Backhand`
`Serve`
`Volley`
`Smash`
`DropShot`
`Unknown`

Types

`FeatureStatusEnum`

Enum Value	Description
`ENABLED`
`DISABLED`
`FUTURE`
`UNKNOWN`

Types

`Features`

Field Name	Description
`walkUpRegistration` - `FeatureStatusEnum`

Example

{"walkUpRegistration": FeatureStatusEnum}

Types

`Float`

The Float scalar type represents signed double-precision fractional values as specified by IEEE 754.

Example

987.65

Types

`GenderEnum`

Enum Value	Description
`M`
`F`
`X`
`O`

Types

`HandednessEnum`

Enum Value	Description
`UNKNOWN`
`LEFT`
`RIGHT`

Types

`ID`

The ID scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as "4") or integer (such as 4) input value will be accepted as an ID.

Example

object

Types

`IDOperators`

Field Name	Description
`in` - `[ID]`
`ne` - `ID`
`eq` - `ID`

Example

{
  "in": [ID],
  "ne": ID,
  "eq": ID
}

Types

`IndoorOutdoorEnum`

Enum Value	Description
`UNKNOWN`
`INDOOR`
`OUTDOOR`

Types

`Int`

The Int scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.

Example

Types

`InviteLink`

Field Name	Description
`tennisId` - `String`
`url` - `String`
`errorCode` - `String`
`errorMessage` - `String`

Example

{
  "tennisId": "xyz789",
  "url": "xyz789",
  "errorCode": "xyz789",
  "errorMessage": "abc123"
}

Types

`JSON`

The JSON scalar type represents JSON values as specified by ECMA-404.

Example

{}

Types

`MatchIntervals`

Field Name	Description
`avgDays` - `Int`

Example

{"avgDays": 123}

Types

`MatchUp`

Field Name	Description
`id` - `ID!`
`score` - `Score`
`sides` - `[Side]`
`winningSide` - `SideEnum`
`providerMatchId` - `ID!`
`ageCategoryCode` - `String`
`surfaceCategory` - `SurfaceCategoryEnum`
`indoorOutdoor` - `IndoorOutdoorEnum`
`type` - `MatchUpTypeEnum`
`matchUpFormat` - `String`
`grade` - `String`
`start` - `DateTime`
`end` - `DateTime`
`circuit` - `CircuitEnum`
`roundNumber` - `Int`
`roundPosition` - `Int`
`roundName` - `String`
`humidity` - `Float`
`duration` - `Float`
`status` - `MatchUpStatusEnum`
`statusCodes` - `[String]`
`extensions` - `[Extension]`
`createdAt` - `DateTime`
`updatedAt` - `DateTime`
`competitiveness` - `Float`
`state` - `StateEnum`
`divisionType` - `String`
`drawStructure` - `DrawStructureEnum`
`drawType` - `String`
`tieMatchUpId` - `ID`
`courtId` - `ID`
`surfaceType` - `SurfaceTypeEnum`
`tournamentLevel` - `StandardGradeEnum`
`pace` - `PaceEnum`
`gender` - `MatchUpGenderEnum`
`drawId` - `ID`
`drawName` - `String`
`venueId` - `ID`
`selfSubmittedResult` - `Boolean`
`ballType` - `BallTypeEnum`
`deleted` - `Boolean`
`collectionPosition` - `Int`
`wtnId` - `ID`
`wtnErrors` - `[String]`
`isTied` - `Boolean`
`tournament` - `Tournament`
`court` - `Court`
`venue` - `Venue`
`provider` - `Provider`
`ownerId` - `ID`
`reviewedBy` - `Person`
`submissionState` - `MatchUpSubmissionStateEnum`
`reviewedAt` - `DateTime`
`worldTennisNumbers` - `[MatchUpWorldTennisNumber]`	Retrieves the WorldTennisNumbers for the persons involved in the MatchUp. The rating returned is the rating going into the MatchUp.

Example

{
  "id": ID,
  "score": Score,
  "sides": [Side],
  "winningSide": SideEnum,
  "providerMatchId": ID,
  "ageCategoryCode": "abc123",
  "surfaceCategory": SurfaceCategoryEnum,
  "indoorOutdoor": IndoorOutdoorEnum,
  "type": MatchUpTypeEnum,
  "matchUpFormat": "xyz789",
  "grade": "abc123",
  "start": DateTime,
  "end": DateTime,
  "circuit": CircuitEnum,
  "roundNumber": 123,
  "roundPosition": 123,
  "roundName": "xyz789",
  "humidity": 987.65,
  "duration": 987.65,
  "status": MatchUpStatusEnum,
  "statusCodes": ["abc123"],
  "extensions": [Extension],
  "createdAt": DateTime,
  "updatedAt": DateTime,
  "competitiveness": 987.65,
  "state": StateEnum,
  "divisionType": "xyz789",
  "drawStructure": DrawStructureEnum,
  "drawType": "xyz789",
  "tieMatchUpId": ID,
  "courtId": ID,
  "surfaceType": SurfaceTypeEnum,
  "tournamentLevel": StandardGradeEnum,
  "pace": PaceEnum,
  "gender": MatchUpGenderEnum,
  "drawId": ID,
  "drawName": "xyz789",
  "venueId": ID,
  "selfSubmittedResult": false,
  "ballType": BallTypeEnum,
  "deleted": false,
  "collectionPosition": 987,
  "wtnId": ID,
  "wtnErrors": ["abc123"],
  "isTied": false,
  "tournament": Tournament,
  "court": Court,
  "venue": Venue,
  "provider": Provider,
  "ownerId": ID,
  "reviewedBy": Person,
  "submissionState": MatchUpSubmissionStateEnum,
  "reviewedAt": DateTime,
  "worldTennisNumbers": [MatchUpWorldTennisNumber]
}

Types

`MatchUpAggregateFilterOptions`

Field Name	Description
`personId` - `PersonIDInput!`
`providerIds` - `[ID]`
`type` - `MatchUpTypeEnum`
`start` - `DateOperators`
`end` - `DateOperators`
`tournamentIds` - `[ID]`
`indoorOutdoor` - `IndoorOutdoorEnum`
`surfaceCategory` - `SurfaceCategoryEnum`
`statuses` - `[MatchUpStatusEnum]`

Example

{
  "personId": PersonIDInput,
  "providerIds": [ID],
  "type": MatchUpTypeEnum,
  "start": DateOperators,
  "end": DateOperators,
  "tournamentIds": [ID],
  "indoorOutdoor": IndoorOutdoorEnum,
  "surfaceCategory": SurfaceCategoryEnum,
  "statuses": [MatchUpStatusEnum]
}

Types

`MatchUpFilterOptions`

Field Name	Description
`matchUpIds` - `[ID]`
`personIds` - `[PersonIDInput]`
`type` - `[MatchUpTypeEnum]`
`indoorOutdoor` - `IndoorOutdoorEnum`
`surfaceCategory` - `SurfaceCategoryEnum`
`start` - `DateOperators`
`end` - `DateOperators`
`tournamentIds` - `[ID]`
`state` - `StateEnum`
`updatedAt` - `DateOperators`
`createdAt` - `DateOperators`
`providerIds` - `[ID]`
`statuses` - `[MatchUpStatusEnum]`
`providerMatchIds` - `[ID]`
`tournamentLevels` - `[StandardGradeEnum]`
`ageCategoryCode` - `StringOperators`
`selfSubmittedResult` - `BooleanOperators`

Example

{
  "matchUpIds": [ID],
  "personIds": [PersonIDInput],
  "type": [MatchUpTypeEnum],
  "indoorOutdoor": IndoorOutdoorEnum,
  "surfaceCategory": SurfaceCategoryEnum,
  "start": DateOperators,
  "end": DateOperators,
  "tournamentIds": [ID],
  "state": StateEnum,
  "updatedAt": DateOperators,
  "createdAt": DateOperators,
  "providerIds": [ID],
  "statuses": [MatchUpStatusEnum],
  "providerMatchIds": [ID],
  "tournamentLevels": [StandardGradeEnum],
  "ageCategoryCode": StringOperators,
  "selfSubmittedResult": BooleanOperators
}

Types

`MatchUpGenderEnum`

Enum Value	Description
`M`	MALE
`F`	FEMALE
`X`	MIXED
`O`	OPEN

Types

`MatchUpInput`

Field Name	Description
`score` - `ScoreInput`
`sides` - `[SideInput!]!`
`winningSide` - `SideEnum`
`ageCategoryCode` - `String`
`surfaceCategory` - `SurfaceCategoryEnum`
`indoorOutdoor` - `IndoorOutdoorEnum`
`type` - `MatchUpTypeEnum`
`matchUpFormat` - `String`
`grade` - `String`
`providerId` - `ID`
`start` - `DateTime!`
`end` - `DateTime`
`tournamentId` - `ID`
`circuit` - `CircuitEnum`
`roundNumber` - `Int`
`roundPosition` - `Int`
`roundName` - `String`
`humidity` - `Float`
`duration` - `Float`
`championship` - `ChampionshipInput`
`divisionType` - `String`
`drawStructure` - `DrawStructureEnum`
`drawType` - `String`
`status` - `MatchUpStatusEnum`
`statusCodes` - `[String]`
`extensions` - `[ExtensionInput]`
`providerMatchId` - `ID!`
`tieMatchUpId` - `ID`
`drawId` - `ID`
`drawName` - `String`
`courtId` - `ID`
`surfaceType` - `SurfaceTypeEnum`
`tournamentLevel` - `StandardGradeEnum`
`pace` - `PaceEnum`
`gender` - `MatchUpGenderEnum`
`venueId` - `ID`
`selfSubmittedResult` - `Boolean`
`ballType` - `BallTypeEnum`
`collectionPosition` - `Int`
`tournament` - `TournamentInput`

Example

{
  "score": ScoreInput,
  "sides": [SideInput],
  "winningSide": SideEnum,
  "ageCategoryCode": "abc123",
  "surfaceCategory": SurfaceCategoryEnum,
  "indoorOutdoor": IndoorOutdoorEnum,
  "type": MatchUpTypeEnum,
  "matchUpFormat": "xyz789",
  "grade": "xyz789",
  "providerId": ID,
  "start": DateTime,
  "end": DateTime,
  "tournamentId": ID,
  "circuit": CircuitEnum,
  "roundNumber": 987,
  "roundPosition": 123,
  "roundName": "xyz789",
  "humidity": 123.45,
  "duration": 987.65,
  "championship": ChampionshipInput,
  "divisionType": "xyz789",
  "drawStructure": DrawStructureEnum,
  "drawType": "xyz789",
  "status": MatchUpStatusEnum,
  "statusCodes": ["abc123"],
  "extensions": [ExtensionInput],
  "providerMatchId": ID,
  "tieMatchUpId": ID,
  "drawId": ID,
  "drawName": "abc123",
  "courtId": ID,
  "surfaceType": SurfaceTypeEnum,
  "tournamentLevel": StandardGradeEnum,
  "pace": PaceEnum,
  "gender": MatchUpGenderEnum,
  "venueId": ID,
  "selfSubmittedResult": false,
  "ballType": BallTypeEnum,
  "collectionPosition": 123,
  "tournament": TournamentInput
}

Types

`MatchUpIntervals`

Field Name	Description
`avgDays` - `Int`

Example

{"avgDays": 987}

Types

`MatchUpList`

Field Name	Description
`items` - `[MatchUp!]`
`totalItems` - `Int`

Example

{"items": [MatchUp], "totalItems": 123}

Types

`MatchUpRemoveOptions`

Input Field	Description
`ids` - `[ID!]`
`tournamentId` - `ID`
`providerTournamentId` - `ID`
`providerMatchIds` - `[ID!]`

Example

{
  "ids": [ID],
  "tournamentId": ID,
  "providerTournamentId": ID,
  "providerMatchIds": [ID]
}

Types

`MatchUpStatisticsCountFilterOptions`

Input Field	Description
`start` - `DateOperators`
`end` - `DateOperators`

Example

{
  "start": DateOperators,
  "end": DateOperators
}

Types

`MatchUpStatisticsFilterOptions`

Field Name	Description
`persons` - `[PersonIDInput!]!`
`opponents` - `[PersonIDInput!]`
`start` - `DateOperators`
`end` - `DateOperators`
`providerIds` - `[ID]`

Example

{
  "persons": [PersonIDInput],
  "opponents": [PersonIDInput],
  "start": DateOperators,
  "end": DateOperators,
  "providerIds": [ID]
}

Types

`MatchUpStatusEnum`

Enum Value	Description
`BYE`
`DEFAULTED`
`RETIRED`
`WALKOVER`
`COMPLETED`
`SUSPENDED`
`DEAD_RUBBER`
`DISQUALIFIED`
`ABANDONED`
`CANCELLED`
`TIED`

Types

`MatchUpSubmissionStateEnum`

Enum Value	Description
`PENDING`
`REJECTED`
`APPROVED`

Types

`MatchUpTypeEnum`

Enum Value	Description
`SINGLES`
`DOUBLES`
`UNKNOWN`

Types

`MatchUpUpdateInput`

Field Name	Description
`score` - `ScoreInput`
`sides` - `[SideInput!]`
`winningSide` - `SideEnum`
`ageCategoryCode` - `String`
`surfaceCategory` - `SurfaceCategoryEnum`
`indoorOutdoor` - `IndoorOutdoorEnum`
`type` - `MatchUpTypeEnum`
`matchUpFormat` - `String`
`grade` - `String`
`providerId` - `ID`
`start` - `DateTime`
`end` - `DateTime`
`tournamentId` - `ID`
`circuit` - `CircuitEnum`
`roundNumber` - `Int`
`roundPosition` - `Int`
`roundName` - `String`
`humidity` - `Float`
`duration` - `Float`
`championship` - `ChampionshipInput`
`divisionType` - `String`
`drawStructure` - `DrawStructureEnum`
`drawType` - `String`
`status` - `MatchUpStatusEnum`
`statusCodes` - `[String]`
`extensions` - `[ExtensionInput]`
`providerMatchId` - `ID`
`tieMatchUpId` - `ID`
`drawId` - `ID`
`drawName` - `String`
`courtId` - `ID`
`surfaceType` - `SurfaceTypeEnum`
`tournamentLevel` - `StandardGradeEnum`
`pace` - `PaceEnum`
`gender` - `MatchUpGenderEnum`
`venueId` - `ID`
`selfSubmittedResult` - `Boolean`
`ballType` - `BallTypeEnum`
`collectionPosition` - `Int`
`tournament` - `TournamentUpdateInput`

Example

{
  "score": ScoreInput,
  "sides": [SideInput],
  "winningSide": SideEnum,
  "ageCategoryCode": "abc123",
  "surfaceCategory": SurfaceCategoryEnum,
  "indoorOutdoor": IndoorOutdoorEnum,
  "type": MatchUpTypeEnum,
  "matchUpFormat": "abc123",
  "grade": "xyz789",
  "providerId": ID,
  "start": DateTime,
  "end": DateTime,
  "tournamentId": ID,
  "circuit": CircuitEnum,
  "roundNumber": 123,
  "roundPosition": 123,
  "roundName": "abc123",
  "humidity": 123.45,
  "duration": 123.45,
  "championship": ChampionshipInput,
  "divisionType": "xyz789",
  "drawStructure": DrawStructureEnum,
  "drawType": "xyz789",
  "status": MatchUpStatusEnum,
  "statusCodes": ["xyz789"],
  "extensions": [ExtensionInput],
  "providerMatchId": ID,
  "tieMatchUpId": ID,
  "drawId": ID,
  "drawName": "xyz789",
  "courtId": ID,
  "surfaceType": SurfaceTypeEnum,
  "tournamentLevel": StandardGradeEnum,
  "pace": PaceEnum,
  "gender": MatchUpGenderEnum,
  "venueId": ID,
  "selfSubmittedResult": false,
  "ballType": BallTypeEnum,
  "collectionPosition": 123,
  "tournament": TournamentUpdateInput
}

Types

`MatchUpVsStatistics`

Field Name	Description
`matchUpVsStatisticsCount` - `MatchUpWinLossCount!`
Arguments `filter` - `MatchUpStatisticsCountFilterOptions`
`matchUps` - `MatchUpList`
Arguments `pageArgs` - `PaginationArgs` `filter` - `MatchUpFilterOptions` `sort` - `SortOrder`
`commonCompetitorIds` - `[ID!]`
`commonCompetitors` - `[Person!]`
`winLikelihood` - `Int`

Example

{
  "matchUpVsStatisticsCount": MatchUpWinLossCount,
  "matchUps": MatchUpList,
  "commonCompetitorIds": [ID],
  "commonCompetitors": [Person],
  "winLikelihood": 987
}

Types

`MatchUpVsStatisticsCountFilterOptions`

Input Field	Description
`opponents` - `[PersonIDInput!]!`
`start` - `DateOperators`
`end` - `DateOperators`

Example

{
  "opponents": [PersonIDInput],
  "start": DateOperators,
  "end": DateOperators
}

Types

`MatchUpVsStatisticsWinLossCount`

Field Name	Description
`totalMatches` - `Int`
`wins` - `Int`
`losses` - `Int`

Example

{"totalMatches": 987, "wins": 987, "losses": 123}

Types

`MatchUpWinLossCount`

Field Name	Description
`totalMatches` - `Int!`
`wins` - `Int`
Arguments `id` - `ID!`
`losses` - `Int`
Arguments `id` - `ID!`

Example

{"totalMatches": 123, "wins": 987, "losses": 123}

Types

`MatchUpWorldTennisNumber`

Field Name	Description
`personId` - `ID!`
`confidence` - `Float`
`ratingDate` - `DateTime!`
`tennisNumber` - `Float!`
`type` - `WorldTennisNumberTypeEnum!`
`gameZoneUpper` - `Float`
`gameZoneLower` - `Float`
`source` - `RatingSourceEnum`
`isRanked` - `Boolean`

Example

{
  "personId": ID,
  "confidence": 987.65,
  "ratingDate": DateTime,
  "tennisNumber": 123.45,
  "type": WorldTennisNumberTypeEnum,
  "gameZoneUpper": 123.45,
  "gameZoneLower": 987.65,
  "source": RatingSourceEnum,
  "isRanked": false
}

Types

`NationalityCode`

An ISO 3166-1 alpha-3 code encoded string.

Example

object

Types

`NumberOperators`

Input Field	Description
`eq` - `Float`
`ne` - `Float`
`lt` - `Float`
`lte` - `Float`
`gt` - `Float`
`gte` - `Float`
`between` - `NumberRange`

Example

{
  "eq": 123.45,
  "ne": 123.45,
  "lt": 123.45,
  "lte": 123.45,
  "gt": 987.65,
  "gte": 987.65,
  "between": NumberRange
}

Types

`NumberRange`

Input Field	Description
`start` - `Float!`
`end` - `Float!`

Example

{"start": 123.45, "end": 123.45}

Types

`PaceEnum`

Enum Value	Description
`SLOW`
`MEDIUM_SLOW`
`MEDIUM`
`MEDIUM_FAST`
`FAST`

Types

`PaginationArgs`

Input Field	Description
`limit` - `Int`
`skip` - `Int`

Example

{"limit": 123, "skip": 123}

Types

`Person`

Field Name	Description
`registrationInvite` - `InviteLink`
`clubs` - `[Club]`
`clubStatus` - `PersonClubStatus`
`id` - `ID!`	Unique identifier
`clubsparkId` - `ID`	Clubspark user ID (UUID format)
`externalID` - `ID`
`tennisID` - `ID`
`nationalID` - `ID`
`personID` - `ID`
`biographicalInformation` - `BiographicalInformation`	Additional information on Person
`extensions` - `[Extension]`	Free-form addtional data in key-value pairs
`nationalityCode` - `String`	ISO-3166-1 alpha-3 country code of Person's nationality
`nativeFamilyName` - `String!`	Family name of the person in native language and character set. Limited to 40 characters.
`nativeGivenName` - `String!`	Given name to the person,in native language and character set. Limited to 40 characters.
`nationalRating` - `String`	Rating assigned to the Person by the owning NGB (not updated by WTN systems)
`notes` - `String`	Additional free-form string data
`standardGivenName` - `String`	The given name in Latin script that the person is usually known by. This will usually be a translation or transliteration of the Native Name.
`standardFamilyName` - `String`	The family name in Latin script that the person is usually known by. This will usually be a translation or transliteration of the Native Name.
`birthDate` - `Date!`
`isDeceased` - `Boolean!`
`sex` - `SexEnum!`
`age` - `Int!`
`birthYear` - `Int!`	Year of Person's birth in four digit form, eg. 1987
`worldTennisNumbers` - `[WorldTennisNumber]`	Holds the current WTN calculated for this Person
`addresses` - `[Address]`	Person's postal address
`createdAt` - `DateTime`	Record metadata - timestamp of creation
`updatedAt` - `DateTime`	Record metadata - timestamp of last update
`belongsToRequestingProvider` - `Boolean`
`lastPlayedSingles` - `DateTime`	Date of Person's last singles match
`lastPlayedDoubles` - `DateTime`	Date of Person's last doubles match
`optedOutOfPublicDataConsent` - `Boolean`	Opt out of having data shown on public site.
`owningProviderId` - `ID`	The ID of the owning provider of this Person
`school` - `[SchoolInfo]`	School information
`isRanked` - `Boolean`
`rankedSingles` - `Boolean`
`rankedDoubles` - `Boolean`
`eligibleForSelfSubmission` - `Boolean`
`eligibleForPsq` - `Boolean`
`isRegistered` - `Boolean`
`section` - `Section`
`hasSubmittedResult` - `Boolean`	Check for if this Person is the owner of a self-submitted result, including rejected and deleted results
`tournaments` - `TournamentList`
Arguments `pageArgs` - `PaginationArgs` `filter` - `TournamentFilterOptions` `sort` - `SortOrder`
`matchUpIntervals` - `MatchUpIntervals!`
Arguments `filter` - `MatchUpFilterOptions`
`matchUpVsStatisticsCount` - `MatchUpVsStatisticsWinLossCount`
Arguments `filter` - `MatchUpVsStatisticsCountFilterOptions`
`matchUps` - `MatchUpList`
Arguments `pageArgs` - `PaginationArgs` `filter` - `MatchUpFilterOptions` `sort` - `SortOrder`
`demographicStats` - `[DemographicStat]`
`ratingBounds` - `RatingBounds!`
Arguments `dateFilter` - `DateFilter`

Example

{
  "registrationInvite": InviteLink,
  "clubs": [Club],
  "clubStatus": PersonClubStatus,
  "id": ID,
  "clubsparkId": ID,
  "externalID": ID,
  "tennisID": ID,
  "nationalID": ID,
  "personID": ID,
  "biographicalInformation": BiographicalInformation,
  "extensions": [Extension],
  "nationalityCode": "abc123",
  "nativeFamilyName": "abc123",
  "nativeGivenName": "xyz789",
  "nationalRating": "abc123",
  "notes": "xyz789",
  "standardGivenName": "xyz789",
  "standardFamilyName": "xyz789",
  "birthDate": "2025-10-01T14:07:52.371Z",
  "isDeceased": true,
  "sex": SexEnum,
  "age": 123,
  "birthYear": 123,
  "worldTennisNumbers": [WorldTennisNumber],
  "addresses": [Address],
  "createdAt": DateTime,
  "updatedAt": DateTime,
  "belongsToRequestingProvider": true,
  "lastPlayedSingles": DateTime,
  "lastPlayedDoubles": DateTime,
  "optedOutOfPublicDataConsent": false,
  "owningProviderId": ID,
  "school": [SchoolInfo],
  "isRanked": true,
  "rankedSingles": true,
  "rankedDoubles": false,
  "eligibleForSelfSubmission": false,
  "eligibleForPsq": false,
  "isRegistered": false,
  "section": Section,
  "hasSubmittedResult": true,
  "tournaments": TournamentList,
  "matchUpIntervals": MatchUpIntervals,
  "matchUpVsStatisticsCount": MatchUpVsStatisticsWinLossCount,
  "matchUps": MatchUpList,
  "demographicStats": [DemographicStat],
  "ratingBounds": RatingBounds
}

Types

`PersonAggregatedFilterOptions`

Field Name	Description
`ageBuckets` - `[Int!]`
`nationalityCode` - `NationalityCode`
`sex` - `SexEnum`
`age` - `NumberOperators`
`daysAgo` - `Int`
`providerId` - `String`
`providerIds` - `[String]`

Example

{
  "ageBuckets": [987],
  "nationalityCode": NationalityCode,
  "sex": SexEnum,
  "age": NumberOperators,
  "daysAgo": 123,
  "providerId": "abc123",
  "providerIds": ["xyz789"]
}

Types

`PersonClubStatus`

Enum Value	Description
`UNKNOWN`
`CLUB_NOT_LISTED`
`NON_CLUB_PLAYER`
`CLUB_PLAYER`

Types

`PersonDate`

The date that represents the persons date of birth and the person must be over 9 years old

Example

object

Types

`PersonDeltaChange`

Field Name	Description
`_id` - `ID`
`loggedErrors` - `[AuditError]`
`createdAt` - `DateTime`
`updatedAt` - `DateTime`
`status` - `SyncStatusEnum`

Example

{
  "_id": ID,
  "loggedErrors": [AuditError],
  "createdAt": DateTime,
  "updatedAt": DateTime,
  "status": SyncStatusEnum
}

Types

`PersonFilterOptions`

Field Name	Description
`clubId` - `ID`
`search` - `SearchOperators`
`age` - `NumberOperators`
`birthYear` - `Int`
`updatedAt` - `DateOperators`
`createdAt` - `DateOperators`
`nationalityCode` - `StringOperators`
`sex` - `SexEnum`
`ratings` - `RatingFilterOptions`
`ratingsMulti` - `[RatingFilterOptions]`
`ids` - `[PersonIDInput]`
`providerId` - `String`
`providerIds` - `[String]`
`involvedInMatchUps` - `Boolean`
`lastPlayedSingles` - `DateOperators`
`lastPlayedDoubles` - `DateOperators`
`providerNationalityPersons` - `Boolean`
`ignoreProviderPersons` - `Boolean`
`owningProviderId` - `ID`
`scopeForSelfSubmission` - `Boolean`

Example

{
  "clubId": ID,
  "search": SearchOperators,
  "age": NumberOperators,
  "birthYear": 987,
  "updatedAt": DateOperators,
  "createdAt": DateOperators,
  "nationalityCode": StringOperators,
  "sex": SexEnum,
  "ratings": RatingFilterOptions,
  "ratingsMulti": [RatingFilterOptions],
  "ids": [PersonIDInput],
  "providerId": "abc123",
  "providerIds": ["abc123"],
  "involvedInMatchUps": true,
  "lastPlayedSingles": DateOperators,
  "lastPlayedDoubles": DateOperators,
  "providerNationalityPersons": false,
  "ignoreProviderPersons": true,
  "owningProviderId": ID,
  "scopeForSelfSubmission": false
}

Types

`PersonIDEnum`

Enum Value	Description
`ID`
`ClubsparkID`
`TennisID`
`NationalID`
`ExternalID`
`PersonID`

Types

`PersonIDInput`

Input Field	Description
`identifier` - `String!`
`type` - `PersonIDEnum!`

Example

{"identifier": "xyz789", "type": PersonIDEnum}

Types

`PersonInput`

Field Name	Description
`biographicalInformation` - `BiographicalInformationInput`
`emailAddress` - `String`
`secondaryEmailAddress` - `String`
`extensions` - `[ExtensionInput]`
`nationalityCode` - `NationalityCode!`
`nativeFamilyName` - `String!`
`nativeGivenName` - `String!`
`standardGivenName` - `String`	deprecated: generated from the nativeGivenName
`standardFamilyName` - `String`	deprecated: generated from the nativeFamilyName
`nationalRating` - `String`
`notes` - `String`
`isDeceased` - `Boolean`
`birthDate` - `PersonDate!`
`sex` - `SexEnum!`
`addresses` - `[AddressInput]`
`clubsparkId` - `ID`
`optedOutOfPublicDataConsent` - `Boolean`
`nationalID` - `String`
`externalID` - `ID`
`personID` - `ID`
`section` - `SectionInput`

Example

{
  "biographicalInformation": BiographicalInformationInput,
  "emailAddress": "abc123",
  "secondaryEmailAddress": "abc123",
  "extensions": [ExtensionInput],
  "nationalityCode": NationalityCode,
  "nativeFamilyName": "xyz789",
  "nativeGivenName": "xyz789",
  "standardGivenName": "abc123",
  "standardFamilyName": "xyz789",
  "nationalRating": "abc123",
  "notes": "abc123",
  "isDeceased": false,
  "birthDate": PersonDate,
  "sex": SexEnum,
  "addresses": [AddressInput],
  "clubsparkId": ID,
  "optedOutOfPublicDataConsent": false,
  "nationalID": "abc123",
  "externalID": ID,
  "personID": ID,
  "section": SectionInput
}

Types

`PersonList`

Field Name	Description
`items` - `[Person!]`
`totalItems` - `Int`

Example

{"items": [Person], "totalItems": 987}

Types

`PersonMerge`

Field Name	Description
`newPersonTennisId` - `String!`
`newPersonNationalId` - `String`
`mergedPersonTennisId` - `String!`
`mergedPersonNationalId` - `String`
`timestamp` - `DateTime!`

Example

{
  "newPersonTennisId": "abc123",
  "newPersonNationalId": "abc123",
  "mergedPersonTennisId": "abc123",
  "mergedPersonNationalId": "xyz789",
  "timestamp": DateTime
}

Types

`PersonMergeResult`

Code	Reason	Comments
200	success
140	Persons are of different sexes
150	Provider not the owner of the Person
210	target person owned by ITF
220	additionalPersonID owned by ITF
400	No additionalPersonIDs provided
404	Failed to find target person
404	Failed to find additional person
422	additionalPersonIDs refer to the same person
500	Failed to merge person	Catch all error

Field Name	Description
`code` - `Int!`	Response code (see above table)
`reason` - `String`	Description of response code
`person` - `Person`	Merged person record (on successful merge)

Example

{"code": 123, "reason": "xyz789", "person": Person}

Types

`PersonMergesList`

Field Name	Description
`items` - `[PersonMerge!]`
`totalItems` - `Int`

Example

{"items": [PersonMerge], "totalItems": 987}

Types

`PersonOptedOutOfPublicDataConsent`

Field Name	Description
`setByUser` - `Boolean`
`setByOwningProvider` - `Boolean`
`optedOutOfPublicDataConsent` - `Boolean`
`providersOptedOutOfPublicDataConsent` - `[ProviderOptedOutOfPublicDataConsent]`

Example

{
  "setByUser": true,
  "setByOwningProvider": false,
  "optedOutOfPublicDataConsent": true,
  "providersOptedOutOfPublicDataConsent": [
    ProviderOptedOutOfPublicDataConsent
  ]
}

Types

`PersonPSQAnswerInput`

Input Field	Description
`questionId` - `ID!`
`answerId` - `ID!`

Example

{"questionId": ID, "answerId": ID}

Types

`PersonPSQInput`

Input Field	Description
`answers` - `[PersonPSQAnswerInput!]!`
`gender` - `SexEnum!`
`age` - `Int!`

Example

{
  "answers": [PersonPSQAnswerInput],
  "gender": SexEnum,
  "age": 987
}

Types

`PersonRating`

Field Name	Description
`confidence` - `Float!`
`timestamp` - `DateTime!`
`rating` - `Float!`
`ratingType` - `RatingTypeEnum!`
`gameZoneUpper` - `Float`
`gameZoneLower` - `Float`
`source` - `RatingSourceEnum`

Example

{
  "confidence": 987.65,
  "timestamp": DateTime,
  "rating": 987.65,
  "ratingType": RatingTypeEnum,
  "gameZoneUpper": 123.45,
  "gameZoneLower": 123.45,
  "source": RatingSourceEnum
}

Types

`PersonUpdateInput`

Field Name	Description
`biographicalInformation` - `BiographicalInformationInput`
`emailAddress` - `String`
`secondaryEmailAddress` - `String`
`extensions` - `[ExtensionInput]`
`nationalityCode` - `NationalityCode`
`nativeFamilyName` - `String`
`nativeGivenName` - `String`
`standardGivenName` - `String`	deprecated: generated from the nativeGivenName
`standardFamilyName` - `String`	deprecated: generated from the nativeFamilyName
`nationalRating` - `String`
`notes` - `String`
`isDeceased` - `Boolean`
`birthDate` - `PersonDate`
`sex` - `SexEnum`
`addresses` - `[AddressInput]`
`clubsparkId` - `ID`
`optedOutOfPublicDataConsent` - `Boolean`
`externalID` - `ID`
`personID` - `ID`
`nationalID` - `String`
`section` - `SectionInput`

Example

{
  "biographicalInformation": BiographicalInformationInput,
  "emailAddress": "abc123",
  "secondaryEmailAddress": "abc123",
  "extensions": [ExtensionInput],
  "nationalityCode": NationalityCode,
  "nativeFamilyName": "abc123",
  "nativeGivenName": "abc123",
  "standardGivenName": "abc123",
  "standardFamilyName": "xyz789",
  "nationalRating": "xyz789",
  "notes": "xyz789",
  "isDeceased": true,
  "birthDate": PersonDate,
  "sex": SexEnum,
  "addresses": [AddressInput],
  "clubsparkId": ID,
  "optedOutOfPublicDataConsent": false,
  "externalID": ID,
  "personID": ID,
  "nationalID": "xyz789",
  "section": SectionInput
}

Types

`PersonaTypeEnum`

Enum Value	Description
`CASUAL_PLAY`
`COMPETITIVE_PLAY`
`INTEREST_ONLY`
`COACH`
`PARENT_OR_CARER`
`OTHER`

Types

`Player`

Field Name	Description
`playerNumber` - `Int`
`person` - `Person`

Example

{"playerNumber": 123, "person": Person}

Types

`PlayerInput`

Input Field	Description
`personId` - `PersonIDInput!`
`playerNumber` - `Int`

Example

{"personId": PersonIDInput, "playerNumber": 987}

Types

`PlayerOnSide`

Field Name	Description
`tennisId` - `String`
`nativeGivenName` - `String`
`nativeFamilyName` - `String`

Example

{
  "tennisId": "abc123",
  "nativeGivenName": "xyz789",
  "nativeFamilyName": "xyz789"
}

Types

`PlayingDoubleHandEnumType`

Enum Value	Description
`FH`
`BH`
`FB`
`NO`
`U`

Types

`PlayingHandEnumType`

Enum Value	Description
`A`
`L`
`R`
`U`

Types

`Provider`

Field Name	Description
`id` - `ID`
`providerId` - `String`
`name` - `String!`
`orgId` - `String`
`nationalityCodes` - `[NationalityCode]`
`defaultOptOutStatus` - `Boolean`
`updatedAt` - `DateTime`
`createdAt` - `DateTime`
`personMinimumAge` - `Int`
`logoUrl` - `String`
`displayName` - `String`
`landingPageUrl` - `String`
`supportPageUrl` - `String`
`providerType` - `ProviderTypeEnum`

Example

{
  "id": ID,
  "providerId": "abc123",
  "name": "abc123",
  "orgId": "abc123",
  "nationalityCodes": [NationalityCode],
  "defaultOptOutStatus": false,
  "updatedAt": DateTime,
  "createdAt": DateTime,
  "personMinimumAge": 123,
  "logoUrl": "abc123",
  "displayName": "xyz789",
  "landingPageUrl": "abc123",
  "supportPageUrl": "xyz789",
  "providerType": ProviderTypeEnum
}

Types

`ProviderFilterOptions`

Field Name	Description
`ids` - `[ID]`
`updatedAt` - `DateOperators`
`createdAt` - `DateOperators`

Example

{
  "ids": [ID],
  "updatedAt": DateOperators,
  "createdAt": DateOperators
}

Types

`ProviderInput`

Field Name	Description
`providerId` - `String!`
`name` - `String!`
`orgId` - `String`
`nationalityCodes` - `[NationalityCode]`
`defaultOptOutStatus` - `Boolean`
`personMinimumAge` - `Int`
`logoUrl` - `String`
`displayName` - `String`
`landingPageUrl` - `String`
`supportPageUrl` - `String`
`providerType` - `ProviderTypeEnum`

Example

{
  "providerId": "xyz789",
  "name": "abc123",
  "orgId": "abc123",
  "nationalityCodes": [NationalityCode],
  "defaultOptOutStatus": true,
  "personMinimumAge": 987,
  "logoUrl": "xyz789",
  "displayName": "abc123",
  "landingPageUrl": "xyz789",
  "supportPageUrl": "xyz789",
  "providerType": ProviderTypeEnum
}

Types

`ProviderList`

Field Name	Description
`items` - `[Provider!]`
`totalItems` - `Int`

Example

{"items": [Provider], "totalItems": 987}

Types

`ProviderName`

Field Name	Description
`name` - `String`
`displayName` - `String`

Example

{"name": "abc123", "displayName": "abc123"}

Types

`ProviderNameList`

Field Name	Description
`items` - `[ProviderName!]`
`totalItems` - `Int`

Example

{"items": [ProviderName], "totalItems": 987}

Types

`ProviderOptedOutOfPublicDataConsent`

Field Name	Description
`providerId` - `String`
`optedOutOfPublicDataConsent` - `Boolean`

Example

{"providerId": "xyz789", "optedOutOfPublicDataConsent": true}

Types

`ProviderTournamentIDErrors`

Field Name	Description
`providerTournamentID` - `String`
`transformationErrors` - `[String]`
`additionalFieldsByMatchId` - `[AdditionalFieldsByMatchId]`	Only set in case tournament contains bad matchup

Example

{
  "providerTournamentID": "xyz789",
  "transformationErrors": ["xyz789"],
  "additionalFieldsByMatchId": [AdditionalFieldsByMatchId]
}

Types

`ProviderTypeEnum`

Enum Value	Description
`WTN`
`REDPADEL`

Types

`ProviderUpdateInput`

Field Name	Description
`providerId` - `String`
`name` - `String`
`orgId` - `String`
`nationalityCodes` - `[NationalityCode]`
`defaultOptOutStatus` - `Boolean`
`personMinimumAge` - `Int`
`logoUrl` - `String`
`displayName` - `String`
`landingPageUrl` - `String`
`supportPageUrl` - `String`
`providerType` - `ProviderTypeEnum`

Example

{
  "providerId": "abc123",
  "name": "abc123",
  "orgId": "abc123",
  "nationalityCodes": [NationalityCode],
  "defaultOptOutStatus": true,
  "personMinimumAge": 123,
  "logoUrl": "abc123",
  "displayName": "xyz789",
  "landingPageUrl": "abc123",
  "supportPageUrl": "abc123",
  "providerType": ProviderTypeEnum
}

Types

`PublicPersonFilterOptions`

Field Name	Description
`search` - `SearchFilterOptions`
`age` - `RangeNumberOperators`
`nationalityCodes` - `[NationalityCode]`
`sex` - `SexEnum`
`ratings` - `[PublicPersonRatingFilterOptions]`
`birthYear` - `Int`
`scopeForSelfSubmission` - `Boolean`

Example

{
  "search": SearchFilterOptions,
  "age": RangeNumberOperators,
  "nationalityCodes": [NationalityCode],
  "sex": SexEnum,
  "ratings": [PublicPersonRatingFilterOptions],
  "birthYear": 123,
  "scopeForSelfSubmission": true
}

Types

`PublicPersonRatingFilterOptions`

Input Field	Description
`type` - `RatingTypeEnum!`
`rating` - `RangeNumberOperators`
`confidence` - `NumberOperators`

Example

{
  "type": RatingTypeEnum,
  "rating": RangeNumberOperators,
  "confidence": NumberOperators
}

Types

`RangeNumberOperators`

Input Field	Description
`lt` - `Float`
`lte` - `Float`
`gt` - `Float`
`gte` - `Float`

Example

{"lt": 123.45, "lte": 123.45, "gt": 987.65, "gte": 987.65}

Types

`Rating`

Field Name	Description
`id` - `ID!`
`personId` - `ID!`
`confidence` - `Float`
`timestamp` - `DateTime!`
`updatedAt` - `DateTime`
`rating` - `Float!`
`ratingType` - `RatingTypeEnum!`
`prevRating` - `Float`
`opponentIds` - `[ID]`
`matchIds` - `[ID]`
`vol` - `Float`
`rd` - `Float`
`prevRd` - `Float`
`weight` - `Float`
`upperScaledGamezoneBound` - `Float`
`lowerScaledGamezoneBound` - `Float`
`unscaledRating` - `Float`
`source` - `RatingSourceEnum`
`person` - `Person`
`opponents` - `[Person]`
`matchUps` - `[MatchUp]`

Example

{
  "id": ID,
  "personId": ID,
  "confidence": 987.65,
  "timestamp": DateTime,
  "updatedAt": DateTime,
  "rating": 987.65,
  "ratingType": RatingTypeEnum,
  "prevRating": 123.45,
  "opponentIds": [ID],
  "matchIds": [ID],
  "vol": 123.45,
  "rd": 123.45,
  "prevRd": 987.65,
  "weight": 987.65,
  "upperScaledGamezoneBound": 123.45,
  "lowerScaledGamezoneBound": 987.65,
  "unscaledRating": 987.65,
  "source": RatingSourceEnum,
  "person": Person,
  "opponents": [Person],
  "matchUps": [MatchUp]
}

Types

`RatingBounds`

Field Name	Description
`boundsForType` - `RatingMinMax`
Arguments `ratingType` - `RatingTypeEnum`

Example

{"boundsForType": RatingMinMax}

Types

`RatingFilterInput`

Input Field	Description
`ratingType` - `RatingTypeEnum`
`personId` - `ID`
`rating` - `Float`
`lowerRatingScope` - `Int`
`higherRatingScope` - `Int`
`matchTimestamp` - `DateTime`
`reportFilters` - `ReportFilterInput`

Example

{
  "ratingType": RatingTypeEnum,
  "personId": ID,
  "rating": 987.65,
  "lowerRatingScope": 123,
  "higherRatingScope": 123,
  "matchTimestamp": DateTime,
  "reportFilters": ReportFilterInput
}

Types

`RatingFilterOptions`

Input Field	Description
`type` - `RatingTypeEnum!`
`rating` - `NumberOperators`
`updatedAt` - `DateOperators`
`source` - `RatingSourceEnum`
`confidence` - `NumberOperators`

Example

{
  "type": RatingTypeEnum,
  "rating": NumberOperators,
  "updatedAt": DateOperators,
  "source": RatingSourceEnum,
  "confidence": NumberOperators
}

Types

`RatingMinMax`

Field Name	Description
`min` - `Float`
`max` - `Float`

Example

{"min": 987.65, "max": 987.65}

Types

`RatingSort`

Input Field	Description
`field` - `String`
`direction` - `DirectionEnum`

Example

{"field": "xyz789", "direction": DirectionEnum}

Types

`RatingSourceEnum`

Enum Value	Description
`SEED`
`UNKNOWN`
`INIT`
`PSQ`
`MATCHUPS`

Types

`RatingTypeEnum`

Enum Value	Description
`ITF`
`ITFDBL`
`NTRP`

Types

`RecaptchaInput`

Input Field	Description
`token` - `String!`
`action` - `String`

Example

{"token": "abc123", "action": "abc123"}

Types

`ReportFilterInput`

Field Name	Description
`ratingBandBucket` - `[Int]!`

Example

{"ratingBandBucket": [123]}

Types

`ResidenceCountryCode`

An ISO 3166-1 alpha-3 code encoded string.

Example

object

Types

`SchoolInfo`

Field Name	Description
`name` - `String`
`externalId` - `ID!`
`year` - `String`
`division` - `String`
`class` - `String`
`providerId` - `ID!`
`logoUrl` - `String`
`externalLink` - `String`
`state` - `SchoolMemberStateEnum!`
`updatedAt` - `DateTime`
`createdAt` - `DateTime`

Example

{
  "name": "xyz789",
  "externalId": ID,
  "year": "abc123",
  "division": "abc123",
  "class": "xyz789",
  "providerId": ID,
  "logoUrl": "xyz789",
  "externalLink": "abc123",
  "state": SchoolMemberStateEnum,
  "updatedAt": DateTime,
  "createdAt": DateTime
}

Types

`SchoolInput`

Input Field	Description
`name` - `String`
`externalId` - `ID!`
`year` - `String`
`division` - `String`
`class` - `String`
`logoUrl` - `String`
`state` - `SchoolMemberStateEnum!`

Example

{
  "name": "xyz789",
  "externalId": ID,
  "year": "xyz789",
  "division": "xyz789",
  "class": "xyz789",
  "logoUrl": "abc123",
  "state": SchoolMemberStateEnum
}

Types

`SchoolMemberStateEnum`

Enum Value	Description
`ACTIVE`
`INACTIVE`

Types

`Score`

Field Name	Description
`scoreString` - `String`
`sets` - `[Set]`
`superTiebreak` - `Tiebreaker`

Example

{
  "scoreString": "abc123",
  "sets": [Set],
  "superTiebreak": Tiebreaker
}

Types

`ScoreInput`

Field Name	Description
`scoreString` - `String`
`scoreStringWinnerFirst` - `Boolean`
`sets` - `[SetInput]`
`superTiebreak` - `TiebreakerInput`

Example

{
  "scoreString": "xyz789",
  "scoreStringWinnerFirst": true,
  "sets": [SetInput],
  "superTiebreak": TiebreakerInput
}

Types

`SearchFilterOptions`

Input Field	Description
`term` - `String!`
`fuzzy` - `Boolean`
`exactMatch` - `Boolean`
`autocomplete` - `Boolean`

Example

{"term": "abc123", "fuzzy": false, "exactMatch": true, "autocomplete": true}

Types

`SearchOperators`

Input Field	Description
`normalized` - `String`

Example

{"normalized": "xyz789"}

Types

`Section`

Field Name	Description
`identifier` - `String`
`name` - `String`
`code` - `String`
`district` - `District`

Example

{
  "identifier": "xyz789",
  "name": "abc123",
  "code": "abc123",
  "district": District
}

Types

`SectionInput`

Input Field	Description
`identifier` - `String`
`name` - `String`
`code` - `String`
`district` - `DistrictInput`

Example

{
  "identifier": "xyz789",
  "name": "abc123",
  "code": "xyz789",
  "district": DistrictInput
}

Types

`SelfSubmittedMatchUpInput`

Input Field	Description
`score` - `ScoreInput`
`sides` - `[SideInput!]!`
`winningSide` - `SideEnum`
`start` - `DateTime!`
`matchUpFormat` - `String`

Example

{
  "score": ScoreInput,
  "sides": [SideInput],
  "winningSide": SideEnum,
  "start": DateTime,
  "matchUpFormat": "abc123"
}

Types

`SelfSubmittedMatchUpList`

Field Name	Description
`items` - `[MatchUp]`
`pendingItems` - `Int`
`rejectedItems` - `Int`
`approvedItems` - `Int`
`totalItems` - `Int`

Example

{
  "items": [MatchUp],
  "pendingItems": 987,
  "rejectedItems": 123,
  "approvedItems": 123,
  "totalItems": 987
}

Types

`SelfSubmittedMatchUpUpdateInput`

Input Field	Description
`score` - `ScoreInput`
`sides` - `[SideInput!]`
`winningSide` - `SideEnum`
`start` - `DateTime`
`matchUpFormat` - `String`

Example

{
  "score": ScoreInput,
  "sides": [SideInput],
  "winningSide": SideEnum,
  "start": DateTime,
  "matchUpFormat": "abc123"
}

Types

`Set`

Field Name	Description
`winnerGamesWon` - `Int`
`loserGamesWon` - `Int`
`winRatio` - `Float`
`tiebreaker` - `Tiebreaker`

Example

{
  "winnerGamesWon": 987,
  "loserGamesWon": 987,
  "winRatio": 123.45,
  "tiebreaker": Tiebreaker
}

Types

`SetInput`

Input Field	Description
`winnerGamesWon` - `Int`
`loserGamesWon` - `Int`
`tiebreaker` - `TiebreakerInput`

Example

{
  "winnerGamesWon": 987,
  "loserGamesWon": 123,
  "tiebreaker": TiebreakerInput
}

Types

`SexEnum`

Enum Value	Description
`M`
`F`
`O`

Types

`Side`

Field Name	Description
`extensions` - `[Extension]`
`notes` - `String`
`players` - `[Player!]!`
`sideNumber` - `SideEnum!`

Example

{
  "extensions": [Extension],
  "notes": "xyz789",
  "players": [Player],
  "sideNumber": SideEnum
}

Types

`SideEnum`

Enum Value	Description
`SIDE1`
`SIDE2`

Types

`SideInput`

Input Field	Description
`extensions` - `[ExtensionInput!]`
`notes` - `String`
`teamId` - `ID`
`players` - `[PlayerInput!]!`
`sideNumber` - `SideEnum!`

Example

{
  "extensions": [ExtensionInput],
  "notes": "abc123",
  "teamId": ID,
  "players": [PlayerInput],
  "sideNumber": SideEnum
}

Types

`SignUpTypeEnum`

Enum Value	Description
`walkUp`
`fastTrack`
`accountPerson`

Types

`SortOrder`

Input Field	Description
`field` - `String!`
`direction` - `DirectionEnum!`

Example

{"field": "abc123", "direction": DirectionEnum}

Types

`StandardGradeEnum`

Enum Value	Description
`INT`	International
`NAT`	National
`REG`	Regional
`DIS`	District
`LOC`	Local
`CLB`	Club
`REC`	Recreational
`ZON`	Zonal

Types

`StatBucket`

Field Name	Description
`totalMatches` - `Int`
`matchesWon` - `Int`
`matchesLost` - `Int`
`month` - `Int`
`year` - `Int`
`ties` - `Int`

Example

{
  "totalMatches": 123,
  "matchesWon": 987,
  "matchesLost": 987,
  "month": 987,
  "year": 987,
  "ties": 987
}

Types

`StatTypeEnum`

Enum Value	Description
`Percentile`

Types

`StateEnum`

Enum Value	Description
`SUCCESS`
`FAIL`
`UNKNOWN`

Types

`StrataDetail`

Field Name	Description
`attribute` - `DemographicAttributeEnum`
`label` - `String`

Example

{"attribute": DemographicAttributeEnum, "label": "xyz789"}

Types

`String`

The String scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.

Types

`StringOperators`

Field Name	Description
`eq` - `String`
`contains` - `String`
`in` - `[String]`

Example

{"eq": "abc123", "contains": "abc123", "in": ["abc123"]}

Types

`SurfaceCategoryEnum`

Enum Value	Description
`UNKNOWN`
`HARD`
`CLAY`
`ARTIFICIAL`
`GRASS`

Types

`SurfaceTypeEnum`

Enum Value	Description
`A`	Acrylic/Polyurethane
`B`	Artificial Clay
`C`	Artificial Grass
`D`	Asphalt
`E`	Carpet
`F`	Clay
`G`	Concrete
`H`	Grass
`J`	Hybrid Clay
`K`	Other

Types

`SyncStatusEnum`

Enum Value	Description
`IN_PROGRESS`
`COMPLETED`
`COMPLETED_WITH_ERRORS`
`FAILED`

Types

`TODS`

Field Name	Description
`_id` - `String`
`tournamentId` - `String`
`tournament` - `JSON`
`errors` - `[ValidationError]`	Error set if input does not validate against schema
`createdAt` - `DateTime`
`updatedAt` - `DateTime`
`transformationErrors` - `[String]`	Error set if input contains bad data

Example

{
  "_id": "xyz789",
  "tournamentId": "abc123",
  "tournament": {},
  "errors": [ValidationError],
  "createdAt": DateTime,
  "updatedAt": DateTime,
  "transformationErrors": ["abc123"]
}

Types

`Team`

Field Name	Description
`id` - `ID!`
`extensions` - `[Extension]`
`gender` - `GenderEnum!`
`name` - `String!`
`nativeTeamName` - `String`
`notes` - `String`
`members` - `[Person!]`
`updatedAt` - `DateTime!`
`createdAt` - `DateTime!`
`color` - `TeamColor!`
`logoUrl` - `String`
`providerId` - `ID!`

Example

{
  "id": ID,
  "extensions": [Extension],
  "gender": GenderEnum,
  "name": "xyz789",
  "nativeTeamName": "xyz789",
  "notes": "abc123",
  "members": [Person],
  "updatedAt": DateTime,
  "createdAt": DateTime,
  "color": TeamColor,
  "logoUrl": "abc123",
  "providerId": ID
}

Types

`TeamColor`

Enum Value	Description
`RED`
`ORANGE`
`YELLOW`
`GREEN`
`TURQUOISE`
`BLUE`
`PURPLE`
`BLACK`
`GRAY`
`BROWN`
`NONE`

Types

`TeamFilterOptions`

Input Field	Description
`name` - `StringOperators`
`gender` - `GenderEnum`
`updatedAt` - `DateOperators`
`createdAt` - `DateOperators`
`containsMemberId` - `ID`
`providerId` - `String`
`color` - `TeamColor`

Example

{
  "name": StringOperators,
  "gender": GenderEnum,
  "updatedAt": DateOperators,
  "createdAt": DateOperators,
  "containsMemberId": ID,
  "providerId": "xyz789",
  "color": TeamColor
}

Types

`TeamList`

Field Name	Description
`items` - `[Team!]`
`totalItems` - `Int`

Example

{"items": [Team], "totalItems": 987}

Types

`Tiebreaker`

Field Name	Description
`winnerPointsWon` - `Int`
`loserPointsWon` - `Int`

Example

{"winnerPointsWon": 987, "loserPointsWon": 987}

Types

`TiebreakerInput`

Input Field	Description
`winnerPointsWon` - `Int!`
`loserPointsWon` - `Int!`

Example

{"winnerPointsWon": 987, "loserPointsWon": 123}

Types

`Tournament`

Field Name	Description
`id` - `ID!`
`end` - `DateTime`
`start` - `DateTime`
`entriesClose` - `DateTime`
`entriesOpen` - `DateTime`
`extensions` - `[Extension]`
`formalName` - `String`
`hostCountryCode` - `CountryCode`
`indoorOutdoor` - `IndoorOutdoorEnum`
`localTimeZone` - `String`
`notes` - `String`
`promotionalName` - `String`
`season` - `String`
`surfaceCategory` - `SurfaceCategoryEnum`
`providerTournamentId` - `String!`
`unifiedTournamentId` - `String`
`level` - `String`
`name` - `String`
`updatedAt` - `DateTime`
`createdAt` - `DateTime`
`withdrawalDeadline` - `DateTime`
`belongsToRequestingProvider` - `Boolean`
`subCategory` - `TournamentSubCategoryEnum`
`persons` - `PersonList`
Arguments `pageArgs` - `PaginationArgs` `filter` - `PersonFilterOptions` `sort` - `SortOrder`
`matchUps` - `MatchUpList`
Arguments `pageArgs` - `PaginationArgs` `filter` - `MatchUpFilterOptions` `sort` - `SortOrder`
`provider` - `Provider`

Example

{
  "id": ID,
  "end": DateTime,
  "start": DateTime,
  "entriesClose": DateTime,
  "entriesOpen": DateTime,
  "extensions": [Extension],
  "formalName": "abc123",
  "hostCountryCode": CountryCode,
  "indoorOutdoor": IndoorOutdoorEnum,
  "localTimeZone": "xyz789",
  "notes": "abc123",
  "promotionalName": "abc123",
  "season": "abc123",
  "surfaceCategory": SurfaceCategoryEnum,
  "providerTournamentId": "xyz789",
  "unifiedTournamentId": "abc123",
  "level": "xyz789",
  "name": "abc123",
  "updatedAt": DateTime,
  "createdAt": DateTime,
  "withdrawalDeadline": DateTime,
  "belongsToRequestingProvider": true,
  "subCategory": TournamentSubCategoryEnum,
  "persons": PersonList,
  "matchUps": MatchUpList,
  "provider": Provider
}

Types

`TournamentFilterOptions`

Field Name	Description
`tournamentIds` - `[ID]`
`start` - `DateOperators`
`end` - `DateOperators`
`name` - `StringOperators`
`providerTournamentIds` - `[ID]`
`providerIds` - `[ID]`
`indoorOutdoor` - `IndoorOutdoorEnum`
`surfaceCategory` - `SurfaceCategoryEnum`
`updatedAt` - `DateOperators`
`createdAt` - `DateOperators`
`subCategory` - `TournamentSubCategoryEnum`

Example

{
  "tournamentIds": [ID],
  "start": DateOperators,
  "end": DateOperators,
  "name": StringOperators,
  "providerTournamentIds": [ID],
  "providerIds": [ID],
  "indoorOutdoor": IndoorOutdoorEnum,
  "surfaceCategory": SurfaceCategoryEnum,
  "updatedAt": DateOperators,
  "createdAt": DateOperators,
  "subCategory": TournamentSubCategoryEnum
}

Types

`TournamentInput`

Field Name	Description
`end` - `DateTime!`
`start` - `DateTime!`
`entriesClose` - `DateTime`
`entriesOpen` - `DateTime`
`extensions` - `[ExtensionInput]`
`formalName` - `String`
`hostCountryCode` - `CountryCode`
`indoorOutdoor` - `IndoorOutdoorEnum`
`localTimeZone` - `String`
`notes` - `String`
`promotionalName` - `String`
`season` - `String`
`surfaceCategory` - `SurfaceCategoryEnum`
`providerTournamentId` - `String!`
`level` - `String`
`name` - `String`
`withdrawalDeadline` - `DateTime`
`subCategory` - `TournamentSubCategoryEnum`

Example

{
  "end": DateTime,
  "start": DateTime,
  "entriesClose": DateTime,
  "entriesOpen": DateTime,
  "extensions": [ExtensionInput],
  "formalName": "xyz789",
  "hostCountryCode": CountryCode,
  "indoorOutdoor": IndoorOutdoorEnum,
  "localTimeZone": "xyz789",
  "notes": "xyz789",
  "promotionalName": "xyz789",
  "season": "abc123",
  "surfaceCategory": SurfaceCategoryEnum,
  "providerTournamentId": "xyz789",
  "level": "abc123",
  "name": "xyz789",
  "withdrawalDeadline": DateTime,
  "subCategory": TournamentSubCategoryEnum
}

Types

`TournamentList`

Field Name	Description
`items` - `[Tournament!]`
`totalItems` - `Int`

Example

{"items": [Tournament], "totalItems": 987}

Types

`TournamentSubCategoryEnum`

Enum Value	Description
`UNKNOWN`
`TOURNAMENT`
`LEAGUE`
`DUAL_MATCH`

Types

`TournamentUpdateInput`

Field Name	Description
`end` - `DateTime`
`start` - `DateTime`
`entriesClose` - `DateTime`
`entriesOpen` - `DateTime`
`extensions` - `[ExtensionInput]`
`formalName` - `String`
`hostCountryCode` - `CountryCode`
`indoorOutdoor` - `IndoorOutdoorEnum`
`localTimeZone` - `String`
`notes` - `String`
`promotionalName` - `String`
`season` - `String`
`surfaceCategory` - `SurfaceCategoryEnum`
`providerTournamentId` - `String`
`level` - `String`
`name` - `String`
`withdrawalDeadline` - `DateTime`
`subCategory` - `TournamentSubCategoryEnum`

Example

{
  "end": DateTime,
  "start": DateTime,
  "entriesClose": DateTime,
  "entriesOpen": DateTime,
  "extensions": [ExtensionInput],
  "formalName": "abc123",
  "hostCountryCode": CountryCode,
  "indoorOutdoor": IndoorOutdoorEnum,
  "localTimeZone": "xyz789",
  "notes": "xyz789",
  "promotionalName": "abc123",
  "season": "xyz789",
  "surfaceCategory": SurfaceCategoryEnum,
  "providerTournamentId": "xyz789",
  "level": "abc123",
  "name": "abc123",
  "withdrawalDeadline": DateTime,
  "subCategory": TournamentSubCategoryEnum
}

Types

`UniqueOpponents`

Field Name	Description
`count` - `Int`
`IDs` - `[ID!]`

Example

{"count": 123, "IDs": [ID]}

Types

`UpdateAccountPersonInput`

Input Field	Description
`emailAddress` - `String`
`nativeGivenName` - `String`
`nativeFamilyName` - `String`
`sex` - `SexEnum`
`birthDate` - `Date`
`nationalityCode` - `String`
`countryOfResidenceCode` - `String`
`biographicalInformation` - `BiographicalInformationInput`
`signUpType` - `SignUpTypeEnum`
`parentEmailAddress` - `String`
`parentFullName` - `String`
`personaType` - `PersonaTypeEnum`
`personaDetail` - `String`
`whereDidYouHearAboutUs` - `WhereDidYouHearEnum`
`whereDidYouHearDetail` - `String`
`whereDidYouHearNa` - `String`

Example

{
  "emailAddress": "abc123",
  "nativeGivenName": "xyz789",
  "nativeFamilyName": "xyz789",
  "sex": SexEnum,
  "birthDate": "2025-10-01T14:07:52.371Z",
  "nationalityCode": "abc123",
  "countryOfResidenceCode": "abc123",
  "biographicalInformation": BiographicalInformationInput,
  "signUpType": SignUpTypeEnum,
  "parentEmailAddress": "abc123",
  "parentFullName": "xyz789",
  "personaType": PersonaTypeEnum,
  "personaDetail": "xyz789",
  "whereDidYouHearAboutUs": WhereDidYouHearEnum,
  "whereDidYouHearDetail": "abc123",
  "whereDidYouHearNa": "abc123"
}

Types

`UpdateTeamInput`

Field Name	Description
`providerId` - `ID`
`extensions` - `[ExtensionInput]`
`gender` - `GenderEnum`
`name` - `String`
`nativeTeamName` - `String`
`notes` - `String`
`color` - `TeamColor`
`logoUrl` - `String`

Example

{
  "providerId": ID,
  "extensions": [ExtensionInput],
  "gender": GenderEnum,
  "name": "xyz789",
  "nativeTeamName": "abc123",
  "notes": "xyz789",
  "color": TeamColor,
  "logoUrl": "abc123"
}

Types

`UpsertBatchMatchUpsResult`

Field Name	Description
`items` - `[MatchUp]`
`totalItems` - `Int`
`batchErrors` - `[String]`
`totalBatchErrors` - `Int`

Example

{
  "items": [MatchUp],
  "totalItems": 987,
  "batchErrors": ["abc123"],
  "totalBatchErrors": 123
}

Types

`UpsertBatchTournamentsResult`

Field Name	Description
`items` - `[Tournament]`
`totalItems` - `Int`
`batchErrors` - `[String]`
`totalBatchErrors` - `Int`

Example

{
  "items": [Tournament],
  "totalItems": 987,
  "batchErrors": ["xyz789"],
  "totalBatchErrors": 987
}

Types

`ValidationError`

Field Name	Description
`keyword` - `String`
`dataPath` - `String`
`schemaPath` - `String`
`params` - `ValidationParams`
`message` - `String`

Example

{
  "keyword": "abc123",
  "dataPath": "xyz789",
  "schemaPath": "abc123",
  "params": ValidationParams,
  "message": "abc123"
}

Types

`ValidationParams`

Field Name	Description
`missingProperty` - `String`

Example

{"missingProperty": "abc123"}

Types

`Venue`

Field Name	Description
`id` - `ID!`
`name` - `String`
`type` - `String`
`courts` - `[Court]`
`notes` - `String`
`addresses` - `[Address]`
`extensions` - `[Extension]`
`providerVenueId` - `ID`
`updatedAt` - `DateTime`
`createdAt` - `DateTime`

Example

{
  "id": ID,
  "name": "xyz789",
  "type": "xyz789",
  "courts": [Court],
  "notes": "xyz789",
  "addresses": [Address],
  "extensions": [Extension],
  "providerVenueId": ID,
  "updatedAt": DateTime,
  "createdAt": DateTime
}

Types

`VenueFilterOptions`

Field Name	Description
`venueIds` - `[ID]`
`providerVenueIds` - `[ID]`
`providerIds` - `[ID]`
`updatedAt` - `DateOperators`
`createdAt` - `DateOperators`

Example

{
  "venueIds": [ID],
  "providerVenueIds": [ID],
  "providerIds": [ID],
  "updatedAt": DateOperators,
  "createdAt": DateOperators
}

Types

`VenueInput`

Field Name	Description
`name` - `String`
`courts` - `[CourtInput]`
`notes` - `String`
`type` - `String`
`addresses` - `[AddressInput]`
`extensions` - `[ExtensionInput]`
`providerVenueId` - `ID`
`updatedAt` - `DateTime`
`createdAt` - `DateTime`

Example

{
  "name": "abc123",
  "courts": [CourtInput],
  "notes": "xyz789",
  "type": "xyz789",
  "addresses": [AddressInput],
  "extensions": [ExtensionInput],
  "providerVenueId": ID,
  "updatedAt": DateTime,
  "createdAt": DateTime
}

Types

`VenueList`

Field Name	Description
`items` - `[Venue!]`
`totalItems` - `Int`

Example

{"items": [Venue], "totalItems": 987}

Types

`Watchlist`

Field Name	Description
`ownerId` - `ID!`
`id` - `ID!`
`personIds` - `[ID]`
`name` - `String`
`persons` - `[Person]`
`watchlistStats` - `WatchlistStats`

Example

{
  "ownerId": ID,
  "id": ID,
  "personIds": [ID],
  "name": "xyz789",
  "persons": [Person],
  "watchlistStats": WatchlistStats
}

Types

`WatchlistInput`

Input Field	Description
`name` - `String`
`personIds` - `[ID!]!`

Example

{"name": "abc123", "personIds": [ID]}

Types

`WatchlistItem`

Field Name	Description
`watchlistIds` - `[ID]`
`personId` - `ID`

Example

{
  "watchlistIds": [ID],
  "personId": ID
}

Types

`WatchlistList`

Field Name	Description
`items` - `[Watchlist!]`
`totalItems` - `Int`

Example

{"items": [Watchlist], "totalItems": 987}

Types

`WatchlistStats`

Field Name	Description
`minimumSinglesWorldTennisNumber` - `Float`
`maximumSinglesWorldTennisNumber` - `Float`
`meanSinglesWorldTennisNumber` - `Float`
`minimumDoublesWorldTennisNumber` - `Float`
`maximumDoublesWorldTennisNumber` - `Float`
`meanDoublesWorldTennisNumber` - `Float`

Example

{
  "minimumSinglesWorldTennisNumber": 123.45,
  "maximumSinglesWorldTennisNumber": 123.45,
  "meanSinglesWorldTennisNumber": 987.65,
  "minimumDoublesWorldTennisNumber": 123.45,
  "maximumDoublesWorldTennisNumber": 987.65,
  "meanDoublesWorldTennisNumber": 987.65
}

Types

`WhereDidYouHearEnum`

Enum Value	Description
`NA`
`TENNIS_CLUB`
`TENNIS_TOURNAMENT`
`WORD_OF_MOUTH`
`SOCIAL_MEDIA`
`SEARCH_ENGINE`
`BLOG_OR_PUBLICATION`
`OTHER`

Types

`WorldTennisNumber`

Field Name	Description
`confidence` - `Float`
`ratingDate` - `DateTime!`
`tennisNumber` - `Float!`
`prevTennisNumber` - `Float`
`type` - `WorldTennisNumberTypeEnum!`
`gameZoneUpper` - `Float`
`gameZoneLower` - `Float`
`source` - `RatingSourceEnum`
`isRanked` - `Boolean`

Example

{
  "confidence": 987.65,
  "ratingDate": DateTime,
  "tennisNumber": 123.45,
  "prevTennisNumber": 123.45,
  "type": WorldTennisNumberTypeEnum,
  "gameZoneUpper": 987.65,
  "gameZoneLower": 123.45,
  "source": RatingSourceEnum,
  "isRanked": true
}

Types

`WorldTennisNumberFilterInput`

Input Field	Description
`type` - `WorldTennisNumberTypeEnum`
`ratingDate` - `DateOperators`

Example

{
  "type": WorldTennisNumberTypeEnum,
  "ratingDate": DateOperators
}

Types

`WorldTennisNumberList`

Field Name	Description
`items` - `[WorldTennisNumber!]`
`totalItems` - `Int`

Example

{"items": [WorldTennisNumber], "totalItems": 987}

Types

`WorldTennisNumberTypeEnum`

Enum Value	Description
`SINGLE`
`DOUBLE`

Types

`_Any`

Example

object

Types

`_FieldSet`

Example

object

Types

`_Service`

Field Name	Description
`sdl` - `String`

Example

{"sdl": "xyz789"}

Documentation by Anvil SpectaQL