From abbe255a46ab11cc632948393eb08b2ae572650f Mon Sep 17 00:00:00 2001 From: Stefano Pigozzi Date: Sat, 19 Oct 2024 01:44:47 +0200 Subject: [PATCH 1/7] Start `feature/user` branch From e5ec74b7e5d1b3fda6f65806987f8b7560c4a846 Mon Sep 17 00:00:00 2001 From: Stefano Pigozzi Date: Sat, 19 Oct 2024 02:42:15 +0200 Subject: [PATCH 2/7] Import schema https://github.com/RYGhub/revenants-brooch/blob/main/src/stratz_schema.gql --- .gitattributes | 1 + graphql/2022-03-29-schema-stratz.gql | 8553 ++++++++++++++++++++++++++ 2 files changed, 8554 insertions(+) create mode 100644 .gitattributes create mode 100644 graphql/2022-03-29-schema-stratz.gql diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..7083743 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +graphql linguist-vendored diff --git a/graphql/2022-03-29-schema-stratz.gql b/graphql/2022-03-29-schema-stratz.gql new file mode 100644 index 0000000..12eb1fd --- /dev/null +++ b/graphql/2022-03-29-schema-stratz.gql @@ -0,0 +1,8553 @@ +schema { + query: DotaQuery + mutation: DotaMutation + subscription: DotaSubscription +} + +scalar Int +scalar Long +scalar String +scalar Boolean +scalar Float + +type AbilityActiveListType { + time: Int! + ability0: Short + ability1: Short + ability2: Short + ability3: Short + ability4: Short + ability5: Short + ability6: Short + ability7: Short +} + +type AbilityAttributeType { + name: String + value: String + linkedSpecialBonusAbilityId: Short + requiresScepter: Boolean! +} + +type AbilityCustomGameLanguageType { + displayName: String + description: String +} + +type AbilityCustomGameType { + id: Short + name: String + abilityName: String + language: AbilityCustomGameLanguageType +} + +enum AbilityDispellEnum { + NONE + NO + YES + YES_STRONG +} + +type AbilityLanguageType { + displayName: String + description: [String] + attributes: [String] + lore: String + aghanimDescription: String + shardDescription: String + notes: [String] +} + +type AbilityLearnEventsType { + time: Int! + abilityId: Short + levelObtained: Int! + level: Int! + isUltimate: Boolean + isTalent: Boolean + isMaxLevel: Boolean +} + +type AbilityStatType { + abilityId: Short + type: Int + behavior: Long + unitTargetType: Long + unitTargetTeam: Int + unitTargetFlags: Long + unitDamageType: Int + spellImmunity: Int + modifierSupportValue: Float + modifierSupportBonus: Short + isOnCastbar: Boolean + isOnLearnbar: Boolean + fightRecapLevel: Short + isGrantedByScepter: Boolean + hasScepterUpgrade: Boolean + maxLevel: Byte + levelsBetweenUpgrades: Byte + requiredLevel: Byte + hotKeyOverride: String + displayAdditionalHeroes: Boolean + castRange: [Int] + castRangeBuffer: [Int] + castPoint: [Float] + channelTime: [Float] + cooldown: [Float] + damage: [Float] + manaCost: [Float] + isUltimate: Boolean + duration: String + charges: String + chargeRestoreTime: String + isGrantedByShard: Boolean + dispellable: AbilityDispellEnum +} + +type AbilityType { + id: Short + name: String + uri: String + language: AbilityLanguageType + stat: AbilityStatType + attributes: [AbilityAttributeType] + drawMatchPage: Boolean + isTalent: Boolean +} + +type AbilityUsedEventsType { + time: Int! + abilityId: Short + attacker: Short + target: Short +} + +type AdminMutation { + mergeProSteamAccount(request: [MergeProSteamAccountRequestType]!): Boolean + deleteProSteamAccount(request: DeleteProSteamAccountRequestType!): Boolean +} + +type AdminQuery { + """Returns a list of Stratz blogs.""" + apiMemoryReport: [String] +} + +type AssistDetailType { + time: Int! + attacker: Short + target: Short + gold: Int + xp: Int + subTime: Int + positionX: Int + positionY: Int +} + +enum BasicRegionType { + CHINA + SEA + NORTH_AMERICA + SOUTH_AMERICA + EUROPE +} + +type BlogMetaTagInfoType { + id: Short + name: String! +} + +type BlogMetaTagType { + id: Byte + blogId: Byte + blogMetaTagTypeId: Short + metaTag: BlogMetaTagInfoType +} + +type BlogType { + id: Byte + captainJackIdentityId: Guid + title: String! + bannerImageUrl: String! + poster: SteamAccountType + data: String! + liveDateTime: DateTime + metaTags: [BlogMetaTagType] + link: String! +} + +enum BuildingType { + FORT + TOWER + BARRACKS + HEALER + OUTPOST +} + +type BuyBackDetailType { + time: Int! + heroId: Short + deathTimeRemaining: Int! + cost: Int! +} + +scalar Byte + +type CaptainJackIdentityApiApplicationType { + captainJackIdentityId: Guid + tokenType: StratzApiType + emailAddress: String + discordAddress: String + websiteAddress: String + description: String + isApproved: Boolean + apiKey: String + secretKey: String + issuer: String + matomoReferenceToken: String +} + +type CaptainJackIdentityPrivateProfileType { + captainJackIdentityId: Guid + name: String + email: String + twitter: String + facebook: String + twitch: String + youTube: String + premiumEndDate: Long + isAdmin: Boolean + feedLevel: Byte + emailLevel: Byte + dailyEmail: Boolean! + weeklyEmail: Boolean! + monthlyEmail: Boolean! + proCircuitFeedLevel: Byte + proCircuitEmailLevel: Byte + themeType: Byte + languageId: Byte + emailValidationCode: String + isEmailValidated: Boolean! + emailHour: Byte + lastReadFeedTime: Long + lastDailyEmail: Long + lastWeeklyEmail: Long + lastMonthlyEmail: Long + lastLeagueDailyEmail: Long + lastTeamDailyEmail: Long + lastProCircuitDailyEmail: Long + unsubscribeCode: String + lastSeen: Long +} + +input CaptainJackIdentityProfileUpdateRequestType { + email: String + feedLevel: Byte + emailLevel: Byte + dailyEmail: Boolean + weeklyEmail: Boolean + monthlyEmail: Boolean + proCircuitFeedLevel: Byte + proCircuitEmailLevel: Byte + themeType: Byte + languageId: Byte + emailHour: Byte + isStratzAnonymous: Byte +} + +type CaptainJackIdentityPublicProfileType { + captainJackIdentityId: Guid + name: String + twitter: String + facebook: String + twitch: String + youTube: String + isAdmin: Boolean +} + +type CaptainJackIdentityType { + id: Guid + steamAccountId: String + steamAccount: SteamAccountType + profile: CaptainJackIdentityPublicProfileType +} + +type ClusterType { + """ + ClusterId which determines in which region a match was played. One region has + multiple clusters. When selecting your region in the Dota 2 client, a random + cluster is provided to you for each match for load balancing purposes. + """ + id: Int + + """RegionId gives the exact geographical area where the match is played.""" + regionId: Short +} + +type ConstantQuery { + hero( + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + id: Short! + + """ + The game version id to include in this query, excluding all results that do not have this game version. + """ + gameVersionId: Short + + """ + The language id to include in this query, excluding all results that do not have this language. + """ + language: Language + ): HeroType + heroes( + """ + The game version id to include in this query, excluding all results that do not have this game version. + """ + gameVersionId: Short + + """ + The language id to include in this query, excluding all results that do not have this language. + """ + language: Language + ): [HeroType] + + """List of all the roles types for heroes.""" + roles: [RoleType] + + """Find item details by item id. id is a required input field.""" + item( + """ + The item id to include in this query, excluding all results that do not have this item. + """ + id: Int! + + """ + The game version id to include in this query, excluding all results that do not have this game version. + """ + gameVersionId: Short + + """ + The language id to include in this query, excluding all results that do not have this language. + """ + language: Language + ): ItemType + + """Find item details by item id. id is a required input field.""" + items( + """ + The game version id to include in this query, excluding all results that do not have this game version. + """ + gameVersionId: Short + + """ + The language id to include in this query, excluding all results that do not have this language. + """ + language: Language + ): [ItemType] + + """Find ability details by ability id. id is a required input field.""" + ability( + """ + The ability id to include in this query, excluding all results that do not have this ability. + """ + id: Int! + + """ + The game version id to include in this query, excluding all results that do not have this game version. + """ + gameVersionId: Short + + """ + The language id to include in this query, excluding all results that do not have this language. + """ + language: Language + ): AbilityType + + """Find ability details.""" + abilities( + """ + The game version id to include in this query, excluding all results that do not have this game version. + """ + gameVersionId: Short + + """ + The language id to include in this query, excluding all results that do not have this language. + """ + language: Language + ): [AbilityType] + + """ + Returns a list of game mode types which is directly supplied by Dota 2. Matches API call will have a input for this value. + """ + gameModes: [GameModeType] + + """ + Returns a list of lobby types which are mirrored from the Dota 2 client. + """ + lobbyTypes: [LobbyTypeType] + + """ + Provided directly from Dota 2 Region files, the cluster is the geographically breakdown of where the game is played. + """ + clusters: [ClusterType] + + """Returns a list of region details and an Id for reference.""" + regions: [RegionType] + + """ + Find game version details by game version id. id is a required input field. + """ + gameVersion( + """ + The game version id to include in this query, excluding all results that do not have this game version. + """ + id: Short! + ): GameVersionType + + """Find game version details.""" + gameVersions: [GameVersionType] + + """Find npc details by npc id. id is a required input field.""" + npc( + """ + The npc id to include in this query, excluding all results that do not have this npc. + """ + id: Short! + + """ + The game version id to include in this query, excluding all results that do not have this game version. + """ + gameVersionId: Short + ): NpcType + + """Find npc details.""" + npcs( + """ + The game version id to include in this query, excluding all results that do not have this game version. + """ + gameVersionId: Short + ): [NpcType] + + """ + Find all patch notes for each item and ability. These are found when you hover over each object in-game. + """ + patchNotes( + """ + The language id to include in this query, excluding all results that do not have this language. + """ + languageId: Language + ): [PatchNoteLanguageType] + + """ + Find all abilities that are used in custom events. For example Aghnims Labyrinth. + """ + customAbilities( + """ + The language id to include in this query, excluding all results that do not have this language. + """ + languageId: Language + ): [AbilityCustomGameType] + + """ + Find all modifiers that are used in the game. If you find a bug on a modifier, + let us know as we have to control this ourselves. + """ + modifiers( + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int + ): [ModifierType] + + """Find all players who Valve qualifies as a Pro Player or Streamer.""" + proSteamAccounts: [ProSteamAccountType] +} + +enum Damage { + PHYSICAL + MAGICAL + PURE +} + +""" +The `DateTime` scalar type represents a date and time. `DateTime` expects +timestamps to be formatted in accordance with the +[ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standard. +""" +scalar DateTime + +type DeathDetailType { + time: Int! + attacker: Short + isFromIllusion: Boolean + target: Short + byAbility: Short + byItem: Short + goldFed: Int + xpFed: Int + timeDead: Int + reliableGold: Int + unreliableGold: Int + positionX: Int + positionY: Int + goldLost: Int + assist: [Int] + isWardWalkThrough: Boolean + isAttemptTpOut: Boolean + isDieBack: Boolean + isBurst: Boolean + isEngagedOnDeath: Boolean + hasHealAvailable: Boolean + isTracked: Boolean + isFeed: Boolean +} + +scalar Decimal + +input DeleteProSteamAccountRequestType { + steamAccountId: Long + name: String + realName: String +} + +type DireTide2020CustomGameHeroWinDayType { + day: Long! + heroId: Short! + winCount: Int! + matchCount: Int! + candyScored: Int! +} + +type DireTide2020CustomGameMatchType { + id: Long + didRadiantWin: Boolean + durationSeconds: Short + startDateTime: Long + endDateTime: Long + clusterId: Short + replaySalt: Long + candyLost: Short + candyPickedUp: Short + candyScored: Short + radiantCandyScored: Short + direCandyScored: Short + players( + """ + The steam account id to include in this query, excluding all results that do not have this steam account id. + """ + steamAccountId: Long + ): [DireTide2020CustomGamePlayerType] +} + +type DireTide2020CustomGamePlayerType { + matchId: Long + playerSlot: Byte + steamAccountId: Long + steamAccount: SteamAccountType + isVictory: Boolean! + heroId: Short + hero: HeroType + kills: Byte + deaths: Byte + assists: Byte + leaverStatus: Byte + numLastHits: Short + goldPerMinute: Short + goldSpent: Int + level: Byte + heroDamage: Int + heroHealing: Int + networth: Int + item0Id: Short + item1Id: Short + item2Id: Short + item3Id: Short + item4Id: Short + item5Id: Short + backpack0Id: Short + backpack1Id: Short + backpack2Id: Short + + """ + The item id of the dedicated neutral item slot (7.24 and after). From game + versions 7.23 to 7.24, this was the BackPack3Id (the 4th backpack slot item id). + """ + neutral0Id: Short + partyId: Byte + candyLost: Short + candyPickedUp: Short + candyScored: Short +} + +type DotaMutation { + yogurt: YogurtMutation + user: DotaUserMutation + admin: AdminMutation +} + +type DotaNextQuery { + """ + Used by Overwolf application DotaNext (previously called DotaPlus) to provide data to its users. + """ + enemy( + """ + An array of steam account ids to limit the query to only return matches with these steam account ids. + """ + steamAccountIds: [Long]! + + """ + A steam account id found on your team to include in this query, excluding + all results that do not include this steam account id found on your team. + """ + matchSteamAccountId: Long! + ): [DotaNextWithAllyType] + + """ + Used by Overwolf application DotaNext (previously called DotaPlus) to provide data to its users. + """ + ally( + """ + An array of steam account ids to limit the query to only return matches with these steam account ids. + """ + steamAccountIds: [Long]! + + """ + A steam account id found on your team to include in this query, excluding + all results that do not include this steam account id found on your team. + """ + matchSteamAccountId: Long! + ): [DotaNextWithAllyType] + + """ + Used by Overwolf application DotaNext (previously called DotaPlus) to provide data to its users. + """ + playerHero( + """ + An array of steam account ids to limit the query to only return matches with these steam account ids. + """ + steamAccountIds: Long! + + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: Byte! + + """ + An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. + """ + lobbyTypeIds: Byte! + + """ + An array of item ids to include in this query, excluding all results that do not include one of these item ids. + """ + limitByItemIds: Int! + + """ + The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + startDateTime: Long! + ): [[MatchPlayerItemPurchaseEventType]] +} + +type DotaNextWithAllyType { + steamAccountId: Long + lifetimeMatchCount: Int + lifetimeWinMatchCount: Int +} + +type DotaPlusWeekType { + week: Long + active: Int + expired: Int +} + +type DotaQuery { + """Find match details by the match id. id is a required input field.""" + match( + """ + The id of the Dota match to include in this query, excluding all results that do not include this id. + """ + id: Long! + ): MatchType + + """Find match details for each match id. ids is a required input field.""" + matches( + """An array of Dota match ids to include in this query.""" + ids: [Long]! + ): [MatchType] + + """Find player details by steam account id. id is a required input field.""" + player( + """ + The steam account id to include in this query, excluding all results that do not have this steam account id. + """ + steamAccountId: Long! + ): PlayerType + + """ + Find player details for each steam account id. ids is a required input field. + """ + players( + """ + An array of steam account ids to limit the query to only return matches with these steam account ids. + """ + steamAccountIds: [Long]! + ): [PlayerType] + + """ + Find player details for each steam account id. ids is a required input field. + """ + team( + """ + A team id to include in this query, excluding all results that do not have this team id. + """ + teamId: Int! + ): TeamType + + """ + Results in a list of team objects that contain data about them and their players. + """ + teams( + """ + A team id to include in this query, excluding all results that do not have this team id. + """ + teamIds: [Int]! + ): [TeamType] + + """Find league details by league Id. Id is a required field.""" + league( + """ + A league id to include in this query, excluding all results that do not have this league id. + """ + id: Int! + ): LeagueType + + """Find league details by searching for leagues using a LeagueRequest.""" + leagues(request: LeagueRequestType!): [LeagueType] + + """ + For getting access to one specific Guild which was used at the start of TI10 Compendium. + """ + guild( + """ + A guild id to include in this query, excluding all results that do not have this guild id. + """ + id: Int! + ): GuildType + + """ + Queries used for Stratz Yogurt - users won't be able to access these calls until they have access to the app. + """ + yogurt: YogurtQuery + + """Queries used to populate Stratz Plus.""" + plus: PlusQuery + + """Stratz specific queries.""" + stratz: StratzQuery + + """Queries used to gain insights into hero data and statistics.""" + heroStats: HeroStatsQuery + + """Queries used to query constants in Dota.""" + constants: ConstantQuery + + """Queries used to get leaderboard information.""" + leaderboard: LeaderboardQuery + + """Queries used to find live match data.""" + live: LiveQuery + + """Queries used by 3rd party applications.""" + vendor: VendorQuery +} + +type DotaSubscription { + matchCount: TotalMatchCountType + playerCount: TotalPlayerCountType + feedLive: LiveEventType + matchLive(matchId: Long!): MatchLiveType + matchLiveLeague(leagueId: Int!): MatchLiveType +} + +type DotaUserMutation { + """Marks the user's LastReadFeedTime to the current time.""" + readAllFeed: Boolean + + """Validates a user email address if the password id is correct.""" + validateEmail( + """The password number that was sent via email.""" + code: Guid! + ): Boolean + + """Validates a user email address if the password id is correct.""" + updateTutorial( + """The TutorialId number of the tutorial completed.""" + tutorialId: Short! + ): [Short] + + """Update your user to unsubscribe from Stratz emails.""" + emailUnsubscribe: UserHomepageType + + """Updates the logged in user information profile.""" + updateProfile( + """ + The updated returned object from /user. Only updates ThemeType, LanguageId, Email and Feed/Email Settings. + """ + request: CaptainJackIdentityProfileUpdateRequestType! + ): Boolean + + """Update your user to (un)follow a specific SteamAccountId""" + followPlayer( + """The steam account of the person you wish to (un)follow.""" + steamAccountId: Long! + ): Boolean + + """Update your user to (un)follow a specific SteamAccountId""" + unfollowPlayer( + """The steam account of the person you wish to (un)follow.""" + steamAccountId: Long! + ): Boolean + + """Update your user to (un)follow a specific SteamAccountId""" + updateFollowing( + """The steam account of the person you wish to (un)follow.""" + followedSteamAccountId: Long! + + """ + The updated returned object from /user. Only updates ThemeType, LanguageId, Email and Feed/Email Settings. + """ + request: UpdateFollowerRequestType! + ): Boolean + + """ + Updates every user you are following. This should be handled with care, as + this overrides all your predefinded user specific settings with these settings. + """ + updateAllFollowing( + """ + The updated returned object from /user. Only updates ThemeType, LanguageId, Email and Feed/Email Settings. + """ + request: UpdateFollowerRequestType! + ): Boolean + + """ + Gets more in-depth information about the person you are following. This is a + user specific request, and you can only edit yourself. + """ + updateFollowingFavorite( + """The steam account of the person you wish to (un)follow.""" + followedSteamAccountId: Long! + + """Should the user become a favorite.""" + isFavorite: Boolean! + ): Boolean + + """Update your user to (un)follow a specific LeagueId""" + followLeague( + """ + A league id to include in this query, excluding all results that do not have this league id. + """ + leagueId: Int! + ): Boolean + unfollowLeague( + """ + A league id to include in this query, excluding all results that do not have this league id. + """ + leagueId: Int! + ): Boolean + applyStratzApiKey( + """There are two type of API Tokens, Data Collector and MultiKey""" + tokenType: StratzApiType! + + """ + The desired email address of the match replay upload team. Cannot be blank or whitespace. + """ + emailAddress: String! + + """A users Discord full Identity name.""" + discordAddress: String! + + """A user website where the data can be seen.""" + websiteAddress: String! + description: String! + ): Boolean + + """ + If a user moves from annoymous to public, this will turn it on instantly for them. + """ + checkPublicDotaAccount: Boolean +} + +type ExperienceDetailType { + time: Int! + amount: Int! + reason: XpReason + positionX: Int + positionY: Int +} + +type FeedResponseType { + data: [FeedType] + count: Int + date: DateTime +} + +type FeedType { + steamAccount: SteamAccountType + league: LeagueType + targetSteamAccountId: Long + type: Byte + matchId: Long + heroId: Int! + date: Long + value: Int! + didWin: Boolean +} + +enum FilterDireTide2020CustomGameMatchOrderBy { + CANDY_SCORED + END_DATE_TIME +} + +input FilterDireTide2020CustomMatchRequestType { + """ + The steam account id to include in this query, excluding all results that do not have this steam account id. + """ + steamAccountId: Long + + """The order in which the data returned will be sorted by.""" + orderBy: FilterDireTide2020CustomGameMatchOrderBy + + """If the return should be ordered by Ascending or Desending order.""" + orderDirection: FilterOrder + + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int +} + +enum FilterHeroWinRequestGroupBy { + HERO_ID + ALL + HERO_ID_DURATION_MINUTES +} + +enum FilterLeaderboardGuildOrderBy { + BATTLE_PASS_LEVELS + MEMBER_COUNT + POINTS + ID + PREVIOUS_WEEK_RANK +} + +input FilterLeaderboardGuildRequestType { + """What field to order the data by. Enum values.""" + orderBy: FilterLeaderboardGuildOrderBy + + """If the return should be ordered by Ascending or Desending order.""" + order: FilterOrder + + """The region where the guild was registered.""" + region: Byte + + """If the guild is current set to 50 members.""" + isFull: Boolean + + """If anyone is able to join the guild.""" + isUnlocked: Boolean + + """The minimum amount of members a guild must have.""" + minMemberCount: Byte + + """The max amount of members a guild can have.""" + maxMemberCount: Byte + + """The amount of members a guild must have.""" + memberCount: Byte + + """The language required to join the guild.""" + language: Byte + + """The guild was created before this date time (in Unix TimeStamp).""" + createdBeforeDateTime: Long + + """The guild was created after this date time (in Unix TimeStamp).""" + createdAfterDateTime: Long + + """The rank required to join the guild.""" + minRequiredRank: Byte + + """The rank required to join the guild.""" + maxRequiredRank: Byte + + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int +} + +input FilterLeaderboardHeroRequestType { + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being unknown + MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketIds: [Byte] + + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int +} + +enum FilterLeaderboardOrder { + RECENT + LEVEL + FIRST +} + +input FilterMatchReplayUploadRequestType { + withEnemySteamAccount: [Long] + withFriendHeroId: [Short] + withEnemyHeroId: [Short] + withFriendBannedHeroId: [Short] + withEnemyBannedHeroId: [Short] + byMatchId: Long + byMatchIds: [Long] + byMatchUploadFileName: String + byMatchUploadUploaderCaptainJackId: Guid + bySteamAccountId: Long + bySteamAccountIds: [Long] + byHeroId: [Short] + byLeagueId: Int + bySeriesId: Int + bySeriesIds: [Long] + byTeamId: Int + byGameMode: [Int] + byLobbyType: [Int] + byGameVersion: [Int] + isLeague: Boolean + isValidated: Boolean + isComplete: Boolean + isActive: Boolean + isVictory: Boolean + isRadiant: Boolean + filterPositionIsUs: Boolean + filterPosition: MatchPlayerPositionType + filterPositionOrder: [MatchPlayerTeamPickOrderType] + isRadiantFirstPick: Boolean + firstPick: Boolean + minDuration: Int + maxDuration: Int + minGameVersionId: Int + maxGameVersionId: Int + startDateTime: Long + endDateTime: Long + skip: Int + take: Int +} + +enum FilterOrder { + ASC + DESC +} + +enum FilterOrderBy { + LAST_MATCH_TIME + ID + NONE + START_DATE_THEN_TIER + LAST_MATCH_TIME_THEN_TIER +} + +input FilterSearchRequestType { + """ + The term used to define the search parameters. Minimum input is 2 characters. + """ + query: String! + + """ + Searching our entire database can take time. If you already know what your + searching for you, you can limit the query down to a set of specific types. (0 + - Playuers, 1 - Matches, 2 - Leagues, 3 - Teams, 4 - ProPlayers, 5 - Casters). + Default is all types. + """ + searchType: [Search] + + """ + The minimum rank a player must have to be allowed inside the search query. + """ + minimumRank: Int + + """ + The maximum rank a player must have to be allowed inside the search query. + """ + maximumRank: Int + + """ + The minimum amount of time in which a user must have played a game to be + allowed inside the search query. A unix timestamp. + """ + lastMatchPlayedAgo: Long + + """ + The leaderboard is split into 4 regions. The user must appear in this + region(s) for them to be allowed inside the search query. + """ + leaderboardRegionIds: [Byte] + + """ + When searching for a league, the tier the league must be in. Tiers: Amateur = + 1, Professional = 2, Premium = 3, Pro Circuit = 4, Main Event = 5 + """ + leagueTierIds: [LeagueTier] + + """ + When searching for a team, only return results of those teams of which are considered Professionals. + """ + teamIsPro: Boolean + + """The amount to have returned in your query.""" + take: Int +} + +input FilterSeasonLeaderboardRequestType { + query: String + leaderBoardDivision: LeaderboardDivision + heroId: Short + position: MatchPlayerPositionType + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int +} + +input FilterSeriesRequestType { + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int +} + +enum FilterTI2020CustomGameMatchOrderBy { + DURATION + END_DATE_TIME +} + +input FilterTI2020HeroCompositionRequestType { + """The base level of difficulty""" + difficulty: TI2020CustomGameMatchDifficultyType! + + """If the return should be ordered by Ascending or Desending order.""" + orderDirection: FilterOrder + + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int +} + +input FilterTI2020MatchRequestType { + """Return Matches that only include the set of Match Ids provided.""" + matchIds: [Long] + + """Return matches that only include this single player.""" + steamAccountId: Long + + """Required that the team playing the game won.""" + didWin: Boolean + + """How far into the game (levels) they completed.""" + depth: Byte + + """The base level of difficulty""" + difficulty: TI2020CustomGameMatchDifficultyType + + """The team had to make it at least this far (level).""" + minDepth: Byte + + """The max must be played in this list of regions""" + regionIds: [Byte] + + """ + The game must of been played before this set time. In Unix Time Stamp Format. + """ + createdBeforeDateTime: Long + + """ + The game must of been played after this set time. In Unix Time Stamp Format. + """ + createdAfterDateTime: Long + + """The order in which the data returned will be sorted by.""" + orderBy: FilterTI2020CustomGameMatchOrderBy + + """If the return should be ordered by Ascending or Desending order.""" + orderDirection: FilterOrder + + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + seasonId: Byte +} + +enum FindMatchPlayerGroupBy { + HERO + FACTION + KILLS + DEATHS + ASSISTS + IS_LEAVER + LEVEL + IS_PARTY + IS_RANDOM + LANE + ROLE + IS_INTENTIONAL_FEEDING + AWARD + ROAM_LANE + IS_VICTORY + DURATION_MINUTES + CLUSTER + REGION + LOBBY_TYPE + IS_LEAGUE + IS_SERIES + GAME_MODE + IS_STATS + GAME_VERSION + TEAM + HERO_PERFORMANCE + STEAM_ACCOUNT_ID + STEAM_ACCOUNT_ID_HERO_ID +} + +enum FindMatchPlayerList { + ALL + SINGLE +} + +enum FindMatchPlayerOrderBy { + DESC + ASC +} + +type FollowerType { + captainJackIdentityId: Guid + steamAccountId: Long + feedLevel: Byte + emailLevel: Byte + dailyEmail: Boolean + weeklyEmail: Boolean + monthlyEmail: Boolean + isFavorite: Boolean + lastEmail: Long + didManualUpdate: Boolean! + steamAccount: SteamAccountType + captainJackIdentity: CaptainJackIdentityType +} + +enum GameModeEnumType { + NONE + ALL_PICK + CAPTAINS_MODE + RANDOM_DRAFT + SINGLE_DRAFT + ALL_RANDOM + INTRO + THE_DIRETIDE + REVERSE_CAPTAINS_MODE + THE_GREEVILING + TUTORIAL + MID_ONLY + LEAST_PLAYED + NEW_PLAYER_POOL + COMPENDIUM_MATCHMAKING + CUSTOM + CAPTAINS_DRAFT + BALANCED_DRAFT + ABILITY_DRAFT + EVENT + ALL_RANDOM_DEATH_MATCH + SOLO_MID + ALL_PICK_RANKED + TURBO + MUTATION +} + +type GameModeType { + id: Short + name: String +} + +type GameVersionType { + id: Short + name: String + asOfDateTime: Long +} + +type GoldDetailType { + time: Int! + amount: Int! + reason: GoldReason + npcId: Int + isValidForStats: Boolean +} + +enum GoldReason { + OTHER + DEATH + BUY_BACK + ABADONS + SELLS + STRUCTURES + HEROES + CREEPS + NEUTRAL + ROSHAN + COURIERS + BOUNTY + DOOM_DEVOURER + WARD_DESTRUCTION +} + +scalar Guid + +type GuildMemberType { + guildId: Int + steamAccountId: Int + joinDateTime: Long + guild: GuildType + steamAccount: SteamAccountType + winCount: Int + matchCount: Int + imp: Int +} + +type GuildType { + id: Int + motd: String + name: String + tag: String + createdDateTime: Long + language: Byte + flags: Int + logo: String + region: Byte + description: String + requiredRank: Byte + primaryColor: Byte + secondaryColor: Byte + pattern: Byte + points: Int + pastWeeklyRank: Int + pastWeeklyPercentile: Byte + currentPercentile: Byte + lastUpdateDateTime: Long + members: [GuildMemberType] + matches( + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int + ): [MatchType] + memberCount: Byte + totalBattlePassLevels: Int + rank: Byte +} + +type HealDetailType { + time: Int! + attacker: Short + target: Short + value: Int + byAbility: Short + byItem: Short +} + +type HeroAbilityTalentType { + heroId: Int! + week: Int! + bracketBasic: RankBracketHeroTimeDetail + position: MatchPlayerPositionType + abilityId: Int! + count: Long + wins: Long + time: Long + winsAverage: Decimal + timeAverage: Decimal +} + +type HeroAbilityType { + slot: Byte + gameVersionId: Short + abilityId: Short + ability: AbilityType +} + +type HeroDamageDetailType { + time: Int! + attacker: Short + target: Short + value: Int! + byAbility: Short + byItem: Short + damageType: Damage + fromNpc: Short + toNpc: Short + fromIllusion: Boolean + toIllusion: Boolean + isPhysicalAttack: Boolean + isSourceMainHero: Boolean + isTargetMainHero: Boolean +} + +type HeroDotaPlusLeaderboardRankType { + heroId: Short + steamId: Long + level: Byte + totalActions: Long + createdDateTime: Long + steamAccount: SteamAccountType +} + +type HeroDryadType { + heroId: Short + with: [HeroStatsHeroDryadType] + matchCountWith: Long + vs: [HeroStatsHeroDryadType] + matchCountVs: Long +} + +type HeroGuideListType { + heroId: Short + matchCount: Int + + """Guides are auto-generated of games that are successful in a game.""" + guides( + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int + ): [HeroGuideType] +} + +type HeroGuideType { + heroId: Short + steamAccountId: Long + matchId: Long + match: MatchType + matchPlayer: MatchPlayerType + createdDateTime: Long +} + +type HeroHighPerformanceMatchObjectType { + matchId: Long + endDateTime: Long + imp: Int! +} + +type HeroHighPerformancePlayerObjectType { + steamId: Long + endDateTime: Long + imp: Int! + playerName: String! +} + +type HeroHighPerformanceRampageObjectType { + matchId: Long + endDateTime: Long + time: Int! + playerName: String! + steamId: Long +} + +type HeroHighPerformanceType { + heroId: Int! + week: Int! + bracketBasic: RankBracketHeroTimeDetail + position: MatchPlayerPositionType + rampages: [HeroHighPerformanceRampageObjectType] + matches: [HeroHighPerformanceMatchObjectType] + players: [HeroHighPerformancePlayerObjectType] + items: HeroPurchasePatternType +} + +type HeroItemBootPurchaseObjectType { + itemId: Int! + instance: Int! + time: Long + timeAverage: Decimal + count: Long + wins: Long + winAverage: Decimal + kills: Long + killsAverage: Decimal + deaths: Long + deathsAverage: Decimal + assists: Long + assistsAverage: Decimal + goldEarned: Long + goldEarnedAverage: Decimal + xp: Long + xpAverage: Decimal + activations: Long + activationsAverage: Decimal + activationTime: Long + activationsTimeAverage: Decimal +} + +type HeroItemBootPurchaseType { + heroId: Int! + week: Int! + bracketBasic: RankBracketHeroTimeDetail + position: MatchPlayerPositionType + events: [HeroItemBootPurchaseObjectType] + count: Long +} + +type HeroItemPurchaseObjectType { + itemId: Int! + instance: Int! + time: Long + count: Long + wins: Long + winsAverage: Decimal +} + +type HeroItemPurchaseType { + heroId: Int! + week: Int! + bracketBasic: RankBracketHeroTimeDetail + position: MatchPlayerPositionType + events: [HeroItemPurchaseObjectType] + count: Long +} + +type HeroItemStartingPurchaseObjectType { + itemId: Int! + instance: Int! + wasGiven: Boolean! + count: Long + wins: Long + winsAverage: Decimal +} + +type HeroItemStartingPurchaseType { + heroId: Int! + week: Int! + bracketBasic: RankBracketHeroTimeDetail + position: MatchPlayerPositionType + events: [HeroItemStartingPurchaseObjectType] + count: Long +} + +type HeroLanguageType { + displayName: String + lore: String + hype: String +} + +type HeroMatchupType { + advantage: [HeroDryadType] + disadvantage: [HeroDryadType] +} + +type HeroMetaTrendType { + heroId: Int! + win: [Long] + pick: [Long] + ban: [Long] +} + +type HeroPositionDetailType { + position: MatchPlayerPositionType + count: Long + wins: Decimal + kills: Decimal + deaths: Decimal + assists: Decimal + cs: Decimal + dn: Decimal + heroDamage: Decimal + towerDamage: Decimal +} + +type HeroPositionTimeDetailAverageObjectType { + time: Int! + matchCount: Long + remainingMatchCount: Int + wins: Decimal + mvp: Decimal + topCore: Decimal + topSupport: Decimal + courierKills: Decimal + apm: Decimal + casts: Decimal + abilityCasts: Decimal + kills: Decimal + deaths: Decimal + assists: Decimal + networth: Decimal + xp: Decimal + cs: Decimal + dn: Decimal + neutrals: Decimal + heroDamage: Decimal + towerDamage: Decimal + physicalDamage: Decimal + magicalDamage: Decimal + physicalDamageReceived: Decimal + magicalDamageReceived: Decimal + tripleKill: Decimal + ultraKill: Decimal + rampage: Decimal + godLike: Decimal + disableCount: Decimal + disableDuration: Decimal + stunCount: Decimal + stunDuration: Decimal + slowCount: Decimal + slowDuration: Decimal + healingSelf: Decimal + healingAllies: Decimal + invisibleCount: Decimal + runePower: Decimal + runeBounty: Decimal + level: Decimal + campsStacked: Decimal + supportGold: Decimal + purgeModifiers: Decimal + ancients: Decimal + teamKills: Decimal + goldLost: Decimal + goldFed: Decimal + buybackCount: Decimal + weakenCount: Decimal + weakenDuration: Decimal + physicalItemDamage: Decimal + magicalItemDamage: Decimal + healingItemSelf: Decimal + healingItemAllies: Decimal + xpFed: Decimal + pureDamageReceived: Decimal + attackDamage: Decimal + castDamage: Decimal + damageReceived: Decimal + damage: Decimal + pureDamage: Decimal + kDAAverage: Decimal + killContributionAverage: Decimal + stompWon: Decimal + stompLost: Decimal + comeBackWon: Decimal + comeBackLost: Decimal +} + +type HeroPositionTimeDetailAverageType { + heroId: Short! + week: Int! + bracketBasic: RankBracketHeroTimeDetail + position: MatchPlayerPositionType + events: [HeroPositionTimeDetailAverageObjectType] +} + +type HeroPurchasePatternType { + startingItems: HeroItemStartingPurchaseType + earlyGame: HeroItemPurchaseType + midGame: HeroItemPurchaseType + lateGame: HeroItemPurchaseType +} + +type HeroRatingObjectType { + heroId1: Int! + heroId2: Int + heroId3: Int + pickRate: Decimal + winRate: Decimal + banRate: Decimal +} + +type HeroRatingType { + single: [HeroRatingObjectType] + dryad: [HeroRatingObjectType] +} + +type HeroRoleType { + roleId: Short + level: Short +} + +type HeroStatsHeroDryadType { + heroId1: Short + heroId2: Short + week: Int + bracketBasic: RankBracketHeroTimeDetail + count: Long + kills: Long + deaths: Long + assists: Long + networth: Long + duration: Long + wins: Long + firstBloodTime: Long + cs: Long + dn: Long + goldEarned: Long + xp: Long + heroDamage: Long + towerDamage: Long + heroHealing: Long + level: Long + synergy: Decimal + winsAverage: Decimal +} + +type HeroStatsQuery { + """Detailed output of data per minute for each hero.""" + stats( + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """ + The week to include in this query, excluding all results that do not include + this week. The value is an epoc TimeStamp of the week of data you want. + Leaving null gives the current week. + """ + week: Long + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketBasicIds: [RankBracketHeroTimeDetail] + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionIds: [MatchPlayerPositionType] + groupByTime: Boolean + groupByPosition: Boolean + groupByBracket: Boolean + + """ + Integer in minutes which determines the start of the data. For example, 10 + would result in every event after 10:00 mark in-game. Minimum input value is 0. + """ + minTime: Int + + """ + Integer in minutes which determines the start of the data. For example, 10 + would result in every event before 10:00 mark in-game Maximum input value is 75. + """ + maxTime: Int + ): [HeroPositionTimeDetailAverageType] + + """Hero Data and statistics listed by what lane the hero plays in.""" + position( + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short! + + """ + The week to include in this query, excluding all results that do not include + this week. The value is an epoc TimeStamp of the week of data you want. + Leaving null gives the current week. + """ + week: Long + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketBasicIds: [RankBracketHeroTimeDetail] + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionIds: [MatchPlayerPositionType] + + """ + Integer in minutes which determines the start of the data. For example, 10 + would result in every event after 10:00 mark in-game. Minimum input value is 0. + """ + minTime: Int + + """ + Integer in minutes which determines the start of the data. For example, 10 + would result in every event before 10:00 mark in-game Maximum input value is 75. + """ + maxTime: Int + ): [HeroPositionDetailType] + + """ + Returns back a list of the hero matchups, showing how that hero's win rate is affected with or against other heroes. + """ + matchUp( + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short! + + """ + The week to include in this query, excluding all results that do not include + this week. The value is an epoc TimeStamp of the week of data you want. + Leaving null gives the current week. + """ + week: Long + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketBasicIds: [RankBracketHeroTimeDetail] + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionIds: [MatchPlayerPositionType] + + """ + Id representing how to order dryads and triads. Synergy is STRATZ formula to + help determine the best outcome of wins and picks in one. Accepted Inputs : + Synergy = 0, Pick = 1, Win = 2, Loss = 3, Disadvantage = 4, Advantage = 5 + """ + orderBy: Byte + + """Minimum amount of MatchCount required for a Duo to qualify""" + matchLimit: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int + ): [HeroDryadType] + + """ + Used in STRATZ Hero Page. Includes Starting items and full items based in groupings of 0-14 minutes, 15-34 minutes and 35+ + """ + purchasePattern( + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short! + + """ + The week to include in this query, excluding all results that do not include + this week. The value is an epoc TimeStamp of the week of data you want. + Leaving null gives the current week. + """ + week: Long + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketBasicIds: [RankBracketHeroTimeDetail] + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionIds: [MatchPlayerPositionType] + ): HeroPurchasePatternType + + """ + Returns the items purchased for the selected hero. Adjusting the time adjusts + the purchase amount. Shows win rate by item timings. + """ + itemFullPurchase( + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short! + + """ + The week to include in this query, excluding all results that do not include + this week. The value is an epoc TimeStamp of the week of data you want. + Leaving null gives the current week. + """ + week: Long + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketBasicIds: [RankBracketHeroTimeDetail] + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionIds: [MatchPlayerPositionType] + + """ + Integer in minutes which determines the start of the data. For example, 10 + would result in every event after 10:00 mark in-game. Minimum input value is 0. + """ + minTime: Int + + """ + Integer in minutes which determines the start of the data. For example, 10 + would result in every event before 10:00 mark in-game Maximum input value is 75. + """ + maxTime: Int + + """Minimum amount of MatchCount required for a Duo to qualify""" + matchLimit: Int + ): HeroItemPurchaseType + + """ + This snapshots all items in the inventory of a hero at -00:30. It tracks if an item was given or purchased. + """ + itemStartingPurchase( + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short! + + """ + The week to include in this query, excluding all results that do not include + this week. The value is an epoc TimeStamp of the week of data you want. + Leaving null gives the current week. + """ + week: Long + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketBasicIds: [RankBracketHeroTimeDetail] + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionIds: [MatchPlayerPositionType] + ): HeroItemStartingPurchaseType + + """ + The purchase Item Components for a Hero's Boots. Tracks things like activations or uses throughout the game. + """ + itemBootPurchase( + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short! + + """ + The week to include in this query, excluding all results that do not include + this week. The value is an epoc TimeStamp of the week of data you want. + Leaving null gives the current week. + """ + week: Long + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketBasicIds: [RankBracketHeroTimeDetail] + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionIds: [MatchPlayerPositionType] + ): HeroItemBootPurchaseType + + """ + This call is used in Hero Of the Day. It shows recent Rampages, High Performance and Good Players on the selected hero. + """ + highPerformance( + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short! + + """ + The week to include in this query, excluding all results that do not include + this week. The value is an epoc TimeStamp of the week of data you want. + Leaving null gives the current week. + """ + week: Long + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketBasicIds: [RankBracketHeroTimeDetail] + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionIds: [MatchPlayerPositionType] + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int + ): HeroHighPerformanceType + + """ + This is used on the Hero page to show the comparison of skill with the + selected hero with other heroes. It includes our Synergy and our Advantage + formulas to ensure that a hero with a high win rate isn't simply just on the + top of all the fields. + """ + heroVsHeroMatchup( + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short! + + """ + The week to include in this query, excluding all results that do not include + this week. The value is an epoc TimeStamp of the week of data you want. + Leaving null gives the current week. + """ + week: Long + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketBasicIds: [RankBracketHeroTimeDetail] + + """Minimum amount of MatchCount required for a Duo to qualify""" + matchLimit: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int + ): HeroMatchupType + + """ + This is used on the Hero page to show the comparison of all Hero Talents with the selected hero. + """ + talent( + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short! + + """ + The week to include in this query, excluding all results that do not include + this week. The value is an epoc TimeStamp of the week of data you want. + Leaving null gives the current week. + """ + week: Long + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketBasicIds: [RankBracketHeroTimeDetail] + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionIds: [MatchPlayerPositionType] + ): [HeroAbilityTalentType] + + """ + Used on the Heroes page, includes a small subset of Single Heroes, Dryads and + Triads. Includes Win Rate, Pick Rate, Ban Rate. + """ + ratings( + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: Short! + + """ + The week to include in this query, excluding all results that do not include + this week. The value is an epoc TimeStamp of the week of data you want. + Leaving null gives the current week. + """ + week: Long + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketBasicIds: [RankBracketHeroTimeDetail] + + """ + Id representing how to order dryads and triads. Synergy is STRATZ formula to + help determine the best outcome of wins and picks in one. Accepted Inputs : + Synergy = 0, Pick = 1, Win = 2, Loss = 3, Disadvantage = 4, Advantage = 5 + """ + positionIds: Byte + ): HeroRatingType + + """Used on the Heroes page, for determining popular hero trends.""" + metaTrend( + """ + Epoc TimeStamp of the day of data you want the data to start. Leaving null + gives the current day. Will include the last 14 days with it. The 14th + object in each array will be this day you have specificed. + """ + day: Long + ): [HeroMetaTrendType] + + """ + Returns the last 12 hours by hour showing the amount of matches and the amount of wins by hero id. + """ + winHour( + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """The amount to have returned in your query.""" + take: Int + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketIds: [RankBracket] + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionIds: [MatchPlayerPositionType] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [BasicRegionType] + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [GameModeEnumType] + + """ + Only used when doing matchesGroupBy endpoint. This is how the data will be grouped and makes your return Id field. + """ + groupBy: FilterHeroWinRequestGroupBy + ): [HeroWinHourType] + + """ + Returns the last 12 days by day showing the amount of matches and the amount of wins by hero id. + """ + winDay( + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """The amount to have returned in your query.""" + take: Int + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketIds: [RankBracket] + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionIds: [MatchPlayerPositionType] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [BasicRegionType] + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [GameModeEnumType] + + """ + Only used when doing matchesGroupBy endpoint. This is how the data will be grouped and makes your return Id field. + """ + groupBy: FilterHeroWinRequestGroupBy + ): [HeroWinDayType] + + """ + Returns the last 12 weeks by week showing the amount of matches and the amount of wins by hero id. + """ + winWeek( + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """The amount to have returned in your query.""" + take: Int + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketIds: [RankBracket] + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionIds: [MatchPlayerPositionType] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [BasicRegionType] + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [GameModeEnumType] + + """ + Only used when doing matchesGroupBy endpoint. This is how the data will be grouped and makes your return Id field. + """ + groupBy: FilterHeroWinRequestGroupBy + ): [HeroWinWeekType] + + """ + Returns the data by month showing the amount of matches and the amount of wins by hero id. + """ + winMonth( + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketIds: [RankBracket] + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionIds: [MatchPlayerPositionType] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [BasicRegionType] + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [GameModeEnumType] + + """ + Only used when doing matchesGroupBy endpoint. This is how the data will be grouped and makes your return Id field. + """ + groupBy: FilterHeroWinRequestGroupBy + ): [HeroWinMonthType] + + """ + Returns the data by game version showing the amount of matches and the amount of wins by hero id. + """ + winGameVersion( + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being + unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketIds: [RankBracket] + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionIds: [MatchPlayerPositionType] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [BasicRegionType] + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [GameModeEnumType] + + """ + Only used when doing matchesGroupBy endpoint. This is how the data will be grouped and makes your return Id field. + """ + groupBy: FilterHeroWinRequestGroupBy + ): [HeroWinGameVersionType] + guide( + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short + + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + withHeroId: Short + + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + againstHeroId: Short + + """ + Determines that the query require the results come with a player that is qualified as a Pro. + """ + isPro: Boolean + + """ + An array of positions ids (enum MatchPlayerPositionType) to include in this + query, excluding all results that do not include one of these lanes. + """ + positionId: MatchPlayerPositionType + + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + ): [HeroGuideListType] +} + +type HeroStatType { + enabled: Boolean + heroUnlockOrder: Float + team: Boolean + cMEnabled: Boolean + newPlayerEnabled: Boolean + attackType: String + startingArmor: Float + startingMagicArmor: Float + startingDamageMin: Float + startingDamageMax: Float + attackRate: Float + attackAnimationPoint: Float + attackAcquisitionRange: Float + attackRange: Float + primaryAttribute: String + strengthBase: Float + strengthGain: Float + intelligenceBase: Float + intelligenceGain: Float + agilityBase: Float + agilityGain: Float + mpRegen: Float + moveSpeed: Float + moveTurnRate: Float + hpBarOffset: Float + visionDaytimeRange: Float + visionNighttimeRange: Float + complexity: Byte +} + +type HeroTalentType { + abilityId: Short + slot: Byte +} + +type HeroType { + id: Short + name: String + displayName: String + shortName: String + aliases: [String] + gameVersionId: Short + abilities: [HeroAbilityType] + roles: [HeroRoleType] + language: HeroLanguageType + talents: [HeroTalentType] + stats: HeroStatType +} + +type HeroWinDayType { + day: Long! + heroId: Short! + winCount: Int! + matchCount: Int! +} + +type HeroWinGameVersionType { + gameVersionId: Short! + heroId: Short! + durationMinute: Byte! + winCount: Int! + matchCount: Int! +} + +type HeroWinHourType { + hour: Long! + heroId: Short! + winCount: Int! + matchCount: Int! +} + +type HeroWinMonthType { + month: Long! + heroId: Short! + durationMinute: Byte! + winCount: Int! + matchCount: Int! +} + +type HeroWinWeekType { + week: Long! + heroId: Short! + durationMinute: Byte! + winCount: Int! + matchCount: Int! +} + +type HomepageHeroDryadType { + mainHeroId: Short + comparisonHeroId: Short + bracketBasic: RankBracketHeroTimeDetail + matchCount: Long + winCount: Long + synergy: Decimal + winsAverage: Decimal + comparisonHeroBaseWinRate: Decimal +} + +type HomepageHeroSynergyType { + mainHeroId: Short + mainHeroBaseWinRate: Decimal + heroDryads: [HomepageHeroDryadType] +} + +type ImpGeneratorMatchPlayerType { + winChance: [Float] + winRateByPlayerMinuteValues: [[Float]] + events: [[ImpGeneratorPlayerEventType]] + impValues: [[Int]] +} + +input ImpGeneratorPlayerEventRequestType { + time: Byte! + kills: UShort! + deaths: UShort! + assists: UShort! + cs: UShort! + dn: UShort! + level: Byte! + physicalDamage: Int! + magicalDamage: Int! + pureDamage: Int! + damageReceived: Int! + healingAllies: Int! + runePower: Int! + neutrals: Int! +} + +type ImpGeneratorPlayerEventType { + time: Byte + kills: UShort + deaths: UShort + assists: UShort + cs: UShort + dn: UShort + level: Byte + physicalDamage: Int + magicalDamage: Int + pureDamage: Int + damageReceived: Int + healingAllies: Int + runePower: Int + neutrals: Int +} + +input ImpGeneratorPlayerRequestType { + heroId: Short! + bracket: RankBracket! + position: MatchPlayerPositionType! + events: [ImpGeneratorPlayerEventRequestType]! +} + +type ImpGeneratorPlayerType { + winChance: [Float] + winRateByPlayerMinuteValues: [[Float]] + events: [ImpGeneratorPlayerEventType] + impValues: [[Int]] +} + +input ImpGeneratorRequestType { + bans: [Short]! + players: [ImpGeneratorPlayerRequestType]! + isTurbo: Boolean! +} + +input ImportPickBanType { + playerSlot: Byte + isPick: Boolean! + heroId: Short + time: Byte + isRadiant: Boolean + order: Byte + wasBannedSuccessfully: Boolean +} + +type ImpQuery { + """ + Returns details about all players in a specific match and details regarding Imp + """ + matchGenerator( + """ + The id of the Dota match to include in this query, excluding all results that do not include this id. + """ + matchId: Long! + ): ImpGeneratorMatchPlayerType + + """ + Returns details about a specific player in a game with certains events. + """ + playerGenerator(request: ImpGeneratorRequestType!): ImpGeneratorPlayerType +} + +type InventoryObjectType { + itemId: Short + charges: Int + secondaryCharges: Int +} + +type InventoryType { + time: Int! + item0: InventoryObjectType + item1: InventoryObjectType + item2: InventoryObjectType + item3: InventoryObjectType + item4: InventoryObjectType + item5: InventoryObjectType + backPack0: InventoryObjectType + backPack1: InventoryObjectType + backPack2: InventoryObjectType + teleport0: InventoryObjectType + neutral0: InventoryObjectType +} + +type ItemAttributeType { + name: String + value: String +} + +type ItemComponentType { + index: Byte + componentId: Short +} + +type ItemLanguageType { + displayName: String + description: [String] + lore: [String] + notes: [String] + attributes: [String] +} + +type ItemPurchaseType { + time: Int! + itemId: Short +} + +type ItemStatType { + behavior: Long + unitTargetType: Long + unitTargetTeam: Long + unitTargetFlags: Long + fightRecapLevel: Byte + castRange: [Int] + castPoint: [Float] + cooldown: [Float] + manaCost: [Float] + channelTime: [Float] + sharedCooldown: String + cost: Int + shopTags: String + aliases: String + quality: String + isSellable: Boolean + isDroppable: Boolean + isPurchasable: Boolean + isSideShop: Boolean + isStackable: Boolean + isPermanent: Boolean + isHideCharges: Boolean + isRequiresCharges: Boolean + isDisplayCharges: Boolean + isSupport: Boolean + isAlertable: Boolean + isTempestDoubleClonable: Boolean + stockMax: Short + initialCharges: Short + initialStock: Short + stockTime: Int + initialStockTime: Short + isRecipe: Boolean + needsComponents: Boolean + upgradeItem: Short + upgradeRecipe: Short + itemResult: Short +} + +type ItemType { + id: Short + name: String + displayName: String + shortName: String + isSupportFullItem: Boolean + language: ItemLanguageType + stat: ItemStatType + attributes: [ItemAttributeType] + components: [ItemComponentType] + image: String +} + +type ItemUsedEventType { + time: Int! + itemId: Short + attacker: Short + target: Short +} + +type KillDetailType { + time: Int! + attacker: Short + isFromIllusion: Boolean + target: Short + byAbility: Short + byItem: Short + gold: Int + xp: Int + positionX: Int + positionY: Int + assist: [Int] + isSolo: Boolean + isGank: Boolean + isInvisible: Boolean + isSmoke: Boolean + isTpRecently: Boolean + isRuneEffected: Boolean +} + +enum Language { + ENGLISH + BRAZILIAN + BULGARIAN + CZECH + DANISH + DUTCH + FINNISH + FRENCH + GERMAN + GREEK + HUNGARIAN + ITALIAN + JAPANESE + KOREAN + KOREANA + NORWEGIAN + POLISH + PORTUGUESE + ROMANIAN + RUSSIAN + S_CHINESE + SPANISH + SWEDISH + T_CHINESE + THAI + TURKISH + UKRAINIAN +} + +type LanguageType { + id: Byte! + languageCode: String + languageName: String +} + +type LastHitDetailType { + time: Int! + attacker: Short + isFromIllusion: Boolean + npcId: Short + byAbility: Short + byItem: Short + gold: Int + xp: Int + positionX: Int + positionY: Int + isCreep: Boolean + isNeutral: Boolean + isAncient: Boolean + mapLocation: MapLocationEnums +} + +enum LeaderboardDivision { + AMERICAS + SE_ASIA + EUROPE + CHINA +} + +type LeaderboardQuery { + """Returns the list of the current season leaderboard.""" + season(request: FilterSeasonLeaderboardRequestType): [SteamAccountSeasonActiveLeaderboardRankType] + + """ + Gets the players of Dota which have DotaPlus and have a high level hero. + """ + dotaPlus( + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short + + """ + Id representing how to order the dota plus leader board. Accepted values are + Recent = 0 (Shows the most recent awards given) and Level = 1 (shows by the + highest level first) + """ + orderBy: FilterLeaderboardOrder + + """Only returns players of this level.""" + level: Byte + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int + ): PlayerHeroDotaPlusLeaderboardRankResponseType + + """Gets the top player of DotaPlus order by Level and Time Achived.""" + dotaPlusTopLevels: [HeroDotaPlusLeaderboardRankType] + + """Show amount of active and expired DotaPlus users by Week""" + dotaPlusWeek: [DotaPlusWeekType] + + """Gets the current leaderboard for Battle Pass levels.""" + battlePass( + """The Event Id Assigned by Valve. 22 is TI8, 25 is TI9.""" + eventId: Byte + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int + ): PlayerBattlePassResponseType + + """Gets the current leaderboard for all coaches by level.""" + coaching( + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int + ): PlayerCoachingLeaderboardResponseType + + """Gets the current leaderboard for all guilds by points.""" + guild(request: FilterLeaderboardGuildRequestType): [GuildType] + + """ + Gets the current leaderboard for all players by a specific Hero, order by IMP. + """ + hero(request: FilterLeaderboardHeroRequestType): [PlayerLeaderBoardByHeroType] +} + +type LeagueBattlePassType { + count: Int + average: Int +} + +input LeagueMatchesRequestType { + """ + The steam account id to include in this query, excluding all results that do not have this steam account id. + """ + steamAccountId: Long + + """An array of Dota match ids to include in this query.""" + matchIds: [Long] + + """ + A series id to include in this query, excluding all results that do not have this series id. + """ + seriesId: Long + + """ + A team id to include in this query, excluding all results that do not have this team id. + """ + teamId: Int + + """ + Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. + """ + isParsed: Boolean + + """ + The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + startDateTime: Long + + """ + The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + endDateTime: Long + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [Byte] + + """ + An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. + """ + lobbyTypeIds: [Byte] + + """ + An array of game version ids to include in this query, excluding all results + that do not include one of these game versions. + """ + gameVersionIds: [Int] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [Int] + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-80 with 0 being + unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. + """ + rankIds: [Int] + + """ + STRATZ applys an formula to determine if a game is considered 'real'. We + attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches + that do not include any of these poor quality matches. + """ + isStats: Boolean + + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """ + An array of lane ids (enum MatchLaneType) to include in this query, excluding + all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, + Midlane = 2, Offlane = 3, Jungle = 4 + """ + laneIds: [Int] + + """ + An array of role ids (enum MatchPlayerRoleType) to include in this query, + excluding all results that do not include one of these roles. Core = 0, Light + Support = 1, Hard Support = 2 + """ + roleIds: [Int] + + """ + An array of award ids to include in this query, excluding all results that do + not include one of these awards. The player award types include MVP (1), Top + Core (2), and Top Support (3). + """ + awardIds: [Int] + + """Include all matches that are party games, excluding all others.""" + isParty: Boolean + + """ + STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, + Top Support (enum MatchPlayerAwardType). If you include a query of + 'steamAccountId' then it will require that player to have gotten at least 1 of + these awards for each match result. + """ + hasAward: Boolean + + """ + An array of stage type ids to include in this query, excluding all results that do not include one of these stage types. + """ + leagueStageTypeIds: [LeagueStage] + + """ + An array of steam account ids found on your team to include in this query, + excluding all results that do not include one of these steam accounts found on your team. + """ + withFriendSteamAccountIds: [Long] + + """ + An array of hero ids found on your team to include in this query, excluding + all results that do not include one of these heroes found on your team. + """ + withFriendHeroIds: [Int] + + """ + The amount of matches to skip before collecting your query. Hint: Paging + """ + skip: Int! + + """The amount of matches to have returned in your query. Max 1000""" + take: Int! +} + +type LeagueMetaDetailType { + heroId: Short + winCount: Int + lossCount: Int + winRate: Decimal + pickRate: Decimal + pickCount: Int + banRate: Decimal + banCount: Int +} + +type LeagueMetaType { + leagueId: Int + bestRecord: LeagueMetaDetailType + mostPicked: LeagueMetaDetailType + mostBanned: LeagueMetaDetailType + missingMatchCount: Int + totalMatchCount: Int + league: LeagueType +} + +enum LeagueNodeDefaultGroupEnum { + INVALID + BEST_OF_ONE + BEST_OF_THREE + BEST_OF_FIVE + BEST_OF_TWO +} + +type LeagueNodeGroupType { + id: Short + name: String + parentNodeGroupId: Short + advancingNodeGroupId: Short + advancingTeamCount: Byte + teamCount: Byte + defaultNodeType: LeagueNodeDefaultGroupEnum + nodeGroupType: LeagueNodeGroupTypeEnum + round: Byte + maxRounds: Byte + isTieBreaker: Boolean + isFinalGroup: Boolean + isCompleted: Boolean + phase: Byte + region: Byte + startDate: Long + endDate: Long + secondaryAdvancingNodeGroupId: Short + secondaryAdvancingTeamCount: Byte + tertiaryAdvancingNodeGroupId: Short + tertiaryAdvancingTeamCount: Byte + eliminationDPCPoints: Int + nodes: [LeagueNodeType] +} + +enum LeagueNodeGroupTypeEnum { + INVALID + ORGANIZATIONAL + ROUND_ROBIN + SWISS + BRACKET_SINGLE + BRACKET_DOUBLE_SEED_LOSER + BRACKET_DOUBLE_ALL_WINNER + SHOWMATCH + GSL +} + +type LeagueNodeType { + nodeGroupId: Short + id: Short + name: String + winningNodeId: Short + losingNodeId: Short + nodeType: LeagueNodeDefaultGroupEnum + scheduledTime: Long + actualTime: Long + seriesId: Long + matches: [MatchType] + teamOneId: Int + teamOne: TeamType + teamTwoId: Int + teamTwo: TeamType + teamOneWins: Byte + teamTwoWins: Byte + hasStarted: Boolean + isCompleted: Boolean + streamIds: [Int] + streams: [LeagueStreamType] +} + +type LeaguePrizePoolPercentageType { + leagueId: Int + index: Byte + percentage: Int +} + +enum LeagueRegion { + UNSET + NA + SA + EUROPE + CIS + CHINA + SEA +} + +type LeagueRegisteredPlayerType { + leagueId: Int + league: LeagueType + teamId: Int + radiantTeam: TeamType + steamAccountId: Long + steamAccount: SteamAccountType +} + +input LeagueRequestType { + """ + A league id to include in this query, excluding all results that do not have this league id. + """ + leagueId: Int + + """ + An array of league ids to include in this query, excluding all results that do not include one of these leagues. + """ + leagueIds: [Int] + + """ + An array of tier ids to include in this query, excluding all results that do not include one of these tiers. + """ + tiers: [LeagueTier] + + """Whether an image is required or not, represented in a boolean.""" + requireImage: Boolean + + """Whether a prize pool is required or not, represented in a boolean.""" + requirePrizePool: Boolean + + """ + Whether a start and end date is required or not, represented in a boolean. + """ + requireStartAndEndDates: Boolean + + """Whether a league has live matches or not, represented in a boolean.""" + hasLiveMatches: Boolean + + """Whether a league has ended or not, represented in a boolean.""" + leagueEnded: Boolean + + """Whether a league has started or not, represented in a boolean.""" + isFutureLeague: Boolean + + """If a league is set to start after this time.""" + startDateTime: Long + + """If a league is set to end before this time.""" + endDateTime: Long + + """ + Determine to Start value of finding a League Between two specific datetimes. + """ + betweenStartDateTime: Long + + """ + Determine to End value of finding a League Between two specific datetimes. + """ + betweenEndDateTime: Long + + """The id to order the results by in this query.""" + orderBy: FilterOrderBy + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int +} + +enum LeagueStage { + OPEN_QUALIFERS + CLOSED_QUALIFERS + CHAMPIONS_QUALIFERS + GROUP_STAGE + MAIN_EVENT +} + +type LeagueStatType { + matchCount: Int + radiantWinMatchCount: Int + averageMatchDurationSeconds: Int +} + +type LeagueStreamType { + id: Int + languageId: Language + name: String + broadcastProvider: Byte + streamUrl: String + vodUrl: String +} + +type LeagueTableHeroLanesObjectType { + id: Byte + matchCount: Int! + matchWins: Int! +} + +type LeagueTableHeroOverviewType { + matchCount: Int! + matchWins: Int! + pickPhaseOne: Int! + pickPhaseTwo: Int! + pickPhaseThree: Int! + banCount: Int! + banPhaseOne: Int! + banPhaseTwo: Int! + banPhaseThree: Int! +} + +type LeagueTableHeroStatsType { + kills: Float! + deaths: Float! + assists: Float! + cs: Float! + gpm: Float! + xpm: Float! + heal: Float! + heroDamage: Float! + towerDamage: Float! + killContribution: Float! +} + +type LeagueTableHeroType { + heroId: Short + overview: LeagueTableHeroOverviewType + stats: LeagueTableHeroStatsType + heroes: [LeagueTableHeroStatsType] + lanes: [LeagueTableHeroLanesObjectType] +} + +type LeagueTablePlayerHeroesObjectType { + heroId: Int! + matchCount: Int! + matchWins: Int! + imp: Int! +} + +type LeagueTablePlayerLanesObjectType { + id: Byte + matchCount: Int! + matchWins: Int! +} + +type LeagueTablePlayerOverviewType { + points: Float + earnings: Float + seriesCount: Int! + seriesWins: Int! + matchCount: Int! + matchWins: Int! + imp: Int! +} + +type LeagueTablePlayerStatsType { + kills: Float! + deaths: Float! + assists: Float! + cs: Float! + gpm: Float! + xpm: Float! + heal: Float! + heroDamage: Float! + towerDamage: Float! + killContribution: Float! +} + +type LeagueTablePlayerType { + steamAccountId: Long + steamAccount: SteamAccountType + overview: LeagueTablePlayerOverviewType + stats: LeagueTablePlayerStatsType + heroes: [LeagueTablePlayerHeroesObjectType] + lanes: [LeagueTablePlayerLanesObjectType] +} + +type LeagueTableTeamHeroesObjectType { + heroId: Int! + matchCount: Int! + matchWins: Int! + imp: Decimal + banCount: Int +} + +type LeagueTableTeamLanesObjectType { + id: Byte + matchCount: Int! + matchWins: Int! +} + +type LeagueTableTeamOverviewType { + points: Float + earnings: Float + seriesCount: Int! + seriesWins: Int! + seriesDraws: Int! + matchCount: Int! + matchWins: Int! + tmp: Float +} + +type LeagueTableTeamStatsType { + kills: Float! + deaths: Float! + assists: Float! + cs: Float! + gpm: Float! + xpm: Float! + heal: Float! + heroDamage: Float! + towerDamage: Float! + duration: Float! +} + +type LeagueTableTeamType { + teamId: Int + team: TeamType + members: [LeagueRegisteredPlayerType] + overview: LeagueTableTeamOverviewType + stats: LeagueTableTeamStatsType + heroes: [LeagueTableTeamHeroesObjectType] + lanes: [LeagueTableTeamLanesObjectType] +} + +type LeagueTableType { + leagueId: Int! + tableTeams: [LeagueTableTeamType] + tableHeroes: [LeagueTableHeroType] + tablePlayers: [LeagueTablePlayerType] +} + +enum LeagueTier { + UNSET + AMATEUR + PROFESSIONAL + MINOR + MAJOR + INTERNATIONAL + DPC_QUALIFIER + DPC_LEAGUE_QUALIFIER + DPC_LEAGUE + DPC_LEAGUE_FINALS +} + +type LeagueType { + id: Int + name: String + banner: String + basePrizePool: Int + stopSalesTime: DateTime + tier: LeagueTier + region: LeagueRegion + private: Boolean + freeToSpectate: Boolean + startDateTime: Long + endDateTime: Long + tournamentUrl: String + lastMatchDate: Long + modifiedDateTime: Long + hasLiveMatches: Boolean + prizePool: Int + imageUri: String + displayName: String + description: String + country: String + venue: String + isFollowed: Boolean + nodeGroups: [LeagueNodeGroupType] + liveMatches: [MatchLiveType] + matches( + """ + The request object used to filter matches returned based on input criteria. + """ + request: LeagueMatchesRequestType! + ): [MatchType] + series( + """ + When searching for league matches, an array of the stage type ids the match + must be in. Stages: Open Qualifers = 1, Closed Qualifers = 2, Champions + Qualifers = 3, Group Stage = 4, Main Event = 5 + """ + leagueStageTypeIds: [LeagueStage] + + """ + A team id to include in this query, excluding all results that do not have this team id. + """ + teamId: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int + ): [SeriesType] + tables( + """ + When searching for league matches, an array of the stage type ids the match + must be in. Stages: Open Qualifers = 1, Closed Qualifers = 2, Champions + Qualifers = 3, Group Stage = 4, Main Event = 5 + """ + leagueStageTypeIds: [LeagueStage] + + """ + To modify the values of Kills, Deaths, Assists, etc. Accepted inputs are Average (default), Highest, Lowest, Median. + """ + calculateTypeId: TableCalculateEnum + ): LeagueTableType + battlePass: LeagueBattlePassType + stats( + """ + When searching for league matches, an array of the stage type ids the match + must be in. Stages: Open Qualifers = 1, Closed Qualifers = 2, Champions + Qualifers = 3, Group Stage = 4, Main Event = 5 + """ + leagueStageTypeIds: [LeagueStage] + ): LeagueStatType + prizePoolPercentages: [LeaguePrizePoolPercentageType] + standings: [TeamPrizeType] + streams: [LeagueStreamType] +} + +enum LeaverStatusEnum { + NONE + DISCONNECTED + DISCONNECTED_TOO_LONG + ABANDONED + AFK + NEVER_CONNECTED + NEVER_CONNECTED_TOO_LONG + FAILED_TO_READY_UP + DECLINED_READY_UP +} + +type LiveEventMatchDireTide2020StompType { + match: DireTide2020CustomGameMatchType +} + +type LiveEventPlayerDireTide2020CandyScoredType { + steamAccount: SteamAccountType + match: DireTide2020CustomGameMatchType + heroId: Short + candyScored: Short +} + +type LiveEventPlayerHeroAssistsType { + steamAccount: SteamAccountType + match: MatchType + heroId: Short + assistCount: Byte +} + +type LiveEventPlayerHeroBuildingDamageType { + steamAccount: SteamAccountType + match: MatchType + heroId: Short + buildingDamage: Int +} + +type LiveEventPlayerHeroDewardType { + steamAccount: SteamAccountType + match: MatchType + heroId: Short + dewardCount: Byte +} + +type LiveEventPlayerHeroDotaPlusLevelType { + steamAccount: SteamAccountType + match: MatchType + heroId: Short + level: Byte +} + +type LiveEventPlayerHeroExpPerMinuteType { + steamAccount: SteamAccountType + match: MatchType + heroId: Short + expPerMinute: Short +} + +type LiveEventPlayerHeroGoldPerMinuteType { + steamAccount: SteamAccountType + match: MatchType + heroId: Short + goldPerMinute: Short +} + +type LiveEventPlayerHeroHealingType { + steamAccount: SteamAccountType + match: MatchType + heroId: Short + healingAmount: Int +} + +type LiveEventPlayerHeroHeroDamageType { + steamAccount: SteamAccountType + match: MatchType + heroId: Short + heroDamage: Int +} + +type LiveEventPlayerHeroHighImpType { + steamAccount: SteamAccountType + match: MatchType + heroId: Short + imp: Byte +} + +type LiveEventPlayerHeroItemPurchaseType { + steamAccount: SteamAccountType + match: MatchType + heroId: Short + itemId: Short + itemCount: Byte +} + +type LiveEventPlayerHeroKillsType { + steamAccount: SteamAccountType + match: MatchType + heroId: Short + killCount: Byte +} + +type LiveEventPlayerHeroWinStreakType { + steamAccount: SteamAccountType + match: MatchType + heroId: Short + winStreakCount: Byte +} + +type LiveEventPlayerRampageType { + steamAccount: SteamAccountType + match: MatchType + heroId: Short + rampageCount: Byte +} + +type LiveEventPlayerRankUpType { + steamAccount: SteamAccountType + match: MatchType + rank: Byte +} + +type LiveEventPlayerWinStreakType { + steamAccount: SteamAccountType + match: MatchType + winStreakCount: Byte +} + +type LiveEventProPlayerLiveType { + steamAccounts: [SteamAccountType] + match: MatchLiveType +} + +union LiveEventType = LiveEventPlayerRampageType | LiveEventPlayerWinStreakType | LiveEventPlayerHeroWinStreakType | LiveEventPlayerHeroKillsType | LiveEventPlayerHeroAssistsType | LiveEventPlayerHeroBuildingDamageType | LiveEventPlayerHeroHealingType | LiveEventPlayerHeroHeroDamageType | LiveEventPlayerHeroGoldPerMinuteType | LiveEventPlayerHeroExpPerMinuteType | LiveEventPlayerHeroHighImpType | LiveEventPlayerHeroDotaPlusLevelType | LiveEventPlayerRankUpType | LiveEventProPlayerLiveType | LiveEventPlayerHeroItemPurchaseType | LiveEventPlayerHeroDewardType | LiveEventMatchDireTide2020StompType | LiveEventPlayerDireTide2020CandyScoredType + +type LiveQuery { + """ + Find a live match by match id. A live match is data where a match is on the + Dota watch list and still active. All League games are also Live. id is a + required input field. + """ + match( + """ + The id of the Dota match to include in this query, excluding all results that do not include this id. + """ + id: Long! + + """ + The amount in seconds you wish to skip until you start getting MatchEvents + or PlayerMatchEvents. When requesting reply data back, you may only want the + updates from X second on. This will skip the first set of seconds and give + everything after this time. + """ + skipPlaybackDuration: Int + ): MatchLiveType + + """ + Find all live matches. A live match is data where a match is on the Dota watch + list and still active. All League games are also Live. + """ + matches(request: MatchLiveRequestType): [MatchLiveType] +} + +enum LobbyTypeEnum { + UNRANKED + PRACTICE + TOURNAMENT + TUTORIAL + COOP_VS_BOTS + TEAM_MATCH + SOLO_QUEUE + RANKED + SOLO_MID + BATTLE_CUP + EVENT +} + +type LobbyTypeType { + id: Int! + name: String +} + +scalar Long + +enum MapLocationEnums { + RADIANT_BASE + RADIANT_OFF_LANE + RADIANT_MID_LANE + RADIANT_SAFE_LANE + DIRE_BASE + DIRE_OFF_LANE + DIRE_MID_LANE + DIRE_SAFE_LANE + RIVER + ROSHAN + ROAMING + RADIANT_FOUNTAIN + DIRE_FOUNTAIN +} + +enum MatchAnalysisOutcomeType { + NONE + STOMPED + COMEBACK + CLOSE_GAME +} + +type MatchesDayType { + day: Long! + matchCount: Int! +} + +type MatchesGameVersionType { + gameVersionId: Short! + matchCount: Int! +} + +type MatchesHourType { + hour: Long! + matchCount: Int! +} + +type MatchesMonthType { + month: Long! + matchCount: Int! +} + +type MatchesWeekType { + week: Long! + matchCount: Int! +} + +type MatchGroupByType { + id: Long + id2: Long + id3: Long + matchCount: Int + winCount: Int + avgImp: Int + avgGoldPerMinute: Int + avgExperiencePerMinute: Int + avgKDA: Float + avgKills: Float + avgDeaths: Float + avgAssists: Float + lastMatchDateTime: Long + firstMatchDateTime: Long +} + +enum MatchLaneType { + ROAMING + SAFE_LANE + MID_LANE + OFF_LANE + JUNGLE + UNKNOWN +} + +type MatchLiveBuildingDetailType { + time: Int! + indexId: Int + type: BuildingType + isAlive: Boolean! + positionX: Int + positionY: Int + isRadiant: Boolean + npcId: Int +} + +enum MatchLiveGameState { + INIT + WAIT_FOR_PLAYERS_TO_LOAD + HERO_SELECTION + STRATEGY_TIME + PRE_GAME + GAME_IN_PROGRESS + POST_GAME + DISCONNECT + TEAM_SHOWCASE + CUSTOM_GAME_SETUP + WAIT_FOR_MAP_TO_LOAD + LAST +} + +type MatchLiveInsightType { + teamOneVsWinCount: Int! + teamTwoVsWinCount: Int! + teamOneLeagueWinCount: Int! + teamOneLeagueMatchCount: Int! + teamTwoLeagueWinCount: Int! + teamTwoLeagueMatchCount: Int! + lastSeries: [SeriesType] +} + +type MatchLivePickBanType { + isPick: Boolean! + heroId: Short + order: Int + bannedHeroId: Short + isRadiant: Boolean + baseWinRate: Float + adjustedWinRate: Float + letter: PlusLetterType + positionValues: [Float] + winRateValues: [Float] + durationValues: [Float] + position: MatchPlayerPositionType +} + +type MatchLivePlaybackDataType { + roshanEvents: [MatchLiveRoshanDetailType] + buildingEvents: [MatchLiveBuildingDetailType] + pickBans: [MatchLivePickBanType] + radiantScore: [MatchLiveTeamScoreDetailType] + direScore: [MatchLiveTeamScoreDetailType] +} + +type MatchLivePlayerAssistDetailType { + time: Int! + positionX: Int! + positionY: Int! +} + +type MatchLivePlayerDeathDetailType { + time: Int! + positionX: Int! + positionY: Int! +} + +type MatchLivePlayerDenyDetailType { + time: Int! + positionX: Int! + positionY: Int! +} + +type MatchLivePlayerExperienceDetailType { + time: Int! + expPerMinute: Int! +} + +type MatchLivePlayerGoldDetailType { + time: Int! + gold: Int! + networth: Int! + networthDifference: Int! + goldPerMinute: Int! +} + +type MatchLivePlayerImpDetailType { + time: Int! + imp: Short! +} + +type MatchLivePlayerInventoryDetailType { + time: Int! + itemId0: Short + itemId1: Short + itemId2: Short + itemId3: Short + itemId4: Short + itemId5: Short + backpackId0: Short + backpackId1: Short + backpackId2: Short +} + +type MatchLivePlayerKillDetailType { + time: Int! + positionX: Int! + positionY: Int! +} + +type MatchLivePlayerLastHitDetailType { + time: Int! + positionX: Int! + positionY: Int! +} + +type MatchLivePlayerLevelDetailType { + time: Int! + level: Int! +} + +type MatchLivePlayerPositionDetailType { + time: Int! + x: Int! + y: Int! +} + +type MatchLivePlayerType { + matchId: Long + heroId: Short + hero: HeroType + name: String + playerSlot: Byte + steamAccountId: Long + steamAccount: SteamAccountType + isRadiant: Boolean + numKills: Byte + numDeaths: Byte + numAssists: Byte + leaverStatus: Byte + numLastHits: UShort + numDenies: UShort + goldPerMinute: UShort + experiencePerMinute: UShort + level: Byte + gold: Int + goldSpent: Int + heroDamage: Int + towerDamage: Int + itemId0: Short + itemId1: Short + itemId2: Short + itemId3: Short + itemId4: Short + itemId5: Short + backpackId0: Short + backpackId1: Short + backpackId2: Short + playbackData: MatchPlayerLivePlaybackDataType + networth: Int + respawnTimer: Short + ultimateCooldown: Short + ultimateState: Short + impPerMinute: [MatchLivePlayerImpDetailType] + gameVersionId: Short + baseWinRateValue: Float + position: MatchPlayerPositionType +} + +enum MatchLiveRequestOrderBy { + GAME_TIME + MATCH_ID + SPECTATOR_COUNT +} + +input MatchLiveRequestType { + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short + + """ + A league id to include in this query, excluding all results that do not have this league id. + """ + leagueId: Int + + """ + Returns only matches that are currently still being updated by the backend. + """ + isParsing: Boolean + + """ + Returns only matches that are no longer active and completed but not yet deleted. + """ + isCompleted: Boolean + + """ + An array of league ids to include in this query, excluding all results that do not include one of these leagues. + """ + leagueIds: [Int] + + """ + Only return Live Matches In Progress that are currently in these states. + """ + gameStates: [MatchLiveGameState] + + """ + An array of tier ids to include in this query, excluding all results that do not include one of these tiers. + """ + tiers: [LeagueTier] + + """ + Playback Data can contain a lot of information. This will only display the most recent event for each of the fields. + """ + lastPlaybackEventOnly: Boolean + + """If the return should be ordered by Ascending or Desending order.""" + orderBy: MatchLiveRequestOrderBy + + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int +} + +type MatchLiveRoshanDetailType { + time: Int + isAlive: Boolean + respawnTimer: Int +} + +type MatchLiveTeamScoreDetailType { + time: Int + score: Short +} + +type MatchLiveType { + matchId: Long + radiantScore: Byte + direScore: Byte + leagueId: Int + league: LeagueType + delay: Short + spectators: Int + averageRank: Int + buildingState: Long + radiantLead: Int + lobbyId: Long + lobbyType: LobbyTypeEnum + serverSteamId: String + gameTime: Int + completed: Boolean + isUpdating: Boolean + isParsing: Boolean + radiantTeamId: Int + direTeamId: Int + radiantTeam: TeamType + direTeam: TeamType + parseBeginGameTime: Int + numHumanPlayers: Byte + gameMode: GameModeEnumType + playbackData: MatchLivePlaybackDataType + gameState: MatchLiveGameState + gameMinute: Short + players: [MatchLivePlayerType] + createdDateTime: Long + modifiedDateTime: Long + insight: MatchLiveInsightType + winRateValues: [Float] + durationValues: [Float] + liveWinRateValues: [MatchLiveWinRateDetailType] +} + +type MatchLiveWinRateDetailType { + time: Int! + winRate: Float! +} + +type MatchmakingStatsType { + time: Long! + uSWest: Int! + uSEast: Int! + europe: Int! + singapore: Int! + brazil: Int! + stockholm: Int! + austria: Int! + australia: Int! + southAfrica: Int! + perfectWorldTelecom: Int! + perfectWorldUnicom: Int! + dubai: Int! + chile: Int! + peru: Int! + india: Int! + perfectWorldTelecomGuangdong: Int! + perfectWorldTelecomZhejiang: Int! + japan: Int! + perfectWorldTelecomWuhan: Int! + taiwan: Int! + perfectWorldUnicomTianjin: Int! +} + +type MatchPickBanGroupByType { + heroId: Short + pickCount: Int + banCount: Int +} + +type MatchPlaybackDataBuildingEventType { + time: Int! + indexId: Int + type: BuildingType + hp: Int + maxHp: Int + positionX: Int + positionY: Int + isRadiant: Boolean + npcId: Int + didShrineActivate: Boolean +} + +type MatchplaybackDataCourierEventObjectType { + time: Int! + positionX: Int + positionY: Int + hp: Int + isFlying: Boolean + respawnTime: Int + didCastBoost: Boolean + item0Id: Int + item1Id: Int + item2Id: Int + item3Id: Int + item4Id: Int + item5Id: Int +} + +type MatchPlaybackDataCourierEventType { + id: Int! + ownerHero: Int + isRadiant: Boolean + events: [MatchplaybackDataCourierEventObjectType] +} + +type MatchPlaybackDataRoshanEventType { + time: Int! + hp: Int + maxHp: Int + createTime: Int + x: Int + y: Int + totalDamageTaken: Int + item0: Int + item1: Int + item2: Int + item3: Int + item4: Int + item5: Int +} + +type MatchPlaybackDataRuneEventType { + indexId: Int! + time: Int! + positionX: Int! + positionY: Int! + fromPlayer: Int! + location: Int! + rune: Int! + action: Int! +} + +type MatchPlaybackDataTowerDeathEventType { + time: Int! + radiant: Int! + dire: Int! +} + +type MatchPlaybackDataType { + courierEvents: [MatchPlaybackDataCourierEventType] + runeEvents: [MatchPlaybackDataRuneEventType] + wardEvents: [MatchPlaybackDataWardEventType] + buildingEvents: [MatchPlaybackDataBuildingEventType] + towerDeathEvents: [MatchPlaybackDataTowerDeathEventType] + roshanEvents: [MatchPlaybackDataRoshanEventType] + radiantCaptainSteamAccountId: Long + radiantCaptainSteamAccount: SteamAccountType + direCaptainSteamAccountId: Long + direCaptainSteamAccount: SteamAccountType +} + +type MatchPlaybackDataWardEventType { + indexId: Int! + time: Int! + positionX: Int! + positionY: Int! + fromPlayer: Int + wardType: Byte + action: Byte +} + +type MatchPlayerAdditionalUnitType { + item0Id: Short + item1Id: Short + item2Id: Short + item3Id: Short + item4Id: Short + item5Id: Short + backpack0Id: Short + backpack1Id: Short + backpack2Id: Short + neutral0Id: Short +} + +enum MatchPlayerAward { + NONE + MVP + TOP_CORE + TOP_SUPPORT +} + +type MatchPlayerHeroDamageSourceAbilityReportObjectType { + abilityId: Int! + count: Int! + amount: Int! +} + +type MatchPlayerHeroDamageSourceItemReportObjectType { + itemId: Int! + count: Int! + amount: Int! +} + +type MatchPlayerHeroDamageTargetReportObjectType { + target: Int! + amount: Int! +} + +type MatchPlayerHeroDamageTotalRecievedReportObjectType { + physicalDamage: Int! + magicalDamage: Int! + pureDamage: Int! + heal: Int! + stunCount: Int! + stunDuration: Int! + disableCount: Int! + disableDuration: Int! + slowCount: Int! + slowDuration: Int! +} + +type MatchPlayerHeroDamageTotalReportObjectType { + physicalDamage: Int! + magicalDamage: Int! + pureDamage: Int! + selfHeal: Int! + allyHeal: Int! + stunCount: Int! + stunDuration: Int! + disableCount: Int! + disableDuration: Int! + slowCount: Int! + slowDuration: Int! +} + +type MatchPlayerInventoryObjectType { + itemId: Int! + charges: Int + secondaryCharges: Int +} + +type MatchPlayerInventoryType { + item0: MatchPlayerInventoryObjectType + item1: MatchPlayerInventoryObjectType + item2: MatchPlayerInventoryObjectType + item3: MatchPlayerInventoryObjectType + item4: MatchPlayerInventoryObjectType + item5: MatchPlayerInventoryObjectType + backPack0: MatchPlayerInventoryObjectType + backPack1: MatchPlayerInventoryObjectType + backPack2: MatchPlayerInventoryObjectType + neutral0: MatchPlayerInventoryObjectType +} + +type MatchPlayerItemPurchaseEventType { + time: Int! + itemId: Int! +} + +type MatchPlayerLivePlaybackDataType { + positionEvents: [MatchLivePlayerPositionDetailType] + goldEvents: [MatchLivePlayerGoldDetailType] + levelEvents: [MatchLivePlayerLevelDetailType] + killEvents: [MatchLivePlayerKillDetailType] + deathEvents: [MatchLivePlayerDeathDetailType] + assistEvents: [MatchLivePlayerAssistDetailType] + csEvents: [MatchLivePlayerLastHitDetailType] + denyEvents: [MatchLivePlayerDenyDetailType] + experienceEvents: [MatchLivePlayerExperienceDetailType] + inventoryEvents: [MatchLivePlayerInventoryDetailType] +} + +type MatchPlayerPlaybackDataType { + abilityLearnEvents: [AbilityLearnEventsType] + abilityUsedEvents: [AbilityUsedEventsType] + abilityActiveLists: [AbilityActiveListType] + itemUsedEvents: [ItemUsedEventType] + playerUpdatePositionEvents: [PlayerUpdatePositionDetailType] + playerUpdateGoldEvents: [PlayerUpdateGoldDetailType] + playerUpdateAttributeEvents: [PlayerUpdateAttributeDetailType] + playerUpdateLevelEvents: [PlayerUpdateLevelDetailType] + playerUpdateHealthEvents: [PlayerUpdateHealthDetailType] + playerUpdateBattleEvents: [PlayerUpdateBattleDetailType] + killEvents: [KillDetailType] + deathEvents: [DeathDetailType] + assistEvents: [AssistDetailType] + csEvents: [LastHitDetailType] + goldEvents: [GoldDetailType] + experienceEvents: [ExperienceDetailType] + healEvents: [HealDetailType] + heroDamageEvents: [HeroDamageDetailType] + towerDamageEvents: [TowerDamageDetailType] + inventoryEvents: [InventoryType] + purchaseEvents: [ItemPurchaseType] + buyBackEvents: [BuyBackDetailType] + streakEvents: [StreakEventType] + spiritBearInventoryEvents: [SpiritBearInventoryType] +} + +enum MatchPlayerPositionType { + POSITION_1 + POSITION_2 + POSITION_3 + POSITION_4 + POSITION_5 + UNKNOWN + FILTERED + ALL +} + +enum MatchPlayerRoleType { + CORE + LIGHT_SUPPORT + HARD_SUPPORT + UNKNOWN +} + +type MatchPlayerSpectatorType { + steamId: Long + isRadiantCoach: Boolean + isVictory: Boolean +} + +type MatchPlayerSpiritBearInventoryType { + item0Id: Int + item1Id: Int + item2Id: Int + item3Id: Int + item4Id: Int + item5Id: Int + backPack0Id: Int + backPack1Id: Int + backPack2Id: Int + neutral0Id: Int +} + +type MatchPlayerStatsAbilityCastObjectType { + target: Int! + count: Int! + damage: Int! + duration: Int +} + +type MatchPlayerStatsAbilityCastReportType { + abilityId: Int! + count: Int! + targets: [MatchPlayerStatsAbilityCastObjectType] +} + +type MatchPlayerStatsActionReportType { + moveToPosition: Int! + moveToTarget: Int! + attackPosition: Int! + attackTarget: Int! + castPosition: Int! + castTarget: Int! + castNoTarget: Int! + heldPosition: Int! + glyphCast: Int! + scanUsed: Int! + pingUsed: Int! +} + +type MatchPlayerStatsAllTalkEventType { + time: Int! + message: String + pausedTick: Int! +} + +type MatchPlayerStatsAssistEventType { + time: Int! + target: Int + gold: Int + xp: Int + positionX: Int + positionY: Int +} + +type MatchPlayerStatsBuffEventType { + time: Int! + abilityId: Int + itemId: Int + stackCount: Int +} + +type MatchPlayerStatsChatWheelEventType { + time: Int! + chatWheelId: Short +} + +type MatchPlayerStatsCourierKillEventType { + time: Int! + positionX: Int + positionY: Int +} + +type MatchPlayerStatsDeathEventType { + time: Int! + attacker: Short + target: Int + byAbility: Int + byItem: Int + goldFed: Int + xpFed: Int + timeDead: Int + positionX: Int + positionY: Int + goldLost: Int + assist: [Int!] + isWardWalkThrough: Boolean + isAttemptTpOut: Boolean + isDieBack: Boolean + isBurst: Boolean + isEngagedOnDeath: Boolean + hasHealAvailable: Boolean + isTracked: Boolean +} + +type MatchPlayerStatsFarmDistributionObjectType { + id: Int! + count: Int! + gold: Int + xp: Int +} + +type MatchPlayerStatsFarmDistributionReportType { + creepType: [MatchPlayerStatsFarmDistributionObjectType] + creepLocation: [MatchPlayerStatsFarmDistributionObjectType] + neutralLocation: [MatchPlayerStatsFarmDistributionObjectType] + ancientLocation: [MatchPlayerStatsFarmDistributionObjectType] + buildings: [MatchPlayerStatsFarmDistributionObjectType] + buyBackGold: Int! + abandonGold: Int! + bountyGold: MatchPlayerStatsFarmDistributionObjectType + talentGold: Int! + other: [MatchPlayerStatsFarmDistributionObjectType] + itemGold: Int! +} + +type MatchPlayerStatsHeroDamageReportType { + dealtTotal: MatchPlayerHeroDamageTotalReportObjectType + receivedTotal: MatchPlayerHeroDamageTotalRecievedReportObjectType + dealtTargets: [MatchPlayerHeroDamageTargetReportObjectType] + receivedTargets: [MatchPlayerHeroDamageTargetReportObjectType] + dealtSourceAbility: [MatchPlayerHeroDamageSourceAbilityReportObjectType] + receivedSourceAbility: [MatchPlayerHeroDamageSourceAbilityReportObjectType] + dealtSourceItem: [MatchPlayerHeroDamageSourceItemReportObjectType] + receivedSourceItem: [MatchPlayerHeroDamageSourceItemReportObjectType] +} + +type MatchPlayerStatsItemUsedEventType { + itemId: Int! + count: Int +} + +type MatchPlayerStatsKillEventType { + time: Int! + target: Int + byAbility: Int + byItem: Int + gold: Int + xp: Int + positionX: Int + positionY: Int + assist: [Int!] + isSolo: Boolean + isGank: Boolean + isInvisible: Boolean + isSmoke: Boolean + isTpRecently: Boolean +} + +type MatchPlayerStatsLocationReportType { + positionX: Int! + positionY: Int! +} + +type MatchPlayerStatsRuneEventType { + time: Int! + rune: RuneEnums + action: RuneAction + gold: Int + positionX: Int + positionY: Int +} + +type MatchPlayerStatsTowerDamageReportType { + npcId: Int! + damage: Int! +} + +type MatchPlayerStatsType { + matchId: Long + steamAccountId: Long + gameVersionId: Short + level: [Int] + killEvents: [MatchPlayerStatsKillEventType] + killCount: Int + deathEvents: [MatchPlayerStatsDeathEventType] + deathCount: Int + assistEvents: [MatchPlayerStatsAssistEventType] + assistCount: Int + lastHitsPerMinute: [Int] + lastHitCount: Int + + """ + Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. + """ + goldPerMinute: [Int] + goldCount: Int + + """ + Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. + """ + experiencePerMinute: [Int] + experienceCount: Int + + """ + Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. + """ + healPerMinute: [Int] + healCount: Int + + """ + Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. + """ + heroDamagePerMinute: [Int] + heroDamageCount: Int + + """ + Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. + """ + towerDamagePerMinute: [Int] + towerDamageCount: Int + towerDamageReport: [MatchPlayerStatsTowerDamageReportType] + courierKills: [MatchPlayerStatsCourierKillEventType] + wards: [MatchPlayerStatsWardEventType] + itemPurchases: [MatchPlayerItemPurchaseEventType] + itemUsed: [MatchPlayerStatsItemUsedEventType] + allTalks: [MatchPlayerStatsAllTalkEventType] + chatWheels: [MatchPlayerStatsChatWheelEventType] + actionsPerMinute: [Int] + actionReport: MatchPlayerStatsActionReportType + invisibleSeconds: Int + locationReport: [MatchPlayerStatsLocationReportType] + farmDistributionReport: [MatchPlayerStatsFarmDistributionReportType] + runes: [MatchPlayerStatsRuneEventType] + abilityCastReport: [MatchPlayerStatsAbilityCastReportType] + heroDamageReport: MatchPlayerStatsHeroDamageReportType + inventoryReport: [MatchPlayerInventoryType] + + """ + Starts at minute 0:00 and Index 0 will show the Networth at 0:00 in the game. + """ + networthPerMinute: [Int] + + """ + Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. + """ + campStack: [Int] + matchPlayerBuffEvent: [MatchPlayerStatsBuffEventType] + + """ + Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. + """ + deniesPerMinute: [Int] + + """ + Starts at minute 0:00. The last index will contain the last subset of data, + so if a match is 41:01 long, the last index will be the change in the last 1 second. + """ + impPerMinute: [Int] + + """ + Starts at minute 0:00. The last index will contain the last subset of data, + so if a match is 41:01 long, the last index will be the change in the last 1 second. + """ + impPerMinute2: [Int] + dotaPlusHeroXp: Int + + """ + Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. + """ + tripsFountainPerMinute: [Int] + spiritBearInventoryReport: [MatchPlayerSpiritBearInventoryType] + abilities( + """ + The game version id to include in this query, excluding all results that do not have this game version. + """ + gameVerionId: Int + ): [PlayerAbilityType] + + """ + Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. + """ + heroDamageReceivedPerMinute: [Int] +} + +type MatchPlayerStatsWardEventType { + time: Int! + type: Int! + positionX: Int + positionY: Int +} + +enum MatchPlayerTeamPickOrderType { + FIRST_PICK + SECOND_PICK + THIRD_PICK + FOURTH_PICK + FIFTH_PICK +} + +type MatchPlayerType { + matchId: Long + match: MatchType + playerSlot: Byte + steamAccountId: Long + steamAccount: SteamAccountType + isRadiant: Boolean + isVictory: Boolean + heroId: Short + gameVersionId: Short + hero: HeroType + kills: Byte + deaths: Byte + assists: Byte + leaverStatus: LeaverStatusEnum + numLastHits: Short + numDenies: Short + goldPerMinute: Short + networth: Int + experiencePerMinute: Short + level: Byte + gold: Int + goldSpent: Int + heroDamage: Int + towerDamage: Int + heroHealing: Int + partyId: Byte + isRandom: Boolean + lane: MatchLaneType + streakPrediction: Byte + intentionalFeeding: Boolean + role: MatchPlayerRoleType + roleBasic: MatchPlayerRoleType + imp: Short + award: MatchPlayerAward + item0Id: Short + item1Id: Short + item2Id: Short + item3Id: Short + item4Id: Short + item5Id: Short + backpack0Id: Short + backpack1Id: Short + backpack2Id: Short + + """ + The item id of the dedicated neutral item slot (7.24 and after). From game + versions 7.23 to 7.24, this was the BackPack3Id (the 4th backpack slot item id). + """ + neutral0Id: Short + behavior: Short + stats: MatchPlayerStatsType + playbackData: MatchPlayerPlaybackDataType + heroAverage: [HeroPositionTimeDetailAverageObjectType] + additionalUnit: MatchPlayerAdditionalUnitType + + """ + Gets the players of Dota which have DotaPlus and have a high level hero. + """ + dotaPlus: [HeroDotaPlusLeaderboardRankType] +} + +type MatchReplayUploadHeroDuoSummaryType { + heroId: Short + winCountWith: Int! + winCountAgainst: Int! + matchCountWith: Int! + matchCountAgainst: Int! +} + +type MatchReplayUploadHeroSummaryType { + heroId: Short + winCountWith: Int! + winCountAgainst: Int! + matchCountWith: Int! + matchCountAgainst: Int! + banCountWith: Int! + banCountAgainst: Int! + duos: [MatchReplayUploadHeroDuoSummaryType] +} + +type MatchReplayUploadMatchType { + matchUploadTeamId: Int! + id: Long + fileName: String! + uploaderCaptainJackIdentityId: Guid + isValidated: Boolean! + isComplete: Boolean! + isActive: Boolean! + didRadiantWin: Boolean! + durationSeconds: Short + durationMinutes: Int! + startDateTime: DateTime + endDateTime: DateTime + lobbyType: Byte + numHumanPlayers: Byte + numHumanSpectators: Byte + leagueId: Int + seriesId: Long + gameMode: Byte + radiantTeamId: Int + radiantKills: Byte + direTeamId: Int + direKills: Byte + isRadiantFirstPick: Boolean! + gameVersionId: Int! + notes: String + players: [MatchReplayUploadPlayerType] + stats: MatchReplayUploadStatsType + radiantTeam: TeamType + direTeam: TeamType + league: LeagueType +} + +type MatchReplayUploadOverviewType { + matchCount: Int! + winCount: Int! + matches: [MatchReplayUploadMatchType] +} + +type MatchReplayUploadPickBanType { + playerSlot: Byte + isPick: Boolean! + heroId: Short + bannedHeroId: Short + time: Byte + isRadiant: Boolean + order: Byte + wasBannedSuccessfully: Boolean! +} + +type MatchReplayUploadPlayerStatsItemsType { + item0IdList: [Byte] + item1IdList: [Byte] + item2IdList: [Byte] + item3IdList: [Byte] + item4IdList: [Byte] + item5IdList: [Byte] + backpack0IdList: [Byte] + backpack1IdList: [Byte] + backpack2IdList: [Byte] +} + +type MatchReplayUploadPlayerStatsType { + killsList: [Int] + assistsList: [Int] + deathsList: [Int] + streakList: [Int] + levelList: [Int] + totalEarnedGoldList: [Int] + reliableGoldList: [Int] + unreliableGoldList: [Int] + totalEarnedXpList: [Int] + sharedGoldList: [Int] + heroKillGoldList: [Int] + creepKillGoldList: [Int] + incomeGoldList: [Int] + networthList: [Int] + denyCountList: [Int] + lastHitCountList: [Int] + lastHitStreakList: [Int] + lastHitMultiKillList: [Int] + nearbyCreepDeathCountList: [Int] + claimedDenyCountList: [Int] + claimedMissCountList: [Int] + missCountList: [Int] + stunsList: [Int] + heroHealingList: [Int] + towerKillsList: [Int] + roshanKillsList: [Int] + observerWardsPlacedList: [Int] + sentryWardsPlacedList: [Int] + creepStackList: [Int] + campStackList: [Int] + runePicksupList: [Int] + goldSpentOnSupportList: [Int] + heroDamageList: [Int] + wardsPurchasedList: [Int] + wardsDestroyedList: [Int] + commandsIssuedList: [Int] + goldSpentOnConsumablesList: [Int] + goldSpentOnItemsList: [Int] + goldSpentOnBuybacksList: [Int] + goldLostToDeathList: [Int] + maxHealthList: [Int] + maxManaList: [Int] + bkbChargesUsedList: [Int] + damageMinList: [Int] + damageMaxList: [Int] + damageBonusList: [Int] + strengthTotalList: [Int] + agilityTotalList: [Int] + intellectTotalList: [Int] + towerDamageList: [Int] + items: MatchReplayUploadPlayerStatsItemsType +} + +type MatchReplayUploadPlayerType { + matchId: Long + playerSlot: Byte + matchUploadTeamId: Int! + steamAccountId: Long + isRadiant: Boolean! + isDire: Boolean! + teamSlot: Byte + heroId: Short + kills: Byte + deaths: Byte + assists: Byte + networth: Int! + lastHits: Short + denies: Short + goldPerMinute: Short + experiencePerMinute: Short + totalGoldSpent: Int! + goldSpentOnBuybacks: Int + goldSpentOnConsumables: Int + goldSpentOnItems: Int + goldSpentOnSupport: Int + heroDamage: Int! + towerDamage: Int! + towerKills: Short + heroHealing: Int! + level: Byte + item0Id: Short + item1Id: Short + item2Id: Short + item3Id: Short + item4Id: Short + item5Id: Short + backpack0Id: Short + backpack1Id: Short + backpack2Id: Short + lane: MatchLaneType + role: MatchPlayerRoleType + position: MatchPlayerPositionType + pickOrder: Byte + teamPickOrder: MatchPlayerTeamPickOrderType + isVictory: Boolean! + stats: MatchReplayUploadPlayerStatsType + steamAccount: SteamAccountType +} + +type MatchReplayUploadStatsType { + spectators: [Long] + pickBans: [MatchReplayUploadPickBanType] +} + +type MatchReplayUploadTeamMemberType { + captainJackIdentityId: Guid + matchUploadTeamId: Int! + isAdmin: Boolean! + isDefaultTeam: Boolean! + steamAccount: SteamAccountType +} + +type MatchReplayUploadTeamType { + id: Int! + name: String! + email: String! + teamId: Int! + creatorCaptainJackIdentityId: Guid + team: TeamType + members: [MatchReplayUploadTeamMemberType] + isDefault: Boolean +} + +type MatchStatsChatEventType { + time: Int + type: Int + fromHeroId: Short + toHeroId: Short + value: Short + pausedTick: Int + isRadiant: Boolean +} + +type MatchStatsLaneReportFactionLaneObject { + meleeCount: Int! + rangeCount: Int! + siegeCount: Int! + denyCount: Int! + neutralCount: Int! +} + +type MatchStatsLaneReportFactionObjectType { + midLane: MatchStatsLaneReportFactionLaneObject + offLane: MatchStatsLaneReportFactionLaneObject + safeLane: MatchStatsLaneReportFactionLaneObject +} + +type MatchStatsLaneReportType { + radiant: [MatchStatsLaneReportFactionObjectType] + dire: [MatchStatsLaneReportFactionObjectType] +} + +type MatchStatsOutpostReportObjectType { + npcId: Int + isControlledByRadiant: Boolean! + isRadiantSide: Boolean! +} + +type MatchStatsPickBanType { + isPick: Boolean! + heroId: Short + team: Int + order: Int + bannedHeroId: Short + isRadiant: Boolean + playerIndex: Int + wasBannedSuccessfully: Boolean + baseWinRate: Byte + adjustedWinRate: Byte + letter: Int +} + +type MatchStatsTowerDeathType { + time: Int + npcId: Short + isRadiant: Boolean + attacker: Short +} + +type MatchStatsTowerReportObjectType { + npcId: Int + hp: Int +} + +type MatchStatsTowerReportType { + towers: [MatchStatsTowerReportObjectType] + outposts: [MatchStatsOutpostReportObjectType] +} + +type MatchStatsType { + matchId: Long + + """This begins at -60 to 0 seconds (Index 0).""" + radiantNetworthLeads: [Int] + + """This begins at -60 to 0 seconds (Index 0).""" + radiantExperienceLeads: [Int] + + """This begins at -60 to 0 seconds (Index 0).""" + radiantKills: [Int] + + """This begins at -60 to 0 seconds (Index 0).""" + direKills: [Int] + + """This begins at -60 to 0 seconds (Index 0).""" + pickBans: [MatchStatsPickBanType] + towerStatus: [MatchStatsTowerReportType] + laneReport: MatchStatsLaneReportType + winRates: [Decimal] + predictedWinRates: [Decimal] + chatEvents: [MatchStatsChatEventType] + towerDeaths: [MatchStatsTowerDeathType] +} + +type MatchType { + id: Long + didRadiantWin: Boolean + durationSeconds: Int + startDateTime: Long + endDateTime: Long + towerStatusRadiant: Int + towerStatusDire: Int + barracksStatusRadiant: Short + barracksStatusDire: Short + clusterId: Int + firstBloodTime: Int + lobbyType: LobbyTypeEnum + numHumanPlayers: Int + gameMode: GameModeEnumType + replaySalt: Long + isStats: Boolean + tournamentId: Int + tournamentRound: Short + actualRank: Short + averageRank: Short + averageImp: Short + parsedDateTime: Long + statsDateTime: Long + leagueId: Int + radiantTeamId: Int + direTeamId: Int + seriesId: Long + gameVersionId: Short + regionId: Byte + sequenceNum: Long + rank: Int + bracket: Byte + analysisOutcome: MatchAnalysisOutcomeType + predictedOutcomeWeight: Byte + players( + """ + The steam account id to include in this query, excluding all results that do not have this steam account id. + """ + steamAccountId: Long + ): [MatchPlayerType] + radiantTeam: TeamType + direTeam: TeamType + series: SeriesType + stats: MatchStatsType + playbackData: MatchPlaybackDataType + spectators: [MatchPlayerSpectatorType] + league: LeagueType +} + +input MergeProSteamAccountRequestType { + steamAccountId: Long + name: String! + realName: String +} + +type ModifierType { + id: Short + name: String + buffDuration: Int + isRoot: Boolean + isStun: Boolean + isSilence: Boolean + isInvisible: Boolean + isShackle: Boolean + isHex: Boolean + isSleep: Boolean + isCyclone: Boolean + isTaunt: Boolean + isDisarm: Boolean + isBlind: Boolean + isEthereal: Boolean + isMovementSlow: Boolean + isAttackSlow: Boolean + isBreak: Boolean + isArmorReduce: Boolean + isAttackReduce: Boolean + isMute: Boolean + isDamageAmplified: Boolean + isMovementDebuff: Boolean + isKnockback: Boolean + isWeaken: Boolean + isItem: Boolean + isBanished: Boolean +} + +type NewsItemType { + id: Long + title: String! + uri: String! + author: String! + contents: String! + feedLabel: String! + date: Long + feedName: String! +} + +type NpcStatType { + level: Float + statusHealth: Float + statusHealthRegen: Float + statusMana: Float + statusManaRegen: Float + movementSpeed: Float + movementTurnRate: Float + dayTimeVision: Float + nightTimeVision: Float + attackRangeBuffer: Float + attackRange: Float + isNeutralUnitType: Boolean + isAncient: Boolean + canBeDominated: Boolean + autoAttacksByDefault: Boolean + attackDamageMin: Float + attackDamageMax: Float + attackRate: Float + attackAnimationPoint: Float + projectileSpeed: Float + teamName: String + combatClassAttack: String + combatClassDefend: String + unitRelationshipClass: String + attackDesire: Float + hasInventory: Boolean + wakesNeutrals: Boolean +} + +type NpcType { + id: Short + name: String + stat: NpcStatType +} + +type PageAghanimQuery { + """Returns a match by Id based on the TI10 (2020) summer event.""" + match( + """ + The id of the Dota match to include in this query, excluding all results that do not include this id. + """ + id: Long! + ): TI2020CustomGameMatchType + + """Returns a list of matches by based on the TI10 (2020) summer event.""" + matches(request: FilterTI2020MatchRequestType): [TI2020CustomGameMatchType] + + """ + Returns all the combinations of Heroes and their success on the TI10 (2020) summer event. + """ + heroCompositions(request: FilterTI2020HeroCompositionRequestType!): [TI2020CustomGameHeroCompositionType] + + """ + Returns all the combinations of Heroes and their success on the TI10 (2020) summer event. + """ + heroComposition(heroIds: [Short]!, difficulty: TI2020CustomGameMatchDifficultyType!): TI2020CustomGameHeroCompositionType + + """ + Returns the last 3 days winrate for each hero by Difficulty in the TI10 (2020) summer event. + """ + winRate(difficulty: TI2020CustomGameMatchDifficultyType!): TI2020CustomGameHeroWinRateType + + """Returns all the Abilities for a Hero on the TI10 (2020) summer event.""" + heroAbility(difficulty: TI2020CustomGameMatchDifficultyType!): [TI2020CustomGameHeroAbilityType] + + """ + Returns all the Room Types by Difficulty for the TI10 (2020) summer event. + """ + room(difficulty: TI2020CustomGameMatchDifficultyType!): [TI2020CustomGameRoomType] + + """ + Returns all the Room Modifiers by Difficulty for the TI10 (2020) summer event. + """ + roomModifier(difficulty: TI2020CustomGameMatchDifficultyType!): [TI2020CustomGameRoomModifierType] +} + +type PageDireTide2020Query { + """Returns a match by Id based on the 2020 Halloween Event DireTide.""" + match( + """ + The id of the Dota match to include in this query, excluding all results that do not include this id. + """ + id: Long! + ): DireTide2020CustomGameMatchType + + """ + Returns a list of matches by based on the 2020 Halloween Event DireTide. + """ + matches(request: FilterDireTide2020CustomMatchRequestType): [DireTide2020CustomGameMatchType] + + """ + Returns the last 12 days by day showing the amount of matches and the amount of wins by hero id. + """ + winHour( + """The amount to have returned in your query.""" + take: Int + ): [DireTide2020CustomGameHeroWinDayType] +} + +type PageMatchesQuery { + """Returns the last 12 hours by hour showing the amount of matches.""" + matchesStatsHour( + """The amount to have returned in your query.""" + take: Int + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-80 with 0 being + unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. + """ + bracketIds: [RankBracket] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [BasicRegionType] + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [GameModeEnumType] + ): [MatchesHourType] + + """Returns the last 12 days by day showing the amount of matches.""" + matchesStatsDay( + """The amount to have returned in your query.""" + take: Int + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-80 with 0 being + unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. + """ + bracketIds: [RankBracket] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [BasicRegionType] + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [GameModeEnumType] + ): [MatchesDayType] + + """Returns the last 12 weeks by week showing the amount of matches.""" + matchesStatsWeek( + """The amount to have returned in your query.""" + take: Int + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-80 with 0 being + unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. + """ + bracketIds: [RankBracket] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [BasicRegionType] + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [GameModeEnumType] + ): [MatchesWeekType] + + """Returns the data by month showing the amount of matches.""" + matchesStatsMonth( + """The amount to have returned in your query.""" + take: Int + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-80 with 0 being + unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. + """ + bracketIds: [RankBracket] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [BasicRegionType] + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [GameModeEnumType] + ): [MatchesMonthType] + + """Returns the data by game version showing the amount of matches.""" + matchesStatsGameVersion( + """The amount to have returned in your query.""" + take: Int + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-80 with 0 being + unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. + """ + bracketIds: [RankBracket] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [BasicRegionType] + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [GameModeEnumType] + ): [MatchesGameVersionType] + + """ + Amount of players who are active and searching for a game in this region. + """ + matchmakingStats: [MatchmakingStatsType] +} + +type PagePlayerQuery { + """Returns the violations commited by a player in their last 500 games.""" + conduct: PlayerConductResponseType + + """Get very simple data for the on-hover of a player icon.""" + simpleSummary: PlayerCardHoverType + + """ + Provided in-depth look of a player and how they proform globally on all heroes. + """ + performance( + """ + The request object used to filter matches returned based on input criteria. + """ + request: PlayerPerformanceMatchesRequestType! + ): PlayerPerformanceType + + """A more in depth at a single player's single hero performance.""" + heroPerformance( + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short! + + """ + The request object used to filter matches returned based on input criteria. + """ + request: PlayerHeroPerformanceMatchesRequestType! + ): PlayerPerformanceType + + """ + Returns a list of all heroes played by the steam account id and contains data about the average performance. + """ + heroesPerformance( + """ + The request object used to filter matches returned based on input criteria. + """ + request: PlayerHeroesPerformanceMatchesRequestType + ): [PlayerHeroesPerformanceType] + + """ + Picked the top pros and annoucers and determines if you ever have played with them and when. + """ + playedWithPro: PlayerPlayedWithProType + + """Returns a general player summary of random set of predefinded filters.""" + breakdown( + """ + The request object used to filter matches returned based on input criteria. + """ + request: PlayerBreakdownRequestType! + ): PlayerBreakdownType +} + +type PagePlayersQuery { + """ + Endpoint which breaks down all the SteamAccounts in the database by their current season rank. + """ + steamAccountByRank: [SteamAccountByRankType] +} + +type PageQuery { + """ + STRATZ specific endpoints found on the /player/ section of the website. id is a required input field. + """ + player( + """ + The steam account id to include in this query, excluding all results that do not have this steam account id. + """ + steamAccountId: Long! + ): PagePlayerQuery + + """ + STRATZ specific endpoints found on the /players/ section of the website. + """ + players: PagePlayersQuery + + """ + STRATZ specific endpoints found on the /matches/ section of the website. + """ + matches: PageMatchesQuery + + """Endpoints for the TI10 (2020) regarding the summer event.""" + aghanim: PageAghanimQuery + + """Endpoints for Imp Related calls.""" + imp: ImpQuery + direTide2020: PageDireTide2020Query +} + +type PatchNoteLanguageType { + id: String + gameVersionId: Short + languageId: Byte + index: Byte + abilityId: Short + itemId: Short + heroId: Short + generalId: PatchNoteType + text: String +} + +enum PatchNoteType { + HERO + GENERAL + GENERIC + ITEM + NPC +} + +type PlayerAbilityType { + abilityId: Int! + time: Int! + level: Int! + gameVersionId: Short + abilityType( + """ + The game version id to include in this query, excluding all results that do not have this game version. + """ + gameVerionId: Int + + """ + The language id to include in this query, excluding all results that do not have this language. + """ + langaugeId: Int + ): AbilityType + isTalent: Boolean +} + +type PlayerActivitySummaryHeroType { + heroId: Int + winCount: Int + lossCount: Int +} + +type PlayerActivitySummaryType { + activity: PlayerBehaviorActivity + matchCount: Int + coreCount: Int + supportCount: Int + imp: Int + heroes: [PlayerActivitySummaryHeroType] +} + +type PlayerBadgeType { + badgeId: Byte + slot: Byte + createdDateTime: Long +} + +type PlayerBattlePassResponseType { + players: [PlayerBattlePassType] + playerCount: Int! + accountsAbove2000Count: Int! + accountsAbove1000Count: Int! + accountsAbove500Count: Int! + accountsAbove330Count: Int! + accountsAbove275Count: Int! + accountsAbove225Count: Int! + accountsAbove195Count: Int! + accountsAbove75Count: Int! +} + +type PlayerBattlePassType { + steamAccount: SteamAccountType + activity: Byte + level: Int! +} + +enum PlayerBehaviorActivity { + NONE + VERY_LOW + LOW + MEDIUM + HIGH + VERY_HIGH + INTENSE +} + +type PlayerBreakdownObjectType { + id: Int + matchCount: Int! + win: Int + imp: Int + lastSeenDateTime: Long +} + +input PlayerBreakdownRequestType { + """An array of Dota match ids to include in this query.""" + matchIds: [Long] + + """ + A league id to include in this query, excluding all results that do not have this league id. + """ + leagueId: Int + + """ + A series id to include in this query, excluding all results that do not have this series id. + """ + seriesId: Long + + """ + A team id to include in this query, excluding all results that do not have this team id. + """ + teamId: Int + + """ + Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. + """ + isParsed: Boolean + + """Whether the match is a league match or not.""" + isLeague: Boolean + + """Whether the match has a team assigned or not.""" + isTeam: Boolean + + """ + Requests matches where the match is at least this many minutes. Default is null and there is no minimum. + """ + minDuration: Int + + """ + Requests matches where the match is no longer than this many minutes. Default is null and there is no maximum. + """ + maxDuration: Int + + """ + The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + startDateTime: Long + + """ + The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + endDateTime: Long + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [Byte] + + """ + An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. + """ + lobbyTypeIds: [Byte] + + """ + An array of game version ids to include in this query, excluding all results + that do not include one of these game versions. + """ + gameVersionIds: [Int] + + """ + Requests matches where the match is at least than this input. See GameVersion + API call for a list of patch ids. Default is null and there is no minimum. + """ + minGameVersionId: Int + + """ + Requests matches where the match is lower than this input. See GameVersion + API call for a list of patch ids. Default is null and there is no maximum. + """ + maxGameVersionId: Int + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [Int] + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-80 with 0 being + unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. + """ + rankIds: [Int] + + """ + STRATZ applys an formula to determine if a game is considered 'real'. We + attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches + that do not include any of these poor quality matches. + """ + isStats: Boolean + + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """ + An array of lane ids (enum MatchLaneType) to include in this query, excluding + all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, + Midlane = 2, Offlane = 3, Jungle = 4 + """ + laneIds: [Int] + + """ + An array of role ids (enum MatchPlayerRoleType) to include in this query, + excluding all results that do not include one of these roles. Core = 0, Light + Support = 1, Hard Support = 2 + """ + roleIds: [Int] + + """ + An array of award ids to include in this query, excluding all results that do + not include one of these awards. The player award types include MVP (1), Top + Core (2), and Top Support (3). + """ + awardIds: [Int] + + """Include all matches that are party games, excluding all others.""" + isParty: Boolean + + """Whether the specified player was on Radiant or not.""" + isRadiant: Boolean + + """ + Matches where the user is in a party with this many friends. Automatically applys IsParty = true. This is an array input. + """ + partyCounts: [Int] + + """ + STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, + Top Support (enum MatchPlayerAwardType). If you include a query of + 'steamAccountId' then it will require that player to have gotten at least 1 of + these awards for each match result. + """ + hasAward: Boolean + + """ + An array of steam account ids found on your team to include in this query, + excluding all results that do not include one of these steam accounts found on your team. + """ + withFriendSteamAccountIds: [Long] + + """ + An array of hero ids found on your team to include in this query, excluding + all results that do not include one of these heroes found on your team. + """ + withFriendHeroIds: [Int] +} + +type PlayerBreakdownType { + matches: PlayerBreakdownObjectType + isStatsMatches: [PlayerBreakdownObjectType] + rankMatches: [PlayerBreakdownObjectType] + lobbyMatches: [PlayerBreakdownObjectType] + gameModeMatches: [PlayerBreakdownObjectType] + factionMatches: [PlayerBreakdownObjectType] + regionMatches: [PlayerBreakdownObjectType] + laneMatches: [PlayerBreakdownObjectType] + roleMatches: [PlayerBreakdownObjectType] + partyMatches: [PlayerBreakdownObjectType] + impMatches: [PlayerBreakdownObjectType] + durationMatches: [PlayerBreakdownObjectType] + heroAttributeMatches: [PlayerBreakdownObjectType] + dayOfWeekMatches: [PlayerBreakdownObjectType] + timeOfDayMatches: [PlayerBreakdownObjectType] + weekEndMatches: [PlayerBreakdownObjectType] +} + +type PlayerCardHoverHeroType { + heroId: Int! + winCount: Int! + lossCount: Int! +} + +type PlayerCardHoverType { + steamAccount: SteamAccountType + lastUpdateDateTime: Long + matchCount: Int + coreCount: Int + supportCount: Int + imp: Int + heroes: PlayerCardHoverHeroType + activity: Byte +} + +type PlayerCoachingLeaderboardResponseType { + players: PlayerCoachingLeaderboardType + accounts: Int! + accountsAbove500: Int! + accountsAbove2500: Int! +} + +type PlayerCoachingLeaderboardType { + steamAccount: SteamAccountType + activity: Byte + rating: Int! + matchCount: Int! + winCount: Int! + firstMatchDateTime: Long + lastMatchDateTime: Long +} + +type PlayerConductResponseType { + lastIncidentDateTime: Long + lastIncidentMatchId: Long + recentMatchIncidents: [Short] + behaviorScore: Short +} + +type PlayerDraftHeroHighlightType { + lastPlayed: Long + winCount: Int + matchCount: Int + impAllTime: Int + mvpCountLastMonth: Int + topCoreCountLastMonth: Int + topSupportCountLastMonth: Int + winCountLastMonth: Int + matchCountLastMonth: Int + impLastMonth: Int + winCountLastSixMonths: Int + matchCountLastSixMonths: Int + impLastSixMonths: Int +} + +type PlayerHeroDotaPlusLeaderboardRankResponseType { + players: [HeroDotaPlusLeaderboardRankType] +} + +input PlayerHeroesPerformanceMatchesRequestType { + """An array of Dota match ids to include in this query.""" + matchIds: [Long] + + """ + A league id to include in this query, excluding all results that do not have this league id. + """ + leagueId: Int + + """ + A series id to include in this query, excluding all results that do not have this series id. + """ + seriesId: Long + + """ + A team id to include in this query, excluding all results that do not have this team id. + """ + teamId: Int + + """ + Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. + """ + isParsed: Boolean + + """Whether the match is a league match or not.""" + isLeague: Boolean + + """Whether the match has a team assigned or not.""" + isTeam: Boolean + + """ + Requests matches where the match is at least this many minutes. Default is null and there is no minimum. + """ + minDuration: Int + + """ + Requests matches where the match is no longer than this many minutes. Default is null and there is no maximum. + """ + maxDuration: Int + + """ + The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + startDateTime: Long + + """ + The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + endDateTime: Long + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [Byte] + + """ + An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. + """ + lobbyTypeIds: [Byte] + + """ + An array of game version ids to include in this query, excluding all results + that do not include one of these game versions. + """ + gameVersionIds: [Int] + + """ + Requests matches where the match is at least than this input. See GameVersion + API call for a list of patch ids. Default is null and there is no minimum. + """ + minGameVersionId: Int + + """ + Requests matches where the match is lower than this input. See GameVersion + API call for a list of patch ids. Default is null and there is no maximum. + """ + maxGameVersionId: Int + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [Int] + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-80 with 0 being + unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. + """ + rankIds: [Int] + + """ + STRATZ applys an formula to determine if a game is considered 'real'. We + attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches + that do not include any of these poor quality matches. + """ + isStats: Boolean + + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """ + An array of lane ids (enum MatchLaneType) to include in this query, excluding + all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, + Midlane = 2, Offlane = 3, Jungle = 4 + """ + laneIds: [Int] + + """ + An array of role ids (enum MatchPlayerRoleType) to include in this query, + excluding all results that do not include one of these roles. Core = 0, Light + Support = 1, Hard Support = 2 + """ + roleIds: [Int] + + """ + An array of award ids to include in this query, excluding all results that do + not include one of these awards. The player award types include MVP (1), Top + Core (2), and Top Support (3). + """ + awardIds: [Int] + + """Include all matches that are party games, excluding all others.""" + isParty: Boolean + + """Whether the specified player was on Radiant or not.""" + isRadiant: Boolean + + """ + Matches where the user is in a party with this many friends. Automatically applys IsParty = true. This is an array input. + """ + partyCounts: [Int] + + """ + STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, + Top Support (enum MatchPlayerAwardType). If you include a query of + 'steamAccountId' then it will require that player to have gotten at least 1 of + these awards for each match result. + """ + hasAward: Boolean + + """ + An array of steam account ids found on your team to include in this query, + excluding all results that do not include one of these steam accounts found on your team. + """ + withFriendSteamAccountIds: [Long] + + """ + An array of hero ids found on your team to include in this query, excluding + all results that do not include one of these heroes found on your team. + """ + withFriendHeroIds: [Int] +} + +type PlayerHeroesPerformanceScoreType { + id: Int! + score: Float! + matchCount: Int! + winCount: Int! + imp: Int +} + +type PlayerHeroesPerformanceType { + heroId: Short! + hero: HeroType + winCount: Int! + kDA: Float + avgKills: Float + avgDeaths: Float + avgAssists: Float + duration: Int! + imp: Int + best: Float + matchCount: Int! + goldPerMinute: Int! + experiencePerMinute: Int! + laneScore: [PlayerHeroesPerformanceScoreType] + roleScore: [PlayerHeroesPerformanceScoreType] + lastPlayedDateTime: Long +} + +type PlayerHeroPerformanceLongestStreakType { + heroId: Short + longestStreak: Int + currentStreak: Int +} + +input PlayerHeroPerformanceMatchesRequestType { + """An array of Dota match ids to include in this query.""" + matchIds: [Long] + + """ + A league id to include in this query, excluding all results that do not have this league id. + """ + leagueId: Int + + """ + A series id to include in this query, excluding all results that do not have this series id. + """ + seriesId: Long + + """ + A team id to include in this query, excluding all results that do not have this team id. + """ + teamId: Int + + """ + Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. + """ + isParsed: Boolean + + """Whether the match is a league match or not.""" + isLeague: Boolean + + """Whether the match has a team assigned or not.""" + isTeam: Boolean + + """ + Requests matches where the match is at least this many minutes. Default is null and there is no minimum. + """ + minDuration: Int + + """ + Requests matches where the match is no longer than this many minutes. Default is null and there is no maximum. + """ + maxDuration: Int + + """ + The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + startDateTime: Long + + """ + The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + endDateTime: Long + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [Byte] + + """ + An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. + """ + lobbyTypeIds: [Byte] + + """ + An array of game version ids to include in this query, excluding all results + that do not include one of these game versions. + """ + gameVersionIds: [Int] + + """ + Requests matches where the match is at least than this input. See GameVersion + API call for a list of patch ids. Default is null and there is no minimum. + """ + minGameVersionId: Int + + """ + Requests matches where the match is lower than this input. See GameVersion + API call for a list of patch ids. Default is null and there is no maximum. + """ + maxGameVersionId: Int + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [Int] + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-80 with 0 being + unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. + """ + rankIds: [Int] + + """ + STRATZ applys an formula to determine if a game is considered 'real'. We + attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches + that do not include any of these poor quality matches. + """ + isStats: Boolean + + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """ + An array of lane ids (enum MatchLaneType) to include in this query, excluding + all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, + Midlane = 2, Offlane = 3, Jungle = 4 + """ + laneIds: [Int] + + """ + An array of role ids (enum MatchPlayerRoleType) to include in this query, + excluding all results that do not include one of these roles. Core = 0, Light + Support = 1, Hard Support = 2 + """ + roleIds: [Int] + + """ + An array of award ids to include in this query, excluding all results that do + not include one of these awards. The player award types include MVP (1), Top + Core (2), and Top Support (3). + """ + awardIds: [Int] + + """Include all matches that are party games, excluding all others.""" + isParty: Boolean + + """Whether the specified player was on Radiant or not.""" + isRadiant: Boolean + + """ + Matches where the user is in a party with this many friends. Automatically applys IsParty = true. This is an array input. + """ + partyCounts: [Int] + + """ + STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, + Top Support (enum MatchPlayerAwardType). If you include a query of + 'steamAccountId' then it will require that player to have gotten at least 1 of + these awards for each match result. + """ + hasAward: Boolean + + """ + An array of steam account ids found on your team to include in this query, + excluding all results that do not include one of these steam accounts found on your team. + """ + withFriendSteamAccountIds: [Long] + + """ + An array of hero ids found on your team to include in this query, excluding + all results that do not include one of these heroes found on your team. + """ + withFriendHeroIds: [Int] +} + +type PlayerLeaderBoardByHeroType { + heroId: Short + seasonBracket: Byte + steamAccountId: Long + steamAccount: SteamAccountType + impAverage: Byte + role: MatchPlayerRoleType + lane: MatchLaneType + wins: Byte + losses: Byte + winStreak: Byte + regionId: Byte + changeInRanking: Short + createdDateTime: Long +} + +input PlayerMatchesGroupByRequestType { + """ + Only used when doing matchesGroupBy endpoint. This is how the data will be grouped and makes your return Id field. + """ + groupBy: FindMatchPlayerGroupBy! + + """An array of Dota match ids to include in this query.""" + matchIds: [Long] + + """ + A league id to include in this query, excluding all results that do not have this league id. + """ + leagueId: Int + + """ + A series id to include in this query, excluding all results that do not have this series id. + """ + seriesId: Long + + """ + A team id to include in this query, excluding all results that do not have this team id. + """ + teamId: Int + + """ + Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. + """ + isParsed: Boolean + + """ + The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + startDateTime: Long + + """ + The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + endDateTime: Long + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [Byte] + + """ + An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. + """ + lobbyTypeIds: [Byte] + + """ + An array of game version ids to include in this query, excluding all results + that do not include one of these game versions. + """ + gameVersionIds: [Int] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [Int] + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-80 with 0 being + unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. + """ + rankIds: [Int] + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being unknown + MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketIds: [Int] + + """ + STRATZ applys an formula to determine if a game is considered 'real'. We + attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches + that do not include any of these poor quality matches. + """ + isStats: Boolean + + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """ + An array of lane ids (enum MatchLaneType) to include in this query, excluding + all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, + Midlane = 2, Offlane = 3, Jungle = 4 + """ + laneIds: [Int] + + """ + An array of role ids (enum MatchPlayerRoleType) to include in this query, + excluding all results that do not include one of these roles. Core = 0, Light + Support = 1, Hard Support = 2 + """ + roleIds: [Int] + + """ + An array of award ids to include in this query, excluding all results that do + not include one of these awards. The player award types include MVP (1), Top + Core (2), and Top Support (3). + """ + awardIds: [Int] + + """Include all matches that are party games, excluding all others.""" + isParty: Boolean + + """ + STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, + Top Support (enum MatchPlayerAwardType). If you include a query of + 'steamAccountId' then it will require that player to have gotten at least 1 of + these awards for each match result. + """ + hasAward: Boolean + + """ + An array of steam account ids found on your team to include in this query, + excluding all results that do not include one of these steam accounts found on your team. + """ + withFriendSteamAccountIds: [Long] + + """ + An array of hero ids found on your team to include in this query, excluding + all results that do not include one of these heroes found on your team. + """ + withFriendHeroIds: [Int] +} + +input PlayerMatchesRequestType { + """An array of Dota match ids to include in this query.""" + matchIds: [Long] + + """ + A league id to include in this query, excluding all results that do not have this league id. + """ + leagueId: Int + + """ + A series id to include in this query, excluding all results that do not have this series id. + """ + seriesId: Long + + """ + A team id to include in this query, excluding all results that do not have this team id. + """ + teamId: Int + + """ + When requesting matches with a primary SteamAccountId, this will ensure that player is on specific team Id being sent in. + """ + teamIdSteamAccount: Int + + """ + Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. + """ + isParsed: Boolean + + """ + The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + startDateTime: Long + + """ + The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + endDateTime: Long + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [Byte] + + """ + An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. + """ + lobbyTypeIds: [Byte] + + """ + An array of game version ids to include in this query, excluding all results + that do not include one of these game versions. + """ + gameVersionIds: [Int] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [Int] + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-80 with 0 being + unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. + """ + rankIds: [Int] + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-8 with 0 being unknown + MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. + """ + bracketIds: [Int] + + """ + STRATZ applys an formula to determine if a game is considered 'real'. We + attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches + that do not include any of these poor quality matches. + """ + isStats: Boolean + + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """ + An array of lane ids (enum MatchLaneType) to include in this query, excluding + all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, + Midlane = 2, Offlane = 3, Jungle = 4 + """ + laneIds: [Int] + + """ + An array of role ids (enum MatchPlayerRoleType) to include in this query, + excluding all results that do not include one of these roles. Core = 0, Light + Support = 1, Hard Support = 2 + """ + roleIds: [Int] + + """ + An array of award ids to include in this query, excluding all results that do + not include one of these awards. The player award types include MVP (1), Top + Core (2), and Top Support (3). + """ + awardIds: [Int] + + """Include all matches that are party games, excluding all others.""" + isParty: Boolean + + """ + STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, + Top Support (enum MatchPlayerAwardType). If you include a query of + 'steamAccountId' then it will require that player to have gotten at least 1 of + these awards for each match result. + """ + hasAward: Boolean + + """ + An array of steam account ids found on your team to include in this query, + excluding all results that do not include one of these steam accounts found on your team. + """ + withFriendSteamAccountIds: [Long] + + """ + An array of hero ids found on your team to include in this query, excluding + all results that do not include one of these heroes found on your team. + """ + withFriendHeroIds: [Int] + + """ + Requests matches where the match is at least than this input. See GameVersion + API call for a list of patch ids. Default is null and there is no minimum. + """ + minGameVersionId: Int + + """ + Requests matches where the match is lower than this input. See GameVersion + API call for a list of patch ids. Default is null and there is no maximum. + """ + maxGameVersionId: Int + + """ + Determines if you want a single player returned, only the player by + SteamAccountId, or if you want all 10 players in the match. + """ + playerList: FindMatchPlayerList + + """ + The amount of matches to skip before collecting your query. Hint: Paging + """ + skip: Int + + """The amount of matches to have returned in your query. Max 1000""" + take: Int + + """Only return matches before this match id. Can be used instead of Skip.""" + before: Long + + """Only return matches after this match id. Can be used instead of Skip.""" + after: Long + + """In what order the returned data will come in.""" + orderBy: FindMatchPlayerOrderBy +} + +type PlayerPerformanceCompositionHeroType { + heroId: Short + matchCount: Int! + winCount: Int! +} + +type PlayerPerformanceCompositionType { + allies: [PlayerPerformanceCompositionHeroType] + foes: [PlayerPerformanceCompositionHeroType] +} + +input PlayerPerformanceMatchesRequestType { + """An array of Dota match ids to include in this query.""" + matchIds: [Long] + + """ + A league id to include in this query, excluding all results that do not have this league id. + """ + leagueId: Int + + """ + A series id to include in this query, excluding all results that do not have this series id. + """ + seriesId: Long + + """ + A team id to include in this query, excluding all results that do not have this team id. + """ + teamId: Int + + """ + Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. + """ + isParsed: Boolean + + """Whether the match is a league match or not.""" + isLeague: Boolean + + """Whether the match has a team assigned or not.""" + isTeam: Boolean + + """ + The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + startDateTime: Long + + """ + The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + endDateTime: Long + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [Byte] + + """ + An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. + """ + lobbyTypeIds: [Byte] + + """ + An array of game version ids to include in this query, excluding all results + that do not include one of these game versions. + """ + gameVersionIds: [Int] + + """ + When searching for a league, the tier the league must be in. Tiers: Amateur = + 1, Professional = 2, Premium = 3, Pro Circuit = 4, Main Event = 5 + """ + tier: [Int] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [Int] + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-80 with 0 being + unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. + """ + rankIds: [Int] + + """ + STRATZ applys an formula to determine if a game is considered 'real'. We + attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches + that do not include any of these poor quality matches. + """ + isStats: Boolean + + """ + An array of lane ids (enum MatchLaneType) to include in this query, excluding + all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, + Midlane = 2, Offlane = 3, Jungle = 4 + """ + laneIds: [Int] + + """ + An array of role ids (enum MatchPlayerRoleType) to include in this query, + excluding all results that do not include one of these roles. Core = 0, Light + Support = 1, Hard Support = 2 + """ + roleIds: [Int] + + """ + An array of award ids to include in this query, excluding all results that do + not include one of these awards. The player award types include MVP (1), Top + Core (2), and Top Support (3). + """ + awardIds: [Int] + + """Include all matches that are party games, excluding all others.""" + isParty: Boolean + + """ + STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, + Top Support (enum MatchPlayerAwardType). If you include a query of + 'steamAccountId' then it will require that player to have gotten at least 1 of + these awards for each match result. + """ + hasAward: Boolean + + """Whether the match was a victory or not for the specified player.""" + isVictory: Boolean + + """Whether the specified player was on Radiant or not.""" + isRadiant: Boolean + + """ + An array of steam account ids found on your team to include in this query, + excluding all results that do not include one of these steam accounts found on your team. + """ + withFriendSteamAccountIds: [Long] + + """ + An array of hero ids found on your team to include in this query, excluding + all results that do not include one of these heroes found on your team. + """ + withFriendHeroIds: [Int] +} + +type PlayerPerformancePositionObjectType { + laneType: Byte + laneMatchCount: Int! + laneWinCount: Int! +} + +type PlayerPerformancePositionType { + roleType: Byte + roleMatchCount: Int! + roleWinCount: Int! + lanes: [PlayerPerformancePositionObjectType] +} + +type PlayerPerformanceType { + heroId: [Short] + hero: HeroType + matchCount: Int! + winCount: Int! + streak: Int! + maxStreak: Int! + imp: Int + rank: Int + mmrTier: Int! + mmrBracket: Int! + awardMatchCount: Int! + mvpCount: Int! + topCoreCount: Int! + topSupportCount: Int! + kills: Int + killsAverage: Decimal + deaths: Int + deathsAverage: Decimal + assists: Int + assistsAverage: Decimal + cs: Int + csAverage: Decimal + gpm: Int + gpmAverage: Decimal + xpm: Int + xpmAverage: Decimal + composition: PlayerPerformanceCompositionType + position: [PlayerPerformancePositionType] + + """ + Contains an array of 6 items which are listed as index 0 - 1st Pick, Index 1 - + Pick 2nd, 3rd, Index 2 - Pick 4th, 5th, Index 3 - Pick 6th, Pick 7th, Index 4 + - Pick 8th, 9ths, Index 5 - Pick 10th + """ + pickOrder: [Int] +} + +type PlayerPlayedWithProPlayerMatchType { + matchId: Long + date: Long + isVictory: Boolean! +} + +type PlayerPlayedWithProPlayerType { + steamId: Long + name: String! + with: PlayerPlayedWithProPlayerMatchType + vs: PlayerPlayedWithProPlayerMatchType +} + +type PlayerPlayedWithProTeamType { + teamId: Int! + teamLogo: String! + teamName: String! + players: [PlayerPlayedWithProPlayerType] +} + +type PlayerPlayedWithProType { + playedCount: Int! + totalCount: Int! + casters: [PlayerPlayedWithProPlayerType] + teams: [PlayerPlayedWithProTeamType] + internationalWinners: [PlayerPlayedWithProTeamType] +} + +type PlayerType { + steamAccountId: Long + identity: CaptainJackIdentityPublicProfileType + steamAccount: SteamAccountType + matchCount: Int + winCount: Int + imp: Int + lastMatchDate: Long + lastMatchRegionId: Byte + ranks( + """An array of season in which Dota creates each year for ranks.""" + seasonRankIds: [Byte] + ): [SteamAccountSeasonRankType] + leaderboardRanks( + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int + ): [SteamAccountSeasonLeaderBoardRankType] + languageCodes: [String] + badges: [PlayerBadgeType] + names: [SteamAccountNameType] + behaviorScore: Short + team: SteamAccountTeamMemberType + guildMember: GuildMemberType + activity: PlayerActivitySummaryType + isFollowed: Boolean + simpleSummary: PlayerCardHoverType + performance: PlayerPerformanceType + heroPerformance( + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short! + + """ + The request object used to filter matches returned based on input criteria. + """ + request: PlayerHeroPerformanceMatchesRequestType! + ): PlayerPerformanceType + + """ + Returns a list of all heroes played by the steam account id and contains data about the average performance. + """ + heroesPerformance( + """ + The request object used to filter matches returned based on input criteria. + """ + request: PlayerHeroPerformanceMatchesRequestType + ): [PlayerHeroesPerformanceType] + + """ + Picked the top pros and annoucers and determines if you ever have played with them and when. + """ + playedWithPro: [PlayerPlayedWithProType] + + """ + Find match details by steam account id. steamAccountId is a required input field. + """ + matches( + """ + The request object used to filter matches returned based on input criteria. + """ + request: PlayerMatchesRequestType! + ): [MatchType] + + """ + Find match details by steam account id. The return is modified to group the data by the GroupBy parameter. + """ + matchesGroupBy( + """ + The request object used to filter matches returned based on input criteria. + """ + request: PlayerMatchesGroupByRequestType! + ): [MatchGroupByType] + + """ + Gets the players of Dota which have DotaPlus and have a high level hero. + """ + dotaPlus: [HeroDotaPlusLeaderboardRankType] + + """ + A list of the current Streak and the Longest Streak for each Hero by a Player. + """ + heroStreaks( + """ + The request object used to filter matches returned based on input criteria. + """ + request: PlayerMatchesRequestType + ): [PlayerHeroPerformanceLongestStreakType] +} + +type PlayerUpdateAttributeDetailType { + time: Int! + agi: Int! + int: Int! + str: Int! +} + +type PlayerUpdateBattleDetailType { + time: Int! + damageMinMax: Int! + damageBonus: Int! + hpRegen: Int! + mpRegen: Int! +} + +type PlayerUpdateGoldDetailType { + time: Int! + gold: Int! + unreliableGold: Int! + networth: Int! + networthDifference: Int! +} + +type PlayerUpdateHealthDetailType { + time: Int! + hp: Int! + maxHp: Int! + mp: Int! + maxMp: Int! +} + +type PlayerUpdateLevelDetailType { + time: Int! + level: Int! +} + +type PlayerUpdatePositionDetailType { + time: Int! + x: Int! + y: Int! +} + +input PlusDraftMissingLetterPlayerObjectType { + """The slot of player. It is required to be in order from 0-9.""" + slot: Int! + + """ + When a player has selected a hero, this is the id. If a null is sent, we will send back a hero list of possible heroes. + """ + heroId: Short + + """ + The rank this played is. In the event he is anonymous, use the lowest rank player in the game. + """ + rank: Int + + """ + The lane this player will play. If a null is sent, we will assign the best possible lane. + """ + position: MatchPlayerPositionType + + """ + The order in which this player has picked. If a person has not picked, please send null. Send in order of 0-9. + """ + order: Byte + + """ + To determine the missing letter, isPicking will determine the score before the + hero was selected and after the hero is selected. Only 1 person can have + isPicking = true. + """ + isPicking: Boolean +} + +input PlusDraftMissingLetterRequestType { + """A list of all of the banned hero ids in the draft.""" + bans: [Short] + + """A boolean representing if Radiant is first pick or not.""" + isRadiantFirstPick: Boolean! + + """ + The game mode for this type. We only support All Pick and Ranked All Pick. In the future Captain's Mode will be supported. + """ + gameMode: Int! + + """A list of player request objects.""" + players: [PlusDraftMissingLetterPlayerObjectType]! + + """ + Due to Valve changing the way Picking has happened in the past, we require the + GameVersionId so we know what version of the network to call. + """ + gameVersionId: Short! +} + +type PlusDraftPlayerHeroObjectType { + heroId: Short + pickValue: Decimal + winValues: [Decimal] + score: Float + letter: PlusLetterType +} + +input PlusDraftPlayerRequestType { + """ + The steam id of the player. This will allow us to find player history on the player if he is not anonymous. + """ + steamAccountId: Long + + """The slot of player. It is required to be in order from 0-9.""" + slot: Int! + + """ + When a player has selected a hero, this is the id. If a null is sent, we will send back a hero list of possible heroes. + """ + heroId: Short + + """ + This is used when a player has not selected a hero, but wishes to play a hero. + It will form the draft around the fact that when its his turn to pick, it will be that hero. + """ + suggestHeroId: Short + + """ + The rank this played is. In the event he is anonymous, use the lowest rank player in the game. + """ + rank: Byte + + """ + The role this player will play. If a null is sent, we will assign the best possible role. + """ + position: MatchPlayerPositionType + + """ + The role this player will play. If a null is sent, we will assign the best possible role. + """ + order: Byte +} + +type PlusDraftPlayerType { + slot: Byte + position: MatchPlayerPositionType + positionValues: [Decimal] + heroes: [PlusDraftPlayerHeroObjectType] +} + +input PlusDraftRequestType { + """ + The match Id or the lobby id of the match your sending. This will cache data for the next calls to be quicker. + """ + matchId: Long! + + """A list of all of the banned hero ids in the draft.""" + bans: [Short] + + """A boolean representing if Radiant is first pick or not.""" + isRadiantFirstPick: Boolean! + + """ + The game mode for this type. We only support All Pick and Ranked All Pick. In the future Captain's Mode will be supported. + """ + gameMode: Int! + + """A list of player request objects.""" + players: [PlusDraftPlayerRequestType]! + + """ + Due to Valve changing the way Picking has happened in the past, we require the + GameVersionId so we know what version of the network to call. + """ + gameVersionId: Short! +} + +type PlusDraftType { + midOutcome: Decimal + safeOutcome: Decimal + offOutcome: Decimal + winValues: [Decimal] + durationValues: [Decimal] + players: [PlusDraftPlayerType] +} + +type PlusHeroTeamStatusAveragesType { + cs: Decimal + deaths: Decimal + towerDamage: Decimal + physicalDamage: Decimal + magicalDamage: Decimal + physicalDamageReceived: Decimal + magicalDamageReceived: Decimal + disableCount: Decimal + disableDuration: Decimal + stunCount: Decimal + stunDuration: Decimal + slowCount: Decimal + slowDuration: Decimal + healingAllies: Decimal + purgeModifiers: Decimal + weakenCount: Decimal + weakenDuration: Decimal + pureDamageReceived: Decimal + pureDamage: Decimal +} + +type PlusHeroTeamStatusDetailType { + heroId: Int! + basicBracket: RankBracketHeroTimeDetail + position: MatchPlayerPositionType + averages: PlusHeroTeamStatusAveragesType +} + +type PlusHoverBanType { + heroId: Short + score: Decimal + flags: Byte +} + +type PlusHoverType { + players: [PlusPlayerHoverType] + bans: [PlusHoverBanType] +} + +enum PlusLetterType { + F + D + C + B + A + S +} + +type PlusPlayerHoverHeroType { + heroId: Short + winCount: Int! + lossCount: Int! +} + +type PlusPlayerHoverPlayerType { + steamAccountId: Long + matchCount: Int! + winCount: Int! + lastMatchDateTime: Long +} + +input PlusPlayerHoverRequestType { + """ + An array of steam account ids to limit the query to only return matches with + these steam account ids. There is a maximum of 10 steam account ids allowed. + """ + steamAccountIds: [Long]! + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [Byte] + + """ + An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. + """ + lobbyTypeIds: [Byte] + + """The amount of matches to have returned in your query. Max 1000""" + take: Int + + """ + Should our Networks attempt to try to make Radiant Win the draft or Dire. + """ + shouldRadiantWin: Boolean +} + +type PlusPlayerHoverType { + steamAccount: SteamAccountType + matchCount: Int + winCount: Int! + coreCount: Int + supportCount: Int + imp: Int + heroes: [PlusPlayerHoverHeroType] + activity: Byte + languageCode: [String] + friends: [PlusPlayerHoverPlayerType] + enemies: [PlusPlayerHoverPlayerType] + lastMatchDateTime: Long + heroesExperience: [Short] + behaviorScore: Short +} + +type PlusQuery { + """ + The main call for STRATZ Plus. It will return back probability data based on a draft of players that were given. + """ + draft( + """ + The main call for STRATZ Plus. It will return back probability data based on a draft of players that were given. + """ + request: PlusDraftRequestType! + ): PlusDraftType + + """ + Gets a list of data of the players in the match, can send a max of 10 people. + If a user blocks their data on STRATZ, that data will not be returned. + """ + playerMatchHistory( + """The request object that will filter your PlusPlayerHover data.""" + request: PlusPlayerHoverRequestType! + ): PlusHoverType + + """ + Returns back basic data about the user playing a specific hero. Used in the Draft app to show post-pick data. + """ + playerHeroHighlight( + """ + The Steam Account Id to look up. If the person is anonymous, you will get a null. + """ + steamAccountId: Long! + + """ + The hero id to include in this query, excluding all results that do not include this hero. + """ + heroId: Short! + ): PlayerDraftHeroHighlightType + + """ + Returns a set of events which contain each hero and their averages in each of + the respected categories, sorted by rank bracket. + """ + teamHeroStatus( + """ + The id of the rank bracket to include in this query, excluding all results that do not include this rank bracket. + """ + rankBracket: RankBracketHeroTimeDetail! + ): [PlusHeroTeamStatusDetailType] + + """ + To save CPU cycles we limit the amount of heroes a person can play. If a + player picks a hero outside the default list, we have no idea how good the + hero would of been. You can call this endpoint to update the grade letter for + that hero selection. + """ + draftMissingLetter(request: PlusDraftMissingLetterRequestType!): PlusLetterType +} + +type ProPlayerFollowType { + steamAccountId: Long + activity: Int + matchCount: Int! + coreCount: Int! + supportCount: Int! + steamAccount: SteamAccountType +} + +type ProSteamAccountType { + id: Long + name: String + realName: String + fantasyRole: Byte + teamId: Int + sponsor: String + isLocked: Boolean! + isPro: Boolean! + totalEarnings: Int! + birthday: Long + romanizedRealName: String + roles: Byte + aliases: [String] + statuses: Byte + twitterLink: String + twitchLink: String + instagramLink: String + vkLink: String + youTubeLink: String + facebookLink: String + weiboLink: String + signatureHeroes: [String] + position: MatchPlayerPositionType + countries: [String] + team: TeamType +} + +type RabbitDetailType { + lastUpdated: Long + isOnline: Boolean! + matchHistory: RabbitQueueDetailType + matchDetail: RabbitQueueDetailType + matchDetailDelay: RabbitQueueDetailType + matchStats: RabbitQueueDetailType + steamAccount: RabbitQueueDetailType + matchLive: RabbitQueueDetailType +} + +type RabbitQueueDetailType { + queueCount: Int! + queueInRate: Decimal + queueOutRate: Decimal +} + +enum RankBracket { + UNCALIBRATED + HERALD + GUARDIAN + CRUSADER + ARCHON + LEGEND + ANCIENT + DIVINE + IMMORTAL +} + +enum RankBracketHeroTimeDetail { + UNCALIBRATED + HERALD_GUARDIAN + CRUSADER_ARCHON + LEGEND_ANCIENT + DIVINE_IMMORTAL + FILTERED + ALL +} + +type RecentHighImpType { + matchId: Long + imp: Short + match: MatchType +} + +type RecentRampageType { + matchId: Long + heroId: Short + hero: HeroType + heroesKilled: [Short] + match: MatchType +} + +type RecentWinStreakType { + matchId: Long + winStreakCount: Int + + """The status of the win streak, Ended (0) or Ongoing (1).""" + status: Int + firstWonMatchDateTime: DateTime + lastWonMatchDateTime: DateTime + match: MatchType +} + +type RegionType { + id: Byte + name: String + clientName: String + displayName: String + leaderboardDivision: String + langKey: String + latitude: Decimal + longitude: Decimal + code: String + matchGroup: Byte + weekendTourneyDivision: String +} + +type RoleType { + roleId: Short + name: String + langKey: String +} + +enum RuneAction { + PICKUP + BOTTLE +} + +enum RuneEnums { + HASTE + REGEN + DOUBLE_DAMAGE + ILLUSION + INVISIBILITY + BOUNTY + ARCANE + WATER +} + +enum Search { + PLAYERS + MATCHES + LEAGUES + TEAMS + PRO_PLAYERS + CASTERS + GUILDS +} + +type SearchType { + players: [SteamAccountType] + matches: [MatchType] + leagues: [LeagueType] + teams: [TeamType] + proPlayers: [SteamAccountType] + casters: [SteamAccountType] + guild: GuildType + direTideMatches: [DireTide2020CustomGameMatchType] +} + +enum Series { + BEST_OF_ONE + BEST_OF_THREE + BEST_OF_FIVE + BEST_OF_TWO +} + +type SeriesType { + id: Long! + type: Series + teamOneId: Int + teamTwoId: Int + leagueId: Int + teamOneWinCount: Short + teamTwoWinCount: Short + winningTeamId: Int + lastMatchDateTime: Long + matches: [MatchType] + teamOne: TeamType + teamTwo: TeamType + league: LeagueType +} + +type ServerStatusType { + isRedisOnline: Boolean! + steamApiDetail: SteamApiDetailType + rabbitDetail: RabbitDetailType +} + +scalar Short + +type SpiritBearInventoryObjectType { + itemId: Short +} + +type SpiritBearInventoryType { + time: Int! + item0: SpiritBearInventoryObjectType + item1: SpiritBearInventoryObjectType + item2: SpiritBearInventoryObjectType + item3: SpiritBearInventoryObjectType + item4: SpiritBearInventoryObjectType + item5: SpiritBearInventoryObjectType + backPack0: SpiritBearInventoryObjectType + backPack1: SpiritBearInventoryObjectType + backPack2: SpiritBearInventoryObjectType + teleport0: SpiritBearInventoryObjectType + neutral0: SpiritBearInventoryObjectType +} + +type SteamAccountBattlePassType { + steamId: Long + eventId: Byte + level: Int +} + +type SteamAccountByRankType { + rank: Byte + playerCount: Int +} + +type SteamAccountNameType { + name: String + lastSeenDateTime: Long +} + +type SteamAccountSeasonActiveLeaderboardRankType { + steamAccountId: Long + steamAccount: SteamAccountType + avgImp: Short + divisionId: LeaderboardDivision + lastUpdateDateTime: Long + matchCount: Short + position: MatchPlayerPositionType + positionValue: Byte + rank: Short + rankShift: Short + topHeroOne: Short + topHeroTwo: Short + topHeroThree: Short + winRate: Byte +} + +type SteamAccountSeasonLeaderBoardRankType { + steamAccountId: Long + seasonRankId: Byte + asOfDateTime: Long + seasonLeaderBoardDivisionId: Byte + rank: Short +} + +type SteamAccountSeasonRankType { + seasonRankId: Byte + asOfDateTime: Long + isCore: Boolean + rank: Byte +} + +type SteamAccountTeamMemberType { + steamAccountId: Long + steamAccount: SteamAccountType + player: PlayerType + teamId: Long + firstMatchId: Long + firstMatchDateTime: Long + lastMatchId: Long + lastMatchDateTime: Long + team: TeamType +} + +type SteamAccountType { + id: Long + profileUri: String! + realName: String + timeCreated: Long + countryCode: String + stateCode: String + cityId: Int + communityVisibleState: Int + name: String + lastLogOff: Long + avatar: String + primaryClanId: Long + isDotaPlusSubscriber: Boolean + isAnonymous: Boolean! + isStratzAnonymous: Boolean! + seasonRank: Byte + seasonLeaderboardRank: Short + seasonLeaderboardDivisionId: Byte + proSteamAccount: ProSteamAccountType + smurfFlag: Byte + lastMatchDateTime: Long + lastMatchRegionId: Byte + battlepass: [SteamAccountBattlePassType] +} + +type SteamApiDetailOutageType { + secondsOffline: Int + dateTime: Long +} + +type SteamApiDetailType { + isOnline: Boolean! + outages: [SteamApiDetailOutageType] +} + +enum StratzApiType { + DATA_COLLECTOR + MULTI_KEY +} + +type StratzQuery { + admin: AdminQuery + user: UserQuery + page: PageQuery + + """Returns a list of Stratz blogs.""" + blogs( + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int + ): [BlogType] + + """Returns a list of News Items released by Dota 2 directly.""" + news: [NewsItemType] + + """ + Home page data that shows the total count of players and matches in our database. + """ + ticker: [Int] + + """ + Shows the availability to major components required in the STRATZ foundation. + """ + status: ServerStatusType + + """ + Returns a list of languages and an Id for reference. This is used throughout the site. + """ + languages: [LanguageType] + + """Returns a list of Stratz blogs.""" + matchRetry( + """ + The id of the Dota match to include in this query, excluding all results that do not include this id. + """ + id: Long! + ): Boolean + search(request: FilterSearchRequestType): SearchType +} + +enum Streak { + MULTI_KILL + KILL_STREAK +} + +type StreakEventType { + time: Int! + heroId: Short + type: Streak + value: Int! +} + +enum TableCalculateEnum { + AVERAGE + MEDIAN + HIGHEST + LOWEST +} + +input TeamMatchesRequestType { + """ + The steam account id to include in this query, excluding all results that do not have this steam account id. + """ + steamAccountId: Long + + """An array of Dota match ids to include in this query.""" + matchIds: [Long] + + """ + A league id to include in this query, excluding all results that do not have this league id. + """ + leagueId: Int + + """ + A series id to include in this query, excluding all results that do not have this series id. + """ + seriesId: Long + + """ + Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. + """ + isParsed: Boolean + + """ + The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + startDateTime: Long + + """ + The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. + """ + endDateTime: Long + + """ + An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. + """ + gameModeIds: [Byte] + + """ + An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. + """ + lobbyTypeIds: [Byte] + + """ + An array of game version ids to include in this query, excluding all results + that do not include one of these game versions. + """ + gameVersionIds: [Int] + + """ + An array of region ids to include in this query, excluding all results that do not include one of these regions. + """ + regionIds: [Int] + + """ + An array of rank ids to include in this query, excluding all results that do + not include one of these ranks. The value ranges from 0-80 with 0 being + unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. + """ + rankIds: [Int] + + """ + STRATZ applys an formula to determine if a game is considered 'real'. We + attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches + that do not include any of these poor quality matches. + """ + isStats: Boolean + + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """ + An array of lane ids (enum MatchLaneType) to include in this query, excluding + all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, + Midlane = 2, Offlane = 3, Jungle = 4 + """ + laneIds: [Int] + + """ + An array of role ids (enum MatchPlayerRoleType) to include in this query, + excluding all results that do not include one of these roles. Core = 0, Light + Support = 1, Hard Support = 2 + """ + roleIds: [Int] + + """ + An array of award ids to include in this query, excluding all results that do + not include one of these awards. The player award types include MVP (1), Top + Core (2), and Top Support (3). + """ + awardIds: [Int] + + """Include all matches that are party games, excluding all others.""" + isParty: Boolean + + """ + STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, + Top Support (enum MatchPlayerAwardType). If you include a query of + 'steamAccountId' then it will require that player to have gotten at least 1 of + these awards for each match result. + """ + hasAward: Boolean + + """ + An array of steam account ids found on your team to include in this query, + excluding all results that do not include one of these steam accounts found on your team. + """ + withFriendSteamAccountIds: [Long] + + """ + An array of hero ids found on your team to include in this query, excluding + all results that do not include one of these heroes found on your team. + """ + withFriendHeroIds: [Int] + + """ + The amount of matches to skip before collecting your query. Hint: Paging + """ + skip: Int! + + """The amount of matches to have returned in your query. Max 1000""" + take: Int! +} + +type TeamPrizeType { + leagueId: Int + league: LeagueType + teamId: Int + team: TeamType + standing: Int + prizeAmount: Float +} + +type TeamType { + id: Int! + name: String + tag: String + dateCreated: Long + isPro: Boolean + isLocked: Boolean + countryCode: String + url: String + logo: String + baseLogo: String + bannerLogo: String + winCount: Int + lossCount: Int + lastMatchDateTime: Long + countryName: String + coachSteamAccountId: Long + coachSteamAccount: SteamAccountType + + """Find match details by leauge id.""" + matches( + """ + The request object used to filter matches returned based on input criteria. + """ + request: TeamMatchesRequestType! + ): [MatchType] + + """Find match details by series id.""" + series( + """ + The request object used to filter Series returned based on input criteria. + """ + request: FilterSeriesRequestType! + ): [SeriesType] + + """A List of all the players for a team.""" + members( + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int + ): [SteamAccountTeamMemberType] + + """ + Find match details by team id. The return is modified to group the data by the GroupBy parameter. + """ + matchesGroupBy( + """ + The request object used to filter matches returned based on input criteria. + """ + request: PlayerMatchesGroupByRequestType! + ): [MatchGroupByType] + + """ + Find match details by team id. The return is modified to group the data by the GroupBy parameter. + """ + heroPickBan: [MatchPickBanGroupByType] +} + +type TI2020CustomGameDepthListAscensionAbilitiesObjectType { + type: TI2020CustomGameDepthListAscensionAbilitiesType + abilityId: Short + modifierId: Short +} + +enum TI2020CustomGameDepthListAscensionAbilitiesType { + ASCENSION_ARMOR + ASCENSION_ARMOR_SAPPING + ASCENSION_ATTACK_SPEED + ASCENSION_BOMB + ASCENSION_CHILLING_TOUCH + ASCENSION_CRIT + ASCENSION_DAMAGE + ASCENSION_DRUNKEN + ASCENSION_EXTRA_FAST + ASCENSION_FLICKER + ASCENSION_HEAL_SUPPRESSION + ASCENSION_MAGIC_IMMUNITY + ASCENSION_MAGIC_RESIST + ASCENSION_VAMPIRIC + ASCENSION_MAGNETIC_FIELD + ASCENSION_SILENCE + ASCENSION_FIREFLY + ASCENSION_EMBIGGEN + ASCENSION_VENGEANCE + AGHSFORT_ASCENSION_INVIS + ASCENSION_METEORIC + ASCENSION_PLASMA_FIELD + ASCENSION_BULWARK +} + +enum TI2020CustomGameDepthListEncounterType { + ENCOUNTER_EMPTY_CAVERN + ENCOUNTER_EMPTY_BEACH + ENCOUNTER_BREWMASTER + ENCOUNTER_HELLBEARS_PORTAL_V_3 + ENCOUNTER_PINECONES + ENCOUNTER_QUILL_BEASTS + ENCOUNTER_JUNGLE_HIJINX + ENCOUNTER_TUSK_SKELETONS + ENCOUNTER_BOMBERS + ENCOUNTER_DROW_RANGER_MINIBOSS + ENCOUNTER_WAVE_BLASTERS + ENCOUNTER_BABY_OGRES + ENCOUNTER_MORPHLINGS_B + ENCOUNTER_ZEALOT_SCARABS + ENCOUNTER_OGRE_SEALS + ENCOUNTER_WARLOCKS + ENCOUNTER_GAUNTLET + ENCOUNTER_MORTY_TRANSITION + ENCOUNTER_PENGUINS_TRANSITION + ENCOUNTER_MIRANA + ENCOUNTER_MUSHROOM_MINES + ENCOUNTER_LEGION_COMMANDER + ENCOUNTER_TROLL_WARLORD + ENCOUNTER_PUDGE_MINIBOSS + ENCOUNTER_PUCKS + ENCOUNTER_DARK_SEER + ENCOUNTER_SPECTRES + ENCOUNTER_SHADOW_DEMONS + ENCOUNTER_NAGA_SIREN + ENCOUNTER_DIRE_SIEGE + ENCOUNTER_BIG_OGRES + ENCOUNTER_DRAGON_KNIGHT + ENCOUNTER_KUNKKA_TIDE + ENCOUNTER_ALCHEMIST + ENCOUNTER_ENRAGED_WILDWINGS + ENCOUNTER_ELEMENTAL_TINY + ENCOUNTER_BANDITS + ENCOUNTER_BOMB_SQUAD + ENCOUNTER_UNDEAD_WOODS + ENCOUNTER_PHOENIX + ENCOUNTER_BROODMOTHERS + ENCOUNTER_FIRE_ROSHAN + ENCOUNTER_BOSS_VISAGE + ENCOUNTER_BOSS_TIMBERSAW + ENCOUNTER_TEMPLE_GUARDIANS + ENCOUNTER_STOREGGA + ENCOUNTER_BOSS_VOID_SPIRIT + ENCOUNTER_AGHANIM + ENCOUNTER_JUNGLE_FIRE_MAZE + ENCOUNTER_CLIFF_PASS + ENCOUNTER_HELLFIRE_CANYON + ENCOUNTER_TEMPLE_GARDEN + ENCOUNTER_CASTLE_TRAPS + ENCOUNTER_CRYPT_TRAPS + ENCOUNTER_BONUS_CHICKEN + ENCOUNTER_PANGOLIER + ENCOUNTER_ROCK_GOLEMS + ENCOUNTER_WENDIGOES + ENCOUNTER_COLLAPSED_MINES + ENCOUNTER_BEARS_LAIR + ENCOUNTER_PINE_GROVE + ENCOUNTER_SACRED_GROUNDS + ENCOUNTER_DEEP_TRAPS + ENCOUNTER_DARK_FOREST + ENCOUNTER_TROPICAL_KEEP + ENCOUNTER_SALTY_SHORE + ENCOUNTER_REGAL_TRAPS + ENCOUNTER_DESERT_OASIS + ENCOUNTER_PRISON_TRAPS + ENCOUNTER_BRIDGE_TRAPS + ENCOUNTER_MOLE_CAVE + ENCOUNTER_BLOB_DUNGEON + ENCOUNTER_MULTIPLICITY + ENCOUNTER_CATACOMBS + ENCOUNTER_SWAMP_OF_SADNESS + ENCOUNTER_CAVERN_TRAPS + ENCOUNTER_AZIYOG_CAVERNS + ENCOUNTER_BAMBOO_GARDEN + ENCOUNTER_BOG_TRAPS + ENCOUNTER_BOSS_WINTER_WYVERN + ENCOUNTER_BOSS_EARTHSHAKER + ENCOUNTER_BOSS_DARK_WILLOW + ENCOUNTER_BOSS_RIZZRICK + ENCOUNTER_PENGUIN_SLEDDING + ENCOUNTER_BONUS_MANGO_ORCHARD + ENCOUNTER_BONUS_HOOKING + ENCOUNTER_MUSHROOM_MINES_2021 + ENCOUNTER_GAOLERS + ENCOUNTER_EGGS_HOLDOUT + ENCOUNTER_SPOOK_TOWN + ENCOUNTER_TEMPLE_TRAPS + ENCOUNTER_CANOPY_TRAPS + ENCOUNTER_INNER_RING + ENCOUNTER_LESHRAC + ENCOUNTER_OUTWORLD + ENCOUNTER_TWILIGHT_MAZE + ENCOUNTER_RUINOUS_TRAPS + ENCOUNTER_BEACH_TRAPS + ENCOUNTER_GOLEM_GORGE + ENCOUNTER_SNAPFIRE + ENCOUNTER_POLARITY_SWAP + ENCOUNTER_STONEHALL_CITADEL + ENCOUNTER_MYSTICAL_TRAPS + ENCOUNTER_HEDGE_TRAPS + ENCOUNTER_TEMPLE_SIEGE + ENCOUNTER_FORBIDDEN_PALACE + ENCOUNTER_CRYPT_GATE + ENCOUNTER_PUGNA_NETHER_REACHES + ENCOUNTER_MINING_TRAPS + ENCOUNTER_DUNGEON_TRAPS + ENCOUNTER_BOSS_ARC_WARDEN + ENCOUNTER_BOSS_CLOCKWERK_TINKER + ENCOUNTER_BOSS_AMOEBA + ENCOUNTER_BOSS_STOREGGA + ENCOUNTER_BONUS_LIVESTOCK + ENCOUNTER_BONUS_SMASH_CHICKENS + ENCOUNTER_BONUS_GALLERY + ENCOUNTER_TOXIC_TERRACE + ENCOUNTER_HIDDEN_COLOSSEUM + ENCOUNTER_FROZEN_RAVINE + ENCOUNTER_PALACE_TRAPS + ENCOUNTER_ICY_POOLS + ENCOUNTER_DEMONIC_WOODS + ENCOUNTER_THUNDER_MOUNTAIN + ENCOUNTER_FRIGID_PINNACLE + ENCOUNTER_VILLAGE_TRAPS + ENCOUNTER_FORSAKEN_PIT + ENCOUNTER_BURNING_MESA + ENCOUNTER_SMASHY_AND_BASHY + ENCOUNTER_PUSH_PULL + ENCOUNTER_JUNGLE_TRAPS + ENCOUNTER_TRANSITION_GATEWAY + ENCOUNTER_PRIMAL_BEAST + ENCOUNTER_EVENT_MINOR_SHARD_SHOP + ENCOUNTER_EVENT_DOOM_LIFE_SWAP + ENCOUNTER_EVENT_WARLOCK_LIBRARY + ENCOUNTER_EVENT_ALCHEMIST_NEUTRAL_ITEMS + ENCOUNTER_EVENT_BREWMASTER_BAR + ENCOUNTER_EVENT_LIFE_SHOP + ENCOUNTER_EVENT_MORPHLING_ATTRIBUTE_SHIFT + ENCOUNTER_EVENT_TINKER_RANGE_RETROFIT + ENCOUNTER_EVENT_NAGA_BOTTLE_RUNE + ENCOUNTER_EVENT_SLARK + ENCOUNTER_EVENT_ZEUS + ENCOUNTER_EVENT_LESHRAC + ENCOUNTER_EVENT_NECROPHOS + ENCOUNTER_EVENT_SMALL_TINY_SHRINK + ENCOUNTER_EVENT_BIG_TINY_GROW + ENCOUNTER_EVENT_OGRE_MAGI_CASINO + ENCOUNTER_SPLITSVILLE + ENCOUNTER_AQUA_MANOR + ENCOUNTER_JUNGLE_TREK +} + +enum TI2020CustomGameDepthListRewardType { + REWARD_TYPE_NONE + REWARD_TYPE_GOLD + REWARD_TYPE_EXTRA_LIVES + REWARD_TYPE_TREASURE +} + +type TI2020CustomGameHeroAbilityType { + difficulty: TI2020CustomGameMatchDifficultyType + heroId: Short + customAbilityId: Short + matchCount: Int + winCount: Int + pickCount: Int +} + +type TI2020CustomGameHeroCompositionType { + difficulty: TI2020CustomGameMatchDifficultyType + heroId1: Short + heroId2: Short + heroId3: Short + heroId4: Short + matchCount: Int + winCount: Int + duration: Int + wilsonScore: Decimal +} + +type TI2020CustomGameHeroWinRateType { + difficulty: TI2020CustomGameMatchDifficultyType + heroId: Short + matchCount: Int + winCount: Int +} + +type TI2020CustomGameMatchDepthListType { + selectedElite: Boolean + selectedEncounter: TI2020CustomGameDepthListEncounterType + selectedEncounterType: Byte + selectedHidden: Boolean + selectedReward: TI2020CustomGameDepthListRewardType + unselectedElite: Boolean + unselectedEncounter: TI2020CustomGameDepthListEncounterType + unselectedHidden: Boolean + unselectedReward: TI2020CustomGameDepthListRewardType + ascensionAbilities: [TI2020CustomGameDepthListAscensionAbilitiesObjectType] +} + +enum TI2020CustomGameMatchDifficultyType { + APPRENTICE + MAGICIAN + SORCERER + GRANDMAGUS + APEXMAGE +} + +type TI2020CustomGameMatchType { + id: Long + didWin: Boolean + durationSeconds: Short + startDateTime: Long + endDateTime: Long + clusterId: Short + lobbyType: Byte + numKills: Short + numDeaths: Short + numHumanPlayers: Byte + gameMode: Byte + replaySalt: Long + difficulty: TI2020CustomGameMatchDifficultyType + depth: Byte + seed: Int + battlePoints: Short + score: Int + arcaneFragments: Short + goldBags: Short + regionId: Byte + players( + """ + The steam account id to include in this query, excluding all results that do not have this steam account id. + """ + steamAccountId: Long + ): [TI2020CustomGamePlayerType] + depthList: [TI2020CustomGameMatchDepthListType] +} + +type TI2020CustomGamePlayerBlessingObjectType { + type: TI2020CustomGamePlayerBlessingType + value: Short +} + +enum TI2020CustomGamePlayerBlessingType { + MODIFIER_BLESSING_AGILITY + MODIFIER_BLESSING_ARMOR + MODIFIER_BLESSING_ATTACK_SPEED + MODIFIER_BLESSING_BASE + MODIFIER_BLESSING_BOOK_AGILITY + MODIFIER_BLESSING_BOOK_INTELLIGENCE + MODIFIER_BLESSING_BOOK_STRENGTH + MODIFIER_BLESSING_BOTTLE_UPGRADE + MODIFIER_BLESSING_DAMAGE_BONUS + MODIFIER_BLESSING_DAMAGE_REFLECT + MODIFIER_BLESSING_DETONATION + MODIFIER_BLESSING_EVASION + MODIFIER_BLESSING_HEALTH_BOOST + MODIFIER_BLESSING_INTELLIGENCE + MODIFIER_BLESSING_LIFE_STEAL + MODIFIER_BLESSING_MAGIC_DAMAGE_BONUS + MODIFIER_BLESSING_MAGIC_RESIST + MODIFIER_BLESSING_MANA_BOOST + MODIFIER_BLESSING_MOVEMENT_SPEED + MODIFIER_BLESSING_POTION_ARCANIST + MODIFIER_BLESSING_POTION_DRAGON + MODIFIER_BLESSING_POTION_ECHO_SLAM + MODIFIER_BLESSING_POTION_HEALTH + MODIFIER_BLESSING_POTION_MANA + MODIFIER_BLESSING_POTION_PURIFICATION + MODIFIER_BLESSING_POTION_RAVAGE + MODIFIER_BLESSING_POTION_SHADOW_WAVE + MODIFIER_BLESSING_POTION_TORRENT + MODIFIER_BLESSING_REFRESHER_SHARD + MODIFIER_BLESSING_RESPAWN_INVULNERABILITY + MODIFIER_BLESSING_RESPAWN_TIME_REDUCTION + MODIFIER_BLESSING_RESTORE_MANA + MODIFIER_BLESSING_SPELL_LIFE_STEAL + MODIFIER_BLESSING_STRENGTH + BOTTLE_CHARGES + STAT_AGI + STAT_INT + STAT_STR + STAT_DAMAGE + STAT_SPELL_AMP + STAT_HEALTH + STAT_MANA + STAT_MAGIC_RESIST + STARTING_GOLD + PURIFICATION_POTION + DEATH_DETONATION + POTION_HEALTH + POTION_MANA + RESPAWN_TIME_REDUCTION + BOTTLE_REGEN_DURATION + BOTTLE_REGEN_MOVEMENT_SPEED + ROSHAN_SHOP_DISCOUNT + ORACLE_SHOP_DISCOUNT + RESPAWN_INVULNERABILITY + RESPAWN_HASTE + RESPAWN_ATTACK_SPEED + STAT_EVASION + UPGRADE_REROLL + ELITE_UPGRADE + START_TOME + BOSS_TOME + EXTRA_LIFE + MELEE_CLEAVE + ATTACK_RANGE + PROJECTILE_SPEED + CAST_RANGE + DAMAGE_ON_STUNNED + REGEN_AROUND_ALLIES + DEBUFF_DURATION_INCREASE + LOW_HP_OUTGOING_DAMAGE +} + +type TI2020CustomGamePlayerDepthListType { + numDeaths: Short + goldBags: Short + kills: Short + level: Byte + networth: Int + rarity: Byte + selectedRewardAbilityId: Short + selectedRewardAbility( + """ + The language id to include in this query, excluding all results that do not have this language. + """ + langaugeId: Int + ): AbilityCustomGameType + unSelectedRewardAbilityId1: Short + unSelectedRewardAbility1( + """ + The language id to include in this query, excluding all results that do not have this language. + """ + langaugeId: Int + ): AbilityCustomGameType + unSelectedRewardAbilityId2: Short + unSelectedRewardAbility2( + """ + The language id to include in this query, excluding all results that do not have this language. + """ + langaugeId: Int + ): AbilityCustomGameType + selectedRewardImageAbilityId: Short +} + +type TI2020CustomGamePlayerType { + matchId: Long + playerSlot: Byte + steamAccountId: Long + steamAccount: SteamAccountType + isVictory: Boolean! + heroId: Short + hero: HeroType + deaths: Byte + leaverStatus: Byte + numLastHits: Short + goldPerMinute: Short + networth: Int + experiencePerMinute: Short + level: Byte + goldSpent: Int + partyId: Byte + item0Id: Short + item1Id: Short + item2Id: Short + item3Id: Short + item4Id: Short + item5Id: Short + + """ + The item id of the dedicated neutral item slot (7.24 and after). From game + versions 7.23 to 7.24, this was the BackPack3Id (the 4th backpack slot item id). + """ + neutral0Id: Short + arcaneFragments: Short + bonusArcaneFragments: Short + goldBags: Short + neutralItemId: Short + depthList: [TI2020CustomGamePlayerDepthListType] + blessings: [TI2020CustomGamePlayerBlessingObjectType] +} + +type TI2020CustomGameRoomModifierType { + difficulty: TI2020CustomGameMatchDifficultyType + modifierId: Short + matchCount: Int + winCount: Int + deathCount: Int + eliteMatchCount: Int + eliteWinCount: Int + eliteDeathCount: Int +} + +type TI2020CustomGameRoomType { + difficulty: TI2020CustomGameMatchDifficultyType + encounterId: TI2020CustomGameDepthListEncounterType + matchCount: Int + winCount: Int + pickCount: Int + deathCount: Int + eliteMatchCount: Int + eliteWinCount: Int + elitePickCount: Int + eliteDeathCount: Int +} + +type TopPlayersByHeroType { + heroId: Short + players: [PlayerLeaderBoardByHeroType] +} + +type TotalMatchCountType { + matchCount: Long +} + +type TotalPlayerCountType { + playerCount: Long +} + +type TowerDamageDetailType { + time: Int! + attacker: Short + npcId: Short + damage: Int! + byAbility: Short + byItem: Short +} + +type TwitchTrackerPlayerHeroType { + heroId: Int! + matchCount: Int! + winCount: Int! +} + +type TwitchTrackerPlayerMatchType { + matchId: Long + heroId: Int! + lane: MatchLaneType + role: MatchPlayerRoleType + position: MatchPlayerPositionType + killCount: Short + deathCount: Short + assistCount: Short + endDateTime: Long + isVictory: Boolean! + award: Byte +} + +type TwitchTrackerPlayerType { + steamAccountId: Long + activity: PlayerBehaviorActivity + name: String + avatar: String + rank: Int + leaderboardRank: Int + proPlayerName: String + matchCountLast100: Int! + winCountLast100: Int! + uniqueHeroLast100: Int! + coreCountLast100: Int! + topHeroLast100: [TwitchTrackerPlayerHeroType] + matches: [TwitchTrackerPlayerMatchType] +} + +input UpdateFollowerRequestType { + feedLevel: Byte + emailLevel: Byte + dailyEmail: Boolean + weeklyEmail: Boolean + monthlyEmail: Boolean + overrideAllUsers: Boolean! +} + +input UpdateMatchReplayMatchUploadPlayerObjectType { + steamAccountId: Long! + position: MatchPlayerPositionType +} + +input UpdateMatchReplayUploadObjectType { + matchReplayUploadTeamId: Int! + matchId: Long + leagueId: Int + radiantTeamId: Int + direTeamId: Int + isActive: Boolean + notes: String + players: [UpdateMatchReplayMatchUploadPlayerObjectType] +} + +type UserHomepageType { + """A list of blog components to be displayed separately on the homepage.""" + blogs( + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """ + An array of blog ids to exclude in this query, including all results that do not include one of these blogs. + """ + excludedBlogIds: [Int] + ): [BlogType] + upcomingLeagues( + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """ + An array of league ids to exclude in this query, including all results that do not include one of these leagues. + """ + excludedLeagueIds: [Int] + + """ + An array of league ids to include in this query, excluding all results that do not include one of these leagues. + """ + includedLeagueIds: [Int] + + """ + An array of league tier ids to include in this query, excluding all results + that do not include one of these league tiers. + """ + includedLeagueTierIds: [Int] + ): [LeagueType] + inProgressLeagues( + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """ + An array of league ids to exclude in this query, including all results that do not include one of these leagues. + """ + excludedLeagueIds: [Int] + + """ + An array of league ids to include in this query, excluding all results that do not include one of these leagues. + """ + includedLeagueIds: [Int] + + """ + An array of league tier ids to include in this query, excluding all results + that do not include one of these league tiers. + """ + includedLeagueTierIds: [Int] + ): [LeagueType] + leagueMetas( + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """ + An array of league ids to exclude in this query, including all results that do not include one of these leagues. + """ + excludedLeagueIds: [Int] + + """ + An array of league ids to include in this query, excluding all results that do not include one of these leagues. + """ + includedLeagueIds: [Int] + + """ + An array of league tier ids to include in this query, excluding all results + that do not include one of these league tiers. + """ + includedLeagueTierIds: [Int] + ): [LeagueMetaType] + topProPlayers( + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + ): [ProPlayerFollowType] + topPlayersByHeroType( + """The amount to have returned in your query.""" + heroComponentsTake: Int + + """The amount to have returned in your query.""" + playersTake: Int + + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + + """ + An array of rank bracket ids to include in this query, excluding all results + that do not include one of these rank brackets. + """ + rankBracketIds: [Byte] + ): [TopPlayersByHeroType] + topSynergiesByHero( + """The amount to have returned in your query.""" + synergyComponentsTake: Int + + """ + An array of hero ids to include in this query, excluding all results that do not include one of these heroes. + """ + heroIds: [Short] + ): [HomepageHeroSynergyType] + matchAwards( + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """ + An array of award ids to include in this query, excluding all results that + do not include one of these awards. The player award types include MVP (1), + Top Core (2), and Top Support (3). + """ + matchPlayerAwardTypeIds: [Byte] + ): [MatchType] + recentRampages( + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + ): [RecentRampageType] + recentWinStreaks( + """ + This value is hard-coded to 1 if passed in, due to the way win streaks are currently stored. + """ + take: Int + ): [RecentWinStreakType] + recentHighImps( + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + ): [RecentHighImpType] + recentMatches( + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + ): [MatchPlayerType] + activeLeagueGames( + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + ): [MatchLiveType] + topLiveGames( + """The amount to have returned in your query.""" + take: Int + + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + ): [MatchLiveType] + totalComponents: Int +} + +type UserQuery { + """Find user details of the currently logged in user.""" + profile: UserType + + """Returns a list of Stratz blogs.""" + homepage( + """The amount to have returned in your query.""" + take: Int! + ): UserHomepageType + + """Gets the list of followers the person is following.""" + followers: [FollowerType] + + """Gets the list of followers the person is following.""" + following: [FollowerType] + + """Gets a list of completed tutorials from the logged in user.""" + completedTutorials: [Short] + + """Returns a list of feed events for the logged in user.""" + feed( + """The amount to skip before collecting your query. Hint: Paging""" + skip: Int + + """The amount to have returned in your query.""" + take: Int + ): FeedResponseType +} + +type UserType { + profile: CaptainJackIdentityPrivateProfileType + steamAccount: SteamAccountType + recentMatch: MatchType + followingCount: Int + followerCount: Int + followingLeagueCount: Int + followingTeamCount: Int + stratzApiApplications: [CaptainJackIdentityApiApplicationType] +} + +scalar UShort + +type VendorQuery { + dotaNext: DotaNextQuery + + """Used by the Dota 2 Twitch Tracker for Dota Stats""" + twitchTracker( + """ + The steam account id to include in this query, excluding all results that do not have this steam account id. + """ + steamAccountId: Long! + ): TwitchTrackerPlayerType +} + +enum XpReason { + OTHER + HEROES + CREEPS + ROSHAN + TOME_OF_KNOWLEDGE + OUTPOSTS +} + +type YogurtMutation { + """ + Create a new match replay upload team. teamName, emailAddress, and teamId are required input fields. + """ + createTeam( + """ + The desired team name of the match replay upload team. Cannot be blank or whitespace. + """ + matchReplayUploadTeamName: String! + + """ + The desired email address of the match replay upload team. Cannot be blank or whitespace. + """ + emailAddress: String! + + """ + The desired dota team id of the match replay upload team. Must be a real team created in the dota client. + """ + teamId: Int! + ): MatchReplayUploadTeamType + + """ + Update a new match replay upload team. matchReplayUploadTeamId is a required input field. + """ + updateTeam( + """ + The desired team name of the match replay upload team. Cannot be blank or whitespace. + """ + matchReplayUploadTeamId: Int! + + """ + The desired team name of the match replay upload team. Cannot be blank or whitespace. + """ + matchReplayUploadTeamName: String + + """ + The desired dota team id of the match replay upload team. Must be a real team created in the dota client. + """ + teamId: Int + ): Boolean + + """ + Add a member to a match replay upload team. steamAccountId and matchReplayUploadTeamId are required input fields. + """ + addTeamMember( + """ + The steam account id to include in this query, excluding all results that do not have this steam account id. + """ + steamAccountId: Long! + + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + ): Boolean + + """ + Update a member of a match replay upload team. memberCaptainJackIdentityId, + matchReplayUploadTeamId, and isAdmin are required input fields. + """ + updateTeamMember( + """ + The CaptainJackIdentity id to include in this query, excluding all results that do not have this CaptainJackIdentity id. + """ + captainJackIdentityId: ID! + + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + + """ + Whether the match replay upload team member you wish to update is an admin of that team. + """ + isAdmin: Boolean! + ): Boolean + + """ + Set the default team of a match replay upload team member. + memberCaptainJackIdentityId and matchReplayUploadTeamId are required input fields. + """ + setTeamMemberDefaultTeam( + """ + The CaptainJackIdentity id to include in this query, excluding all results that do not have this CaptainJackIdentity id. + """ + captainJackIdentityId: ID! + + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + ): Boolean + + """ + Remove a member of a match replay upload team. memberCaptainJackIdentityId and + matchReplayUploadTeamId are required input fields. + """ + removeTeamMember( + """ + The CaptainJackIdentity id to include in this query, excluding all results that do not have this CaptainJackIdentity id. + """ + captainJackIdentityId: ID! + + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + ): Boolean + + """ + Update the data of a match replay upload. updateMatchReplayUploadObject is a required input field. + """ + update( + """ + This object contains all of the fields a user is allowed to update on a + match replay upload. Null fields are not updated. Fields set to 0 are + updated to null in the database. + """ + updateMatchReplayUploadObject: UpdateMatchReplayUploadObjectType! + ): Boolean + + """ + Validate the data of a match replay upload, adding the match replay upload to + the queryable data set associated with the match replay upload team. + matchReplayUploadTeamId and matchId are required input fields. + """ + validate( + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + + """ + The id of the Dota match to include in this query, excluding all results that do not include this id. + """ + matchId: Long! + ): Boolean + + """ + Invalidate the data of a match replay upload, removing the match replay upload + from the queryable data set associated with the match replay upload team. + matchReplayUploadTeamId and matchId are required input fields. + """ + invalidate( + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + + """ + The id of the Dota match to include in this query, excluding all results that do not include this id. + """ + matchId: Long! + ): Boolean + + """ + Delete the data of a match replay upload, removing the match replay upload + from the queryable data set associated with the match replay upload team. + matchReplayUploadTeamId and matchId are required input fields. + """ + delete( + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + + """ + The id of the Dota match to include in this query, excluding all results that do not include this id. + """ + matchId: Long! + ): Boolean + + """ + Delete the data of a match replay upload, removing the match replay upload + from the queryable data set associated with the match replay upload team. + matchReplayUploadTeamId and matchId are required input fields. + """ + linkSeriesId( + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + + """An array of Dota match ids to include in this query.""" + matchIds: [Long]! + ): Boolean + + """ + Remove the series id for all of the input matches. matchReplayUploadTeamId and matchIds are required input fields. + """ + removeSeriesId( + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + + """An array of Dota match ids to include in this query.""" + matchIds: [Long]! + ): Boolean + + """ + Import a public match as a match replay upload to the match replay upload + team's data set. matchReplayUploadTeamId and matchId are required input fields. + """ + importMatch( + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + + """ + The id of the Dota match to include in this query, excluding all results that do not include this id. + """ + matchId: Long! + ): Boolean + + """ + If the Picks and Bans for a match are missing or invalid, this allows you to update them. + """ + importPickBans( + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + + """ + The id of the Dota match to include in this query, excluding all results that do not include this id. + """ + matchId: Long! + pickBans: [ImportPickBanType]! + ): Boolean +} + +type YogurtQuery { + """ + Find a match replay upload team by match replay upload team id. matchReplayUploadTeamId is a required input field. + """ + team( + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + ): MatchReplayUploadTeamType + + """ + Find all match replay upload teams associated with the currently logged in user. + """ + teams: [MatchReplayUploadTeamType] + + """ + Find the defualt match replay upload team associated with the currently logged in user. + """ + defaultTeam: MatchReplayUploadTeamType + + """ + Find match replay upload team members by match replay upload team id. matchReplayUploadTeamId is a required input field. + """ + teamMembers( + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + ): [MatchReplayUploadTeamMemberType] + + """ + Find match replay uploads by match replay upload team id. matchReplayUploadTeamId and request are required input fields. + """ + overview( + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + + """ + The request object filtering which match replay uploads to include in this + query, excluding all results that do not pass through this filter. + """ + request: FilterMatchReplayUploadRequestType + ): MatchReplayUploadOverviewType + + """ + Find the list of Hero's in the game and determine basic output by grouping them together. + """ + heroSummary( + """ + The id of the match replay upload team to include in this query, excluding + all results that do not include this match replay upload team id. + """ + matchReplayUploadTeamId: Int! + + """ + The request object filtering which match replay uploads to include in this + query, excluding all results that do not pass through this filter. + """ + request: FilterMatchReplayUploadRequestType + ): [MatchReplayUploadHeroSummaryType] +} From 787cfb36e43e002a721af9e8df14f25bbd4d153b Mon Sep 17 00:00:00 2001 From: Stefano Pigozzi Date: Sat, 19 Oct 2024 02:43:13 +0200 Subject: [PATCH 3/7] Fix multiple `Long` definitions in the old schema --- graphql/2022-03-29-schema-stratz.gql | 2 -- 1 file changed, 2 deletions(-) diff --git a/graphql/2022-03-29-schema-stratz.gql b/graphql/2022-03-29-schema-stratz.gql index 12eb1fd..0a93d76 100644 --- a/graphql/2022-03-29-schema-stratz.gql +++ b/graphql/2022-03-29-schema-stratz.gql @@ -3573,8 +3573,6 @@ type LobbyTypeType { name: String } -scalar Long - enum MapLocationEnums { RADIANT_BASE RADIANT_OFF_LANE From 9f2b8800868c1cf7ae98b5d5703668b769ccf367 Mon Sep 17 00:00:00 2001 From: Stefano Pigozzi Date: Sat, 19 Oct 2024 04:06:08 +0200 Subject: [PATCH 4/7] Add basic GraphQL functionality --- .gitignore | 1 + deno.json | 9 +- deno.lock | 172 +- graphql/2022-03-29-schema-stratz.gql | 8551 -------------------------- src/graphql/stratz.ts | 70 + tests/graphql_test.ts | 30 + tests/main_test.ts | 6 - 7 files changed, 276 insertions(+), 8563 deletions(-) delete mode 100644 graphql/2022-03-29-schema-stratz.gql create mode 100644 src/graphql/stratz.ts create mode 100644 tests/graphql_test.ts delete mode 100644 tests/main_test.ts diff --git a/.gitignore b/.gitignore index e69de29..e0f5bbd 100644 --- a/.gitignore +++ b/.gitignore @@ -0,0 +1 @@ +local.* \ No newline at end of file diff --git a/deno.json b/deno.json index 6f1df61..72b9c7f 100644 --- a/deno.json +++ b/deno.json @@ -1,11 +1,12 @@ { "imports": { + "@@npm/ioredis": "npm:ioredis@^5.4.1", "@fedify/fedify": "jsr:@fedify/fedify@^1.0.2", "@fedify/redis": "jsr:@fedify/redis@^0.3.0", - "@logtape/logtape": "jsr:@logtape/logtape@^0.6.3", - "@std/assert": "jsr:@std/assert@1", "@hongminhee/x-forwarded-fetch": "jsr:@hongminhee/x-forwarded-fetch@^0.2.0", - "@@npm/ioredis": "npm:ioredis@^5.4.1" + "@logtape/logtape": "jsr:@logtape/logtape@^0.6.3", + "@opentelemetry/api": "npm:@opentelemetry/api@^1.9.0", + "@std/assert": "jsr:@std/assert@1" }, "unstable": [ "temporal" @@ -32,4 +33,4 @@ "singleQuote": false, "useTabs": true } -} \ No newline at end of file +} diff --git a/deno.lock b/deno.lock index 428a561..6c220c6 100644 --- a/deno.lock +++ b/deno.lock @@ -2,6 +2,7 @@ "version": "3", "packages": { "specifiers": { + "jsr:@fedify/fedify@^1.0.0": "jsr:@fedify/fedify@1.0.2", "jsr:@fedify/fedify@^1.0.2": "jsr:@fedify/fedify@1.0.2", "jsr:@fedify/redis@^0.3.0": "jsr:@fedify/redis@0.3.0", "jsr:@hongminhee/x-forwarded-fetch@^0.2.0": "jsr:@hongminhee/x-forwarded-fetch@0.2.0", @@ -9,11 +10,15 @@ "jsr:@hugoalh/is-string-singleline@1.0.2": "jsr:@hugoalh/is-string-singleline@1.0.2", "jsr:@logtape/logtape@^0.6.2": "jsr:@logtape/logtape@0.6.3", "jsr:@logtape/logtape@^0.6.3": "jsr:@logtape/logtape@0.6.3", + "jsr:@std/assert@1": "jsr:@std/assert@1.0.6", "jsr:@std/bytes@^1.0.2": "jsr:@std/bytes@1.0.2", "jsr:@std/encoding@^1.0.5": "jsr:@std/encoding@1.0.5", "jsr:@std/http@^1.0.6": "jsr:@std/http@1.0.8", + "jsr:@std/internal@^1.0.4": "jsr:@std/internal@1.0.4", "jsr:@std/semver@^1.0.3": "jsr:@std/semver@1.0.3", + "npm:@opentelemetry/api@^1.9.0": "npm:@opentelemetry/api@1.9.0", "npm:@phensley/language-tag@^1.9.0": "npm:@phensley/language-tag@1.9.0", + "npm:@types/node": "npm:@types/node@18.16.19", "npm:asn1js@^3.0.5": "npm:asn1js@3.0.5", "npm:ioredis@^5.4.1": "npm:ioredis@5.4.1", "npm:json-canon@^1.0.1": "npm:json-canon@1.0.1", @@ -48,7 +53,9 @@ "@fedify/redis@0.3.0": { "integrity": "48068af7ad24d4f6c6935d6f869659faeb92281a9e796921f9ba7d94e74f8cfc", "dependencies": [ - "jsr:@logtape/logtape@^0.6.3" + "jsr:@fedify/fedify@^1.0.0", + "jsr:@logtape/logtape@^0.6.3", + "npm:ioredis@^5.4.1" ] }, "@hongminhee/x-forwarded-fetch@0.2.0": { @@ -66,6 +73,12 @@ "@logtape/logtape@0.6.3": { "integrity": "64cac3459fddf0455b85d36c8ca3e21764d6b2965c426fb40a0e4a98be436d2b" }, + "@std/assert@1.0.6": { + "integrity": "1904c05806a25d94fe791d6d883b685c9e2dcd60e4f9fc30f4fc5cf010c72207", + "dependencies": [ + "jsr:@std/internal@^1.0.4" + ] + }, "@std/bytes@1.0.2": { "integrity": "fbdee322bbd8c599a6af186a1603b3355e59a5fb1baa139f8f4c3c9a1b3e3d57" }, @@ -75,6 +88,9 @@ "@std/http@1.0.8": { "integrity": "6ea1b2e8d33929967754a3b6d6c6f399ad6647d7bbb5a466c1eaf9b294a6ebcd" }, + "@std/internal@1.0.4": { + "integrity": "62e8e4911527e5e4f307741a795c0b0a9e6958d0b3790716ae71ce085f755422" + }, "@std/semver@1.0.3": { "integrity": "7c139c6076a080eeaa4252c78b95ca5302818d7eafab0470d34cafd9930c13c8" } @@ -104,12 +120,20 @@ "integrity": "sha512-1j6kQFb7QRru7eKN3ZDvRcP13rugwdxZqCjbiAVZfIJwgj2A65UmT4TgARXGlXgnRkORLTDTrO19ZErt7+QXgA==", "dependencies": {} }, + "@opentelemetry/api@1.9.0": { + "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==", + "dependencies": {} + }, "@phensley/language-tag@1.9.0": { "integrity": "sha512-nj2uFsnp2SSD/DEGvLqcrpTXerIe9yShGndnwY7p3Z6Ep4m6+GkrgZCNJUc8rKcXWgQmRGC2TUzwG/LlBVtuCA==", "dependencies": { "tslib": "tslib@2.7.0" } }, + "@types/node@18.16.19": { + "integrity": "sha512-IXl7o+R9iti9eBW4Wg2hx1xQDig183jj7YLn8F7udNceyfkbn1ZxmzZXuak20gR40D7pIkIY1kYGx5VIGbaHKA==", + "dependencies": {} + }, "abort-controller@3.0.0": { "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==", "dependencies": { @@ -336,7 +360,150 @@ } } }, - "remote": {}, + "redirects": { + "https://cdn.esm.sh/extract-files@12.0.0/extractFiles.mjs": "https://esm.sh/extract-files@12.0.0/extractFiles.mjs", + "https://cdn.esm.sh/extract-files@12.0.0/isExtractableFile.mjs": "https://esm.sh/extract-files@12.0.0/isExtractableFile.mjs", + "https://esm.sh/v135/@types/extract-files@latest/extractFiles~.d.ts": "https://esm.sh/v135/@types/extract-files@13.0.1/extractFiles~.d.ts", + "https://esm.sh/v135/@types/extract-files@latest/isExtractableFile~.d.ts": "https://esm.sh/v135/@types/extract-files@13.0.1/isExtractableFile~.d.ts" + }, + "remote": { + "https://deno.land/x/graphql_deno@v15.0.0/lib/error/GraphQLError.js": "18adbba7aa651770e0876d0c7df4e6e2ab647a9f09d4b5c107c57d6fa157be9d", + "https://deno.land/x/graphql_deno@v15.0.0/lib/error/formatError.js": "aec87433c501df6d6272b64974e8edf53b2ed192e66782b827328d635ed55df8", + "https://deno.land/x/graphql_deno@v15.0.0/lib/error/index.js": "7557dcea8830550f82dd7b1984fdc216e14327d094f501bd2a03f80bf609a768", + "https://deno.land/x/graphql_deno@v15.0.0/lib/error/locatedError.js": "65ad5e9246747d2b63cd2ea48fa22db617e1c7c2b796a27b8ce32bfb0f2a401c", + "https://deno.land/x/graphql_deno@v15.0.0/lib/error/syntaxError.js": "9c53411030cf5f4e874e9d1c1926f242e4acc4b469197b395ae1a9a7a9092055", + "https://deno.land/x/graphql_deno@v15.0.0/lib/execution/execute.js": "2d3114e49268a50195195039cc14629b0fe3dff7afeafed9876f1532a95ed4e7", + "https://deno.land/x/graphql_deno@v15.0.0/lib/execution/index.js": "064615af63e0da1584c557ce130b3ca42acab750289a085ebcc3107aa024ce52", + "https://deno.land/x/graphql_deno@v15.0.0/lib/execution/values.js": "e9a42ff1593db210a47504eebcc145f70f8d97cfe53c4cce345116bb420fbf95", + "https://deno.land/x/graphql_deno@v15.0.0/lib/graphql.js": "c34b19e78a57ad0a0ac9b39ec2766ab755b23e61ea08edf124dda1d60104ae54", + "https://deno.land/x/graphql_deno@v15.0.0/lib/index.js": "ab428112340017d5b1f74e62f958cf0c50c17b664a33be53974ab8738a531c1c", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/Path.js": "28322158c8208f92d376969de58c30ea393aada1beb44223d40584d8d89285c0", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/defineToJSON.js": "5423bbfe56faf7c3b0cda65b515c7fcc0e111bef46da9f76fed93eaba1859149", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/devAssert.js": "7493987e163c294b31f354091b6ca5e87849a132aa3aad8e3c173ac008c8e970", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/didYouMean.js": "9b83a8fe7bdd5b02012c097de14a0fe08a5e33662624ce55eb0019f46067b974", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/identityFunc.js": "204f973b6a5fc6f60ea62641e58eed254f0bb7d76b2b05e9c0bae54dc7cd324a", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/inspect.js": "bb756ad067f23b137b63bb2dabc4e50b070255da2ff10068d9f0a174dd5f3aae", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/instanceOf.js": "c2940e2f0c71ed73390ab03ceb04484c40a4f5f28973709702c8279b1b6f96cd", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/invariant.js": "b8d3e8438abe0ec591fdc3a3f0f9c2d7750925738ee146ba7a18173a8f2dc1cb", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/isCollection.js": "42ffc930d5982ec031b4a7f29db9fd7f3a9e488ca0ceb73183a51a67ad146e2b", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/isObjectLike.js": "96403248d91ae55fa67ce81d339bec098aa51e5fc7132eae3f8dcce91ac340ce", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/isPromise.js": "dbe9979b7d4ffd920d8a608a9ce7127b943b130822cd907d78b9e56e66843509", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/keyMap.js": "4e54790d45a13998d198b0b7b1bc20ae17259e8131c29821d67e64b96dcb249e", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/keyValMap.js": "515ebb0c4be9c26f8fa38b7e0db4f2ebf96057196a8fcd52078046f05bf4e4e0", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/mapValue.js": "5df0be208d71e372a693ef305287a8f041b061a293cff030aa10bef4c2735981", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/memoize3.js": "4212fbf3f75fc8625a8312b18e0b2907efaf9cf6b8131c78a731a707ba638c74", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/nodejsCustomInspectSymbol.js": "eb85744be5bab6c4511556b095198b45259b2c020ff2f88f3b04197acc9feb01", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/printPathArray.js": "15110572999ddb82bcde2e42a35092d18fa601f5b8312e5823bd43d48f9b773f", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/promiseForObject.js": "b82720027d9bf3b81f302baa8d72f80b5d04f2069ebb538875f22993be83ee11", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/promiseReduce.js": "178a7c704a3c124a68a60aa71f29fb078268e403dab310b41937d10f5bb55e01", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/suggestionList.js": "4504e10e0e9b230cd697ebcf1ffae9b2ae420db2927a44dfbab452558e2f4b4a", + "https://deno.land/x/graphql_deno@v15.0.0/lib/jsutils/toObjMap.js": "482c18508c808bca6a8e657ab7e3dfacadbf9f78603ce452700199d02f1b9d32", + "https://deno.land/x/graphql_deno@v15.0.0/lib/language/ast.js": "faa944fc543e4997c82302a6230c190eaf72bfcca1b8db3b29502826bdf9e9bb", + "https://deno.land/x/graphql_deno@v15.0.0/lib/language/blockString.js": "413ad9886dee36a96875cea8bbb51763b1ab8f1c3e82b8468330e8a5ca877852", + "https://deno.land/x/graphql_deno@v15.0.0/lib/language/directiveLocation.js": "8500c3878eafe0142f1b1255a998e76b20d3f859d9016ef9f7252878926dfdd8", + "https://deno.land/x/graphql_deno@v15.0.0/lib/language/index.js": "9289b05fbe173c54e727465996239a3bce6057fb727677ca44af37d60409480d", + "https://deno.land/x/graphql_deno@v15.0.0/lib/language/kinds.js": "7bdebb8110e7345fe6c14f255225d7c9b5448fb2dd53ea91d035a4b2e1e8f72b", + "https://deno.land/x/graphql_deno@v15.0.0/lib/language/lexer.js": "68bf4d832a8d1b4af3a0432ad308bc6f3ffbf60eb1c4e786503b30aff7e17564", + "https://deno.land/x/graphql_deno@v15.0.0/lib/language/location.js": "9994a20bee8d97ff69781b35477f596a3e6bee9ac1d914340e435bc0298922ee", + "https://deno.land/x/graphql_deno@v15.0.0/lib/language/parser.js": "53af901714fda7e62137fe2fe9eccecb4945a8648cffbb93ace439a0e445f05e", + "https://deno.land/x/graphql_deno@v15.0.0/lib/language/predicates.js": "cfd7e10b724590b618f67845ce1d1ca712b7da5943622b40881e7653f5557ab7", + "https://deno.land/x/graphql_deno@v15.0.0/lib/language/printLocation.js": "26b21c32abaee20e11a072984c381384dd5645be50bcbbdb59bac435490a60e9", + "https://deno.land/x/graphql_deno@v15.0.0/lib/language/printer.js": "a2da61f578725d78182fadfdc0ce809c30ed7d6b8369b98b1606b68b0e949b39", + "https://deno.land/x/graphql_deno@v15.0.0/lib/language/source.js": "e2a870f2446abf092996453d87f98214f12898e83980b76706cc8160993f16a8", + "https://deno.land/x/graphql_deno@v15.0.0/lib/language/tokenKind.js": "ad57e9dddaca5336e49a715b710c8142d9ff963270f3d4d6b63348a482922a74", + "https://deno.land/x/graphql_deno@v15.0.0/lib/language/visitor.js": "47b0a0f0d2f1e1edbf18a4b26861d371c41c0bfebf7c3f9ccb2e423663184dcd", + "https://deno.land/x/graphql_deno@v15.0.0/lib/polyfills/arrayFrom.js": "b57194d34b98ac5926ae83e0a83e884d63ee9ec2d2ae3e846f1783cb26f6dbf8", + "https://deno.land/x/graphql_deno@v15.0.0/lib/polyfills/find.js": "30ebdb4e2cd0ed5b0e3e4a00877f2bd2ac62de6d70a4c63152021fe724e41911", + "https://deno.land/x/graphql_deno@v15.0.0/lib/polyfills/flatMap.js": "29d62564cd9745536e366e09b7f6cbe8860d8423c00ca253ae6cbfba839f2fc6", + "https://deno.land/x/graphql_deno@v15.0.0/lib/polyfills/isFinite.js": "231e2d149aa58e8288b6cf86f588a1597f3f8d432928a17af9c348b48bd8ddde", + "https://deno.land/x/graphql_deno@v15.0.0/lib/polyfills/isInteger.js": "0b68164ae12c46b16e439a5384af0c8c395f5c941e0f03fb71ee2ee9cb45fae6", + "https://deno.land/x/graphql_deno@v15.0.0/lib/polyfills/objectEntries.js": "c261873f15f88ecb1497427844a9afc541168a92b7d75d69446732a0d381c819", + "https://deno.land/x/graphql_deno@v15.0.0/lib/polyfills/objectValues.js": "7c3ed07793a1685cf018fa028275ff556213ba953c43dd2410bb549a86ee801b", + "https://deno.land/x/graphql_deno@v15.0.0/lib/polyfills/symbols.js": "bbe907378637a4264484590815d80563cfbd8a8a5f396ac9d2be4107658e5bf7", + "https://deno.land/x/graphql_deno@v15.0.0/lib/subscription/index.js": "3c2e03b8225f66a541d870fb6729ad2e3afbd923a0d07713a087c22d134097b3", + "https://deno.land/x/graphql_deno@v15.0.0/lib/subscription/mapAsyncIterator.js": "ff581dcfccf8aeedfefe1c42a8f01c7898c1a2b093e5f6fb4d2e62b2f83ab8c8", + "https://deno.land/x/graphql_deno@v15.0.0/lib/subscription/subscribe.js": "f4d316d4f7e3e60cc3f9f8371e6122396653ff1836a27d44a3e8bf1cfa3d5def", + "https://deno.land/x/graphql_deno@v15.0.0/lib/type/definition.js": "94ef1069f5e034f9dc34ca7f25370fe81a58365acbb6e932ab9e0db92efe8287", + "https://deno.land/x/graphql_deno@v15.0.0/lib/type/directives.js": "d4614736de1997413a4970b73865c99d3b01922eda3de1e587c27c25c24e8892", + "https://deno.land/x/graphql_deno@v15.0.0/lib/type/index.js": "4a7d837f30c56cf3074ee527f4b9388d160ad20cd545d4fdebac500acdf102b0", + "https://deno.land/x/graphql_deno@v15.0.0/lib/type/introspection.js": "c63b4c5a578d76f8d159837ce531e1193dd3a2629148aedb895b511141303afd", + "https://deno.land/x/graphql_deno@v15.0.0/lib/type/scalars.js": "d447913dbdcaaa32f2eaa5d86bd39b5342bfcf78d9ddd6b2173ad717ae7fa734", + "https://deno.land/x/graphql_deno@v15.0.0/lib/type/schema.js": "1c92f80cc2c1f0a14a5b3fcb13d55f215f14e1b2bb7b92c2674ede22f969f033", + "https://deno.land/x/graphql_deno@v15.0.0/lib/type/validate.js": "f8300538e4327b46959ff83a7dabd55e42148ef07fa66c79f72b308a46cfd369", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/TypeInfo.js": "03276253d0ab3d4947f7bf63ca4ccc4fe0073f73063952103530f8193a98e546", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/assertValidName.js": "d6b44f4dddcc50ebe92c7cb9b94ecc9b27627994b3c156ce63d33279c7f7d0e4", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/astFromValue.js": "d460204b065b8e1036e215faa9a617a20c268e687ed424208dabc5cd5f40f2d1", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/buildASTSchema.js": "d4aeade98d0a1bc6ffdc160fdc78e9edf22a9efdc550cdc6121d1c83ff1e6c84", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/buildClientSchema.js": "1ac64f6aacdf57e9b552a0c45e7176c988c0d97310f646d7d048899524856d3a", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/coerceInputValue.js": "ee59bf0ed0857af92c4f40a309365fd57770821b3c788b6b13d0d1051ffec0da", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/concatAST.js": "bf410b42f7aa015ff0cd938623894906ac19329d9cd9a2298cf97de7cb01442a", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/extendSchema.js": "802fbd291d21cfa97c1ebea4fa6528ac6cddbbcc27c169942c975ce708a9f295", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/findBreakingChanges.js": "2c8dfd8acf617e5d8a96e389ba6bccb0845fc4470f680957a1ca64514337574a", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/findDeprecatedUsages.js": "5a5366e6ed3c99e16d73b1235ee9062ac10d3ec16afafc4d6c4f635cc12370f6", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/getIntrospectionQuery.js": "81125e8afec11871bf532dff9dd523016292c5a57f84d0c04a142a6704ba1572", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/getOperationAST.js": "5fef27e56f708c5336a78e611f08627122a6673d10ea1db6f5466c6f984ad9a2", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/getOperationRootType.js": "58addddae7feabecce40191d836f7e65a9478cf0d9df6c360c4c30e6f5f6f09c", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/index.js": "d0e34dcf95627362527e93e7eaa970caee63b40ed04ff1da320b6426484c8278", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/introspectionFromSchema.js": "50a2202f28b25e98bc496f151de8fc6b2feeb81bab9739fee97f66ac30ef8652", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/lexicographicSortSchema.js": "ad2b935289966fc75700a3b511b86e79130d505399b0c2de052e9915624e2c2a", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/printSchema.js": "104a4666bf3e745ad1fbd30c227d3e06902a2b255c95e29183dcd6d98fad76be", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/separateOperations.js": "ac7e7789fddc0fcf2b439897fce86601a16c6d3f4e20b7f6837278bcf1c36a56", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/stripIgnoredCharacters.js": "be44c652bfa218b18e5d4387a068d2e431d75e770ddc38ced6eb95a0b8854eab", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/typeComparators.js": "dcda7fffeaf3999bfd993a4faac36547dace3ec3f78d7686f4334f86a6c3aec0", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/typeFromAST.js": "99cd615599626259b8e2b9974e22bf8beb495f541b20d78f4a01d48de2f97942", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/valueFromAST.js": "26098b7e5074d408f877f8b4566e6183cd77f076ee2e3f1413e53c4677e150ce", + "https://deno.land/x/graphql_deno@v15.0.0/lib/utilities/valueFromASTUntyped.js": "9db575f95392635bb02dc417d920e9ae6552b2fa871b19e94ad0cc9ceb83c892", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/ValidationContext.js": "52808fc712f4ef50f79edcb30cb907721e449b55c54225551d2ad09660351dba", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/index.js": "1b91224c90bae4b49c6b8227c190c34cb3600433423c257a672801e12910c06d", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/ExecutableDefinitionsRule.js": "f94c0c866335d1c249d08efa55da0dd6e5954844fa7851b6a0d6b3cd86383819", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/FieldsOnCorrectTypeRule.js": "587eb8a9e7376e58ea6a0bbb12585ca45621a0be102dc7e6c641adee9652e91d", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/FragmentsOnCompositeTypesRule.js": "6a6172831b4e7e6431af810505e23bdf82b7f46d92cfe719226c549a36a75b92", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/KnownArgumentNamesRule.js": "2ab0571f6a6b9c5486b76a09955efde97ef3ff7e9cc06ecfcec8e1f830b8e79b", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/KnownDirectivesRule.js": "57f4c9df617702d3695c3010f6822641b4c7343c65a4873bab6b29c911424e2c", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/KnownFragmentNamesRule.js": "24273c31aa208652113a2e635853c336227a2756fc642ece6e977bd9c4ccb094", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/KnownTypeNamesRule.js": "b600453083f32688c43f2225399439b4f6312903397572b947ea4fc80ac17b52", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/LoneAnonymousOperationRule.js": "ec860c3ce338509b1e407c5cea36aa6e97e34ed207e5cdf719d6f7fa4026398c", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/LoneSchemaDefinitionRule.js": "d3e40186003d89bd45c751156a6df69af6970beb5493c891cd79e1eaab734968", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/NoFragmentCyclesRule.js": "1445f37ad14819d117371c70acdc725459d89b9a8773dd2c15e131f5d71b92ac", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/NoUndefinedVariablesRule.js": "7aaf4409398526fef667fa6cede56b60824166409247b62c2f74b2c4a1ea5497", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/NoUnusedFragmentsRule.js": "9d1c9b11d6287f077cff8661c704f9aa0fdf53de0b4894c4e7fe29597a32a704", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/NoUnusedVariablesRule.js": "8d477bdbc19eb02556e7899b97b147511ccb69777ae29136c12e2f49d6c7a264", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/OverlappingFieldsCanBeMergedRule.js": "5f74a4c076f8c18ce6371bfda2d213c4461655f830fb506569a1cc71faa56e96", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/PossibleFragmentSpreadsRule.js": "0bf927e91d4103c630ef3a10b586586ababb1412874917fed1b5b908d40bc54b", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/PossibleTypeExtensionsRule.js": "2c1f8a1371656ff8c992d0e4df5500ecb36475286b5f131d9a880018baf00c73", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/ProvidedRequiredArgumentsRule.js": "03d3af937d5e08c544a10911770f0660ed6eb18d2b8877acc677aac90583f86e", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/ScalarLeafsRule.js": "374bba26d4e9e085560ef20179604955ae191e7c68c85f2f1905fb68686bc079", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/SingleFieldSubscriptionsRule.js": "8a748eb20d1b21fee38aaeae7b368893f113b5b35bbd0fd94c22df072d23e0be", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/UniqueArgumentNamesRule.js": "fe7fafd8d4a5efe66f0d690ef868f55f46c78512cf98abc1bd6ab4c175b86d79", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/UniqueDirectiveNamesRule.js": "6664f72231dfa4fa4337ffeed4868a95e91970825bd45f77d7d4f92bcb49bb50", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/UniqueDirectivesPerLocationRule.js": "0aedfb8194bd8630b84e344a8ff0f6572bb169ad290a18c8391000324c4d8a03", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/UniqueEnumValueNamesRule.js": "fbfec070d1c6ca58514f0e459b7dc5c8fe505d81bd1323509802d65db1463272", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/UniqueFieldDefinitionNamesRule.js": "3da7356eaaf7ae41bf5b86c7c55c4049b962bd9d5339252a90cc46538714b694", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/UniqueFragmentNamesRule.js": "523f0dfeb1ab059bd396d240376e3b602d32405826dd53d8b2e575aaebd7c055", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/UniqueInputFieldNamesRule.js": "433e878697932b4b5cd82dc9282f10650d568360afcd68a6130b9a54ef21e7f1", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/UniqueOperationNamesRule.js": "1de59fc010ff56ef74c856d23f949c523de78f299e9aa7c6d882f1f49959e3be", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/UniqueOperationTypesRule.js": "2faa2b9c0e9c0197f053162e1356dbfa819e02f0c294271873576ac4ea5786fc", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/UniqueTypeNamesRule.js": "d01564b48843b9a316b314f1f9079a25d381bbe02bb47bc47dca0a144fdb596f", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/UniqueVariableNamesRule.js": "5522d2278b64aaf70c30d0dc5e37f70bdbde0201bd6c06c136e0d9d50b0a3c4a", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/ValuesOfCorrectTypeRule.js": "f50002aac89fa875cfb594c7696d0d6eaa8ad39d699e3d0550cda34799797faa", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/VariablesAreInputTypesRule.js": "13337bf58985546627c8060c3ff1201dd21bb6d67e5293819ad0eefa8196a144", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/rules/VariablesInAllowedPositionRule.js": "3032c0af7f9287cb10230685807e1460f12775e24ac76f88496769ad0acc43f0", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/specifiedRules.js": "0e2f6954eb79701a15731f528209a5616ee028133cbf7d4fbecb4e88ac5028c5", + "https://deno.land/x/graphql_deno@v15.0.0/lib/validation/validate.js": "44bf2bc96845af0bf77e4421f0a05ee57cdc2a688abb32ff6270eacc501327d1", + "https://deno.land/x/graphql_deno@v15.0.0/lib/version.js": "a135d0beee3fa1405733453e86f1c887e4771d56357504dd78eaa872c0a2b482", + "https://deno.land/x/graphql_deno@v15.0.0/mod.ts": "c85d6ab2a9c22ff494bfaa5f662507249650419af6c6c27a7a5c8175de61870d", + "https://deno.land/x/graphql_request@v4.1.0/mod.ts": "a24c6f401b8253bb84c773583bf2b37b1b74eec960639f36eb874ca17972f9e7", + "https://deno.land/x/graphql_request@v4.1.0/src/createRequestBody.ts": "80b40c902de346622c222a068c4f96679a1bb3233c9b31d728518566ca4e679a", + "https://deno.land/x/graphql_request@v4.1.0/src/index.ts": "15194aba3fdfc1ba896e7fcf9c11227dd1962b635c7d2101e23ed2e0a57cd900", + "https://deno.land/x/graphql_request@v4.1.0/src/parseArgs.ts": "d00abde98728be96c902debd7ee5032b05f69fb6bb00f86a2b5adf09159541aa", + "https://deno.land/x/graphql_request@v4.1.0/src/types.dom.ts": "56432fd7ce0aff31542ec7198ff1a3ea5e3d62fda009510f78bf9c0fc47af13e", + "https://deno.land/x/graphql_request@v4.1.0/src/types.ts": "63a98d9f8efb1d6a580bbef62861c764f0f0b0d3dda04674f4d9a32d6490440b", + "https://esm.sh/extract-files@12.0.0/extractFiles.mjs": "58e5f1fcf50e3a362d9bde0e2c1a624a7d89d60ac2de005afd895d0d452cca62", + "https://esm.sh/extract-files@12.0.0/isExtractableFile.mjs": "2757358bbc9141b93cb27d7e0ba98c1e703172dd58fb7d533a31476419d2416f", + "https://esm.sh/v135/extract-files@12.0.0/denonext/extractFiles.js": "59b30d503c5d9ce135dd76c34ac92cf7e9f85cd129d6be2ff61553bb612ac75f", + "https://esm.sh/v135/extract-files@12.0.0/denonext/isExtractableFile.js": "93462c162e29fc0e8fd7e9de3665dfd7705f03d41d2721d654f177bc2a7fe305", + "https://esm.sh/v135/is-plain-obj@4.1.0/denonext/is-plain-obj.mjs": "d3d86a7174ad7935de7b00f904b6424c103bce530c502efb7f42114cbb1a555f" + }, "workspace": { "dependencies": [ "jsr:@fedify/fedify@^1.0.2", @@ -344,6 +511,7 @@ "jsr:@hongminhee/x-forwarded-fetch@^0.2.0", "jsr:@logtape/logtape@^0.6.3", "jsr:@std/assert@1", + "npm:@opentelemetry/api@^1.9.0", "npm:ioredis@^5.4.1" ] } diff --git a/graphql/2022-03-29-schema-stratz.gql b/graphql/2022-03-29-schema-stratz.gql deleted file mode 100644 index 0a93d76..0000000 --- a/graphql/2022-03-29-schema-stratz.gql +++ /dev/null @@ -1,8551 +0,0 @@ -schema { - query: DotaQuery - mutation: DotaMutation - subscription: DotaSubscription -} - -scalar Int -scalar Long -scalar String -scalar Boolean -scalar Float - -type AbilityActiveListType { - time: Int! - ability0: Short - ability1: Short - ability2: Short - ability3: Short - ability4: Short - ability5: Short - ability6: Short - ability7: Short -} - -type AbilityAttributeType { - name: String - value: String - linkedSpecialBonusAbilityId: Short - requiresScepter: Boolean! -} - -type AbilityCustomGameLanguageType { - displayName: String - description: String -} - -type AbilityCustomGameType { - id: Short - name: String - abilityName: String - language: AbilityCustomGameLanguageType -} - -enum AbilityDispellEnum { - NONE - NO - YES - YES_STRONG -} - -type AbilityLanguageType { - displayName: String - description: [String] - attributes: [String] - lore: String - aghanimDescription: String - shardDescription: String - notes: [String] -} - -type AbilityLearnEventsType { - time: Int! - abilityId: Short - levelObtained: Int! - level: Int! - isUltimate: Boolean - isTalent: Boolean - isMaxLevel: Boolean -} - -type AbilityStatType { - abilityId: Short - type: Int - behavior: Long - unitTargetType: Long - unitTargetTeam: Int - unitTargetFlags: Long - unitDamageType: Int - spellImmunity: Int - modifierSupportValue: Float - modifierSupportBonus: Short - isOnCastbar: Boolean - isOnLearnbar: Boolean - fightRecapLevel: Short - isGrantedByScepter: Boolean - hasScepterUpgrade: Boolean - maxLevel: Byte - levelsBetweenUpgrades: Byte - requiredLevel: Byte - hotKeyOverride: String - displayAdditionalHeroes: Boolean - castRange: [Int] - castRangeBuffer: [Int] - castPoint: [Float] - channelTime: [Float] - cooldown: [Float] - damage: [Float] - manaCost: [Float] - isUltimate: Boolean - duration: String - charges: String - chargeRestoreTime: String - isGrantedByShard: Boolean - dispellable: AbilityDispellEnum -} - -type AbilityType { - id: Short - name: String - uri: String - language: AbilityLanguageType - stat: AbilityStatType - attributes: [AbilityAttributeType] - drawMatchPage: Boolean - isTalent: Boolean -} - -type AbilityUsedEventsType { - time: Int! - abilityId: Short - attacker: Short - target: Short -} - -type AdminMutation { - mergeProSteamAccount(request: [MergeProSteamAccountRequestType]!): Boolean - deleteProSteamAccount(request: DeleteProSteamAccountRequestType!): Boolean -} - -type AdminQuery { - """Returns a list of Stratz blogs.""" - apiMemoryReport: [String] -} - -type AssistDetailType { - time: Int! - attacker: Short - target: Short - gold: Int - xp: Int - subTime: Int - positionX: Int - positionY: Int -} - -enum BasicRegionType { - CHINA - SEA - NORTH_AMERICA - SOUTH_AMERICA - EUROPE -} - -type BlogMetaTagInfoType { - id: Short - name: String! -} - -type BlogMetaTagType { - id: Byte - blogId: Byte - blogMetaTagTypeId: Short - metaTag: BlogMetaTagInfoType -} - -type BlogType { - id: Byte - captainJackIdentityId: Guid - title: String! - bannerImageUrl: String! - poster: SteamAccountType - data: String! - liveDateTime: DateTime - metaTags: [BlogMetaTagType] - link: String! -} - -enum BuildingType { - FORT - TOWER - BARRACKS - HEALER - OUTPOST -} - -type BuyBackDetailType { - time: Int! - heroId: Short - deathTimeRemaining: Int! - cost: Int! -} - -scalar Byte - -type CaptainJackIdentityApiApplicationType { - captainJackIdentityId: Guid - tokenType: StratzApiType - emailAddress: String - discordAddress: String - websiteAddress: String - description: String - isApproved: Boolean - apiKey: String - secretKey: String - issuer: String - matomoReferenceToken: String -} - -type CaptainJackIdentityPrivateProfileType { - captainJackIdentityId: Guid - name: String - email: String - twitter: String - facebook: String - twitch: String - youTube: String - premiumEndDate: Long - isAdmin: Boolean - feedLevel: Byte - emailLevel: Byte - dailyEmail: Boolean! - weeklyEmail: Boolean! - monthlyEmail: Boolean! - proCircuitFeedLevel: Byte - proCircuitEmailLevel: Byte - themeType: Byte - languageId: Byte - emailValidationCode: String - isEmailValidated: Boolean! - emailHour: Byte - lastReadFeedTime: Long - lastDailyEmail: Long - lastWeeklyEmail: Long - lastMonthlyEmail: Long - lastLeagueDailyEmail: Long - lastTeamDailyEmail: Long - lastProCircuitDailyEmail: Long - unsubscribeCode: String - lastSeen: Long -} - -input CaptainJackIdentityProfileUpdateRequestType { - email: String - feedLevel: Byte - emailLevel: Byte - dailyEmail: Boolean - weeklyEmail: Boolean - monthlyEmail: Boolean - proCircuitFeedLevel: Byte - proCircuitEmailLevel: Byte - themeType: Byte - languageId: Byte - emailHour: Byte - isStratzAnonymous: Byte -} - -type CaptainJackIdentityPublicProfileType { - captainJackIdentityId: Guid - name: String - twitter: String - facebook: String - twitch: String - youTube: String - isAdmin: Boolean -} - -type CaptainJackIdentityType { - id: Guid - steamAccountId: String - steamAccount: SteamAccountType - profile: CaptainJackIdentityPublicProfileType -} - -type ClusterType { - """ - ClusterId which determines in which region a match was played. One region has - multiple clusters. When selecting your region in the Dota 2 client, a random - cluster is provided to you for each match for load balancing purposes. - """ - id: Int - - """RegionId gives the exact geographical area where the match is played.""" - regionId: Short -} - -type ConstantQuery { - hero( - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - id: Short! - - """ - The game version id to include in this query, excluding all results that do not have this game version. - """ - gameVersionId: Short - - """ - The language id to include in this query, excluding all results that do not have this language. - """ - language: Language - ): HeroType - heroes( - """ - The game version id to include in this query, excluding all results that do not have this game version. - """ - gameVersionId: Short - - """ - The language id to include in this query, excluding all results that do not have this language. - """ - language: Language - ): [HeroType] - - """List of all the roles types for heroes.""" - roles: [RoleType] - - """Find item details by item id. id is a required input field.""" - item( - """ - The item id to include in this query, excluding all results that do not have this item. - """ - id: Int! - - """ - The game version id to include in this query, excluding all results that do not have this game version. - """ - gameVersionId: Short - - """ - The language id to include in this query, excluding all results that do not have this language. - """ - language: Language - ): ItemType - - """Find item details by item id. id is a required input field.""" - items( - """ - The game version id to include in this query, excluding all results that do not have this game version. - """ - gameVersionId: Short - - """ - The language id to include in this query, excluding all results that do not have this language. - """ - language: Language - ): [ItemType] - - """Find ability details by ability id. id is a required input field.""" - ability( - """ - The ability id to include in this query, excluding all results that do not have this ability. - """ - id: Int! - - """ - The game version id to include in this query, excluding all results that do not have this game version. - """ - gameVersionId: Short - - """ - The language id to include in this query, excluding all results that do not have this language. - """ - language: Language - ): AbilityType - - """Find ability details.""" - abilities( - """ - The game version id to include in this query, excluding all results that do not have this game version. - """ - gameVersionId: Short - - """ - The language id to include in this query, excluding all results that do not have this language. - """ - language: Language - ): [AbilityType] - - """ - Returns a list of game mode types which is directly supplied by Dota 2. Matches API call will have a input for this value. - """ - gameModes: [GameModeType] - - """ - Returns a list of lobby types which are mirrored from the Dota 2 client. - """ - lobbyTypes: [LobbyTypeType] - - """ - Provided directly from Dota 2 Region files, the cluster is the geographically breakdown of where the game is played. - """ - clusters: [ClusterType] - - """Returns a list of region details and an Id for reference.""" - regions: [RegionType] - - """ - Find game version details by game version id. id is a required input field. - """ - gameVersion( - """ - The game version id to include in this query, excluding all results that do not have this game version. - """ - id: Short! - ): GameVersionType - - """Find game version details.""" - gameVersions: [GameVersionType] - - """Find npc details by npc id. id is a required input field.""" - npc( - """ - The npc id to include in this query, excluding all results that do not have this npc. - """ - id: Short! - - """ - The game version id to include in this query, excluding all results that do not have this game version. - """ - gameVersionId: Short - ): NpcType - - """Find npc details.""" - npcs( - """ - The game version id to include in this query, excluding all results that do not have this game version. - """ - gameVersionId: Short - ): [NpcType] - - """ - Find all patch notes for each item and ability. These are found when you hover over each object in-game. - """ - patchNotes( - """ - The language id to include in this query, excluding all results that do not have this language. - """ - languageId: Language - ): [PatchNoteLanguageType] - - """ - Find all abilities that are used in custom events. For example Aghnims Labyrinth. - """ - customAbilities( - """ - The language id to include in this query, excluding all results that do not have this language. - """ - languageId: Language - ): [AbilityCustomGameType] - - """ - Find all modifiers that are used in the game. If you find a bug on a modifier, - let us know as we have to control this ourselves. - """ - modifiers( - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int - ): [ModifierType] - - """Find all players who Valve qualifies as a Pro Player or Streamer.""" - proSteamAccounts: [ProSteamAccountType] -} - -enum Damage { - PHYSICAL - MAGICAL - PURE -} - -""" -The `DateTime` scalar type represents a date and time. `DateTime` expects -timestamps to be formatted in accordance with the -[ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standard. -""" -scalar DateTime - -type DeathDetailType { - time: Int! - attacker: Short - isFromIllusion: Boolean - target: Short - byAbility: Short - byItem: Short - goldFed: Int - xpFed: Int - timeDead: Int - reliableGold: Int - unreliableGold: Int - positionX: Int - positionY: Int - goldLost: Int - assist: [Int] - isWardWalkThrough: Boolean - isAttemptTpOut: Boolean - isDieBack: Boolean - isBurst: Boolean - isEngagedOnDeath: Boolean - hasHealAvailable: Boolean - isTracked: Boolean - isFeed: Boolean -} - -scalar Decimal - -input DeleteProSteamAccountRequestType { - steamAccountId: Long - name: String - realName: String -} - -type DireTide2020CustomGameHeroWinDayType { - day: Long! - heroId: Short! - winCount: Int! - matchCount: Int! - candyScored: Int! -} - -type DireTide2020CustomGameMatchType { - id: Long - didRadiantWin: Boolean - durationSeconds: Short - startDateTime: Long - endDateTime: Long - clusterId: Short - replaySalt: Long - candyLost: Short - candyPickedUp: Short - candyScored: Short - radiantCandyScored: Short - direCandyScored: Short - players( - """ - The steam account id to include in this query, excluding all results that do not have this steam account id. - """ - steamAccountId: Long - ): [DireTide2020CustomGamePlayerType] -} - -type DireTide2020CustomGamePlayerType { - matchId: Long - playerSlot: Byte - steamAccountId: Long - steamAccount: SteamAccountType - isVictory: Boolean! - heroId: Short - hero: HeroType - kills: Byte - deaths: Byte - assists: Byte - leaverStatus: Byte - numLastHits: Short - goldPerMinute: Short - goldSpent: Int - level: Byte - heroDamage: Int - heroHealing: Int - networth: Int - item0Id: Short - item1Id: Short - item2Id: Short - item3Id: Short - item4Id: Short - item5Id: Short - backpack0Id: Short - backpack1Id: Short - backpack2Id: Short - - """ - The item id of the dedicated neutral item slot (7.24 and after). From game - versions 7.23 to 7.24, this was the BackPack3Id (the 4th backpack slot item id). - """ - neutral0Id: Short - partyId: Byte - candyLost: Short - candyPickedUp: Short - candyScored: Short -} - -type DotaMutation { - yogurt: YogurtMutation - user: DotaUserMutation - admin: AdminMutation -} - -type DotaNextQuery { - """ - Used by Overwolf application DotaNext (previously called DotaPlus) to provide data to its users. - """ - enemy( - """ - An array of steam account ids to limit the query to only return matches with these steam account ids. - """ - steamAccountIds: [Long]! - - """ - A steam account id found on your team to include in this query, excluding - all results that do not include this steam account id found on your team. - """ - matchSteamAccountId: Long! - ): [DotaNextWithAllyType] - - """ - Used by Overwolf application DotaNext (previously called DotaPlus) to provide data to its users. - """ - ally( - """ - An array of steam account ids to limit the query to only return matches with these steam account ids. - """ - steamAccountIds: [Long]! - - """ - A steam account id found on your team to include in this query, excluding - all results that do not include this steam account id found on your team. - """ - matchSteamAccountId: Long! - ): [DotaNextWithAllyType] - - """ - Used by Overwolf application DotaNext (previously called DotaPlus) to provide data to its users. - """ - playerHero( - """ - An array of steam account ids to limit the query to only return matches with these steam account ids. - """ - steamAccountIds: Long! - - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: Byte! - - """ - An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. - """ - lobbyTypeIds: Byte! - - """ - An array of item ids to include in this query, excluding all results that do not include one of these item ids. - """ - limitByItemIds: Int! - - """ - The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - startDateTime: Long! - ): [[MatchPlayerItemPurchaseEventType]] -} - -type DotaNextWithAllyType { - steamAccountId: Long - lifetimeMatchCount: Int - lifetimeWinMatchCount: Int -} - -type DotaPlusWeekType { - week: Long - active: Int - expired: Int -} - -type DotaQuery { - """Find match details by the match id. id is a required input field.""" - match( - """ - The id of the Dota match to include in this query, excluding all results that do not include this id. - """ - id: Long! - ): MatchType - - """Find match details for each match id. ids is a required input field.""" - matches( - """An array of Dota match ids to include in this query.""" - ids: [Long]! - ): [MatchType] - - """Find player details by steam account id. id is a required input field.""" - player( - """ - The steam account id to include in this query, excluding all results that do not have this steam account id. - """ - steamAccountId: Long! - ): PlayerType - - """ - Find player details for each steam account id. ids is a required input field. - """ - players( - """ - An array of steam account ids to limit the query to only return matches with these steam account ids. - """ - steamAccountIds: [Long]! - ): [PlayerType] - - """ - Find player details for each steam account id. ids is a required input field. - """ - team( - """ - A team id to include in this query, excluding all results that do not have this team id. - """ - teamId: Int! - ): TeamType - - """ - Results in a list of team objects that contain data about them and their players. - """ - teams( - """ - A team id to include in this query, excluding all results that do not have this team id. - """ - teamIds: [Int]! - ): [TeamType] - - """Find league details by league Id. Id is a required field.""" - league( - """ - A league id to include in this query, excluding all results that do not have this league id. - """ - id: Int! - ): LeagueType - - """Find league details by searching for leagues using a LeagueRequest.""" - leagues(request: LeagueRequestType!): [LeagueType] - - """ - For getting access to one specific Guild which was used at the start of TI10 Compendium. - """ - guild( - """ - A guild id to include in this query, excluding all results that do not have this guild id. - """ - id: Int! - ): GuildType - - """ - Queries used for Stratz Yogurt - users won't be able to access these calls until they have access to the app. - """ - yogurt: YogurtQuery - - """Queries used to populate Stratz Plus.""" - plus: PlusQuery - - """Stratz specific queries.""" - stratz: StratzQuery - - """Queries used to gain insights into hero data and statistics.""" - heroStats: HeroStatsQuery - - """Queries used to query constants in Dota.""" - constants: ConstantQuery - - """Queries used to get leaderboard information.""" - leaderboard: LeaderboardQuery - - """Queries used to find live match data.""" - live: LiveQuery - - """Queries used by 3rd party applications.""" - vendor: VendorQuery -} - -type DotaSubscription { - matchCount: TotalMatchCountType - playerCount: TotalPlayerCountType - feedLive: LiveEventType - matchLive(matchId: Long!): MatchLiveType - matchLiveLeague(leagueId: Int!): MatchLiveType -} - -type DotaUserMutation { - """Marks the user's LastReadFeedTime to the current time.""" - readAllFeed: Boolean - - """Validates a user email address if the password id is correct.""" - validateEmail( - """The password number that was sent via email.""" - code: Guid! - ): Boolean - - """Validates a user email address if the password id is correct.""" - updateTutorial( - """The TutorialId number of the tutorial completed.""" - tutorialId: Short! - ): [Short] - - """Update your user to unsubscribe from Stratz emails.""" - emailUnsubscribe: UserHomepageType - - """Updates the logged in user information profile.""" - updateProfile( - """ - The updated returned object from /user. Only updates ThemeType, LanguageId, Email and Feed/Email Settings. - """ - request: CaptainJackIdentityProfileUpdateRequestType! - ): Boolean - - """Update your user to (un)follow a specific SteamAccountId""" - followPlayer( - """The steam account of the person you wish to (un)follow.""" - steamAccountId: Long! - ): Boolean - - """Update your user to (un)follow a specific SteamAccountId""" - unfollowPlayer( - """The steam account of the person you wish to (un)follow.""" - steamAccountId: Long! - ): Boolean - - """Update your user to (un)follow a specific SteamAccountId""" - updateFollowing( - """The steam account of the person you wish to (un)follow.""" - followedSteamAccountId: Long! - - """ - The updated returned object from /user. Only updates ThemeType, LanguageId, Email and Feed/Email Settings. - """ - request: UpdateFollowerRequestType! - ): Boolean - - """ - Updates every user you are following. This should be handled with care, as - this overrides all your predefinded user specific settings with these settings. - """ - updateAllFollowing( - """ - The updated returned object from /user. Only updates ThemeType, LanguageId, Email and Feed/Email Settings. - """ - request: UpdateFollowerRequestType! - ): Boolean - - """ - Gets more in-depth information about the person you are following. This is a - user specific request, and you can only edit yourself. - """ - updateFollowingFavorite( - """The steam account of the person you wish to (un)follow.""" - followedSteamAccountId: Long! - - """Should the user become a favorite.""" - isFavorite: Boolean! - ): Boolean - - """Update your user to (un)follow a specific LeagueId""" - followLeague( - """ - A league id to include in this query, excluding all results that do not have this league id. - """ - leagueId: Int! - ): Boolean - unfollowLeague( - """ - A league id to include in this query, excluding all results that do not have this league id. - """ - leagueId: Int! - ): Boolean - applyStratzApiKey( - """There are two type of API Tokens, Data Collector and MultiKey""" - tokenType: StratzApiType! - - """ - The desired email address of the match replay upload team. Cannot be blank or whitespace. - """ - emailAddress: String! - - """A users Discord full Identity name.""" - discordAddress: String! - - """A user website where the data can be seen.""" - websiteAddress: String! - description: String! - ): Boolean - - """ - If a user moves from annoymous to public, this will turn it on instantly for them. - """ - checkPublicDotaAccount: Boolean -} - -type ExperienceDetailType { - time: Int! - amount: Int! - reason: XpReason - positionX: Int - positionY: Int -} - -type FeedResponseType { - data: [FeedType] - count: Int - date: DateTime -} - -type FeedType { - steamAccount: SteamAccountType - league: LeagueType - targetSteamAccountId: Long - type: Byte - matchId: Long - heroId: Int! - date: Long - value: Int! - didWin: Boolean -} - -enum FilterDireTide2020CustomGameMatchOrderBy { - CANDY_SCORED - END_DATE_TIME -} - -input FilterDireTide2020CustomMatchRequestType { - """ - The steam account id to include in this query, excluding all results that do not have this steam account id. - """ - steamAccountId: Long - - """The order in which the data returned will be sorted by.""" - orderBy: FilterDireTide2020CustomGameMatchOrderBy - - """If the return should be ordered by Ascending or Desending order.""" - orderDirection: FilterOrder - - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int -} - -enum FilterHeroWinRequestGroupBy { - HERO_ID - ALL - HERO_ID_DURATION_MINUTES -} - -enum FilterLeaderboardGuildOrderBy { - BATTLE_PASS_LEVELS - MEMBER_COUNT - POINTS - ID - PREVIOUS_WEEK_RANK -} - -input FilterLeaderboardGuildRequestType { - """What field to order the data by. Enum values.""" - orderBy: FilterLeaderboardGuildOrderBy - - """If the return should be ordered by Ascending or Desending order.""" - order: FilterOrder - - """The region where the guild was registered.""" - region: Byte - - """If the guild is current set to 50 members.""" - isFull: Boolean - - """If anyone is able to join the guild.""" - isUnlocked: Boolean - - """The minimum amount of members a guild must have.""" - minMemberCount: Byte - - """The max amount of members a guild can have.""" - maxMemberCount: Byte - - """The amount of members a guild must have.""" - memberCount: Byte - - """The language required to join the guild.""" - language: Byte - - """The guild was created before this date time (in Unix TimeStamp).""" - createdBeforeDateTime: Long - - """The guild was created after this date time (in Unix TimeStamp).""" - createdAfterDateTime: Long - - """The rank required to join the guild.""" - minRequiredRank: Byte - - """The rank required to join the guild.""" - maxRequiredRank: Byte - - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int -} - -input FilterLeaderboardHeroRequestType { - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being unknown - MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketIds: [Byte] - - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int -} - -enum FilterLeaderboardOrder { - RECENT - LEVEL - FIRST -} - -input FilterMatchReplayUploadRequestType { - withEnemySteamAccount: [Long] - withFriendHeroId: [Short] - withEnemyHeroId: [Short] - withFriendBannedHeroId: [Short] - withEnemyBannedHeroId: [Short] - byMatchId: Long - byMatchIds: [Long] - byMatchUploadFileName: String - byMatchUploadUploaderCaptainJackId: Guid - bySteamAccountId: Long - bySteamAccountIds: [Long] - byHeroId: [Short] - byLeagueId: Int - bySeriesId: Int - bySeriesIds: [Long] - byTeamId: Int - byGameMode: [Int] - byLobbyType: [Int] - byGameVersion: [Int] - isLeague: Boolean - isValidated: Boolean - isComplete: Boolean - isActive: Boolean - isVictory: Boolean - isRadiant: Boolean - filterPositionIsUs: Boolean - filterPosition: MatchPlayerPositionType - filterPositionOrder: [MatchPlayerTeamPickOrderType] - isRadiantFirstPick: Boolean - firstPick: Boolean - minDuration: Int - maxDuration: Int - minGameVersionId: Int - maxGameVersionId: Int - startDateTime: Long - endDateTime: Long - skip: Int - take: Int -} - -enum FilterOrder { - ASC - DESC -} - -enum FilterOrderBy { - LAST_MATCH_TIME - ID - NONE - START_DATE_THEN_TIER - LAST_MATCH_TIME_THEN_TIER -} - -input FilterSearchRequestType { - """ - The term used to define the search parameters. Minimum input is 2 characters. - """ - query: String! - - """ - Searching our entire database can take time. If you already know what your - searching for you, you can limit the query down to a set of specific types. (0 - - Playuers, 1 - Matches, 2 - Leagues, 3 - Teams, 4 - ProPlayers, 5 - Casters). - Default is all types. - """ - searchType: [Search] - - """ - The minimum rank a player must have to be allowed inside the search query. - """ - minimumRank: Int - - """ - The maximum rank a player must have to be allowed inside the search query. - """ - maximumRank: Int - - """ - The minimum amount of time in which a user must have played a game to be - allowed inside the search query. A unix timestamp. - """ - lastMatchPlayedAgo: Long - - """ - The leaderboard is split into 4 regions. The user must appear in this - region(s) for them to be allowed inside the search query. - """ - leaderboardRegionIds: [Byte] - - """ - When searching for a league, the tier the league must be in. Tiers: Amateur = - 1, Professional = 2, Premium = 3, Pro Circuit = 4, Main Event = 5 - """ - leagueTierIds: [LeagueTier] - - """ - When searching for a team, only return results of those teams of which are considered Professionals. - """ - teamIsPro: Boolean - - """The amount to have returned in your query.""" - take: Int -} - -input FilterSeasonLeaderboardRequestType { - query: String - leaderBoardDivision: LeaderboardDivision - heroId: Short - position: MatchPlayerPositionType - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int -} - -input FilterSeriesRequestType { - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int -} - -enum FilterTI2020CustomGameMatchOrderBy { - DURATION - END_DATE_TIME -} - -input FilterTI2020HeroCompositionRequestType { - """The base level of difficulty""" - difficulty: TI2020CustomGameMatchDifficultyType! - - """If the return should be ordered by Ascending or Desending order.""" - orderDirection: FilterOrder - - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int -} - -input FilterTI2020MatchRequestType { - """Return Matches that only include the set of Match Ids provided.""" - matchIds: [Long] - - """Return matches that only include this single player.""" - steamAccountId: Long - - """Required that the team playing the game won.""" - didWin: Boolean - - """How far into the game (levels) they completed.""" - depth: Byte - - """The base level of difficulty""" - difficulty: TI2020CustomGameMatchDifficultyType - - """The team had to make it at least this far (level).""" - minDepth: Byte - - """The max must be played in this list of regions""" - regionIds: [Byte] - - """ - The game must of been played before this set time. In Unix Time Stamp Format. - """ - createdBeforeDateTime: Long - - """ - The game must of been played after this set time. In Unix Time Stamp Format. - """ - createdAfterDateTime: Long - - """The order in which the data returned will be sorted by.""" - orderBy: FilterTI2020CustomGameMatchOrderBy - - """If the return should be ordered by Ascending or Desending order.""" - orderDirection: FilterOrder - - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - seasonId: Byte -} - -enum FindMatchPlayerGroupBy { - HERO - FACTION - KILLS - DEATHS - ASSISTS - IS_LEAVER - LEVEL - IS_PARTY - IS_RANDOM - LANE - ROLE - IS_INTENTIONAL_FEEDING - AWARD - ROAM_LANE - IS_VICTORY - DURATION_MINUTES - CLUSTER - REGION - LOBBY_TYPE - IS_LEAGUE - IS_SERIES - GAME_MODE - IS_STATS - GAME_VERSION - TEAM - HERO_PERFORMANCE - STEAM_ACCOUNT_ID - STEAM_ACCOUNT_ID_HERO_ID -} - -enum FindMatchPlayerList { - ALL - SINGLE -} - -enum FindMatchPlayerOrderBy { - DESC - ASC -} - -type FollowerType { - captainJackIdentityId: Guid - steamAccountId: Long - feedLevel: Byte - emailLevel: Byte - dailyEmail: Boolean - weeklyEmail: Boolean - monthlyEmail: Boolean - isFavorite: Boolean - lastEmail: Long - didManualUpdate: Boolean! - steamAccount: SteamAccountType - captainJackIdentity: CaptainJackIdentityType -} - -enum GameModeEnumType { - NONE - ALL_PICK - CAPTAINS_MODE - RANDOM_DRAFT - SINGLE_DRAFT - ALL_RANDOM - INTRO - THE_DIRETIDE - REVERSE_CAPTAINS_MODE - THE_GREEVILING - TUTORIAL - MID_ONLY - LEAST_PLAYED - NEW_PLAYER_POOL - COMPENDIUM_MATCHMAKING - CUSTOM - CAPTAINS_DRAFT - BALANCED_DRAFT - ABILITY_DRAFT - EVENT - ALL_RANDOM_DEATH_MATCH - SOLO_MID - ALL_PICK_RANKED - TURBO - MUTATION -} - -type GameModeType { - id: Short - name: String -} - -type GameVersionType { - id: Short - name: String - asOfDateTime: Long -} - -type GoldDetailType { - time: Int! - amount: Int! - reason: GoldReason - npcId: Int - isValidForStats: Boolean -} - -enum GoldReason { - OTHER - DEATH - BUY_BACK - ABADONS - SELLS - STRUCTURES - HEROES - CREEPS - NEUTRAL - ROSHAN - COURIERS - BOUNTY - DOOM_DEVOURER - WARD_DESTRUCTION -} - -scalar Guid - -type GuildMemberType { - guildId: Int - steamAccountId: Int - joinDateTime: Long - guild: GuildType - steamAccount: SteamAccountType - winCount: Int - matchCount: Int - imp: Int -} - -type GuildType { - id: Int - motd: String - name: String - tag: String - createdDateTime: Long - language: Byte - flags: Int - logo: String - region: Byte - description: String - requiredRank: Byte - primaryColor: Byte - secondaryColor: Byte - pattern: Byte - points: Int - pastWeeklyRank: Int - pastWeeklyPercentile: Byte - currentPercentile: Byte - lastUpdateDateTime: Long - members: [GuildMemberType] - matches( - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int - ): [MatchType] - memberCount: Byte - totalBattlePassLevels: Int - rank: Byte -} - -type HealDetailType { - time: Int! - attacker: Short - target: Short - value: Int - byAbility: Short - byItem: Short -} - -type HeroAbilityTalentType { - heroId: Int! - week: Int! - bracketBasic: RankBracketHeroTimeDetail - position: MatchPlayerPositionType - abilityId: Int! - count: Long - wins: Long - time: Long - winsAverage: Decimal - timeAverage: Decimal -} - -type HeroAbilityType { - slot: Byte - gameVersionId: Short - abilityId: Short - ability: AbilityType -} - -type HeroDamageDetailType { - time: Int! - attacker: Short - target: Short - value: Int! - byAbility: Short - byItem: Short - damageType: Damage - fromNpc: Short - toNpc: Short - fromIllusion: Boolean - toIllusion: Boolean - isPhysicalAttack: Boolean - isSourceMainHero: Boolean - isTargetMainHero: Boolean -} - -type HeroDotaPlusLeaderboardRankType { - heroId: Short - steamId: Long - level: Byte - totalActions: Long - createdDateTime: Long - steamAccount: SteamAccountType -} - -type HeroDryadType { - heroId: Short - with: [HeroStatsHeroDryadType] - matchCountWith: Long - vs: [HeroStatsHeroDryadType] - matchCountVs: Long -} - -type HeroGuideListType { - heroId: Short - matchCount: Int - - """Guides are auto-generated of games that are successful in a game.""" - guides( - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int - ): [HeroGuideType] -} - -type HeroGuideType { - heroId: Short - steamAccountId: Long - matchId: Long - match: MatchType - matchPlayer: MatchPlayerType - createdDateTime: Long -} - -type HeroHighPerformanceMatchObjectType { - matchId: Long - endDateTime: Long - imp: Int! -} - -type HeroHighPerformancePlayerObjectType { - steamId: Long - endDateTime: Long - imp: Int! - playerName: String! -} - -type HeroHighPerformanceRampageObjectType { - matchId: Long - endDateTime: Long - time: Int! - playerName: String! - steamId: Long -} - -type HeroHighPerformanceType { - heroId: Int! - week: Int! - bracketBasic: RankBracketHeroTimeDetail - position: MatchPlayerPositionType - rampages: [HeroHighPerformanceRampageObjectType] - matches: [HeroHighPerformanceMatchObjectType] - players: [HeroHighPerformancePlayerObjectType] - items: HeroPurchasePatternType -} - -type HeroItemBootPurchaseObjectType { - itemId: Int! - instance: Int! - time: Long - timeAverage: Decimal - count: Long - wins: Long - winAverage: Decimal - kills: Long - killsAverage: Decimal - deaths: Long - deathsAverage: Decimal - assists: Long - assistsAverage: Decimal - goldEarned: Long - goldEarnedAverage: Decimal - xp: Long - xpAverage: Decimal - activations: Long - activationsAverage: Decimal - activationTime: Long - activationsTimeAverage: Decimal -} - -type HeroItemBootPurchaseType { - heroId: Int! - week: Int! - bracketBasic: RankBracketHeroTimeDetail - position: MatchPlayerPositionType - events: [HeroItemBootPurchaseObjectType] - count: Long -} - -type HeroItemPurchaseObjectType { - itemId: Int! - instance: Int! - time: Long - count: Long - wins: Long - winsAverage: Decimal -} - -type HeroItemPurchaseType { - heroId: Int! - week: Int! - bracketBasic: RankBracketHeroTimeDetail - position: MatchPlayerPositionType - events: [HeroItemPurchaseObjectType] - count: Long -} - -type HeroItemStartingPurchaseObjectType { - itemId: Int! - instance: Int! - wasGiven: Boolean! - count: Long - wins: Long - winsAverage: Decimal -} - -type HeroItemStartingPurchaseType { - heroId: Int! - week: Int! - bracketBasic: RankBracketHeroTimeDetail - position: MatchPlayerPositionType - events: [HeroItemStartingPurchaseObjectType] - count: Long -} - -type HeroLanguageType { - displayName: String - lore: String - hype: String -} - -type HeroMatchupType { - advantage: [HeroDryadType] - disadvantage: [HeroDryadType] -} - -type HeroMetaTrendType { - heroId: Int! - win: [Long] - pick: [Long] - ban: [Long] -} - -type HeroPositionDetailType { - position: MatchPlayerPositionType - count: Long - wins: Decimal - kills: Decimal - deaths: Decimal - assists: Decimal - cs: Decimal - dn: Decimal - heroDamage: Decimal - towerDamage: Decimal -} - -type HeroPositionTimeDetailAverageObjectType { - time: Int! - matchCount: Long - remainingMatchCount: Int - wins: Decimal - mvp: Decimal - topCore: Decimal - topSupport: Decimal - courierKills: Decimal - apm: Decimal - casts: Decimal - abilityCasts: Decimal - kills: Decimal - deaths: Decimal - assists: Decimal - networth: Decimal - xp: Decimal - cs: Decimal - dn: Decimal - neutrals: Decimal - heroDamage: Decimal - towerDamage: Decimal - physicalDamage: Decimal - magicalDamage: Decimal - physicalDamageReceived: Decimal - magicalDamageReceived: Decimal - tripleKill: Decimal - ultraKill: Decimal - rampage: Decimal - godLike: Decimal - disableCount: Decimal - disableDuration: Decimal - stunCount: Decimal - stunDuration: Decimal - slowCount: Decimal - slowDuration: Decimal - healingSelf: Decimal - healingAllies: Decimal - invisibleCount: Decimal - runePower: Decimal - runeBounty: Decimal - level: Decimal - campsStacked: Decimal - supportGold: Decimal - purgeModifiers: Decimal - ancients: Decimal - teamKills: Decimal - goldLost: Decimal - goldFed: Decimal - buybackCount: Decimal - weakenCount: Decimal - weakenDuration: Decimal - physicalItemDamage: Decimal - magicalItemDamage: Decimal - healingItemSelf: Decimal - healingItemAllies: Decimal - xpFed: Decimal - pureDamageReceived: Decimal - attackDamage: Decimal - castDamage: Decimal - damageReceived: Decimal - damage: Decimal - pureDamage: Decimal - kDAAverage: Decimal - killContributionAverage: Decimal - stompWon: Decimal - stompLost: Decimal - comeBackWon: Decimal - comeBackLost: Decimal -} - -type HeroPositionTimeDetailAverageType { - heroId: Short! - week: Int! - bracketBasic: RankBracketHeroTimeDetail - position: MatchPlayerPositionType - events: [HeroPositionTimeDetailAverageObjectType] -} - -type HeroPurchasePatternType { - startingItems: HeroItemStartingPurchaseType - earlyGame: HeroItemPurchaseType - midGame: HeroItemPurchaseType - lateGame: HeroItemPurchaseType -} - -type HeroRatingObjectType { - heroId1: Int! - heroId2: Int - heroId3: Int - pickRate: Decimal - winRate: Decimal - banRate: Decimal -} - -type HeroRatingType { - single: [HeroRatingObjectType] - dryad: [HeroRatingObjectType] -} - -type HeroRoleType { - roleId: Short - level: Short -} - -type HeroStatsHeroDryadType { - heroId1: Short - heroId2: Short - week: Int - bracketBasic: RankBracketHeroTimeDetail - count: Long - kills: Long - deaths: Long - assists: Long - networth: Long - duration: Long - wins: Long - firstBloodTime: Long - cs: Long - dn: Long - goldEarned: Long - xp: Long - heroDamage: Long - towerDamage: Long - heroHealing: Long - level: Long - synergy: Decimal - winsAverage: Decimal -} - -type HeroStatsQuery { - """Detailed output of data per minute for each hero.""" - stats( - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """ - The week to include in this query, excluding all results that do not include - this week. The value is an epoc TimeStamp of the week of data you want. - Leaving null gives the current week. - """ - week: Long - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketBasicIds: [RankBracketHeroTimeDetail] - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionIds: [MatchPlayerPositionType] - groupByTime: Boolean - groupByPosition: Boolean - groupByBracket: Boolean - - """ - Integer in minutes which determines the start of the data. For example, 10 - would result in every event after 10:00 mark in-game. Minimum input value is 0. - """ - minTime: Int - - """ - Integer in minutes which determines the start of the data. For example, 10 - would result in every event before 10:00 mark in-game Maximum input value is 75. - """ - maxTime: Int - ): [HeroPositionTimeDetailAverageType] - - """Hero Data and statistics listed by what lane the hero plays in.""" - position( - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short! - - """ - The week to include in this query, excluding all results that do not include - this week. The value is an epoc TimeStamp of the week of data you want. - Leaving null gives the current week. - """ - week: Long - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketBasicIds: [RankBracketHeroTimeDetail] - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionIds: [MatchPlayerPositionType] - - """ - Integer in minutes which determines the start of the data. For example, 10 - would result in every event after 10:00 mark in-game. Minimum input value is 0. - """ - minTime: Int - - """ - Integer in minutes which determines the start of the data. For example, 10 - would result in every event before 10:00 mark in-game Maximum input value is 75. - """ - maxTime: Int - ): [HeroPositionDetailType] - - """ - Returns back a list of the hero matchups, showing how that hero's win rate is affected with or against other heroes. - """ - matchUp( - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short! - - """ - The week to include in this query, excluding all results that do not include - this week. The value is an epoc TimeStamp of the week of data you want. - Leaving null gives the current week. - """ - week: Long - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketBasicIds: [RankBracketHeroTimeDetail] - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionIds: [MatchPlayerPositionType] - - """ - Id representing how to order dryads and triads. Synergy is STRATZ formula to - help determine the best outcome of wins and picks in one. Accepted Inputs : - Synergy = 0, Pick = 1, Win = 2, Loss = 3, Disadvantage = 4, Advantage = 5 - """ - orderBy: Byte - - """Minimum amount of MatchCount required for a Duo to qualify""" - matchLimit: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int - ): [HeroDryadType] - - """ - Used in STRATZ Hero Page. Includes Starting items and full items based in groupings of 0-14 minutes, 15-34 minutes and 35+ - """ - purchasePattern( - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short! - - """ - The week to include in this query, excluding all results that do not include - this week. The value is an epoc TimeStamp of the week of data you want. - Leaving null gives the current week. - """ - week: Long - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketBasicIds: [RankBracketHeroTimeDetail] - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionIds: [MatchPlayerPositionType] - ): HeroPurchasePatternType - - """ - Returns the items purchased for the selected hero. Adjusting the time adjusts - the purchase amount. Shows win rate by item timings. - """ - itemFullPurchase( - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short! - - """ - The week to include in this query, excluding all results that do not include - this week. The value is an epoc TimeStamp of the week of data you want. - Leaving null gives the current week. - """ - week: Long - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketBasicIds: [RankBracketHeroTimeDetail] - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionIds: [MatchPlayerPositionType] - - """ - Integer in minutes which determines the start of the data. For example, 10 - would result in every event after 10:00 mark in-game. Minimum input value is 0. - """ - minTime: Int - - """ - Integer in minutes which determines the start of the data. For example, 10 - would result in every event before 10:00 mark in-game Maximum input value is 75. - """ - maxTime: Int - - """Minimum amount of MatchCount required for a Duo to qualify""" - matchLimit: Int - ): HeroItemPurchaseType - - """ - This snapshots all items in the inventory of a hero at -00:30. It tracks if an item was given or purchased. - """ - itemStartingPurchase( - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short! - - """ - The week to include in this query, excluding all results that do not include - this week. The value is an epoc TimeStamp of the week of data you want. - Leaving null gives the current week. - """ - week: Long - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketBasicIds: [RankBracketHeroTimeDetail] - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionIds: [MatchPlayerPositionType] - ): HeroItemStartingPurchaseType - - """ - The purchase Item Components for a Hero's Boots. Tracks things like activations or uses throughout the game. - """ - itemBootPurchase( - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short! - - """ - The week to include in this query, excluding all results that do not include - this week. The value is an epoc TimeStamp of the week of data you want. - Leaving null gives the current week. - """ - week: Long - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketBasicIds: [RankBracketHeroTimeDetail] - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionIds: [MatchPlayerPositionType] - ): HeroItemBootPurchaseType - - """ - This call is used in Hero Of the Day. It shows recent Rampages, High Performance and Good Players on the selected hero. - """ - highPerformance( - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short! - - """ - The week to include in this query, excluding all results that do not include - this week. The value is an epoc TimeStamp of the week of data you want. - Leaving null gives the current week. - """ - week: Long - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketBasicIds: [RankBracketHeroTimeDetail] - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionIds: [MatchPlayerPositionType] - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int - ): HeroHighPerformanceType - - """ - This is used on the Hero page to show the comparison of skill with the - selected hero with other heroes. It includes our Synergy and our Advantage - formulas to ensure that a hero with a high win rate isn't simply just on the - top of all the fields. - """ - heroVsHeroMatchup( - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short! - - """ - The week to include in this query, excluding all results that do not include - this week. The value is an epoc TimeStamp of the week of data you want. - Leaving null gives the current week. - """ - week: Long - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketBasicIds: [RankBracketHeroTimeDetail] - - """Minimum amount of MatchCount required for a Duo to qualify""" - matchLimit: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int - ): HeroMatchupType - - """ - This is used on the Hero page to show the comparison of all Hero Talents with the selected hero. - """ - talent( - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short! - - """ - The week to include in this query, excluding all results that do not include - this week. The value is an epoc TimeStamp of the week of data you want. - Leaving null gives the current week. - """ - week: Long - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketBasicIds: [RankBracketHeroTimeDetail] - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionIds: [MatchPlayerPositionType] - ): [HeroAbilityTalentType] - - """ - Used on the Heroes page, includes a small subset of Single Heroes, Dryads and - Triads. Includes Win Rate, Pick Rate, Ban Rate. - """ - ratings( - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: Short! - - """ - The week to include in this query, excluding all results that do not include - this week. The value is an epoc TimeStamp of the week of data you want. - Leaving null gives the current week. - """ - week: Long - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketBasicIds: [RankBracketHeroTimeDetail] - - """ - Id representing how to order dryads and triads. Synergy is STRATZ formula to - help determine the best outcome of wins and picks in one. Accepted Inputs : - Synergy = 0, Pick = 1, Win = 2, Loss = 3, Disadvantage = 4, Advantage = 5 - """ - positionIds: Byte - ): HeroRatingType - - """Used on the Heroes page, for determining popular hero trends.""" - metaTrend( - """ - Epoc TimeStamp of the day of data you want the data to start. Leaving null - gives the current day. Will include the last 14 days with it. The 14th - object in each array will be this day you have specificed. - """ - day: Long - ): [HeroMetaTrendType] - - """ - Returns the last 12 hours by hour showing the amount of matches and the amount of wins by hero id. - """ - winHour( - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """The amount to have returned in your query.""" - take: Int - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketIds: [RankBracket] - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionIds: [MatchPlayerPositionType] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [BasicRegionType] - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [GameModeEnumType] - - """ - Only used when doing matchesGroupBy endpoint. This is how the data will be grouped and makes your return Id field. - """ - groupBy: FilterHeroWinRequestGroupBy - ): [HeroWinHourType] - - """ - Returns the last 12 days by day showing the amount of matches and the amount of wins by hero id. - """ - winDay( - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """The amount to have returned in your query.""" - take: Int - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketIds: [RankBracket] - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionIds: [MatchPlayerPositionType] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [BasicRegionType] - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [GameModeEnumType] - - """ - Only used when doing matchesGroupBy endpoint. This is how the data will be grouped and makes your return Id field. - """ - groupBy: FilterHeroWinRequestGroupBy - ): [HeroWinDayType] - - """ - Returns the last 12 weeks by week showing the amount of matches and the amount of wins by hero id. - """ - winWeek( - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """The amount to have returned in your query.""" - take: Int - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketIds: [RankBracket] - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionIds: [MatchPlayerPositionType] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [BasicRegionType] - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [GameModeEnumType] - - """ - Only used when doing matchesGroupBy endpoint. This is how the data will be grouped and makes your return Id field. - """ - groupBy: FilterHeroWinRequestGroupBy - ): [HeroWinWeekType] - - """ - Returns the data by month showing the amount of matches and the amount of wins by hero id. - """ - winMonth( - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketIds: [RankBracket] - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionIds: [MatchPlayerPositionType] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [BasicRegionType] - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [GameModeEnumType] - - """ - Only used when doing matchesGroupBy endpoint. This is how the data will be grouped and makes your return Id field. - """ - groupBy: FilterHeroWinRequestGroupBy - ): [HeroWinMonthType] - - """ - Returns the data by game version showing the amount of matches and the amount of wins by hero id. - """ - winGameVersion( - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being - unknown MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketIds: [RankBracket] - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionIds: [MatchPlayerPositionType] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [BasicRegionType] - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [GameModeEnumType] - - """ - Only used when doing matchesGroupBy endpoint. This is how the data will be grouped and makes your return Id field. - """ - groupBy: FilterHeroWinRequestGroupBy - ): [HeroWinGameVersionType] - guide( - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short - - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - withHeroId: Short - - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - againstHeroId: Short - - """ - Determines that the query require the results come with a player that is qualified as a Pro. - """ - isPro: Boolean - - """ - An array of positions ids (enum MatchPlayerPositionType) to include in this - query, excluding all results that do not include one of these lanes. - """ - positionId: MatchPlayerPositionType - - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - ): [HeroGuideListType] -} - -type HeroStatType { - enabled: Boolean - heroUnlockOrder: Float - team: Boolean - cMEnabled: Boolean - newPlayerEnabled: Boolean - attackType: String - startingArmor: Float - startingMagicArmor: Float - startingDamageMin: Float - startingDamageMax: Float - attackRate: Float - attackAnimationPoint: Float - attackAcquisitionRange: Float - attackRange: Float - primaryAttribute: String - strengthBase: Float - strengthGain: Float - intelligenceBase: Float - intelligenceGain: Float - agilityBase: Float - agilityGain: Float - mpRegen: Float - moveSpeed: Float - moveTurnRate: Float - hpBarOffset: Float - visionDaytimeRange: Float - visionNighttimeRange: Float - complexity: Byte -} - -type HeroTalentType { - abilityId: Short - slot: Byte -} - -type HeroType { - id: Short - name: String - displayName: String - shortName: String - aliases: [String] - gameVersionId: Short - abilities: [HeroAbilityType] - roles: [HeroRoleType] - language: HeroLanguageType - talents: [HeroTalentType] - stats: HeroStatType -} - -type HeroWinDayType { - day: Long! - heroId: Short! - winCount: Int! - matchCount: Int! -} - -type HeroWinGameVersionType { - gameVersionId: Short! - heroId: Short! - durationMinute: Byte! - winCount: Int! - matchCount: Int! -} - -type HeroWinHourType { - hour: Long! - heroId: Short! - winCount: Int! - matchCount: Int! -} - -type HeroWinMonthType { - month: Long! - heroId: Short! - durationMinute: Byte! - winCount: Int! - matchCount: Int! -} - -type HeroWinWeekType { - week: Long! - heroId: Short! - durationMinute: Byte! - winCount: Int! - matchCount: Int! -} - -type HomepageHeroDryadType { - mainHeroId: Short - comparisonHeroId: Short - bracketBasic: RankBracketHeroTimeDetail - matchCount: Long - winCount: Long - synergy: Decimal - winsAverage: Decimal - comparisonHeroBaseWinRate: Decimal -} - -type HomepageHeroSynergyType { - mainHeroId: Short - mainHeroBaseWinRate: Decimal - heroDryads: [HomepageHeroDryadType] -} - -type ImpGeneratorMatchPlayerType { - winChance: [Float] - winRateByPlayerMinuteValues: [[Float]] - events: [[ImpGeneratorPlayerEventType]] - impValues: [[Int]] -} - -input ImpGeneratorPlayerEventRequestType { - time: Byte! - kills: UShort! - deaths: UShort! - assists: UShort! - cs: UShort! - dn: UShort! - level: Byte! - physicalDamage: Int! - magicalDamage: Int! - pureDamage: Int! - damageReceived: Int! - healingAllies: Int! - runePower: Int! - neutrals: Int! -} - -type ImpGeneratorPlayerEventType { - time: Byte - kills: UShort - deaths: UShort - assists: UShort - cs: UShort - dn: UShort - level: Byte - physicalDamage: Int - magicalDamage: Int - pureDamage: Int - damageReceived: Int - healingAllies: Int - runePower: Int - neutrals: Int -} - -input ImpGeneratorPlayerRequestType { - heroId: Short! - bracket: RankBracket! - position: MatchPlayerPositionType! - events: [ImpGeneratorPlayerEventRequestType]! -} - -type ImpGeneratorPlayerType { - winChance: [Float] - winRateByPlayerMinuteValues: [[Float]] - events: [ImpGeneratorPlayerEventType] - impValues: [[Int]] -} - -input ImpGeneratorRequestType { - bans: [Short]! - players: [ImpGeneratorPlayerRequestType]! - isTurbo: Boolean! -} - -input ImportPickBanType { - playerSlot: Byte - isPick: Boolean! - heroId: Short - time: Byte - isRadiant: Boolean - order: Byte - wasBannedSuccessfully: Boolean -} - -type ImpQuery { - """ - Returns details about all players in a specific match and details regarding Imp - """ - matchGenerator( - """ - The id of the Dota match to include in this query, excluding all results that do not include this id. - """ - matchId: Long! - ): ImpGeneratorMatchPlayerType - - """ - Returns details about a specific player in a game with certains events. - """ - playerGenerator(request: ImpGeneratorRequestType!): ImpGeneratorPlayerType -} - -type InventoryObjectType { - itemId: Short - charges: Int - secondaryCharges: Int -} - -type InventoryType { - time: Int! - item0: InventoryObjectType - item1: InventoryObjectType - item2: InventoryObjectType - item3: InventoryObjectType - item4: InventoryObjectType - item5: InventoryObjectType - backPack0: InventoryObjectType - backPack1: InventoryObjectType - backPack2: InventoryObjectType - teleport0: InventoryObjectType - neutral0: InventoryObjectType -} - -type ItemAttributeType { - name: String - value: String -} - -type ItemComponentType { - index: Byte - componentId: Short -} - -type ItemLanguageType { - displayName: String - description: [String] - lore: [String] - notes: [String] - attributes: [String] -} - -type ItemPurchaseType { - time: Int! - itemId: Short -} - -type ItemStatType { - behavior: Long - unitTargetType: Long - unitTargetTeam: Long - unitTargetFlags: Long - fightRecapLevel: Byte - castRange: [Int] - castPoint: [Float] - cooldown: [Float] - manaCost: [Float] - channelTime: [Float] - sharedCooldown: String - cost: Int - shopTags: String - aliases: String - quality: String - isSellable: Boolean - isDroppable: Boolean - isPurchasable: Boolean - isSideShop: Boolean - isStackable: Boolean - isPermanent: Boolean - isHideCharges: Boolean - isRequiresCharges: Boolean - isDisplayCharges: Boolean - isSupport: Boolean - isAlertable: Boolean - isTempestDoubleClonable: Boolean - stockMax: Short - initialCharges: Short - initialStock: Short - stockTime: Int - initialStockTime: Short - isRecipe: Boolean - needsComponents: Boolean - upgradeItem: Short - upgradeRecipe: Short - itemResult: Short -} - -type ItemType { - id: Short - name: String - displayName: String - shortName: String - isSupportFullItem: Boolean - language: ItemLanguageType - stat: ItemStatType - attributes: [ItemAttributeType] - components: [ItemComponentType] - image: String -} - -type ItemUsedEventType { - time: Int! - itemId: Short - attacker: Short - target: Short -} - -type KillDetailType { - time: Int! - attacker: Short - isFromIllusion: Boolean - target: Short - byAbility: Short - byItem: Short - gold: Int - xp: Int - positionX: Int - positionY: Int - assist: [Int] - isSolo: Boolean - isGank: Boolean - isInvisible: Boolean - isSmoke: Boolean - isTpRecently: Boolean - isRuneEffected: Boolean -} - -enum Language { - ENGLISH - BRAZILIAN - BULGARIAN - CZECH - DANISH - DUTCH - FINNISH - FRENCH - GERMAN - GREEK - HUNGARIAN - ITALIAN - JAPANESE - KOREAN - KOREANA - NORWEGIAN - POLISH - PORTUGUESE - ROMANIAN - RUSSIAN - S_CHINESE - SPANISH - SWEDISH - T_CHINESE - THAI - TURKISH - UKRAINIAN -} - -type LanguageType { - id: Byte! - languageCode: String - languageName: String -} - -type LastHitDetailType { - time: Int! - attacker: Short - isFromIllusion: Boolean - npcId: Short - byAbility: Short - byItem: Short - gold: Int - xp: Int - positionX: Int - positionY: Int - isCreep: Boolean - isNeutral: Boolean - isAncient: Boolean - mapLocation: MapLocationEnums -} - -enum LeaderboardDivision { - AMERICAS - SE_ASIA - EUROPE - CHINA -} - -type LeaderboardQuery { - """Returns the list of the current season leaderboard.""" - season(request: FilterSeasonLeaderboardRequestType): [SteamAccountSeasonActiveLeaderboardRankType] - - """ - Gets the players of Dota which have DotaPlus and have a high level hero. - """ - dotaPlus( - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short - - """ - Id representing how to order the dota plus leader board. Accepted values are - Recent = 0 (Shows the most recent awards given) and Level = 1 (shows by the - highest level first) - """ - orderBy: FilterLeaderboardOrder - - """Only returns players of this level.""" - level: Byte - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int - ): PlayerHeroDotaPlusLeaderboardRankResponseType - - """Gets the top player of DotaPlus order by Level and Time Achived.""" - dotaPlusTopLevels: [HeroDotaPlusLeaderboardRankType] - - """Show amount of active and expired DotaPlus users by Week""" - dotaPlusWeek: [DotaPlusWeekType] - - """Gets the current leaderboard for Battle Pass levels.""" - battlePass( - """The Event Id Assigned by Valve. 22 is TI8, 25 is TI9.""" - eventId: Byte - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int - ): PlayerBattlePassResponseType - - """Gets the current leaderboard for all coaches by level.""" - coaching( - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int - ): PlayerCoachingLeaderboardResponseType - - """Gets the current leaderboard for all guilds by points.""" - guild(request: FilterLeaderboardGuildRequestType): [GuildType] - - """ - Gets the current leaderboard for all players by a specific Hero, order by IMP. - """ - hero(request: FilterLeaderboardHeroRequestType): [PlayerLeaderBoardByHeroType] -} - -type LeagueBattlePassType { - count: Int - average: Int -} - -input LeagueMatchesRequestType { - """ - The steam account id to include in this query, excluding all results that do not have this steam account id. - """ - steamAccountId: Long - - """An array of Dota match ids to include in this query.""" - matchIds: [Long] - - """ - A series id to include in this query, excluding all results that do not have this series id. - """ - seriesId: Long - - """ - A team id to include in this query, excluding all results that do not have this team id. - """ - teamId: Int - - """ - Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. - """ - isParsed: Boolean - - """ - The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - startDateTime: Long - - """ - The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - endDateTime: Long - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [Byte] - - """ - An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. - """ - lobbyTypeIds: [Byte] - - """ - An array of game version ids to include in this query, excluding all results - that do not include one of these game versions. - """ - gameVersionIds: [Int] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [Int] - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-80 with 0 being - unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. - """ - rankIds: [Int] - - """ - STRATZ applys an formula to determine if a game is considered 'real'. We - attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches - that do not include any of these poor quality matches. - """ - isStats: Boolean - - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """ - An array of lane ids (enum MatchLaneType) to include in this query, excluding - all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, - Midlane = 2, Offlane = 3, Jungle = 4 - """ - laneIds: [Int] - - """ - An array of role ids (enum MatchPlayerRoleType) to include in this query, - excluding all results that do not include one of these roles. Core = 0, Light - Support = 1, Hard Support = 2 - """ - roleIds: [Int] - - """ - An array of award ids to include in this query, excluding all results that do - not include one of these awards. The player award types include MVP (1), Top - Core (2), and Top Support (3). - """ - awardIds: [Int] - - """Include all matches that are party games, excluding all others.""" - isParty: Boolean - - """ - STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, - Top Support (enum MatchPlayerAwardType). If you include a query of - 'steamAccountId' then it will require that player to have gotten at least 1 of - these awards for each match result. - """ - hasAward: Boolean - - """ - An array of stage type ids to include in this query, excluding all results that do not include one of these stage types. - """ - leagueStageTypeIds: [LeagueStage] - - """ - An array of steam account ids found on your team to include in this query, - excluding all results that do not include one of these steam accounts found on your team. - """ - withFriendSteamAccountIds: [Long] - - """ - An array of hero ids found on your team to include in this query, excluding - all results that do not include one of these heroes found on your team. - """ - withFriendHeroIds: [Int] - - """ - The amount of matches to skip before collecting your query. Hint: Paging - """ - skip: Int! - - """The amount of matches to have returned in your query. Max 1000""" - take: Int! -} - -type LeagueMetaDetailType { - heroId: Short - winCount: Int - lossCount: Int - winRate: Decimal - pickRate: Decimal - pickCount: Int - banRate: Decimal - banCount: Int -} - -type LeagueMetaType { - leagueId: Int - bestRecord: LeagueMetaDetailType - mostPicked: LeagueMetaDetailType - mostBanned: LeagueMetaDetailType - missingMatchCount: Int - totalMatchCount: Int - league: LeagueType -} - -enum LeagueNodeDefaultGroupEnum { - INVALID - BEST_OF_ONE - BEST_OF_THREE - BEST_OF_FIVE - BEST_OF_TWO -} - -type LeagueNodeGroupType { - id: Short - name: String - parentNodeGroupId: Short - advancingNodeGroupId: Short - advancingTeamCount: Byte - teamCount: Byte - defaultNodeType: LeagueNodeDefaultGroupEnum - nodeGroupType: LeagueNodeGroupTypeEnum - round: Byte - maxRounds: Byte - isTieBreaker: Boolean - isFinalGroup: Boolean - isCompleted: Boolean - phase: Byte - region: Byte - startDate: Long - endDate: Long - secondaryAdvancingNodeGroupId: Short - secondaryAdvancingTeamCount: Byte - tertiaryAdvancingNodeGroupId: Short - tertiaryAdvancingTeamCount: Byte - eliminationDPCPoints: Int - nodes: [LeagueNodeType] -} - -enum LeagueNodeGroupTypeEnum { - INVALID - ORGANIZATIONAL - ROUND_ROBIN - SWISS - BRACKET_SINGLE - BRACKET_DOUBLE_SEED_LOSER - BRACKET_DOUBLE_ALL_WINNER - SHOWMATCH - GSL -} - -type LeagueNodeType { - nodeGroupId: Short - id: Short - name: String - winningNodeId: Short - losingNodeId: Short - nodeType: LeagueNodeDefaultGroupEnum - scheduledTime: Long - actualTime: Long - seriesId: Long - matches: [MatchType] - teamOneId: Int - teamOne: TeamType - teamTwoId: Int - teamTwo: TeamType - teamOneWins: Byte - teamTwoWins: Byte - hasStarted: Boolean - isCompleted: Boolean - streamIds: [Int] - streams: [LeagueStreamType] -} - -type LeaguePrizePoolPercentageType { - leagueId: Int - index: Byte - percentage: Int -} - -enum LeagueRegion { - UNSET - NA - SA - EUROPE - CIS - CHINA - SEA -} - -type LeagueRegisteredPlayerType { - leagueId: Int - league: LeagueType - teamId: Int - radiantTeam: TeamType - steamAccountId: Long - steamAccount: SteamAccountType -} - -input LeagueRequestType { - """ - A league id to include in this query, excluding all results that do not have this league id. - """ - leagueId: Int - - """ - An array of league ids to include in this query, excluding all results that do not include one of these leagues. - """ - leagueIds: [Int] - - """ - An array of tier ids to include in this query, excluding all results that do not include one of these tiers. - """ - tiers: [LeagueTier] - - """Whether an image is required or not, represented in a boolean.""" - requireImage: Boolean - - """Whether a prize pool is required or not, represented in a boolean.""" - requirePrizePool: Boolean - - """ - Whether a start and end date is required or not, represented in a boolean. - """ - requireStartAndEndDates: Boolean - - """Whether a league has live matches or not, represented in a boolean.""" - hasLiveMatches: Boolean - - """Whether a league has ended or not, represented in a boolean.""" - leagueEnded: Boolean - - """Whether a league has started or not, represented in a boolean.""" - isFutureLeague: Boolean - - """If a league is set to start after this time.""" - startDateTime: Long - - """If a league is set to end before this time.""" - endDateTime: Long - - """ - Determine to Start value of finding a League Between two specific datetimes. - """ - betweenStartDateTime: Long - - """ - Determine to End value of finding a League Between two specific datetimes. - """ - betweenEndDateTime: Long - - """The id to order the results by in this query.""" - orderBy: FilterOrderBy - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int -} - -enum LeagueStage { - OPEN_QUALIFERS - CLOSED_QUALIFERS - CHAMPIONS_QUALIFERS - GROUP_STAGE - MAIN_EVENT -} - -type LeagueStatType { - matchCount: Int - radiantWinMatchCount: Int - averageMatchDurationSeconds: Int -} - -type LeagueStreamType { - id: Int - languageId: Language - name: String - broadcastProvider: Byte - streamUrl: String - vodUrl: String -} - -type LeagueTableHeroLanesObjectType { - id: Byte - matchCount: Int! - matchWins: Int! -} - -type LeagueTableHeroOverviewType { - matchCount: Int! - matchWins: Int! - pickPhaseOne: Int! - pickPhaseTwo: Int! - pickPhaseThree: Int! - banCount: Int! - banPhaseOne: Int! - banPhaseTwo: Int! - banPhaseThree: Int! -} - -type LeagueTableHeroStatsType { - kills: Float! - deaths: Float! - assists: Float! - cs: Float! - gpm: Float! - xpm: Float! - heal: Float! - heroDamage: Float! - towerDamage: Float! - killContribution: Float! -} - -type LeagueTableHeroType { - heroId: Short - overview: LeagueTableHeroOverviewType - stats: LeagueTableHeroStatsType - heroes: [LeagueTableHeroStatsType] - lanes: [LeagueTableHeroLanesObjectType] -} - -type LeagueTablePlayerHeroesObjectType { - heroId: Int! - matchCount: Int! - matchWins: Int! - imp: Int! -} - -type LeagueTablePlayerLanesObjectType { - id: Byte - matchCount: Int! - matchWins: Int! -} - -type LeagueTablePlayerOverviewType { - points: Float - earnings: Float - seriesCount: Int! - seriesWins: Int! - matchCount: Int! - matchWins: Int! - imp: Int! -} - -type LeagueTablePlayerStatsType { - kills: Float! - deaths: Float! - assists: Float! - cs: Float! - gpm: Float! - xpm: Float! - heal: Float! - heroDamage: Float! - towerDamage: Float! - killContribution: Float! -} - -type LeagueTablePlayerType { - steamAccountId: Long - steamAccount: SteamAccountType - overview: LeagueTablePlayerOverviewType - stats: LeagueTablePlayerStatsType - heroes: [LeagueTablePlayerHeroesObjectType] - lanes: [LeagueTablePlayerLanesObjectType] -} - -type LeagueTableTeamHeroesObjectType { - heroId: Int! - matchCount: Int! - matchWins: Int! - imp: Decimal - banCount: Int -} - -type LeagueTableTeamLanesObjectType { - id: Byte - matchCount: Int! - matchWins: Int! -} - -type LeagueTableTeamOverviewType { - points: Float - earnings: Float - seriesCount: Int! - seriesWins: Int! - seriesDraws: Int! - matchCount: Int! - matchWins: Int! - tmp: Float -} - -type LeagueTableTeamStatsType { - kills: Float! - deaths: Float! - assists: Float! - cs: Float! - gpm: Float! - xpm: Float! - heal: Float! - heroDamage: Float! - towerDamage: Float! - duration: Float! -} - -type LeagueTableTeamType { - teamId: Int - team: TeamType - members: [LeagueRegisteredPlayerType] - overview: LeagueTableTeamOverviewType - stats: LeagueTableTeamStatsType - heroes: [LeagueTableTeamHeroesObjectType] - lanes: [LeagueTableTeamLanesObjectType] -} - -type LeagueTableType { - leagueId: Int! - tableTeams: [LeagueTableTeamType] - tableHeroes: [LeagueTableHeroType] - tablePlayers: [LeagueTablePlayerType] -} - -enum LeagueTier { - UNSET - AMATEUR - PROFESSIONAL - MINOR - MAJOR - INTERNATIONAL - DPC_QUALIFIER - DPC_LEAGUE_QUALIFIER - DPC_LEAGUE - DPC_LEAGUE_FINALS -} - -type LeagueType { - id: Int - name: String - banner: String - basePrizePool: Int - stopSalesTime: DateTime - tier: LeagueTier - region: LeagueRegion - private: Boolean - freeToSpectate: Boolean - startDateTime: Long - endDateTime: Long - tournamentUrl: String - lastMatchDate: Long - modifiedDateTime: Long - hasLiveMatches: Boolean - prizePool: Int - imageUri: String - displayName: String - description: String - country: String - venue: String - isFollowed: Boolean - nodeGroups: [LeagueNodeGroupType] - liveMatches: [MatchLiveType] - matches( - """ - The request object used to filter matches returned based on input criteria. - """ - request: LeagueMatchesRequestType! - ): [MatchType] - series( - """ - When searching for league matches, an array of the stage type ids the match - must be in. Stages: Open Qualifers = 1, Closed Qualifers = 2, Champions - Qualifers = 3, Group Stage = 4, Main Event = 5 - """ - leagueStageTypeIds: [LeagueStage] - - """ - A team id to include in this query, excluding all results that do not have this team id. - """ - teamId: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int - ): [SeriesType] - tables( - """ - When searching for league matches, an array of the stage type ids the match - must be in. Stages: Open Qualifers = 1, Closed Qualifers = 2, Champions - Qualifers = 3, Group Stage = 4, Main Event = 5 - """ - leagueStageTypeIds: [LeagueStage] - - """ - To modify the values of Kills, Deaths, Assists, etc. Accepted inputs are Average (default), Highest, Lowest, Median. - """ - calculateTypeId: TableCalculateEnum - ): LeagueTableType - battlePass: LeagueBattlePassType - stats( - """ - When searching for league matches, an array of the stage type ids the match - must be in. Stages: Open Qualifers = 1, Closed Qualifers = 2, Champions - Qualifers = 3, Group Stage = 4, Main Event = 5 - """ - leagueStageTypeIds: [LeagueStage] - ): LeagueStatType - prizePoolPercentages: [LeaguePrizePoolPercentageType] - standings: [TeamPrizeType] - streams: [LeagueStreamType] -} - -enum LeaverStatusEnum { - NONE - DISCONNECTED - DISCONNECTED_TOO_LONG - ABANDONED - AFK - NEVER_CONNECTED - NEVER_CONNECTED_TOO_LONG - FAILED_TO_READY_UP - DECLINED_READY_UP -} - -type LiveEventMatchDireTide2020StompType { - match: DireTide2020CustomGameMatchType -} - -type LiveEventPlayerDireTide2020CandyScoredType { - steamAccount: SteamAccountType - match: DireTide2020CustomGameMatchType - heroId: Short - candyScored: Short -} - -type LiveEventPlayerHeroAssistsType { - steamAccount: SteamAccountType - match: MatchType - heroId: Short - assistCount: Byte -} - -type LiveEventPlayerHeroBuildingDamageType { - steamAccount: SteamAccountType - match: MatchType - heroId: Short - buildingDamage: Int -} - -type LiveEventPlayerHeroDewardType { - steamAccount: SteamAccountType - match: MatchType - heroId: Short - dewardCount: Byte -} - -type LiveEventPlayerHeroDotaPlusLevelType { - steamAccount: SteamAccountType - match: MatchType - heroId: Short - level: Byte -} - -type LiveEventPlayerHeroExpPerMinuteType { - steamAccount: SteamAccountType - match: MatchType - heroId: Short - expPerMinute: Short -} - -type LiveEventPlayerHeroGoldPerMinuteType { - steamAccount: SteamAccountType - match: MatchType - heroId: Short - goldPerMinute: Short -} - -type LiveEventPlayerHeroHealingType { - steamAccount: SteamAccountType - match: MatchType - heroId: Short - healingAmount: Int -} - -type LiveEventPlayerHeroHeroDamageType { - steamAccount: SteamAccountType - match: MatchType - heroId: Short - heroDamage: Int -} - -type LiveEventPlayerHeroHighImpType { - steamAccount: SteamAccountType - match: MatchType - heroId: Short - imp: Byte -} - -type LiveEventPlayerHeroItemPurchaseType { - steamAccount: SteamAccountType - match: MatchType - heroId: Short - itemId: Short - itemCount: Byte -} - -type LiveEventPlayerHeroKillsType { - steamAccount: SteamAccountType - match: MatchType - heroId: Short - killCount: Byte -} - -type LiveEventPlayerHeroWinStreakType { - steamAccount: SteamAccountType - match: MatchType - heroId: Short - winStreakCount: Byte -} - -type LiveEventPlayerRampageType { - steamAccount: SteamAccountType - match: MatchType - heroId: Short - rampageCount: Byte -} - -type LiveEventPlayerRankUpType { - steamAccount: SteamAccountType - match: MatchType - rank: Byte -} - -type LiveEventPlayerWinStreakType { - steamAccount: SteamAccountType - match: MatchType - winStreakCount: Byte -} - -type LiveEventProPlayerLiveType { - steamAccounts: [SteamAccountType] - match: MatchLiveType -} - -union LiveEventType = LiveEventPlayerRampageType | LiveEventPlayerWinStreakType | LiveEventPlayerHeroWinStreakType | LiveEventPlayerHeroKillsType | LiveEventPlayerHeroAssistsType | LiveEventPlayerHeroBuildingDamageType | LiveEventPlayerHeroHealingType | LiveEventPlayerHeroHeroDamageType | LiveEventPlayerHeroGoldPerMinuteType | LiveEventPlayerHeroExpPerMinuteType | LiveEventPlayerHeroHighImpType | LiveEventPlayerHeroDotaPlusLevelType | LiveEventPlayerRankUpType | LiveEventProPlayerLiveType | LiveEventPlayerHeroItemPurchaseType | LiveEventPlayerHeroDewardType | LiveEventMatchDireTide2020StompType | LiveEventPlayerDireTide2020CandyScoredType - -type LiveQuery { - """ - Find a live match by match id. A live match is data where a match is on the - Dota watch list and still active. All League games are also Live. id is a - required input field. - """ - match( - """ - The id of the Dota match to include in this query, excluding all results that do not include this id. - """ - id: Long! - - """ - The amount in seconds you wish to skip until you start getting MatchEvents - or PlayerMatchEvents. When requesting reply data back, you may only want the - updates from X second on. This will skip the first set of seconds and give - everything after this time. - """ - skipPlaybackDuration: Int - ): MatchLiveType - - """ - Find all live matches. A live match is data where a match is on the Dota watch - list and still active. All League games are also Live. - """ - matches(request: MatchLiveRequestType): [MatchLiveType] -} - -enum LobbyTypeEnum { - UNRANKED - PRACTICE - TOURNAMENT - TUTORIAL - COOP_VS_BOTS - TEAM_MATCH - SOLO_QUEUE - RANKED - SOLO_MID - BATTLE_CUP - EVENT -} - -type LobbyTypeType { - id: Int! - name: String -} - -enum MapLocationEnums { - RADIANT_BASE - RADIANT_OFF_LANE - RADIANT_MID_LANE - RADIANT_SAFE_LANE - DIRE_BASE - DIRE_OFF_LANE - DIRE_MID_LANE - DIRE_SAFE_LANE - RIVER - ROSHAN - ROAMING - RADIANT_FOUNTAIN - DIRE_FOUNTAIN -} - -enum MatchAnalysisOutcomeType { - NONE - STOMPED - COMEBACK - CLOSE_GAME -} - -type MatchesDayType { - day: Long! - matchCount: Int! -} - -type MatchesGameVersionType { - gameVersionId: Short! - matchCount: Int! -} - -type MatchesHourType { - hour: Long! - matchCount: Int! -} - -type MatchesMonthType { - month: Long! - matchCount: Int! -} - -type MatchesWeekType { - week: Long! - matchCount: Int! -} - -type MatchGroupByType { - id: Long - id2: Long - id3: Long - matchCount: Int - winCount: Int - avgImp: Int - avgGoldPerMinute: Int - avgExperiencePerMinute: Int - avgKDA: Float - avgKills: Float - avgDeaths: Float - avgAssists: Float - lastMatchDateTime: Long - firstMatchDateTime: Long -} - -enum MatchLaneType { - ROAMING - SAFE_LANE - MID_LANE - OFF_LANE - JUNGLE - UNKNOWN -} - -type MatchLiveBuildingDetailType { - time: Int! - indexId: Int - type: BuildingType - isAlive: Boolean! - positionX: Int - positionY: Int - isRadiant: Boolean - npcId: Int -} - -enum MatchLiveGameState { - INIT - WAIT_FOR_PLAYERS_TO_LOAD - HERO_SELECTION - STRATEGY_TIME - PRE_GAME - GAME_IN_PROGRESS - POST_GAME - DISCONNECT - TEAM_SHOWCASE - CUSTOM_GAME_SETUP - WAIT_FOR_MAP_TO_LOAD - LAST -} - -type MatchLiveInsightType { - teamOneVsWinCount: Int! - teamTwoVsWinCount: Int! - teamOneLeagueWinCount: Int! - teamOneLeagueMatchCount: Int! - teamTwoLeagueWinCount: Int! - teamTwoLeagueMatchCount: Int! - lastSeries: [SeriesType] -} - -type MatchLivePickBanType { - isPick: Boolean! - heroId: Short - order: Int - bannedHeroId: Short - isRadiant: Boolean - baseWinRate: Float - adjustedWinRate: Float - letter: PlusLetterType - positionValues: [Float] - winRateValues: [Float] - durationValues: [Float] - position: MatchPlayerPositionType -} - -type MatchLivePlaybackDataType { - roshanEvents: [MatchLiveRoshanDetailType] - buildingEvents: [MatchLiveBuildingDetailType] - pickBans: [MatchLivePickBanType] - radiantScore: [MatchLiveTeamScoreDetailType] - direScore: [MatchLiveTeamScoreDetailType] -} - -type MatchLivePlayerAssistDetailType { - time: Int! - positionX: Int! - positionY: Int! -} - -type MatchLivePlayerDeathDetailType { - time: Int! - positionX: Int! - positionY: Int! -} - -type MatchLivePlayerDenyDetailType { - time: Int! - positionX: Int! - positionY: Int! -} - -type MatchLivePlayerExperienceDetailType { - time: Int! - expPerMinute: Int! -} - -type MatchLivePlayerGoldDetailType { - time: Int! - gold: Int! - networth: Int! - networthDifference: Int! - goldPerMinute: Int! -} - -type MatchLivePlayerImpDetailType { - time: Int! - imp: Short! -} - -type MatchLivePlayerInventoryDetailType { - time: Int! - itemId0: Short - itemId1: Short - itemId2: Short - itemId3: Short - itemId4: Short - itemId5: Short - backpackId0: Short - backpackId1: Short - backpackId2: Short -} - -type MatchLivePlayerKillDetailType { - time: Int! - positionX: Int! - positionY: Int! -} - -type MatchLivePlayerLastHitDetailType { - time: Int! - positionX: Int! - positionY: Int! -} - -type MatchLivePlayerLevelDetailType { - time: Int! - level: Int! -} - -type MatchLivePlayerPositionDetailType { - time: Int! - x: Int! - y: Int! -} - -type MatchLivePlayerType { - matchId: Long - heroId: Short - hero: HeroType - name: String - playerSlot: Byte - steamAccountId: Long - steamAccount: SteamAccountType - isRadiant: Boolean - numKills: Byte - numDeaths: Byte - numAssists: Byte - leaverStatus: Byte - numLastHits: UShort - numDenies: UShort - goldPerMinute: UShort - experiencePerMinute: UShort - level: Byte - gold: Int - goldSpent: Int - heroDamage: Int - towerDamage: Int - itemId0: Short - itemId1: Short - itemId2: Short - itemId3: Short - itemId4: Short - itemId5: Short - backpackId0: Short - backpackId1: Short - backpackId2: Short - playbackData: MatchPlayerLivePlaybackDataType - networth: Int - respawnTimer: Short - ultimateCooldown: Short - ultimateState: Short - impPerMinute: [MatchLivePlayerImpDetailType] - gameVersionId: Short - baseWinRateValue: Float - position: MatchPlayerPositionType -} - -enum MatchLiveRequestOrderBy { - GAME_TIME - MATCH_ID - SPECTATOR_COUNT -} - -input MatchLiveRequestType { - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short - - """ - A league id to include in this query, excluding all results that do not have this league id. - """ - leagueId: Int - - """ - Returns only matches that are currently still being updated by the backend. - """ - isParsing: Boolean - - """ - Returns only matches that are no longer active and completed but not yet deleted. - """ - isCompleted: Boolean - - """ - An array of league ids to include in this query, excluding all results that do not include one of these leagues. - """ - leagueIds: [Int] - - """ - Only return Live Matches In Progress that are currently in these states. - """ - gameStates: [MatchLiveGameState] - - """ - An array of tier ids to include in this query, excluding all results that do not include one of these tiers. - """ - tiers: [LeagueTier] - - """ - Playback Data can contain a lot of information. This will only display the most recent event for each of the fields. - """ - lastPlaybackEventOnly: Boolean - - """If the return should be ordered by Ascending or Desending order.""" - orderBy: MatchLiveRequestOrderBy - - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int -} - -type MatchLiveRoshanDetailType { - time: Int - isAlive: Boolean - respawnTimer: Int -} - -type MatchLiveTeamScoreDetailType { - time: Int - score: Short -} - -type MatchLiveType { - matchId: Long - radiantScore: Byte - direScore: Byte - leagueId: Int - league: LeagueType - delay: Short - spectators: Int - averageRank: Int - buildingState: Long - radiantLead: Int - lobbyId: Long - lobbyType: LobbyTypeEnum - serverSteamId: String - gameTime: Int - completed: Boolean - isUpdating: Boolean - isParsing: Boolean - radiantTeamId: Int - direTeamId: Int - radiantTeam: TeamType - direTeam: TeamType - parseBeginGameTime: Int - numHumanPlayers: Byte - gameMode: GameModeEnumType - playbackData: MatchLivePlaybackDataType - gameState: MatchLiveGameState - gameMinute: Short - players: [MatchLivePlayerType] - createdDateTime: Long - modifiedDateTime: Long - insight: MatchLiveInsightType - winRateValues: [Float] - durationValues: [Float] - liveWinRateValues: [MatchLiveWinRateDetailType] -} - -type MatchLiveWinRateDetailType { - time: Int! - winRate: Float! -} - -type MatchmakingStatsType { - time: Long! - uSWest: Int! - uSEast: Int! - europe: Int! - singapore: Int! - brazil: Int! - stockholm: Int! - austria: Int! - australia: Int! - southAfrica: Int! - perfectWorldTelecom: Int! - perfectWorldUnicom: Int! - dubai: Int! - chile: Int! - peru: Int! - india: Int! - perfectWorldTelecomGuangdong: Int! - perfectWorldTelecomZhejiang: Int! - japan: Int! - perfectWorldTelecomWuhan: Int! - taiwan: Int! - perfectWorldUnicomTianjin: Int! -} - -type MatchPickBanGroupByType { - heroId: Short - pickCount: Int - banCount: Int -} - -type MatchPlaybackDataBuildingEventType { - time: Int! - indexId: Int - type: BuildingType - hp: Int - maxHp: Int - positionX: Int - positionY: Int - isRadiant: Boolean - npcId: Int - didShrineActivate: Boolean -} - -type MatchplaybackDataCourierEventObjectType { - time: Int! - positionX: Int - positionY: Int - hp: Int - isFlying: Boolean - respawnTime: Int - didCastBoost: Boolean - item0Id: Int - item1Id: Int - item2Id: Int - item3Id: Int - item4Id: Int - item5Id: Int -} - -type MatchPlaybackDataCourierEventType { - id: Int! - ownerHero: Int - isRadiant: Boolean - events: [MatchplaybackDataCourierEventObjectType] -} - -type MatchPlaybackDataRoshanEventType { - time: Int! - hp: Int - maxHp: Int - createTime: Int - x: Int - y: Int - totalDamageTaken: Int - item0: Int - item1: Int - item2: Int - item3: Int - item4: Int - item5: Int -} - -type MatchPlaybackDataRuneEventType { - indexId: Int! - time: Int! - positionX: Int! - positionY: Int! - fromPlayer: Int! - location: Int! - rune: Int! - action: Int! -} - -type MatchPlaybackDataTowerDeathEventType { - time: Int! - radiant: Int! - dire: Int! -} - -type MatchPlaybackDataType { - courierEvents: [MatchPlaybackDataCourierEventType] - runeEvents: [MatchPlaybackDataRuneEventType] - wardEvents: [MatchPlaybackDataWardEventType] - buildingEvents: [MatchPlaybackDataBuildingEventType] - towerDeathEvents: [MatchPlaybackDataTowerDeathEventType] - roshanEvents: [MatchPlaybackDataRoshanEventType] - radiantCaptainSteamAccountId: Long - radiantCaptainSteamAccount: SteamAccountType - direCaptainSteamAccountId: Long - direCaptainSteamAccount: SteamAccountType -} - -type MatchPlaybackDataWardEventType { - indexId: Int! - time: Int! - positionX: Int! - positionY: Int! - fromPlayer: Int - wardType: Byte - action: Byte -} - -type MatchPlayerAdditionalUnitType { - item0Id: Short - item1Id: Short - item2Id: Short - item3Id: Short - item4Id: Short - item5Id: Short - backpack0Id: Short - backpack1Id: Short - backpack2Id: Short - neutral0Id: Short -} - -enum MatchPlayerAward { - NONE - MVP - TOP_CORE - TOP_SUPPORT -} - -type MatchPlayerHeroDamageSourceAbilityReportObjectType { - abilityId: Int! - count: Int! - amount: Int! -} - -type MatchPlayerHeroDamageSourceItemReportObjectType { - itemId: Int! - count: Int! - amount: Int! -} - -type MatchPlayerHeroDamageTargetReportObjectType { - target: Int! - amount: Int! -} - -type MatchPlayerHeroDamageTotalRecievedReportObjectType { - physicalDamage: Int! - magicalDamage: Int! - pureDamage: Int! - heal: Int! - stunCount: Int! - stunDuration: Int! - disableCount: Int! - disableDuration: Int! - slowCount: Int! - slowDuration: Int! -} - -type MatchPlayerHeroDamageTotalReportObjectType { - physicalDamage: Int! - magicalDamage: Int! - pureDamage: Int! - selfHeal: Int! - allyHeal: Int! - stunCount: Int! - stunDuration: Int! - disableCount: Int! - disableDuration: Int! - slowCount: Int! - slowDuration: Int! -} - -type MatchPlayerInventoryObjectType { - itemId: Int! - charges: Int - secondaryCharges: Int -} - -type MatchPlayerInventoryType { - item0: MatchPlayerInventoryObjectType - item1: MatchPlayerInventoryObjectType - item2: MatchPlayerInventoryObjectType - item3: MatchPlayerInventoryObjectType - item4: MatchPlayerInventoryObjectType - item5: MatchPlayerInventoryObjectType - backPack0: MatchPlayerInventoryObjectType - backPack1: MatchPlayerInventoryObjectType - backPack2: MatchPlayerInventoryObjectType - neutral0: MatchPlayerInventoryObjectType -} - -type MatchPlayerItemPurchaseEventType { - time: Int! - itemId: Int! -} - -type MatchPlayerLivePlaybackDataType { - positionEvents: [MatchLivePlayerPositionDetailType] - goldEvents: [MatchLivePlayerGoldDetailType] - levelEvents: [MatchLivePlayerLevelDetailType] - killEvents: [MatchLivePlayerKillDetailType] - deathEvents: [MatchLivePlayerDeathDetailType] - assistEvents: [MatchLivePlayerAssistDetailType] - csEvents: [MatchLivePlayerLastHitDetailType] - denyEvents: [MatchLivePlayerDenyDetailType] - experienceEvents: [MatchLivePlayerExperienceDetailType] - inventoryEvents: [MatchLivePlayerInventoryDetailType] -} - -type MatchPlayerPlaybackDataType { - abilityLearnEvents: [AbilityLearnEventsType] - abilityUsedEvents: [AbilityUsedEventsType] - abilityActiveLists: [AbilityActiveListType] - itemUsedEvents: [ItemUsedEventType] - playerUpdatePositionEvents: [PlayerUpdatePositionDetailType] - playerUpdateGoldEvents: [PlayerUpdateGoldDetailType] - playerUpdateAttributeEvents: [PlayerUpdateAttributeDetailType] - playerUpdateLevelEvents: [PlayerUpdateLevelDetailType] - playerUpdateHealthEvents: [PlayerUpdateHealthDetailType] - playerUpdateBattleEvents: [PlayerUpdateBattleDetailType] - killEvents: [KillDetailType] - deathEvents: [DeathDetailType] - assistEvents: [AssistDetailType] - csEvents: [LastHitDetailType] - goldEvents: [GoldDetailType] - experienceEvents: [ExperienceDetailType] - healEvents: [HealDetailType] - heroDamageEvents: [HeroDamageDetailType] - towerDamageEvents: [TowerDamageDetailType] - inventoryEvents: [InventoryType] - purchaseEvents: [ItemPurchaseType] - buyBackEvents: [BuyBackDetailType] - streakEvents: [StreakEventType] - spiritBearInventoryEvents: [SpiritBearInventoryType] -} - -enum MatchPlayerPositionType { - POSITION_1 - POSITION_2 - POSITION_3 - POSITION_4 - POSITION_5 - UNKNOWN - FILTERED - ALL -} - -enum MatchPlayerRoleType { - CORE - LIGHT_SUPPORT - HARD_SUPPORT - UNKNOWN -} - -type MatchPlayerSpectatorType { - steamId: Long - isRadiantCoach: Boolean - isVictory: Boolean -} - -type MatchPlayerSpiritBearInventoryType { - item0Id: Int - item1Id: Int - item2Id: Int - item3Id: Int - item4Id: Int - item5Id: Int - backPack0Id: Int - backPack1Id: Int - backPack2Id: Int - neutral0Id: Int -} - -type MatchPlayerStatsAbilityCastObjectType { - target: Int! - count: Int! - damage: Int! - duration: Int -} - -type MatchPlayerStatsAbilityCastReportType { - abilityId: Int! - count: Int! - targets: [MatchPlayerStatsAbilityCastObjectType] -} - -type MatchPlayerStatsActionReportType { - moveToPosition: Int! - moveToTarget: Int! - attackPosition: Int! - attackTarget: Int! - castPosition: Int! - castTarget: Int! - castNoTarget: Int! - heldPosition: Int! - glyphCast: Int! - scanUsed: Int! - pingUsed: Int! -} - -type MatchPlayerStatsAllTalkEventType { - time: Int! - message: String - pausedTick: Int! -} - -type MatchPlayerStatsAssistEventType { - time: Int! - target: Int - gold: Int - xp: Int - positionX: Int - positionY: Int -} - -type MatchPlayerStatsBuffEventType { - time: Int! - abilityId: Int - itemId: Int - stackCount: Int -} - -type MatchPlayerStatsChatWheelEventType { - time: Int! - chatWheelId: Short -} - -type MatchPlayerStatsCourierKillEventType { - time: Int! - positionX: Int - positionY: Int -} - -type MatchPlayerStatsDeathEventType { - time: Int! - attacker: Short - target: Int - byAbility: Int - byItem: Int - goldFed: Int - xpFed: Int - timeDead: Int - positionX: Int - positionY: Int - goldLost: Int - assist: [Int!] - isWardWalkThrough: Boolean - isAttemptTpOut: Boolean - isDieBack: Boolean - isBurst: Boolean - isEngagedOnDeath: Boolean - hasHealAvailable: Boolean - isTracked: Boolean -} - -type MatchPlayerStatsFarmDistributionObjectType { - id: Int! - count: Int! - gold: Int - xp: Int -} - -type MatchPlayerStatsFarmDistributionReportType { - creepType: [MatchPlayerStatsFarmDistributionObjectType] - creepLocation: [MatchPlayerStatsFarmDistributionObjectType] - neutralLocation: [MatchPlayerStatsFarmDistributionObjectType] - ancientLocation: [MatchPlayerStatsFarmDistributionObjectType] - buildings: [MatchPlayerStatsFarmDistributionObjectType] - buyBackGold: Int! - abandonGold: Int! - bountyGold: MatchPlayerStatsFarmDistributionObjectType - talentGold: Int! - other: [MatchPlayerStatsFarmDistributionObjectType] - itemGold: Int! -} - -type MatchPlayerStatsHeroDamageReportType { - dealtTotal: MatchPlayerHeroDamageTotalReportObjectType - receivedTotal: MatchPlayerHeroDamageTotalRecievedReportObjectType - dealtTargets: [MatchPlayerHeroDamageTargetReportObjectType] - receivedTargets: [MatchPlayerHeroDamageTargetReportObjectType] - dealtSourceAbility: [MatchPlayerHeroDamageSourceAbilityReportObjectType] - receivedSourceAbility: [MatchPlayerHeroDamageSourceAbilityReportObjectType] - dealtSourceItem: [MatchPlayerHeroDamageSourceItemReportObjectType] - receivedSourceItem: [MatchPlayerHeroDamageSourceItemReportObjectType] -} - -type MatchPlayerStatsItemUsedEventType { - itemId: Int! - count: Int -} - -type MatchPlayerStatsKillEventType { - time: Int! - target: Int - byAbility: Int - byItem: Int - gold: Int - xp: Int - positionX: Int - positionY: Int - assist: [Int!] - isSolo: Boolean - isGank: Boolean - isInvisible: Boolean - isSmoke: Boolean - isTpRecently: Boolean -} - -type MatchPlayerStatsLocationReportType { - positionX: Int! - positionY: Int! -} - -type MatchPlayerStatsRuneEventType { - time: Int! - rune: RuneEnums - action: RuneAction - gold: Int - positionX: Int - positionY: Int -} - -type MatchPlayerStatsTowerDamageReportType { - npcId: Int! - damage: Int! -} - -type MatchPlayerStatsType { - matchId: Long - steamAccountId: Long - gameVersionId: Short - level: [Int] - killEvents: [MatchPlayerStatsKillEventType] - killCount: Int - deathEvents: [MatchPlayerStatsDeathEventType] - deathCount: Int - assistEvents: [MatchPlayerStatsAssistEventType] - assistCount: Int - lastHitsPerMinute: [Int] - lastHitCount: Int - - """ - Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. - """ - goldPerMinute: [Int] - goldCount: Int - - """ - Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. - """ - experiencePerMinute: [Int] - experienceCount: Int - - """ - Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. - """ - healPerMinute: [Int] - healCount: Int - - """ - Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. - """ - heroDamagePerMinute: [Int] - heroDamageCount: Int - - """ - Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. - """ - towerDamagePerMinute: [Int] - towerDamageCount: Int - towerDamageReport: [MatchPlayerStatsTowerDamageReportType] - courierKills: [MatchPlayerStatsCourierKillEventType] - wards: [MatchPlayerStatsWardEventType] - itemPurchases: [MatchPlayerItemPurchaseEventType] - itemUsed: [MatchPlayerStatsItemUsedEventType] - allTalks: [MatchPlayerStatsAllTalkEventType] - chatWheels: [MatchPlayerStatsChatWheelEventType] - actionsPerMinute: [Int] - actionReport: MatchPlayerStatsActionReportType - invisibleSeconds: Int - locationReport: [MatchPlayerStatsLocationReportType] - farmDistributionReport: [MatchPlayerStatsFarmDistributionReportType] - runes: [MatchPlayerStatsRuneEventType] - abilityCastReport: [MatchPlayerStatsAbilityCastReportType] - heroDamageReport: MatchPlayerStatsHeroDamageReportType - inventoryReport: [MatchPlayerInventoryType] - - """ - Starts at minute 0:00 and Index 0 will show the Networth at 0:00 in the game. - """ - networthPerMinute: [Int] - - """ - Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. - """ - campStack: [Int] - matchPlayerBuffEvent: [MatchPlayerStatsBuffEventType] - - """ - Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. - """ - deniesPerMinute: [Int] - - """ - Starts at minute 0:00. The last index will contain the last subset of data, - so if a match is 41:01 long, the last index will be the change in the last 1 second. - """ - impPerMinute: [Int] - - """ - Starts at minute 0:00. The last index will contain the last subset of data, - so if a match is 41:01 long, the last index will be the change in the last 1 second. - """ - impPerMinute2: [Int] - dotaPlusHeroXp: Int - - """ - Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. - """ - tripsFountainPerMinute: [Int] - spiritBearInventoryReport: [MatchPlayerSpiritBearInventoryType] - abilities( - """ - The game version id to include in this query, excluding all results that do not have this game version. - """ - gameVerionId: Int - ): [PlayerAbilityType] - - """ - Starts at minute 0:00. Each index contains the data for that minute. Index 0 has everything from 0:00 to 0:59. - """ - heroDamageReceivedPerMinute: [Int] -} - -type MatchPlayerStatsWardEventType { - time: Int! - type: Int! - positionX: Int - positionY: Int -} - -enum MatchPlayerTeamPickOrderType { - FIRST_PICK - SECOND_PICK - THIRD_PICK - FOURTH_PICK - FIFTH_PICK -} - -type MatchPlayerType { - matchId: Long - match: MatchType - playerSlot: Byte - steamAccountId: Long - steamAccount: SteamAccountType - isRadiant: Boolean - isVictory: Boolean - heroId: Short - gameVersionId: Short - hero: HeroType - kills: Byte - deaths: Byte - assists: Byte - leaverStatus: LeaverStatusEnum - numLastHits: Short - numDenies: Short - goldPerMinute: Short - networth: Int - experiencePerMinute: Short - level: Byte - gold: Int - goldSpent: Int - heroDamage: Int - towerDamage: Int - heroHealing: Int - partyId: Byte - isRandom: Boolean - lane: MatchLaneType - streakPrediction: Byte - intentionalFeeding: Boolean - role: MatchPlayerRoleType - roleBasic: MatchPlayerRoleType - imp: Short - award: MatchPlayerAward - item0Id: Short - item1Id: Short - item2Id: Short - item3Id: Short - item4Id: Short - item5Id: Short - backpack0Id: Short - backpack1Id: Short - backpack2Id: Short - - """ - The item id of the dedicated neutral item slot (7.24 and after). From game - versions 7.23 to 7.24, this was the BackPack3Id (the 4th backpack slot item id). - """ - neutral0Id: Short - behavior: Short - stats: MatchPlayerStatsType - playbackData: MatchPlayerPlaybackDataType - heroAverage: [HeroPositionTimeDetailAverageObjectType] - additionalUnit: MatchPlayerAdditionalUnitType - - """ - Gets the players of Dota which have DotaPlus and have a high level hero. - """ - dotaPlus: [HeroDotaPlusLeaderboardRankType] -} - -type MatchReplayUploadHeroDuoSummaryType { - heroId: Short - winCountWith: Int! - winCountAgainst: Int! - matchCountWith: Int! - matchCountAgainst: Int! -} - -type MatchReplayUploadHeroSummaryType { - heroId: Short - winCountWith: Int! - winCountAgainst: Int! - matchCountWith: Int! - matchCountAgainst: Int! - banCountWith: Int! - banCountAgainst: Int! - duos: [MatchReplayUploadHeroDuoSummaryType] -} - -type MatchReplayUploadMatchType { - matchUploadTeamId: Int! - id: Long - fileName: String! - uploaderCaptainJackIdentityId: Guid - isValidated: Boolean! - isComplete: Boolean! - isActive: Boolean! - didRadiantWin: Boolean! - durationSeconds: Short - durationMinutes: Int! - startDateTime: DateTime - endDateTime: DateTime - lobbyType: Byte - numHumanPlayers: Byte - numHumanSpectators: Byte - leagueId: Int - seriesId: Long - gameMode: Byte - radiantTeamId: Int - radiantKills: Byte - direTeamId: Int - direKills: Byte - isRadiantFirstPick: Boolean! - gameVersionId: Int! - notes: String - players: [MatchReplayUploadPlayerType] - stats: MatchReplayUploadStatsType - radiantTeam: TeamType - direTeam: TeamType - league: LeagueType -} - -type MatchReplayUploadOverviewType { - matchCount: Int! - winCount: Int! - matches: [MatchReplayUploadMatchType] -} - -type MatchReplayUploadPickBanType { - playerSlot: Byte - isPick: Boolean! - heroId: Short - bannedHeroId: Short - time: Byte - isRadiant: Boolean - order: Byte - wasBannedSuccessfully: Boolean! -} - -type MatchReplayUploadPlayerStatsItemsType { - item0IdList: [Byte] - item1IdList: [Byte] - item2IdList: [Byte] - item3IdList: [Byte] - item4IdList: [Byte] - item5IdList: [Byte] - backpack0IdList: [Byte] - backpack1IdList: [Byte] - backpack2IdList: [Byte] -} - -type MatchReplayUploadPlayerStatsType { - killsList: [Int] - assistsList: [Int] - deathsList: [Int] - streakList: [Int] - levelList: [Int] - totalEarnedGoldList: [Int] - reliableGoldList: [Int] - unreliableGoldList: [Int] - totalEarnedXpList: [Int] - sharedGoldList: [Int] - heroKillGoldList: [Int] - creepKillGoldList: [Int] - incomeGoldList: [Int] - networthList: [Int] - denyCountList: [Int] - lastHitCountList: [Int] - lastHitStreakList: [Int] - lastHitMultiKillList: [Int] - nearbyCreepDeathCountList: [Int] - claimedDenyCountList: [Int] - claimedMissCountList: [Int] - missCountList: [Int] - stunsList: [Int] - heroHealingList: [Int] - towerKillsList: [Int] - roshanKillsList: [Int] - observerWardsPlacedList: [Int] - sentryWardsPlacedList: [Int] - creepStackList: [Int] - campStackList: [Int] - runePicksupList: [Int] - goldSpentOnSupportList: [Int] - heroDamageList: [Int] - wardsPurchasedList: [Int] - wardsDestroyedList: [Int] - commandsIssuedList: [Int] - goldSpentOnConsumablesList: [Int] - goldSpentOnItemsList: [Int] - goldSpentOnBuybacksList: [Int] - goldLostToDeathList: [Int] - maxHealthList: [Int] - maxManaList: [Int] - bkbChargesUsedList: [Int] - damageMinList: [Int] - damageMaxList: [Int] - damageBonusList: [Int] - strengthTotalList: [Int] - agilityTotalList: [Int] - intellectTotalList: [Int] - towerDamageList: [Int] - items: MatchReplayUploadPlayerStatsItemsType -} - -type MatchReplayUploadPlayerType { - matchId: Long - playerSlot: Byte - matchUploadTeamId: Int! - steamAccountId: Long - isRadiant: Boolean! - isDire: Boolean! - teamSlot: Byte - heroId: Short - kills: Byte - deaths: Byte - assists: Byte - networth: Int! - lastHits: Short - denies: Short - goldPerMinute: Short - experiencePerMinute: Short - totalGoldSpent: Int! - goldSpentOnBuybacks: Int - goldSpentOnConsumables: Int - goldSpentOnItems: Int - goldSpentOnSupport: Int - heroDamage: Int! - towerDamage: Int! - towerKills: Short - heroHealing: Int! - level: Byte - item0Id: Short - item1Id: Short - item2Id: Short - item3Id: Short - item4Id: Short - item5Id: Short - backpack0Id: Short - backpack1Id: Short - backpack2Id: Short - lane: MatchLaneType - role: MatchPlayerRoleType - position: MatchPlayerPositionType - pickOrder: Byte - teamPickOrder: MatchPlayerTeamPickOrderType - isVictory: Boolean! - stats: MatchReplayUploadPlayerStatsType - steamAccount: SteamAccountType -} - -type MatchReplayUploadStatsType { - spectators: [Long] - pickBans: [MatchReplayUploadPickBanType] -} - -type MatchReplayUploadTeamMemberType { - captainJackIdentityId: Guid - matchUploadTeamId: Int! - isAdmin: Boolean! - isDefaultTeam: Boolean! - steamAccount: SteamAccountType -} - -type MatchReplayUploadTeamType { - id: Int! - name: String! - email: String! - teamId: Int! - creatorCaptainJackIdentityId: Guid - team: TeamType - members: [MatchReplayUploadTeamMemberType] - isDefault: Boolean -} - -type MatchStatsChatEventType { - time: Int - type: Int - fromHeroId: Short - toHeroId: Short - value: Short - pausedTick: Int - isRadiant: Boolean -} - -type MatchStatsLaneReportFactionLaneObject { - meleeCount: Int! - rangeCount: Int! - siegeCount: Int! - denyCount: Int! - neutralCount: Int! -} - -type MatchStatsLaneReportFactionObjectType { - midLane: MatchStatsLaneReportFactionLaneObject - offLane: MatchStatsLaneReportFactionLaneObject - safeLane: MatchStatsLaneReportFactionLaneObject -} - -type MatchStatsLaneReportType { - radiant: [MatchStatsLaneReportFactionObjectType] - dire: [MatchStatsLaneReportFactionObjectType] -} - -type MatchStatsOutpostReportObjectType { - npcId: Int - isControlledByRadiant: Boolean! - isRadiantSide: Boolean! -} - -type MatchStatsPickBanType { - isPick: Boolean! - heroId: Short - team: Int - order: Int - bannedHeroId: Short - isRadiant: Boolean - playerIndex: Int - wasBannedSuccessfully: Boolean - baseWinRate: Byte - adjustedWinRate: Byte - letter: Int -} - -type MatchStatsTowerDeathType { - time: Int - npcId: Short - isRadiant: Boolean - attacker: Short -} - -type MatchStatsTowerReportObjectType { - npcId: Int - hp: Int -} - -type MatchStatsTowerReportType { - towers: [MatchStatsTowerReportObjectType] - outposts: [MatchStatsOutpostReportObjectType] -} - -type MatchStatsType { - matchId: Long - - """This begins at -60 to 0 seconds (Index 0).""" - radiantNetworthLeads: [Int] - - """This begins at -60 to 0 seconds (Index 0).""" - radiantExperienceLeads: [Int] - - """This begins at -60 to 0 seconds (Index 0).""" - radiantKills: [Int] - - """This begins at -60 to 0 seconds (Index 0).""" - direKills: [Int] - - """This begins at -60 to 0 seconds (Index 0).""" - pickBans: [MatchStatsPickBanType] - towerStatus: [MatchStatsTowerReportType] - laneReport: MatchStatsLaneReportType - winRates: [Decimal] - predictedWinRates: [Decimal] - chatEvents: [MatchStatsChatEventType] - towerDeaths: [MatchStatsTowerDeathType] -} - -type MatchType { - id: Long - didRadiantWin: Boolean - durationSeconds: Int - startDateTime: Long - endDateTime: Long - towerStatusRadiant: Int - towerStatusDire: Int - barracksStatusRadiant: Short - barracksStatusDire: Short - clusterId: Int - firstBloodTime: Int - lobbyType: LobbyTypeEnum - numHumanPlayers: Int - gameMode: GameModeEnumType - replaySalt: Long - isStats: Boolean - tournamentId: Int - tournamentRound: Short - actualRank: Short - averageRank: Short - averageImp: Short - parsedDateTime: Long - statsDateTime: Long - leagueId: Int - radiantTeamId: Int - direTeamId: Int - seriesId: Long - gameVersionId: Short - regionId: Byte - sequenceNum: Long - rank: Int - bracket: Byte - analysisOutcome: MatchAnalysisOutcomeType - predictedOutcomeWeight: Byte - players( - """ - The steam account id to include in this query, excluding all results that do not have this steam account id. - """ - steamAccountId: Long - ): [MatchPlayerType] - radiantTeam: TeamType - direTeam: TeamType - series: SeriesType - stats: MatchStatsType - playbackData: MatchPlaybackDataType - spectators: [MatchPlayerSpectatorType] - league: LeagueType -} - -input MergeProSteamAccountRequestType { - steamAccountId: Long - name: String! - realName: String -} - -type ModifierType { - id: Short - name: String - buffDuration: Int - isRoot: Boolean - isStun: Boolean - isSilence: Boolean - isInvisible: Boolean - isShackle: Boolean - isHex: Boolean - isSleep: Boolean - isCyclone: Boolean - isTaunt: Boolean - isDisarm: Boolean - isBlind: Boolean - isEthereal: Boolean - isMovementSlow: Boolean - isAttackSlow: Boolean - isBreak: Boolean - isArmorReduce: Boolean - isAttackReduce: Boolean - isMute: Boolean - isDamageAmplified: Boolean - isMovementDebuff: Boolean - isKnockback: Boolean - isWeaken: Boolean - isItem: Boolean - isBanished: Boolean -} - -type NewsItemType { - id: Long - title: String! - uri: String! - author: String! - contents: String! - feedLabel: String! - date: Long - feedName: String! -} - -type NpcStatType { - level: Float - statusHealth: Float - statusHealthRegen: Float - statusMana: Float - statusManaRegen: Float - movementSpeed: Float - movementTurnRate: Float - dayTimeVision: Float - nightTimeVision: Float - attackRangeBuffer: Float - attackRange: Float - isNeutralUnitType: Boolean - isAncient: Boolean - canBeDominated: Boolean - autoAttacksByDefault: Boolean - attackDamageMin: Float - attackDamageMax: Float - attackRate: Float - attackAnimationPoint: Float - projectileSpeed: Float - teamName: String - combatClassAttack: String - combatClassDefend: String - unitRelationshipClass: String - attackDesire: Float - hasInventory: Boolean - wakesNeutrals: Boolean -} - -type NpcType { - id: Short - name: String - stat: NpcStatType -} - -type PageAghanimQuery { - """Returns a match by Id based on the TI10 (2020) summer event.""" - match( - """ - The id of the Dota match to include in this query, excluding all results that do not include this id. - """ - id: Long! - ): TI2020CustomGameMatchType - - """Returns a list of matches by based on the TI10 (2020) summer event.""" - matches(request: FilterTI2020MatchRequestType): [TI2020CustomGameMatchType] - - """ - Returns all the combinations of Heroes and their success on the TI10 (2020) summer event. - """ - heroCompositions(request: FilterTI2020HeroCompositionRequestType!): [TI2020CustomGameHeroCompositionType] - - """ - Returns all the combinations of Heroes and their success on the TI10 (2020) summer event. - """ - heroComposition(heroIds: [Short]!, difficulty: TI2020CustomGameMatchDifficultyType!): TI2020CustomGameHeroCompositionType - - """ - Returns the last 3 days winrate for each hero by Difficulty in the TI10 (2020) summer event. - """ - winRate(difficulty: TI2020CustomGameMatchDifficultyType!): TI2020CustomGameHeroWinRateType - - """Returns all the Abilities for a Hero on the TI10 (2020) summer event.""" - heroAbility(difficulty: TI2020CustomGameMatchDifficultyType!): [TI2020CustomGameHeroAbilityType] - - """ - Returns all the Room Types by Difficulty for the TI10 (2020) summer event. - """ - room(difficulty: TI2020CustomGameMatchDifficultyType!): [TI2020CustomGameRoomType] - - """ - Returns all the Room Modifiers by Difficulty for the TI10 (2020) summer event. - """ - roomModifier(difficulty: TI2020CustomGameMatchDifficultyType!): [TI2020CustomGameRoomModifierType] -} - -type PageDireTide2020Query { - """Returns a match by Id based on the 2020 Halloween Event DireTide.""" - match( - """ - The id of the Dota match to include in this query, excluding all results that do not include this id. - """ - id: Long! - ): DireTide2020CustomGameMatchType - - """ - Returns a list of matches by based on the 2020 Halloween Event DireTide. - """ - matches(request: FilterDireTide2020CustomMatchRequestType): [DireTide2020CustomGameMatchType] - - """ - Returns the last 12 days by day showing the amount of matches and the amount of wins by hero id. - """ - winHour( - """The amount to have returned in your query.""" - take: Int - ): [DireTide2020CustomGameHeroWinDayType] -} - -type PageMatchesQuery { - """Returns the last 12 hours by hour showing the amount of matches.""" - matchesStatsHour( - """The amount to have returned in your query.""" - take: Int - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-80 with 0 being - unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. - """ - bracketIds: [RankBracket] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [BasicRegionType] - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [GameModeEnumType] - ): [MatchesHourType] - - """Returns the last 12 days by day showing the amount of matches.""" - matchesStatsDay( - """The amount to have returned in your query.""" - take: Int - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-80 with 0 being - unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. - """ - bracketIds: [RankBracket] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [BasicRegionType] - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [GameModeEnumType] - ): [MatchesDayType] - - """Returns the last 12 weeks by week showing the amount of matches.""" - matchesStatsWeek( - """The amount to have returned in your query.""" - take: Int - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-80 with 0 being - unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. - """ - bracketIds: [RankBracket] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [BasicRegionType] - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [GameModeEnumType] - ): [MatchesWeekType] - - """Returns the data by month showing the amount of matches.""" - matchesStatsMonth( - """The amount to have returned in your query.""" - take: Int - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-80 with 0 being - unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. - """ - bracketIds: [RankBracket] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [BasicRegionType] - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [GameModeEnumType] - ): [MatchesMonthType] - - """Returns the data by game version showing the amount of matches.""" - matchesStatsGameVersion( - """The amount to have returned in your query.""" - take: Int - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-80 with 0 being - unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. - """ - bracketIds: [RankBracket] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [BasicRegionType] - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [GameModeEnumType] - ): [MatchesGameVersionType] - - """ - Amount of players who are active and searching for a game in this region. - """ - matchmakingStats: [MatchmakingStatsType] -} - -type PagePlayerQuery { - """Returns the violations commited by a player in their last 500 games.""" - conduct: PlayerConductResponseType - - """Get very simple data for the on-hover of a player icon.""" - simpleSummary: PlayerCardHoverType - - """ - Provided in-depth look of a player and how they proform globally on all heroes. - """ - performance( - """ - The request object used to filter matches returned based on input criteria. - """ - request: PlayerPerformanceMatchesRequestType! - ): PlayerPerformanceType - - """A more in depth at a single player's single hero performance.""" - heroPerformance( - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short! - - """ - The request object used to filter matches returned based on input criteria. - """ - request: PlayerHeroPerformanceMatchesRequestType! - ): PlayerPerformanceType - - """ - Returns a list of all heroes played by the steam account id and contains data about the average performance. - """ - heroesPerformance( - """ - The request object used to filter matches returned based on input criteria. - """ - request: PlayerHeroesPerformanceMatchesRequestType - ): [PlayerHeroesPerformanceType] - - """ - Picked the top pros and annoucers and determines if you ever have played with them and when. - """ - playedWithPro: PlayerPlayedWithProType - - """Returns a general player summary of random set of predefinded filters.""" - breakdown( - """ - The request object used to filter matches returned based on input criteria. - """ - request: PlayerBreakdownRequestType! - ): PlayerBreakdownType -} - -type PagePlayersQuery { - """ - Endpoint which breaks down all the SteamAccounts in the database by their current season rank. - """ - steamAccountByRank: [SteamAccountByRankType] -} - -type PageQuery { - """ - STRATZ specific endpoints found on the /player/ section of the website. id is a required input field. - """ - player( - """ - The steam account id to include in this query, excluding all results that do not have this steam account id. - """ - steamAccountId: Long! - ): PagePlayerQuery - - """ - STRATZ specific endpoints found on the /players/ section of the website. - """ - players: PagePlayersQuery - - """ - STRATZ specific endpoints found on the /matches/ section of the website. - """ - matches: PageMatchesQuery - - """Endpoints for the TI10 (2020) regarding the summer event.""" - aghanim: PageAghanimQuery - - """Endpoints for Imp Related calls.""" - imp: ImpQuery - direTide2020: PageDireTide2020Query -} - -type PatchNoteLanguageType { - id: String - gameVersionId: Short - languageId: Byte - index: Byte - abilityId: Short - itemId: Short - heroId: Short - generalId: PatchNoteType - text: String -} - -enum PatchNoteType { - HERO - GENERAL - GENERIC - ITEM - NPC -} - -type PlayerAbilityType { - abilityId: Int! - time: Int! - level: Int! - gameVersionId: Short - abilityType( - """ - The game version id to include in this query, excluding all results that do not have this game version. - """ - gameVerionId: Int - - """ - The language id to include in this query, excluding all results that do not have this language. - """ - langaugeId: Int - ): AbilityType - isTalent: Boolean -} - -type PlayerActivitySummaryHeroType { - heroId: Int - winCount: Int - lossCount: Int -} - -type PlayerActivitySummaryType { - activity: PlayerBehaviorActivity - matchCount: Int - coreCount: Int - supportCount: Int - imp: Int - heroes: [PlayerActivitySummaryHeroType] -} - -type PlayerBadgeType { - badgeId: Byte - slot: Byte - createdDateTime: Long -} - -type PlayerBattlePassResponseType { - players: [PlayerBattlePassType] - playerCount: Int! - accountsAbove2000Count: Int! - accountsAbove1000Count: Int! - accountsAbove500Count: Int! - accountsAbove330Count: Int! - accountsAbove275Count: Int! - accountsAbove225Count: Int! - accountsAbove195Count: Int! - accountsAbove75Count: Int! -} - -type PlayerBattlePassType { - steamAccount: SteamAccountType - activity: Byte - level: Int! -} - -enum PlayerBehaviorActivity { - NONE - VERY_LOW - LOW - MEDIUM - HIGH - VERY_HIGH - INTENSE -} - -type PlayerBreakdownObjectType { - id: Int - matchCount: Int! - win: Int - imp: Int - lastSeenDateTime: Long -} - -input PlayerBreakdownRequestType { - """An array of Dota match ids to include in this query.""" - matchIds: [Long] - - """ - A league id to include in this query, excluding all results that do not have this league id. - """ - leagueId: Int - - """ - A series id to include in this query, excluding all results that do not have this series id. - """ - seriesId: Long - - """ - A team id to include in this query, excluding all results that do not have this team id. - """ - teamId: Int - - """ - Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. - """ - isParsed: Boolean - - """Whether the match is a league match or not.""" - isLeague: Boolean - - """Whether the match has a team assigned or not.""" - isTeam: Boolean - - """ - Requests matches where the match is at least this many minutes. Default is null and there is no minimum. - """ - minDuration: Int - - """ - Requests matches where the match is no longer than this many minutes. Default is null and there is no maximum. - """ - maxDuration: Int - - """ - The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - startDateTime: Long - - """ - The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - endDateTime: Long - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [Byte] - - """ - An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. - """ - lobbyTypeIds: [Byte] - - """ - An array of game version ids to include in this query, excluding all results - that do not include one of these game versions. - """ - gameVersionIds: [Int] - - """ - Requests matches where the match is at least than this input. See GameVersion - API call for a list of patch ids. Default is null and there is no minimum. - """ - minGameVersionId: Int - - """ - Requests matches where the match is lower than this input. See GameVersion - API call for a list of patch ids. Default is null and there is no maximum. - """ - maxGameVersionId: Int - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [Int] - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-80 with 0 being - unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. - """ - rankIds: [Int] - - """ - STRATZ applys an formula to determine if a game is considered 'real'. We - attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches - that do not include any of these poor quality matches. - """ - isStats: Boolean - - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """ - An array of lane ids (enum MatchLaneType) to include in this query, excluding - all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, - Midlane = 2, Offlane = 3, Jungle = 4 - """ - laneIds: [Int] - - """ - An array of role ids (enum MatchPlayerRoleType) to include in this query, - excluding all results that do not include one of these roles. Core = 0, Light - Support = 1, Hard Support = 2 - """ - roleIds: [Int] - - """ - An array of award ids to include in this query, excluding all results that do - not include one of these awards. The player award types include MVP (1), Top - Core (2), and Top Support (3). - """ - awardIds: [Int] - - """Include all matches that are party games, excluding all others.""" - isParty: Boolean - - """Whether the specified player was on Radiant or not.""" - isRadiant: Boolean - - """ - Matches where the user is in a party with this many friends. Automatically applys IsParty = true. This is an array input. - """ - partyCounts: [Int] - - """ - STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, - Top Support (enum MatchPlayerAwardType). If you include a query of - 'steamAccountId' then it will require that player to have gotten at least 1 of - these awards for each match result. - """ - hasAward: Boolean - - """ - An array of steam account ids found on your team to include in this query, - excluding all results that do not include one of these steam accounts found on your team. - """ - withFriendSteamAccountIds: [Long] - - """ - An array of hero ids found on your team to include in this query, excluding - all results that do not include one of these heroes found on your team. - """ - withFriendHeroIds: [Int] -} - -type PlayerBreakdownType { - matches: PlayerBreakdownObjectType - isStatsMatches: [PlayerBreakdownObjectType] - rankMatches: [PlayerBreakdownObjectType] - lobbyMatches: [PlayerBreakdownObjectType] - gameModeMatches: [PlayerBreakdownObjectType] - factionMatches: [PlayerBreakdownObjectType] - regionMatches: [PlayerBreakdownObjectType] - laneMatches: [PlayerBreakdownObjectType] - roleMatches: [PlayerBreakdownObjectType] - partyMatches: [PlayerBreakdownObjectType] - impMatches: [PlayerBreakdownObjectType] - durationMatches: [PlayerBreakdownObjectType] - heroAttributeMatches: [PlayerBreakdownObjectType] - dayOfWeekMatches: [PlayerBreakdownObjectType] - timeOfDayMatches: [PlayerBreakdownObjectType] - weekEndMatches: [PlayerBreakdownObjectType] -} - -type PlayerCardHoverHeroType { - heroId: Int! - winCount: Int! - lossCount: Int! -} - -type PlayerCardHoverType { - steamAccount: SteamAccountType - lastUpdateDateTime: Long - matchCount: Int - coreCount: Int - supportCount: Int - imp: Int - heroes: PlayerCardHoverHeroType - activity: Byte -} - -type PlayerCoachingLeaderboardResponseType { - players: PlayerCoachingLeaderboardType - accounts: Int! - accountsAbove500: Int! - accountsAbove2500: Int! -} - -type PlayerCoachingLeaderboardType { - steamAccount: SteamAccountType - activity: Byte - rating: Int! - matchCount: Int! - winCount: Int! - firstMatchDateTime: Long - lastMatchDateTime: Long -} - -type PlayerConductResponseType { - lastIncidentDateTime: Long - lastIncidentMatchId: Long - recentMatchIncidents: [Short] - behaviorScore: Short -} - -type PlayerDraftHeroHighlightType { - lastPlayed: Long - winCount: Int - matchCount: Int - impAllTime: Int - mvpCountLastMonth: Int - topCoreCountLastMonth: Int - topSupportCountLastMonth: Int - winCountLastMonth: Int - matchCountLastMonth: Int - impLastMonth: Int - winCountLastSixMonths: Int - matchCountLastSixMonths: Int - impLastSixMonths: Int -} - -type PlayerHeroDotaPlusLeaderboardRankResponseType { - players: [HeroDotaPlusLeaderboardRankType] -} - -input PlayerHeroesPerformanceMatchesRequestType { - """An array of Dota match ids to include in this query.""" - matchIds: [Long] - - """ - A league id to include in this query, excluding all results that do not have this league id. - """ - leagueId: Int - - """ - A series id to include in this query, excluding all results that do not have this series id. - """ - seriesId: Long - - """ - A team id to include in this query, excluding all results that do not have this team id. - """ - teamId: Int - - """ - Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. - """ - isParsed: Boolean - - """Whether the match is a league match or not.""" - isLeague: Boolean - - """Whether the match has a team assigned or not.""" - isTeam: Boolean - - """ - Requests matches where the match is at least this many minutes. Default is null and there is no minimum. - """ - minDuration: Int - - """ - Requests matches where the match is no longer than this many minutes. Default is null and there is no maximum. - """ - maxDuration: Int - - """ - The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - startDateTime: Long - - """ - The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - endDateTime: Long - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [Byte] - - """ - An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. - """ - lobbyTypeIds: [Byte] - - """ - An array of game version ids to include in this query, excluding all results - that do not include one of these game versions. - """ - gameVersionIds: [Int] - - """ - Requests matches where the match is at least than this input. See GameVersion - API call for a list of patch ids. Default is null and there is no minimum. - """ - minGameVersionId: Int - - """ - Requests matches where the match is lower than this input. See GameVersion - API call for a list of patch ids. Default is null and there is no maximum. - """ - maxGameVersionId: Int - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [Int] - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-80 with 0 being - unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. - """ - rankIds: [Int] - - """ - STRATZ applys an formula to determine if a game is considered 'real'. We - attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches - that do not include any of these poor quality matches. - """ - isStats: Boolean - - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """ - An array of lane ids (enum MatchLaneType) to include in this query, excluding - all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, - Midlane = 2, Offlane = 3, Jungle = 4 - """ - laneIds: [Int] - - """ - An array of role ids (enum MatchPlayerRoleType) to include in this query, - excluding all results that do not include one of these roles. Core = 0, Light - Support = 1, Hard Support = 2 - """ - roleIds: [Int] - - """ - An array of award ids to include in this query, excluding all results that do - not include one of these awards. The player award types include MVP (1), Top - Core (2), and Top Support (3). - """ - awardIds: [Int] - - """Include all matches that are party games, excluding all others.""" - isParty: Boolean - - """Whether the specified player was on Radiant or not.""" - isRadiant: Boolean - - """ - Matches where the user is in a party with this many friends. Automatically applys IsParty = true. This is an array input. - """ - partyCounts: [Int] - - """ - STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, - Top Support (enum MatchPlayerAwardType). If you include a query of - 'steamAccountId' then it will require that player to have gotten at least 1 of - these awards for each match result. - """ - hasAward: Boolean - - """ - An array of steam account ids found on your team to include in this query, - excluding all results that do not include one of these steam accounts found on your team. - """ - withFriendSteamAccountIds: [Long] - - """ - An array of hero ids found on your team to include in this query, excluding - all results that do not include one of these heroes found on your team. - """ - withFriendHeroIds: [Int] -} - -type PlayerHeroesPerformanceScoreType { - id: Int! - score: Float! - matchCount: Int! - winCount: Int! - imp: Int -} - -type PlayerHeroesPerformanceType { - heroId: Short! - hero: HeroType - winCount: Int! - kDA: Float - avgKills: Float - avgDeaths: Float - avgAssists: Float - duration: Int! - imp: Int - best: Float - matchCount: Int! - goldPerMinute: Int! - experiencePerMinute: Int! - laneScore: [PlayerHeroesPerformanceScoreType] - roleScore: [PlayerHeroesPerformanceScoreType] - lastPlayedDateTime: Long -} - -type PlayerHeroPerformanceLongestStreakType { - heroId: Short - longestStreak: Int - currentStreak: Int -} - -input PlayerHeroPerformanceMatchesRequestType { - """An array of Dota match ids to include in this query.""" - matchIds: [Long] - - """ - A league id to include in this query, excluding all results that do not have this league id. - """ - leagueId: Int - - """ - A series id to include in this query, excluding all results that do not have this series id. - """ - seriesId: Long - - """ - A team id to include in this query, excluding all results that do not have this team id. - """ - teamId: Int - - """ - Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. - """ - isParsed: Boolean - - """Whether the match is a league match or not.""" - isLeague: Boolean - - """Whether the match has a team assigned or not.""" - isTeam: Boolean - - """ - Requests matches where the match is at least this many minutes. Default is null and there is no minimum. - """ - minDuration: Int - - """ - Requests matches where the match is no longer than this many minutes. Default is null and there is no maximum. - """ - maxDuration: Int - - """ - The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - startDateTime: Long - - """ - The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - endDateTime: Long - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [Byte] - - """ - An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. - """ - lobbyTypeIds: [Byte] - - """ - An array of game version ids to include in this query, excluding all results - that do not include one of these game versions. - """ - gameVersionIds: [Int] - - """ - Requests matches where the match is at least than this input. See GameVersion - API call for a list of patch ids. Default is null and there is no minimum. - """ - minGameVersionId: Int - - """ - Requests matches where the match is lower than this input. See GameVersion - API call for a list of patch ids. Default is null and there is no maximum. - """ - maxGameVersionId: Int - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [Int] - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-80 with 0 being - unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. - """ - rankIds: [Int] - - """ - STRATZ applys an formula to determine if a game is considered 'real'. We - attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches - that do not include any of these poor quality matches. - """ - isStats: Boolean - - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """ - An array of lane ids (enum MatchLaneType) to include in this query, excluding - all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, - Midlane = 2, Offlane = 3, Jungle = 4 - """ - laneIds: [Int] - - """ - An array of role ids (enum MatchPlayerRoleType) to include in this query, - excluding all results that do not include one of these roles. Core = 0, Light - Support = 1, Hard Support = 2 - """ - roleIds: [Int] - - """ - An array of award ids to include in this query, excluding all results that do - not include one of these awards. The player award types include MVP (1), Top - Core (2), and Top Support (3). - """ - awardIds: [Int] - - """Include all matches that are party games, excluding all others.""" - isParty: Boolean - - """Whether the specified player was on Radiant or not.""" - isRadiant: Boolean - - """ - Matches where the user is in a party with this many friends. Automatically applys IsParty = true. This is an array input. - """ - partyCounts: [Int] - - """ - STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, - Top Support (enum MatchPlayerAwardType). If you include a query of - 'steamAccountId' then it will require that player to have gotten at least 1 of - these awards for each match result. - """ - hasAward: Boolean - - """ - An array of steam account ids found on your team to include in this query, - excluding all results that do not include one of these steam accounts found on your team. - """ - withFriendSteamAccountIds: [Long] - - """ - An array of hero ids found on your team to include in this query, excluding - all results that do not include one of these heroes found on your team. - """ - withFriendHeroIds: [Int] -} - -type PlayerLeaderBoardByHeroType { - heroId: Short - seasonBracket: Byte - steamAccountId: Long - steamAccount: SteamAccountType - impAverage: Byte - role: MatchPlayerRoleType - lane: MatchLaneType - wins: Byte - losses: Byte - winStreak: Byte - regionId: Byte - changeInRanking: Short - createdDateTime: Long -} - -input PlayerMatchesGroupByRequestType { - """ - Only used when doing matchesGroupBy endpoint. This is how the data will be grouped and makes your return Id field. - """ - groupBy: FindMatchPlayerGroupBy! - - """An array of Dota match ids to include in this query.""" - matchIds: [Long] - - """ - A league id to include in this query, excluding all results that do not have this league id. - """ - leagueId: Int - - """ - A series id to include in this query, excluding all results that do not have this series id. - """ - seriesId: Long - - """ - A team id to include in this query, excluding all results that do not have this team id. - """ - teamId: Int - - """ - Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. - """ - isParsed: Boolean - - """ - The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - startDateTime: Long - - """ - The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - endDateTime: Long - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [Byte] - - """ - An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. - """ - lobbyTypeIds: [Byte] - - """ - An array of game version ids to include in this query, excluding all results - that do not include one of these game versions. - """ - gameVersionIds: [Int] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [Int] - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-80 with 0 being - unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. - """ - rankIds: [Int] - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being unknown - MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketIds: [Int] - - """ - STRATZ applys an formula to determine if a game is considered 'real'. We - attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches - that do not include any of these poor quality matches. - """ - isStats: Boolean - - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """ - An array of lane ids (enum MatchLaneType) to include in this query, excluding - all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, - Midlane = 2, Offlane = 3, Jungle = 4 - """ - laneIds: [Int] - - """ - An array of role ids (enum MatchPlayerRoleType) to include in this query, - excluding all results that do not include one of these roles. Core = 0, Light - Support = 1, Hard Support = 2 - """ - roleIds: [Int] - - """ - An array of award ids to include in this query, excluding all results that do - not include one of these awards. The player award types include MVP (1), Top - Core (2), and Top Support (3). - """ - awardIds: [Int] - - """Include all matches that are party games, excluding all others.""" - isParty: Boolean - - """ - STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, - Top Support (enum MatchPlayerAwardType). If you include a query of - 'steamAccountId' then it will require that player to have gotten at least 1 of - these awards for each match result. - """ - hasAward: Boolean - - """ - An array of steam account ids found on your team to include in this query, - excluding all results that do not include one of these steam accounts found on your team. - """ - withFriendSteamAccountIds: [Long] - - """ - An array of hero ids found on your team to include in this query, excluding - all results that do not include one of these heroes found on your team. - """ - withFriendHeroIds: [Int] -} - -input PlayerMatchesRequestType { - """An array of Dota match ids to include in this query.""" - matchIds: [Long] - - """ - A league id to include in this query, excluding all results that do not have this league id. - """ - leagueId: Int - - """ - A series id to include in this query, excluding all results that do not have this series id. - """ - seriesId: Long - - """ - A team id to include in this query, excluding all results that do not have this team id. - """ - teamId: Int - - """ - When requesting matches with a primary SteamAccountId, this will ensure that player is on specific team Id being sent in. - """ - teamIdSteamAccount: Int - - """ - Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. - """ - isParsed: Boolean - - """ - The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - startDateTime: Long - - """ - The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - endDateTime: Long - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [Byte] - - """ - An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. - """ - lobbyTypeIds: [Byte] - - """ - An array of game version ids to include in this query, excluding all results - that do not include one of these game versions. - """ - gameVersionIds: [Int] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [Int] - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-80 with 0 being - unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. - """ - rankIds: [Int] - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-8 with 0 being unknown - MMR and 1-8 is low to high MMR brackets. Example 7 is Divine. - """ - bracketIds: [Int] - - """ - STRATZ applys an formula to determine if a game is considered 'real'. We - attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches - that do not include any of these poor quality matches. - """ - isStats: Boolean - - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """ - An array of lane ids (enum MatchLaneType) to include in this query, excluding - all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, - Midlane = 2, Offlane = 3, Jungle = 4 - """ - laneIds: [Int] - - """ - An array of role ids (enum MatchPlayerRoleType) to include in this query, - excluding all results that do not include one of these roles. Core = 0, Light - Support = 1, Hard Support = 2 - """ - roleIds: [Int] - - """ - An array of award ids to include in this query, excluding all results that do - not include one of these awards. The player award types include MVP (1), Top - Core (2), and Top Support (3). - """ - awardIds: [Int] - - """Include all matches that are party games, excluding all others.""" - isParty: Boolean - - """ - STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, - Top Support (enum MatchPlayerAwardType). If you include a query of - 'steamAccountId' then it will require that player to have gotten at least 1 of - these awards for each match result. - """ - hasAward: Boolean - - """ - An array of steam account ids found on your team to include in this query, - excluding all results that do not include one of these steam accounts found on your team. - """ - withFriendSteamAccountIds: [Long] - - """ - An array of hero ids found on your team to include in this query, excluding - all results that do not include one of these heroes found on your team. - """ - withFriendHeroIds: [Int] - - """ - Requests matches where the match is at least than this input. See GameVersion - API call for a list of patch ids. Default is null and there is no minimum. - """ - minGameVersionId: Int - - """ - Requests matches where the match is lower than this input. See GameVersion - API call for a list of patch ids. Default is null and there is no maximum. - """ - maxGameVersionId: Int - - """ - Determines if you want a single player returned, only the player by - SteamAccountId, or if you want all 10 players in the match. - """ - playerList: FindMatchPlayerList - - """ - The amount of matches to skip before collecting your query. Hint: Paging - """ - skip: Int - - """The amount of matches to have returned in your query. Max 1000""" - take: Int - - """Only return matches before this match id. Can be used instead of Skip.""" - before: Long - - """Only return matches after this match id. Can be used instead of Skip.""" - after: Long - - """In what order the returned data will come in.""" - orderBy: FindMatchPlayerOrderBy -} - -type PlayerPerformanceCompositionHeroType { - heroId: Short - matchCount: Int! - winCount: Int! -} - -type PlayerPerformanceCompositionType { - allies: [PlayerPerformanceCompositionHeroType] - foes: [PlayerPerformanceCompositionHeroType] -} - -input PlayerPerformanceMatchesRequestType { - """An array of Dota match ids to include in this query.""" - matchIds: [Long] - - """ - A league id to include in this query, excluding all results that do not have this league id. - """ - leagueId: Int - - """ - A series id to include in this query, excluding all results that do not have this series id. - """ - seriesId: Long - - """ - A team id to include in this query, excluding all results that do not have this team id. - """ - teamId: Int - - """ - Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. - """ - isParsed: Boolean - - """Whether the match is a league match or not.""" - isLeague: Boolean - - """Whether the match has a team assigned or not.""" - isTeam: Boolean - - """ - The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - startDateTime: Long - - """ - The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - endDateTime: Long - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [Byte] - - """ - An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. - """ - lobbyTypeIds: [Byte] - - """ - An array of game version ids to include in this query, excluding all results - that do not include one of these game versions. - """ - gameVersionIds: [Int] - - """ - When searching for a league, the tier the league must be in. Tiers: Amateur = - 1, Professional = 2, Premium = 3, Pro Circuit = 4, Main Event = 5 - """ - tier: [Int] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [Int] - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-80 with 0 being - unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. - """ - rankIds: [Int] - - """ - STRATZ applys an formula to determine if a game is considered 'real'. We - attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches - that do not include any of these poor quality matches. - """ - isStats: Boolean - - """ - An array of lane ids (enum MatchLaneType) to include in this query, excluding - all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, - Midlane = 2, Offlane = 3, Jungle = 4 - """ - laneIds: [Int] - - """ - An array of role ids (enum MatchPlayerRoleType) to include in this query, - excluding all results that do not include one of these roles. Core = 0, Light - Support = 1, Hard Support = 2 - """ - roleIds: [Int] - - """ - An array of award ids to include in this query, excluding all results that do - not include one of these awards. The player award types include MVP (1), Top - Core (2), and Top Support (3). - """ - awardIds: [Int] - - """Include all matches that are party games, excluding all others.""" - isParty: Boolean - - """ - STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, - Top Support (enum MatchPlayerAwardType). If you include a query of - 'steamAccountId' then it will require that player to have gotten at least 1 of - these awards for each match result. - """ - hasAward: Boolean - - """Whether the match was a victory or not for the specified player.""" - isVictory: Boolean - - """Whether the specified player was on Radiant or not.""" - isRadiant: Boolean - - """ - An array of steam account ids found on your team to include in this query, - excluding all results that do not include one of these steam accounts found on your team. - """ - withFriendSteamAccountIds: [Long] - - """ - An array of hero ids found on your team to include in this query, excluding - all results that do not include one of these heroes found on your team. - """ - withFriendHeroIds: [Int] -} - -type PlayerPerformancePositionObjectType { - laneType: Byte - laneMatchCount: Int! - laneWinCount: Int! -} - -type PlayerPerformancePositionType { - roleType: Byte - roleMatchCount: Int! - roleWinCount: Int! - lanes: [PlayerPerformancePositionObjectType] -} - -type PlayerPerformanceType { - heroId: [Short] - hero: HeroType - matchCount: Int! - winCount: Int! - streak: Int! - maxStreak: Int! - imp: Int - rank: Int - mmrTier: Int! - mmrBracket: Int! - awardMatchCount: Int! - mvpCount: Int! - topCoreCount: Int! - topSupportCount: Int! - kills: Int - killsAverage: Decimal - deaths: Int - deathsAverage: Decimal - assists: Int - assistsAverage: Decimal - cs: Int - csAverage: Decimal - gpm: Int - gpmAverage: Decimal - xpm: Int - xpmAverage: Decimal - composition: PlayerPerformanceCompositionType - position: [PlayerPerformancePositionType] - - """ - Contains an array of 6 items which are listed as index 0 - 1st Pick, Index 1 - - Pick 2nd, 3rd, Index 2 - Pick 4th, 5th, Index 3 - Pick 6th, Pick 7th, Index 4 - - Pick 8th, 9ths, Index 5 - Pick 10th - """ - pickOrder: [Int] -} - -type PlayerPlayedWithProPlayerMatchType { - matchId: Long - date: Long - isVictory: Boolean! -} - -type PlayerPlayedWithProPlayerType { - steamId: Long - name: String! - with: PlayerPlayedWithProPlayerMatchType - vs: PlayerPlayedWithProPlayerMatchType -} - -type PlayerPlayedWithProTeamType { - teamId: Int! - teamLogo: String! - teamName: String! - players: [PlayerPlayedWithProPlayerType] -} - -type PlayerPlayedWithProType { - playedCount: Int! - totalCount: Int! - casters: [PlayerPlayedWithProPlayerType] - teams: [PlayerPlayedWithProTeamType] - internationalWinners: [PlayerPlayedWithProTeamType] -} - -type PlayerType { - steamAccountId: Long - identity: CaptainJackIdentityPublicProfileType - steamAccount: SteamAccountType - matchCount: Int - winCount: Int - imp: Int - lastMatchDate: Long - lastMatchRegionId: Byte - ranks( - """An array of season in which Dota creates each year for ranks.""" - seasonRankIds: [Byte] - ): [SteamAccountSeasonRankType] - leaderboardRanks( - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int - ): [SteamAccountSeasonLeaderBoardRankType] - languageCodes: [String] - badges: [PlayerBadgeType] - names: [SteamAccountNameType] - behaviorScore: Short - team: SteamAccountTeamMemberType - guildMember: GuildMemberType - activity: PlayerActivitySummaryType - isFollowed: Boolean - simpleSummary: PlayerCardHoverType - performance: PlayerPerformanceType - heroPerformance( - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short! - - """ - The request object used to filter matches returned based on input criteria. - """ - request: PlayerHeroPerformanceMatchesRequestType! - ): PlayerPerformanceType - - """ - Returns a list of all heroes played by the steam account id and contains data about the average performance. - """ - heroesPerformance( - """ - The request object used to filter matches returned based on input criteria. - """ - request: PlayerHeroPerformanceMatchesRequestType - ): [PlayerHeroesPerformanceType] - - """ - Picked the top pros and annoucers and determines if you ever have played with them and when. - """ - playedWithPro: [PlayerPlayedWithProType] - - """ - Find match details by steam account id. steamAccountId is a required input field. - """ - matches( - """ - The request object used to filter matches returned based on input criteria. - """ - request: PlayerMatchesRequestType! - ): [MatchType] - - """ - Find match details by steam account id. The return is modified to group the data by the GroupBy parameter. - """ - matchesGroupBy( - """ - The request object used to filter matches returned based on input criteria. - """ - request: PlayerMatchesGroupByRequestType! - ): [MatchGroupByType] - - """ - Gets the players of Dota which have DotaPlus and have a high level hero. - """ - dotaPlus: [HeroDotaPlusLeaderboardRankType] - - """ - A list of the current Streak and the Longest Streak for each Hero by a Player. - """ - heroStreaks( - """ - The request object used to filter matches returned based on input criteria. - """ - request: PlayerMatchesRequestType - ): [PlayerHeroPerformanceLongestStreakType] -} - -type PlayerUpdateAttributeDetailType { - time: Int! - agi: Int! - int: Int! - str: Int! -} - -type PlayerUpdateBattleDetailType { - time: Int! - damageMinMax: Int! - damageBonus: Int! - hpRegen: Int! - mpRegen: Int! -} - -type PlayerUpdateGoldDetailType { - time: Int! - gold: Int! - unreliableGold: Int! - networth: Int! - networthDifference: Int! -} - -type PlayerUpdateHealthDetailType { - time: Int! - hp: Int! - maxHp: Int! - mp: Int! - maxMp: Int! -} - -type PlayerUpdateLevelDetailType { - time: Int! - level: Int! -} - -type PlayerUpdatePositionDetailType { - time: Int! - x: Int! - y: Int! -} - -input PlusDraftMissingLetterPlayerObjectType { - """The slot of player. It is required to be in order from 0-9.""" - slot: Int! - - """ - When a player has selected a hero, this is the id. If a null is sent, we will send back a hero list of possible heroes. - """ - heroId: Short - - """ - The rank this played is. In the event he is anonymous, use the lowest rank player in the game. - """ - rank: Int - - """ - The lane this player will play. If a null is sent, we will assign the best possible lane. - """ - position: MatchPlayerPositionType - - """ - The order in which this player has picked. If a person has not picked, please send null. Send in order of 0-9. - """ - order: Byte - - """ - To determine the missing letter, isPicking will determine the score before the - hero was selected and after the hero is selected. Only 1 person can have - isPicking = true. - """ - isPicking: Boolean -} - -input PlusDraftMissingLetterRequestType { - """A list of all of the banned hero ids in the draft.""" - bans: [Short] - - """A boolean representing if Radiant is first pick or not.""" - isRadiantFirstPick: Boolean! - - """ - The game mode for this type. We only support All Pick and Ranked All Pick. In the future Captain's Mode will be supported. - """ - gameMode: Int! - - """A list of player request objects.""" - players: [PlusDraftMissingLetterPlayerObjectType]! - - """ - Due to Valve changing the way Picking has happened in the past, we require the - GameVersionId so we know what version of the network to call. - """ - gameVersionId: Short! -} - -type PlusDraftPlayerHeroObjectType { - heroId: Short - pickValue: Decimal - winValues: [Decimal] - score: Float - letter: PlusLetterType -} - -input PlusDraftPlayerRequestType { - """ - The steam id of the player. This will allow us to find player history on the player if he is not anonymous. - """ - steamAccountId: Long - - """The slot of player. It is required to be in order from 0-9.""" - slot: Int! - - """ - When a player has selected a hero, this is the id. If a null is sent, we will send back a hero list of possible heroes. - """ - heroId: Short - - """ - This is used when a player has not selected a hero, but wishes to play a hero. - It will form the draft around the fact that when its his turn to pick, it will be that hero. - """ - suggestHeroId: Short - - """ - The rank this played is. In the event he is anonymous, use the lowest rank player in the game. - """ - rank: Byte - - """ - The role this player will play. If a null is sent, we will assign the best possible role. - """ - position: MatchPlayerPositionType - - """ - The role this player will play. If a null is sent, we will assign the best possible role. - """ - order: Byte -} - -type PlusDraftPlayerType { - slot: Byte - position: MatchPlayerPositionType - positionValues: [Decimal] - heroes: [PlusDraftPlayerHeroObjectType] -} - -input PlusDraftRequestType { - """ - The match Id or the lobby id of the match your sending. This will cache data for the next calls to be quicker. - """ - matchId: Long! - - """A list of all of the banned hero ids in the draft.""" - bans: [Short] - - """A boolean representing if Radiant is first pick or not.""" - isRadiantFirstPick: Boolean! - - """ - The game mode for this type. We only support All Pick and Ranked All Pick. In the future Captain's Mode will be supported. - """ - gameMode: Int! - - """A list of player request objects.""" - players: [PlusDraftPlayerRequestType]! - - """ - Due to Valve changing the way Picking has happened in the past, we require the - GameVersionId so we know what version of the network to call. - """ - gameVersionId: Short! -} - -type PlusDraftType { - midOutcome: Decimal - safeOutcome: Decimal - offOutcome: Decimal - winValues: [Decimal] - durationValues: [Decimal] - players: [PlusDraftPlayerType] -} - -type PlusHeroTeamStatusAveragesType { - cs: Decimal - deaths: Decimal - towerDamage: Decimal - physicalDamage: Decimal - magicalDamage: Decimal - physicalDamageReceived: Decimal - magicalDamageReceived: Decimal - disableCount: Decimal - disableDuration: Decimal - stunCount: Decimal - stunDuration: Decimal - slowCount: Decimal - slowDuration: Decimal - healingAllies: Decimal - purgeModifiers: Decimal - weakenCount: Decimal - weakenDuration: Decimal - pureDamageReceived: Decimal - pureDamage: Decimal -} - -type PlusHeroTeamStatusDetailType { - heroId: Int! - basicBracket: RankBracketHeroTimeDetail - position: MatchPlayerPositionType - averages: PlusHeroTeamStatusAveragesType -} - -type PlusHoverBanType { - heroId: Short - score: Decimal - flags: Byte -} - -type PlusHoverType { - players: [PlusPlayerHoverType] - bans: [PlusHoverBanType] -} - -enum PlusLetterType { - F - D - C - B - A - S -} - -type PlusPlayerHoverHeroType { - heroId: Short - winCount: Int! - lossCount: Int! -} - -type PlusPlayerHoverPlayerType { - steamAccountId: Long - matchCount: Int! - winCount: Int! - lastMatchDateTime: Long -} - -input PlusPlayerHoverRequestType { - """ - An array of steam account ids to limit the query to only return matches with - these steam account ids. There is a maximum of 10 steam account ids allowed. - """ - steamAccountIds: [Long]! - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [Byte] - - """ - An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. - """ - lobbyTypeIds: [Byte] - - """The amount of matches to have returned in your query. Max 1000""" - take: Int - - """ - Should our Networks attempt to try to make Radiant Win the draft or Dire. - """ - shouldRadiantWin: Boolean -} - -type PlusPlayerHoverType { - steamAccount: SteamAccountType - matchCount: Int - winCount: Int! - coreCount: Int - supportCount: Int - imp: Int - heroes: [PlusPlayerHoverHeroType] - activity: Byte - languageCode: [String] - friends: [PlusPlayerHoverPlayerType] - enemies: [PlusPlayerHoverPlayerType] - lastMatchDateTime: Long - heroesExperience: [Short] - behaviorScore: Short -} - -type PlusQuery { - """ - The main call for STRATZ Plus. It will return back probability data based on a draft of players that were given. - """ - draft( - """ - The main call for STRATZ Plus. It will return back probability data based on a draft of players that were given. - """ - request: PlusDraftRequestType! - ): PlusDraftType - - """ - Gets a list of data of the players in the match, can send a max of 10 people. - If a user blocks their data on STRATZ, that data will not be returned. - """ - playerMatchHistory( - """The request object that will filter your PlusPlayerHover data.""" - request: PlusPlayerHoverRequestType! - ): PlusHoverType - - """ - Returns back basic data about the user playing a specific hero. Used in the Draft app to show post-pick data. - """ - playerHeroHighlight( - """ - The Steam Account Id to look up. If the person is anonymous, you will get a null. - """ - steamAccountId: Long! - - """ - The hero id to include in this query, excluding all results that do not include this hero. - """ - heroId: Short! - ): PlayerDraftHeroHighlightType - - """ - Returns a set of events which contain each hero and their averages in each of - the respected categories, sorted by rank bracket. - """ - teamHeroStatus( - """ - The id of the rank bracket to include in this query, excluding all results that do not include this rank bracket. - """ - rankBracket: RankBracketHeroTimeDetail! - ): [PlusHeroTeamStatusDetailType] - - """ - To save CPU cycles we limit the amount of heroes a person can play. If a - player picks a hero outside the default list, we have no idea how good the - hero would of been. You can call this endpoint to update the grade letter for - that hero selection. - """ - draftMissingLetter(request: PlusDraftMissingLetterRequestType!): PlusLetterType -} - -type ProPlayerFollowType { - steamAccountId: Long - activity: Int - matchCount: Int! - coreCount: Int! - supportCount: Int! - steamAccount: SteamAccountType -} - -type ProSteamAccountType { - id: Long - name: String - realName: String - fantasyRole: Byte - teamId: Int - sponsor: String - isLocked: Boolean! - isPro: Boolean! - totalEarnings: Int! - birthday: Long - romanizedRealName: String - roles: Byte - aliases: [String] - statuses: Byte - twitterLink: String - twitchLink: String - instagramLink: String - vkLink: String - youTubeLink: String - facebookLink: String - weiboLink: String - signatureHeroes: [String] - position: MatchPlayerPositionType - countries: [String] - team: TeamType -} - -type RabbitDetailType { - lastUpdated: Long - isOnline: Boolean! - matchHistory: RabbitQueueDetailType - matchDetail: RabbitQueueDetailType - matchDetailDelay: RabbitQueueDetailType - matchStats: RabbitQueueDetailType - steamAccount: RabbitQueueDetailType - matchLive: RabbitQueueDetailType -} - -type RabbitQueueDetailType { - queueCount: Int! - queueInRate: Decimal - queueOutRate: Decimal -} - -enum RankBracket { - UNCALIBRATED - HERALD - GUARDIAN - CRUSADER - ARCHON - LEGEND - ANCIENT - DIVINE - IMMORTAL -} - -enum RankBracketHeroTimeDetail { - UNCALIBRATED - HERALD_GUARDIAN - CRUSADER_ARCHON - LEGEND_ANCIENT - DIVINE_IMMORTAL - FILTERED - ALL -} - -type RecentHighImpType { - matchId: Long - imp: Short - match: MatchType -} - -type RecentRampageType { - matchId: Long - heroId: Short - hero: HeroType - heroesKilled: [Short] - match: MatchType -} - -type RecentWinStreakType { - matchId: Long - winStreakCount: Int - - """The status of the win streak, Ended (0) or Ongoing (1).""" - status: Int - firstWonMatchDateTime: DateTime - lastWonMatchDateTime: DateTime - match: MatchType -} - -type RegionType { - id: Byte - name: String - clientName: String - displayName: String - leaderboardDivision: String - langKey: String - latitude: Decimal - longitude: Decimal - code: String - matchGroup: Byte - weekendTourneyDivision: String -} - -type RoleType { - roleId: Short - name: String - langKey: String -} - -enum RuneAction { - PICKUP - BOTTLE -} - -enum RuneEnums { - HASTE - REGEN - DOUBLE_DAMAGE - ILLUSION - INVISIBILITY - BOUNTY - ARCANE - WATER -} - -enum Search { - PLAYERS - MATCHES - LEAGUES - TEAMS - PRO_PLAYERS - CASTERS - GUILDS -} - -type SearchType { - players: [SteamAccountType] - matches: [MatchType] - leagues: [LeagueType] - teams: [TeamType] - proPlayers: [SteamAccountType] - casters: [SteamAccountType] - guild: GuildType - direTideMatches: [DireTide2020CustomGameMatchType] -} - -enum Series { - BEST_OF_ONE - BEST_OF_THREE - BEST_OF_FIVE - BEST_OF_TWO -} - -type SeriesType { - id: Long! - type: Series - teamOneId: Int - teamTwoId: Int - leagueId: Int - teamOneWinCount: Short - teamTwoWinCount: Short - winningTeamId: Int - lastMatchDateTime: Long - matches: [MatchType] - teamOne: TeamType - teamTwo: TeamType - league: LeagueType -} - -type ServerStatusType { - isRedisOnline: Boolean! - steamApiDetail: SteamApiDetailType - rabbitDetail: RabbitDetailType -} - -scalar Short - -type SpiritBearInventoryObjectType { - itemId: Short -} - -type SpiritBearInventoryType { - time: Int! - item0: SpiritBearInventoryObjectType - item1: SpiritBearInventoryObjectType - item2: SpiritBearInventoryObjectType - item3: SpiritBearInventoryObjectType - item4: SpiritBearInventoryObjectType - item5: SpiritBearInventoryObjectType - backPack0: SpiritBearInventoryObjectType - backPack1: SpiritBearInventoryObjectType - backPack2: SpiritBearInventoryObjectType - teleport0: SpiritBearInventoryObjectType - neutral0: SpiritBearInventoryObjectType -} - -type SteamAccountBattlePassType { - steamId: Long - eventId: Byte - level: Int -} - -type SteamAccountByRankType { - rank: Byte - playerCount: Int -} - -type SteamAccountNameType { - name: String - lastSeenDateTime: Long -} - -type SteamAccountSeasonActiveLeaderboardRankType { - steamAccountId: Long - steamAccount: SteamAccountType - avgImp: Short - divisionId: LeaderboardDivision - lastUpdateDateTime: Long - matchCount: Short - position: MatchPlayerPositionType - positionValue: Byte - rank: Short - rankShift: Short - topHeroOne: Short - topHeroTwo: Short - topHeroThree: Short - winRate: Byte -} - -type SteamAccountSeasonLeaderBoardRankType { - steamAccountId: Long - seasonRankId: Byte - asOfDateTime: Long - seasonLeaderBoardDivisionId: Byte - rank: Short -} - -type SteamAccountSeasonRankType { - seasonRankId: Byte - asOfDateTime: Long - isCore: Boolean - rank: Byte -} - -type SteamAccountTeamMemberType { - steamAccountId: Long - steamAccount: SteamAccountType - player: PlayerType - teamId: Long - firstMatchId: Long - firstMatchDateTime: Long - lastMatchId: Long - lastMatchDateTime: Long - team: TeamType -} - -type SteamAccountType { - id: Long - profileUri: String! - realName: String - timeCreated: Long - countryCode: String - stateCode: String - cityId: Int - communityVisibleState: Int - name: String - lastLogOff: Long - avatar: String - primaryClanId: Long - isDotaPlusSubscriber: Boolean - isAnonymous: Boolean! - isStratzAnonymous: Boolean! - seasonRank: Byte - seasonLeaderboardRank: Short - seasonLeaderboardDivisionId: Byte - proSteamAccount: ProSteamAccountType - smurfFlag: Byte - lastMatchDateTime: Long - lastMatchRegionId: Byte - battlepass: [SteamAccountBattlePassType] -} - -type SteamApiDetailOutageType { - secondsOffline: Int - dateTime: Long -} - -type SteamApiDetailType { - isOnline: Boolean! - outages: [SteamApiDetailOutageType] -} - -enum StratzApiType { - DATA_COLLECTOR - MULTI_KEY -} - -type StratzQuery { - admin: AdminQuery - user: UserQuery - page: PageQuery - - """Returns a list of Stratz blogs.""" - blogs( - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int - ): [BlogType] - - """Returns a list of News Items released by Dota 2 directly.""" - news: [NewsItemType] - - """ - Home page data that shows the total count of players and matches in our database. - """ - ticker: [Int] - - """ - Shows the availability to major components required in the STRATZ foundation. - """ - status: ServerStatusType - - """ - Returns a list of languages and an Id for reference. This is used throughout the site. - """ - languages: [LanguageType] - - """Returns a list of Stratz blogs.""" - matchRetry( - """ - The id of the Dota match to include in this query, excluding all results that do not include this id. - """ - id: Long! - ): Boolean - search(request: FilterSearchRequestType): SearchType -} - -enum Streak { - MULTI_KILL - KILL_STREAK -} - -type StreakEventType { - time: Int! - heroId: Short - type: Streak - value: Int! -} - -enum TableCalculateEnum { - AVERAGE - MEDIAN - HIGHEST - LOWEST -} - -input TeamMatchesRequestType { - """ - The steam account id to include in this query, excluding all results that do not have this steam account id. - """ - steamAccountId: Long - - """An array of Dota match ids to include in this query.""" - matchIds: [Long] - - """ - A league id to include in this query, excluding all results that do not have this league id. - """ - leagueId: Int - - """ - A series id to include in this query, excluding all results that do not have this series id. - """ - seriesId: Long - - """ - Whether STRATZ has yet parsed the data of the match or not, represented in a boolean. - """ - isParsed: Boolean - - """ - The start DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - startDateTime: Long - - """ - The end DateTime of the Dota match(es) to include in this query, represented in unix seconds. - """ - endDateTime: Long - - """ - An array of game mode ids to include in this query, excluding all results that do not include one of these game modes. - """ - gameModeIds: [Byte] - - """ - An array of lobby type ids to include in this query, excluding all results that do not include one of these lobby types. - """ - lobbyTypeIds: [Byte] - - """ - An array of game version ids to include in this query, excluding all results - that do not include one of these game versions. - """ - gameVersionIds: [Int] - - """ - An array of region ids to include in this query, excluding all results that do not include one of these regions. - """ - regionIds: [Int] - - """ - An array of rank ids to include in this query, excluding all results that do - not include one of these ranks. The value ranges from 0-80 with 0 being - unknown MMR and 1-80 is low to high MMR brackets. Example: 74 is Divine with 4 Stars. - """ - rankIds: [Int] - - """ - STRATZ applys an formula to determine if a game is considered 'real'. We - attempt to detect AFKers, leavers, feeders, etc. 'IsStats' will return matches - that do not include any of these poor quality matches. - """ - isStats: Boolean - - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """ - An array of lane ids (enum MatchLaneType) to include in this query, excluding - all results that do not include one of these lanes. Roaming = 0, SafeLane = 1, - Midlane = 2, Offlane = 3, Jungle = 4 - """ - laneIds: [Int] - - """ - An array of role ids (enum MatchPlayerRoleType) to include in this query, - excluding all results that do not include one of these roles. Core = 0, Light - Support = 1, Hard Support = 2 - """ - roleIds: [Int] - - """ - An array of award ids to include in this query, excluding all results that do - not include one of these awards. The player award types include MVP (1), Top - Core (2), and Top Support (3). - """ - awardIds: [Int] - - """Include all matches that are party games, excluding all others.""" - isParty: Boolean - - """ - STRATZ gives 3 players in each game an award for playing well. MVP, Top Core, - Top Support (enum MatchPlayerAwardType). If you include a query of - 'steamAccountId' then it will require that player to have gotten at least 1 of - these awards for each match result. - """ - hasAward: Boolean - - """ - An array of steam account ids found on your team to include in this query, - excluding all results that do not include one of these steam accounts found on your team. - """ - withFriendSteamAccountIds: [Long] - - """ - An array of hero ids found on your team to include in this query, excluding - all results that do not include one of these heroes found on your team. - """ - withFriendHeroIds: [Int] - - """ - The amount of matches to skip before collecting your query. Hint: Paging - """ - skip: Int! - - """The amount of matches to have returned in your query. Max 1000""" - take: Int! -} - -type TeamPrizeType { - leagueId: Int - league: LeagueType - teamId: Int - team: TeamType - standing: Int - prizeAmount: Float -} - -type TeamType { - id: Int! - name: String - tag: String - dateCreated: Long - isPro: Boolean - isLocked: Boolean - countryCode: String - url: String - logo: String - baseLogo: String - bannerLogo: String - winCount: Int - lossCount: Int - lastMatchDateTime: Long - countryName: String - coachSteamAccountId: Long - coachSteamAccount: SteamAccountType - - """Find match details by leauge id.""" - matches( - """ - The request object used to filter matches returned based on input criteria. - """ - request: TeamMatchesRequestType! - ): [MatchType] - - """Find match details by series id.""" - series( - """ - The request object used to filter Series returned based on input criteria. - """ - request: FilterSeriesRequestType! - ): [SeriesType] - - """A List of all the players for a team.""" - members( - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int - ): [SteamAccountTeamMemberType] - - """ - Find match details by team id. The return is modified to group the data by the GroupBy parameter. - """ - matchesGroupBy( - """ - The request object used to filter matches returned based on input criteria. - """ - request: PlayerMatchesGroupByRequestType! - ): [MatchGroupByType] - - """ - Find match details by team id. The return is modified to group the data by the GroupBy parameter. - """ - heroPickBan: [MatchPickBanGroupByType] -} - -type TI2020CustomGameDepthListAscensionAbilitiesObjectType { - type: TI2020CustomGameDepthListAscensionAbilitiesType - abilityId: Short - modifierId: Short -} - -enum TI2020CustomGameDepthListAscensionAbilitiesType { - ASCENSION_ARMOR - ASCENSION_ARMOR_SAPPING - ASCENSION_ATTACK_SPEED - ASCENSION_BOMB - ASCENSION_CHILLING_TOUCH - ASCENSION_CRIT - ASCENSION_DAMAGE - ASCENSION_DRUNKEN - ASCENSION_EXTRA_FAST - ASCENSION_FLICKER - ASCENSION_HEAL_SUPPRESSION - ASCENSION_MAGIC_IMMUNITY - ASCENSION_MAGIC_RESIST - ASCENSION_VAMPIRIC - ASCENSION_MAGNETIC_FIELD - ASCENSION_SILENCE - ASCENSION_FIREFLY - ASCENSION_EMBIGGEN - ASCENSION_VENGEANCE - AGHSFORT_ASCENSION_INVIS - ASCENSION_METEORIC - ASCENSION_PLASMA_FIELD - ASCENSION_BULWARK -} - -enum TI2020CustomGameDepthListEncounterType { - ENCOUNTER_EMPTY_CAVERN - ENCOUNTER_EMPTY_BEACH - ENCOUNTER_BREWMASTER - ENCOUNTER_HELLBEARS_PORTAL_V_3 - ENCOUNTER_PINECONES - ENCOUNTER_QUILL_BEASTS - ENCOUNTER_JUNGLE_HIJINX - ENCOUNTER_TUSK_SKELETONS - ENCOUNTER_BOMBERS - ENCOUNTER_DROW_RANGER_MINIBOSS - ENCOUNTER_WAVE_BLASTERS - ENCOUNTER_BABY_OGRES - ENCOUNTER_MORPHLINGS_B - ENCOUNTER_ZEALOT_SCARABS - ENCOUNTER_OGRE_SEALS - ENCOUNTER_WARLOCKS - ENCOUNTER_GAUNTLET - ENCOUNTER_MORTY_TRANSITION - ENCOUNTER_PENGUINS_TRANSITION - ENCOUNTER_MIRANA - ENCOUNTER_MUSHROOM_MINES - ENCOUNTER_LEGION_COMMANDER - ENCOUNTER_TROLL_WARLORD - ENCOUNTER_PUDGE_MINIBOSS - ENCOUNTER_PUCKS - ENCOUNTER_DARK_SEER - ENCOUNTER_SPECTRES - ENCOUNTER_SHADOW_DEMONS - ENCOUNTER_NAGA_SIREN - ENCOUNTER_DIRE_SIEGE - ENCOUNTER_BIG_OGRES - ENCOUNTER_DRAGON_KNIGHT - ENCOUNTER_KUNKKA_TIDE - ENCOUNTER_ALCHEMIST - ENCOUNTER_ENRAGED_WILDWINGS - ENCOUNTER_ELEMENTAL_TINY - ENCOUNTER_BANDITS - ENCOUNTER_BOMB_SQUAD - ENCOUNTER_UNDEAD_WOODS - ENCOUNTER_PHOENIX - ENCOUNTER_BROODMOTHERS - ENCOUNTER_FIRE_ROSHAN - ENCOUNTER_BOSS_VISAGE - ENCOUNTER_BOSS_TIMBERSAW - ENCOUNTER_TEMPLE_GUARDIANS - ENCOUNTER_STOREGGA - ENCOUNTER_BOSS_VOID_SPIRIT - ENCOUNTER_AGHANIM - ENCOUNTER_JUNGLE_FIRE_MAZE - ENCOUNTER_CLIFF_PASS - ENCOUNTER_HELLFIRE_CANYON - ENCOUNTER_TEMPLE_GARDEN - ENCOUNTER_CASTLE_TRAPS - ENCOUNTER_CRYPT_TRAPS - ENCOUNTER_BONUS_CHICKEN - ENCOUNTER_PANGOLIER - ENCOUNTER_ROCK_GOLEMS - ENCOUNTER_WENDIGOES - ENCOUNTER_COLLAPSED_MINES - ENCOUNTER_BEARS_LAIR - ENCOUNTER_PINE_GROVE - ENCOUNTER_SACRED_GROUNDS - ENCOUNTER_DEEP_TRAPS - ENCOUNTER_DARK_FOREST - ENCOUNTER_TROPICAL_KEEP - ENCOUNTER_SALTY_SHORE - ENCOUNTER_REGAL_TRAPS - ENCOUNTER_DESERT_OASIS - ENCOUNTER_PRISON_TRAPS - ENCOUNTER_BRIDGE_TRAPS - ENCOUNTER_MOLE_CAVE - ENCOUNTER_BLOB_DUNGEON - ENCOUNTER_MULTIPLICITY - ENCOUNTER_CATACOMBS - ENCOUNTER_SWAMP_OF_SADNESS - ENCOUNTER_CAVERN_TRAPS - ENCOUNTER_AZIYOG_CAVERNS - ENCOUNTER_BAMBOO_GARDEN - ENCOUNTER_BOG_TRAPS - ENCOUNTER_BOSS_WINTER_WYVERN - ENCOUNTER_BOSS_EARTHSHAKER - ENCOUNTER_BOSS_DARK_WILLOW - ENCOUNTER_BOSS_RIZZRICK - ENCOUNTER_PENGUIN_SLEDDING - ENCOUNTER_BONUS_MANGO_ORCHARD - ENCOUNTER_BONUS_HOOKING - ENCOUNTER_MUSHROOM_MINES_2021 - ENCOUNTER_GAOLERS - ENCOUNTER_EGGS_HOLDOUT - ENCOUNTER_SPOOK_TOWN - ENCOUNTER_TEMPLE_TRAPS - ENCOUNTER_CANOPY_TRAPS - ENCOUNTER_INNER_RING - ENCOUNTER_LESHRAC - ENCOUNTER_OUTWORLD - ENCOUNTER_TWILIGHT_MAZE - ENCOUNTER_RUINOUS_TRAPS - ENCOUNTER_BEACH_TRAPS - ENCOUNTER_GOLEM_GORGE - ENCOUNTER_SNAPFIRE - ENCOUNTER_POLARITY_SWAP - ENCOUNTER_STONEHALL_CITADEL - ENCOUNTER_MYSTICAL_TRAPS - ENCOUNTER_HEDGE_TRAPS - ENCOUNTER_TEMPLE_SIEGE - ENCOUNTER_FORBIDDEN_PALACE - ENCOUNTER_CRYPT_GATE - ENCOUNTER_PUGNA_NETHER_REACHES - ENCOUNTER_MINING_TRAPS - ENCOUNTER_DUNGEON_TRAPS - ENCOUNTER_BOSS_ARC_WARDEN - ENCOUNTER_BOSS_CLOCKWERK_TINKER - ENCOUNTER_BOSS_AMOEBA - ENCOUNTER_BOSS_STOREGGA - ENCOUNTER_BONUS_LIVESTOCK - ENCOUNTER_BONUS_SMASH_CHICKENS - ENCOUNTER_BONUS_GALLERY - ENCOUNTER_TOXIC_TERRACE - ENCOUNTER_HIDDEN_COLOSSEUM - ENCOUNTER_FROZEN_RAVINE - ENCOUNTER_PALACE_TRAPS - ENCOUNTER_ICY_POOLS - ENCOUNTER_DEMONIC_WOODS - ENCOUNTER_THUNDER_MOUNTAIN - ENCOUNTER_FRIGID_PINNACLE - ENCOUNTER_VILLAGE_TRAPS - ENCOUNTER_FORSAKEN_PIT - ENCOUNTER_BURNING_MESA - ENCOUNTER_SMASHY_AND_BASHY - ENCOUNTER_PUSH_PULL - ENCOUNTER_JUNGLE_TRAPS - ENCOUNTER_TRANSITION_GATEWAY - ENCOUNTER_PRIMAL_BEAST - ENCOUNTER_EVENT_MINOR_SHARD_SHOP - ENCOUNTER_EVENT_DOOM_LIFE_SWAP - ENCOUNTER_EVENT_WARLOCK_LIBRARY - ENCOUNTER_EVENT_ALCHEMIST_NEUTRAL_ITEMS - ENCOUNTER_EVENT_BREWMASTER_BAR - ENCOUNTER_EVENT_LIFE_SHOP - ENCOUNTER_EVENT_MORPHLING_ATTRIBUTE_SHIFT - ENCOUNTER_EVENT_TINKER_RANGE_RETROFIT - ENCOUNTER_EVENT_NAGA_BOTTLE_RUNE - ENCOUNTER_EVENT_SLARK - ENCOUNTER_EVENT_ZEUS - ENCOUNTER_EVENT_LESHRAC - ENCOUNTER_EVENT_NECROPHOS - ENCOUNTER_EVENT_SMALL_TINY_SHRINK - ENCOUNTER_EVENT_BIG_TINY_GROW - ENCOUNTER_EVENT_OGRE_MAGI_CASINO - ENCOUNTER_SPLITSVILLE - ENCOUNTER_AQUA_MANOR - ENCOUNTER_JUNGLE_TREK -} - -enum TI2020CustomGameDepthListRewardType { - REWARD_TYPE_NONE - REWARD_TYPE_GOLD - REWARD_TYPE_EXTRA_LIVES - REWARD_TYPE_TREASURE -} - -type TI2020CustomGameHeroAbilityType { - difficulty: TI2020CustomGameMatchDifficultyType - heroId: Short - customAbilityId: Short - matchCount: Int - winCount: Int - pickCount: Int -} - -type TI2020CustomGameHeroCompositionType { - difficulty: TI2020CustomGameMatchDifficultyType - heroId1: Short - heroId2: Short - heroId3: Short - heroId4: Short - matchCount: Int - winCount: Int - duration: Int - wilsonScore: Decimal -} - -type TI2020CustomGameHeroWinRateType { - difficulty: TI2020CustomGameMatchDifficultyType - heroId: Short - matchCount: Int - winCount: Int -} - -type TI2020CustomGameMatchDepthListType { - selectedElite: Boolean - selectedEncounter: TI2020CustomGameDepthListEncounterType - selectedEncounterType: Byte - selectedHidden: Boolean - selectedReward: TI2020CustomGameDepthListRewardType - unselectedElite: Boolean - unselectedEncounter: TI2020CustomGameDepthListEncounterType - unselectedHidden: Boolean - unselectedReward: TI2020CustomGameDepthListRewardType - ascensionAbilities: [TI2020CustomGameDepthListAscensionAbilitiesObjectType] -} - -enum TI2020CustomGameMatchDifficultyType { - APPRENTICE - MAGICIAN - SORCERER - GRANDMAGUS - APEXMAGE -} - -type TI2020CustomGameMatchType { - id: Long - didWin: Boolean - durationSeconds: Short - startDateTime: Long - endDateTime: Long - clusterId: Short - lobbyType: Byte - numKills: Short - numDeaths: Short - numHumanPlayers: Byte - gameMode: Byte - replaySalt: Long - difficulty: TI2020CustomGameMatchDifficultyType - depth: Byte - seed: Int - battlePoints: Short - score: Int - arcaneFragments: Short - goldBags: Short - regionId: Byte - players( - """ - The steam account id to include in this query, excluding all results that do not have this steam account id. - """ - steamAccountId: Long - ): [TI2020CustomGamePlayerType] - depthList: [TI2020CustomGameMatchDepthListType] -} - -type TI2020CustomGamePlayerBlessingObjectType { - type: TI2020CustomGamePlayerBlessingType - value: Short -} - -enum TI2020CustomGamePlayerBlessingType { - MODIFIER_BLESSING_AGILITY - MODIFIER_BLESSING_ARMOR - MODIFIER_BLESSING_ATTACK_SPEED - MODIFIER_BLESSING_BASE - MODIFIER_BLESSING_BOOK_AGILITY - MODIFIER_BLESSING_BOOK_INTELLIGENCE - MODIFIER_BLESSING_BOOK_STRENGTH - MODIFIER_BLESSING_BOTTLE_UPGRADE - MODIFIER_BLESSING_DAMAGE_BONUS - MODIFIER_BLESSING_DAMAGE_REFLECT - MODIFIER_BLESSING_DETONATION - MODIFIER_BLESSING_EVASION - MODIFIER_BLESSING_HEALTH_BOOST - MODIFIER_BLESSING_INTELLIGENCE - MODIFIER_BLESSING_LIFE_STEAL - MODIFIER_BLESSING_MAGIC_DAMAGE_BONUS - MODIFIER_BLESSING_MAGIC_RESIST - MODIFIER_BLESSING_MANA_BOOST - MODIFIER_BLESSING_MOVEMENT_SPEED - MODIFIER_BLESSING_POTION_ARCANIST - MODIFIER_BLESSING_POTION_DRAGON - MODIFIER_BLESSING_POTION_ECHO_SLAM - MODIFIER_BLESSING_POTION_HEALTH - MODIFIER_BLESSING_POTION_MANA - MODIFIER_BLESSING_POTION_PURIFICATION - MODIFIER_BLESSING_POTION_RAVAGE - MODIFIER_BLESSING_POTION_SHADOW_WAVE - MODIFIER_BLESSING_POTION_TORRENT - MODIFIER_BLESSING_REFRESHER_SHARD - MODIFIER_BLESSING_RESPAWN_INVULNERABILITY - MODIFIER_BLESSING_RESPAWN_TIME_REDUCTION - MODIFIER_BLESSING_RESTORE_MANA - MODIFIER_BLESSING_SPELL_LIFE_STEAL - MODIFIER_BLESSING_STRENGTH - BOTTLE_CHARGES - STAT_AGI - STAT_INT - STAT_STR - STAT_DAMAGE - STAT_SPELL_AMP - STAT_HEALTH - STAT_MANA - STAT_MAGIC_RESIST - STARTING_GOLD - PURIFICATION_POTION - DEATH_DETONATION - POTION_HEALTH - POTION_MANA - RESPAWN_TIME_REDUCTION - BOTTLE_REGEN_DURATION - BOTTLE_REGEN_MOVEMENT_SPEED - ROSHAN_SHOP_DISCOUNT - ORACLE_SHOP_DISCOUNT - RESPAWN_INVULNERABILITY - RESPAWN_HASTE - RESPAWN_ATTACK_SPEED - STAT_EVASION - UPGRADE_REROLL - ELITE_UPGRADE - START_TOME - BOSS_TOME - EXTRA_LIFE - MELEE_CLEAVE - ATTACK_RANGE - PROJECTILE_SPEED - CAST_RANGE - DAMAGE_ON_STUNNED - REGEN_AROUND_ALLIES - DEBUFF_DURATION_INCREASE - LOW_HP_OUTGOING_DAMAGE -} - -type TI2020CustomGamePlayerDepthListType { - numDeaths: Short - goldBags: Short - kills: Short - level: Byte - networth: Int - rarity: Byte - selectedRewardAbilityId: Short - selectedRewardAbility( - """ - The language id to include in this query, excluding all results that do not have this language. - """ - langaugeId: Int - ): AbilityCustomGameType - unSelectedRewardAbilityId1: Short - unSelectedRewardAbility1( - """ - The language id to include in this query, excluding all results that do not have this language. - """ - langaugeId: Int - ): AbilityCustomGameType - unSelectedRewardAbilityId2: Short - unSelectedRewardAbility2( - """ - The language id to include in this query, excluding all results that do not have this language. - """ - langaugeId: Int - ): AbilityCustomGameType - selectedRewardImageAbilityId: Short -} - -type TI2020CustomGamePlayerType { - matchId: Long - playerSlot: Byte - steamAccountId: Long - steamAccount: SteamAccountType - isVictory: Boolean! - heroId: Short - hero: HeroType - deaths: Byte - leaverStatus: Byte - numLastHits: Short - goldPerMinute: Short - networth: Int - experiencePerMinute: Short - level: Byte - goldSpent: Int - partyId: Byte - item0Id: Short - item1Id: Short - item2Id: Short - item3Id: Short - item4Id: Short - item5Id: Short - - """ - The item id of the dedicated neutral item slot (7.24 and after). From game - versions 7.23 to 7.24, this was the BackPack3Id (the 4th backpack slot item id). - """ - neutral0Id: Short - arcaneFragments: Short - bonusArcaneFragments: Short - goldBags: Short - neutralItemId: Short - depthList: [TI2020CustomGamePlayerDepthListType] - blessings: [TI2020CustomGamePlayerBlessingObjectType] -} - -type TI2020CustomGameRoomModifierType { - difficulty: TI2020CustomGameMatchDifficultyType - modifierId: Short - matchCount: Int - winCount: Int - deathCount: Int - eliteMatchCount: Int - eliteWinCount: Int - eliteDeathCount: Int -} - -type TI2020CustomGameRoomType { - difficulty: TI2020CustomGameMatchDifficultyType - encounterId: TI2020CustomGameDepthListEncounterType - matchCount: Int - winCount: Int - pickCount: Int - deathCount: Int - eliteMatchCount: Int - eliteWinCount: Int - elitePickCount: Int - eliteDeathCount: Int -} - -type TopPlayersByHeroType { - heroId: Short - players: [PlayerLeaderBoardByHeroType] -} - -type TotalMatchCountType { - matchCount: Long -} - -type TotalPlayerCountType { - playerCount: Long -} - -type TowerDamageDetailType { - time: Int! - attacker: Short - npcId: Short - damage: Int! - byAbility: Short - byItem: Short -} - -type TwitchTrackerPlayerHeroType { - heroId: Int! - matchCount: Int! - winCount: Int! -} - -type TwitchTrackerPlayerMatchType { - matchId: Long - heroId: Int! - lane: MatchLaneType - role: MatchPlayerRoleType - position: MatchPlayerPositionType - killCount: Short - deathCount: Short - assistCount: Short - endDateTime: Long - isVictory: Boolean! - award: Byte -} - -type TwitchTrackerPlayerType { - steamAccountId: Long - activity: PlayerBehaviorActivity - name: String - avatar: String - rank: Int - leaderboardRank: Int - proPlayerName: String - matchCountLast100: Int! - winCountLast100: Int! - uniqueHeroLast100: Int! - coreCountLast100: Int! - topHeroLast100: [TwitchTrackerPlayerHeroType] - matches: [TwitchTrackerPlayerMatchType] -} - -input UpdateFollowerRequestType { - feedLevel: Byte - emailLevel: Byte - dailyEmail: Boolean - weeklyEmail: Boolean - monthlyEmail: Boolean - overrideAllUsers: Boolean! -} - -input UpdateMatchReplayMatchUploadPlayerObjectType { - steamAccountId: Long! - position: MatchPlayerPositionType -} - -input UpdateMatchReplayUploadObjectType { - matchReplayUploadTeamId: Int! - matchId: Long - leagueId: Int - radiantTeamId: Int - direTeamId: Int - isActive: Boolean - notes: String - players: [UpdateMatchReplayMatchUploadPlayerObjectType] -} - -type UserHomepageType { - """A list of blog components to be displayed separately on the homepage.""" - blogs( - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """ - An array of blog ids to exclude in this query, including all results that do not include one of these blogs. - """ - excludedBlogIds: [Int] - ): [BlogType] - upcomingLeagues( - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """ - An array of league ids to exclude in this query, including all results that do not include one of these leagues. - """ - excludedLeagueIds: [Int] - - """ - An array of league ids to include in this query, excluding all results that do not include one of these leagues. - """ - includedLeagueIds: [Int] - - """ - An array of league tier ids to include in this query, excluding all results - that do not include one of these league tiers. - """ - includedLeagueTierIds: [Int] - ): [LeagueType] - inProgressLeagues( - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """ - An array of league ids to exclude in this query, including all results that do not include one of these leagues. - """ - excludedLeagueIds: [Int] - - """ - An array of league ids to include in this query, excluding all results that do not include one of these leagues. - """ - includedLeagueIds: [Int] - - """ - An array of league tier ids to include in this query, excluding all results - that do not include one of these league tiers. - """ - includedLeagueTierIds: [Int] - ): [LeagueType] - leagueMetas( - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """ - An array of league ids to exclude in this query, including all results that do not include one of these leagues. - """ - excludedLeagueIds: [Int] - - """ - An array of league ids to include in this query, excluding all results that do not include one of these leagues. - """ - includedLeagueIds: [Int] - - """ - An array of league tier ids to include in this query, excluding all results - that do not include one of these league tiers. - """ - includedLeagueTierIds: [Int] - ): [LeagueMetaType] - topProPlayers( - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - ): [ProPlayerFollowType] - topPlayersByHeroType( - """The amount to have returned in your query.""" - heroComponentsTake: Int - - """The amount to have returned in your query.""" - playersTake: Int - - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - - """ - An array of rank bracket ids to include in this query, excluding all results - that do not include one of these rank brackets. - """ - rankBracketIds: [Byte] - ): [TopPlayersByHeroType] - topSynergiesByHero( - """The amount to have returned in your query.""" - synergyComponentsTake: Int - - """ - An array of hero ids to include in this query, excluding all results that do not include one of these heroes. - """ - heroIds: [Short] - ): [HomepageHeroSynergyType] - matchAwards( - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """ - An array of award ids to include in this query, excluding all results that - do not include one of these awards. The player award types include MVP (1), - Top Core (2), and Top Support (3). - """ - matchPlayerAwardTypeIds: [Byte] - ): [MatchType] - recentRampages( - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - ): [RecentRampageType] - recentWinStreaks( - """ - This value is hard-coded to 1 if passed in, due to the way win streaks are currently stored. - """ - take: Int - ): [RecentWinStreakType] - recentHighImps( - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - ): [RecentHighImpType] - recentMatches( - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - ): [MatchPlayerType] - activeLeagueGames( - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - ): [MatchLiveType] - topLiveGames( - """The amount to have returned in your query.""" - take: Int - - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - ): [MatchLiveType] - totalComponents: Int -} - -type UserQuery { - """Find user details of the currently logged in user.""" - profile: UserType - - """Returns a list of Stratz blogs.""" - homepage( - """The amount to have returned in your query.""" - take: Int! - ): UserHomepageType - - """Gets the list of followers the person is following.""" - followers: [FollowerType] - - """Gets the list of followers the person is following.""" - following: [FollowerType] - - """Gets a list of completed tutorials from the logged in user.""" - completedTutorials: [Short] - - """Returns a list of feed events for the logged in user.""" - feed( - """The amount to skip before collecting your query. Hint: Paging""" - skip: Int - - """The amount to have returned in your query.""" - take: Int - ): FeedResponseType -} - -type UserType { - profile: CaptainJackIdentityPrivateProfileType - steamAccount: SteamAccountType - recentMatch: MatchType - followingCount: Int - followerCount: Int - followingLeagueCount: Int - followingTeamCount: Int - stratzApiApplications: [CaptainJackIdentityApiApplicationType] -} - -scalar UShort - -type VendorQuery { - dotaNext: DotaNextQuery - - """Used by the Dota 2 Twitch Tracker for Dota Stats""" - twitchTracker( - """ - The steam account id to include in this query, excluding all results that do not have this steam account id. - """ - steamAccountId: Long! - ): TwitchTrackerPlayerType -} - -enum XpReason { - OTHER - HEROES - CREEPS - ROSHAN - TOME_OF_KNOWLEDGE - OUTPOSTS -} - -type YogurtMutation { - """ - Create a new match replay upload team. teamName, emailAddress, and teamId are required input fields. - """ - createTeam( - """ - The desired team name of the match replay upload team. Cannot be blank or whitespace. - """ - matchReplayUploadTeamName: String! - - """ - The desired email address of the match replay upload team. Cannot be blank or whitespace. - """ - emailAddress: String! - - """ - The desired dota team id of the match replay upload team. Must be a real team created in the dota client. - """ - teamId: Int! - ): MatchReplayUploadTeamType - - """ - Update a new match replay upload team. matchReplayUploadTeamId is a required input field. - """ - updateTeam( - """ - The desired team name of the match replay upload team. Cannot be blank or whitespace. - """ - matchReplayUploadTeamId: Int! - - """ - The desired team name of the match replay upload team. Cannot be blank or whitespace. - """ - matchReplayUploadTeamName: String - - """ - The desired dota team id of the match replay upload team. Must be a real team created in the dota client. - """ - teamId: Int - ): Boolean - - """ - Add a member to a match replay upload team. steamAccountId and matchReplayUploadTeamId are required input fields. - """ - addTeamMember( - """ - The steam account id to include in this query, excluding all results that do not have this steam account id. - """ - steamAccountId: Long! - - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - ): Boolean - - """ - Update a member of a match replay upload team. memberCaptainJackIdentityId, - matchReplayUploadTeamId, and isAdmin are required input fields. - """ - updateTeamMember( - """ - The CaptainJackIdentity id to include in this query, excluding all results that do not have this CaptainJackIdentity id. - """ - captainJackIdentityId: ID! - - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - - """ - Whether the match replay upload team member you wish to update is an admin of that team. - """ - isAdmin: Boolean! - ): Boolean - - """ - Set the default team of a match replay upload team member. - memberCaptainJackIdentityId and matchReplayUploadTeamId are required input fields. - """ - setTeamMemberDefaultTeam( - """ - The CaptainJackIdentity id to include in this query, excluding all results that do not have this CaptainJackIdentity id. - """ - captainJackIdentityId: ID! - - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - ): Boolean - - """ - Remove a member of a match replay upload team. memberCaptainJackIdentityId and - matchReplayUploadTeamId are required input fields. - """ - removeTeamMember( - """ - The CaptainJackIdentity id to include in this query, excluding all results that do not have this CaptainJackIdentity id. - """ - captainJackIdentityId: ID! - - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - ): Boolean - - """ - Update the data of a match replay upload. updateMatchReplayUploadObject is a required input field. - """ - update( - """ - This object contains all of the fields a user is allowed to update on a - match replay upload. Null fields are not updated. Fields set to 0 are - updated to null in the database. - """ - updateMatchReplayUploadObject: UpdateMatchReplayUploadObjectType! - ): Boolean - - """ - Validate the data of a match replay upload, adding the match replay upload to - the queryable data set associated with the match replay upload team. - matchReplayUploadTeamId and matchId are required input fields. - """ - validate( - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - - """ - The id of the Dota match to include in this query, excluding all results that do not include this id. - """ - matchId: Long! - ): Boolean - - """ - Invalidate the data of a match replay upload, removing the match replay upload - from the queryable data set associated with the match replay upload team. - matchReplayUploadTeamId and matchId are required input fields. - """ - invalidate( - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - - """ - The id of the Dota match to include in this query, excluding all results that do not include this id. - """ - matchId: Long! - ): Boolean - - """ - Delete the data of a match replay upload, removing the match replay upload - from the queryable data set associated with the match replay upload team. - matchReplayUploadTeamId and matchId are required input fields. - """ - delete( - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - - """ - The id of the Dota match to include in this query, excluding all results that do not include this id. - """ - matchId: Long! - ): Boolean - - """ - Delete the data of a match replay upload, removing the match replay upload - from the queryable data set associated with the match replay upload team. - matchReplayUploadTeamId and matchId are required input fields. - """ - linkSeriesId( - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - - """An array of Dota match ids to include in this query.""" - matchIds: [Long]! - ): Boolean - - """ - Remove the series id for all of the input matches. matchReplayUploadTeamId and matchIds are required input fields. - """ - removeSeriesId( - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - - """An array of Dota match ids to include in this query.""" - matchIds: [Long]! - ): Boolean - - """ - Import a public match as a match replay upload to the match replay upload - team's data set. matchReplayUploadTeamId and matchId are required input fields. - """ - importMatch( - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - - """ - The id of the Dota match to include in this query, excluding all results that do not include this id. - """ - matchId: Long! - ): Boolean - - """ - If the Picks and Bans for a match are missing or invalid, this allows you to update them. - """ - importPickBans( - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - - """ - The id of the Dota match to include in this query, excluding all results that do not include this id. - """ - matchId: Long! - pickBans: [ImportPickBanType]! - ): Boolean -} - -type YogurtQuery { - """ - Find a match replay upload team by match replay upload team id. matchReplayUploadTeamId is a required input field. - """ - team( - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - ): MatchReplayUploadTeamType - - """ - Find all match replay upload teams associated with the currently logged in user. - """ - teams: [MatchReplayUploadTeamType] - - """ - Find the defualt match replay upload team associated with the currently logged in user. - """ - defaultTeam: MatchReplayUploadTeamType - - """ - Find match replay upload team members by match replay upload team id. matchReplayUploadTeamId is a required input field. - """ - teamMembers( - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - ): [MatchReplayUploadTeamMemberType] - - """ - Find match replay uploads by match replay upload team id. matchReplayUploadTeamId and request are required input fields. - """ - overview( - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - - """ - The request object filtering which match replay uploads to include in this - query, excluding all results that do not pass through this filter. - """ - request: FilterMatchReplayUploadRequestType - ): MatchReplayUploadOverviewType - - """ - Find the list of Hero's in the game and determine basic output by grouping them together. - """ - heroSummary( - """ - The id of the match replay upload team to include in this query, excluding - all results that do not include this match replay upload team id. - """ - matchReplayUploadTeamId: Int! - - """ - The request object filtering which match replay uploads to include in this - query, excluding all results that do not pass through this filter. - """ - request: FilterMatchReplayUploadRequestType - ): [MatchReplayUploadHeroSummaryType] -} diff --git a/src/graphql/stratz.ts b/src/graphql/stratz.ts new file mode 100644 index 0000000..b2bd3a2 --- /dev/null +++ b/src/graphql/stratz.ts @@ -0,0 +1,70 @@ +import { getLogger } from "@logtape/logtape" + +const l = getLogger(["dotino-veloce", "graphql"]) + +l.debug`Getting Stratz API URL from environment variable DOTINO_STRATZ_URL...` +const urlString = Deno.env.get("DOTINO_STRATZ_URL") +if(!urlString) { + l.error`DOTINO_STRATZ_URL is unset.` + throw new Error("DOTINO_STRATZ_URL is unset.") +} + +l.debug`Attempting to parse Stratz API URL...` +const url = new URL(urlString) + +l.debug`Getting Stratz API key from environment variable DOTINO_STRATZ_KEY...` +const key = Deno.env.get("DOTINO_STRATZ_KEY") +if(!key) { + l.error`DOTINO_STRATZ_KEY is unset.` + throw new Error("DOTINO_STRATZ_KEY is unset.") +} + +// Little trick to get VSCode to highlight queries! +const graphql = String.raw + +export async function doQuery(query: string, variables: object) { + const request = await fetch(url, { + method: "POST", + headers: { + "Content-Type": "application/json", + "Accept": "application/json", + "Authorization": `Bearer ${key}`, + "User-Agent": "STRATZ_API", + }, + body: JSON.stringify({query, variables}) + }) + const data = await request.json() + + if(data["error"]) { + throw new Error("GraphQL query failed.", data["error"]) + } + + return data["data"] +} + +export async function doQueryPlayer(steamId: number): Promise<{ + communityVisibleState: number, + isAnonymous: boolean, + id: number, + name: string, + avatar: string, +} | null> { + l.info`Querying player ${steamId} on the Stratz API...` + const player = await doQuery( + graphql` + query ($steamId: Long!) { + player (steamAccountId: $steamId) { + steamAccount { + communityVisibleState + isAnonymous + id + name + avatar + } + } + } + `, + {steamId} + ) + return player?.player?.steamAccount ?? null +} diff --git a/tests/graphql_test.ts b/tests/graphql_test.ts new file mode 100644 index 0000000..23ec1cf --- /dev/null +++ b/tests/graphql_test.ts @@ -0,0 +1,30 @@ +import { configure, getConsoleSink } from "@logtape/logtape" +import { doQueryPlayer } from "../src/graphql/stratz.ts" +import { assert, assertEquals} from "@std/assert" + + +await configure({ + sinks: { console: getConsoleSink() }, + filters: {}, + loggers: [ + { category: ["logtape", "meta"], sinks: ["console"], level: "warning" }, + { category: ["fedify"], sinks: ["console"], level: "info" }, + { category: ["dotino-veloce"], sinks: ["console"], level: "debug" }, + ], +}) + +Deno.test(async function querySteffo() { + const user = await doQueryPlayer(74048532) + assert(user) + assertEquals(user.id, 74048532) +}) + +Deno.test(async function queryOne() { + const user = await doQueryPlayer(1) + assertEquals(user, null) +}) + +Deno.test(async function queryMinusOne() { + const user = await doQueryPlayer(-1) + assertEquals(user, null) +}) diff --git a/tests/main_test.ts b/tests/main_test.ts deleted file mode 100644 index 93299e9..0000000 --- a/tests/main_test.ts +++ /dev/null @@ -1,6 +0,0 @@ -import { assertEquals } from "@std/assert" -import { add } from "../src/main.ts" - -Deno.test(function addTest() { - assertEquals(add(2, 3), 5) -}) From d8ac0284cb49537ac67b774460634251179c345d Mon Sep 17 00:00:00 2001 From: Stefano Pigozzi Date: Sat, 19 Oct 2024 04:23:42 +0200 Subject: [PATCH 5/7] Return basic Steam user data --- src/federation.ts | 73 ++++++++++++++++++++++++++++++++++------------- 1 file changed, 53 insertions(+), 20 deletions(-) diff --git a/src/federation.ts b/src/federation.ts index 6b4c6d1..3eaa5ad 100644 --- a/src/federation.ts +++ b/src/federation.ts @@ -1,42 +1,75 @@ -import { createFederation, Follow, Service } from "@fedify/fedify" +import { createFederation, Service, Application, Image } from "@fedify/fedify" import { kv } from "./redis.ts" import { getLogger } from "https://jsr.io/@logtape/logtape/0.6.3/logtape/logger.ts" +import { doQueryPlayer } from "./graphql/stratz.ts" const l = getLogger(["dotino-veloce", "federation"]) l.debug`Creating federation object...` export const federation = createFederation({ kv }) +const userMatcher = /u([0-9]+)/ + l.debug`Creating actor dispatcher...` // deno-lint-ignore require-await async function actorDispatcher(ctx: any, handle: string) { - l.debug`Received request for actor ${handle}, handling...` + l.debug`Determining id of requested actor: ${handle}` + const id = ctx.getActorUri(handle) + l.debug`Requested actor is: ${id.href}` - if (handle !== "service") { - l.debug`No match found for ${handle}, returning null.` - return null + if (handle === "service") { + l.info`Dispatching service account...` + return new Application({ + id, + preferredUsername: id.href, + // Akkoma expects URL to be equal to ID + // https://akkoma.dev/AkkomaGang/akkoma/src/commit/f1018867097e6f293d8b2b5b6935f0a7ebf99bd0/lib/pleroma/object/fetcher.ex#L287 + url: id, + // Akkoma requires inboxes to be setup to display profiles + // https://akkoma.dev/AkkomaGang/akkoma/src/commit/f1018867097e6f293d8b2b5b6935f0a7ebf99bd0/lib/pleroma/web/activity_pub/object_validators/user_validator.ex#L72 + inbox: ctx.getInboxUri(handle), + + name: "[TEST] Dotino Veloce", + summary: "Service account of a Dotino Veloce instance.", + }) } - l.debug`Determining id of actor ${handle}...` - const id = ctx.getActorUri(handle) + const steamId = Number.parseInt(handle.match(userMatcher)?.[1] as any) + if(Number.isFinite(steamId)) { + l.info`Dispatching user account with Steam ID: ${steamId}` + + const player = await doQueryPlayer(steamId) + + if(player === null) { + l.warn`No Steam account was found with ID: ${steamId}` + return null + } + + return new Service({ + id, + preferredUsername: id.href, + // Akkoma expects URL to be equal to ID + // https://akkoma.dev/AkkomaGang/akkoma/src/commit/f1018867097e6f293d8b2b5b6935f0a7ebf99bd0/lib/pleroma/object/fetcher.ex#L287 + url: id, + // Akkoma requires inboxes to be setup to display profiles + // https://akkoma.dev/AkkomaGang/akkoma/src/commit/f1018867097e6f293d8b2b5b6935f0a7ebf99bd0/lib/pleroma/web/activity_pub/object_validators/user_validator.ex#L72 + inbox: ctx.getInboxUri(handle), + + name: `[TEST] ${player.name}`, + icon: new Image({ + url: new URL(player.avatar), + mediaType: "image/jpeg" + }) + }) + } + + l.warn`No dispatcher was found for handle: ${handle}` + return null - l.info`Returning actor: ${id.href}` - return new Service({ - id, - name: "[TEST] Dotino Veloce", - summary: "Core account of a Dotino Veloce instance.", - preferredUsername: id.href, - // Akkoma expects URL to be equal to ID - // https://akkoma.dev/AkkomaGang/akkoma/src/commit/f1018867097e6f293d8b2b5b6935f0a7ebf99bd0/lib/pleroma/object/fetcher.ex#L287 - url: id, - inbox: ctx.getInboxUri(handle), - }) } l.debug`Connecting actor dispatcher to federation object...` federation.setActorDispatcher("/users/{identifier}", actorDispatcher) -// Akkoma requires inboxes to be setup to display profiles -// https://akkoma.dev/AkkomaGang/akkoma/src/commit/f1018867097e6f293d8b2b5b6935f0a7ebf99bd0/lib/pleroma/web/activity_pub/object_validators/user_validator.ex#L72 l.debug`Initializing inbox listener...` federation.setInboxListeners("/inbox/{identifier}") // I don't really care about the shared inbox for this project From 329b6cc629ab95f441f5d0c295156ef1abe22541 Mon Sep 17 00:00:00 2001 From: Stefano Pigozzi Date: Sat, 19 Oct 2024 04:36:47 +0200 Subject: [PATCH 6/7] Return a Person instead of a Service --- src/federation.ts | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/src/federation.ts b/src/federation.ts index 3eaa5ad..66ae0cf 100644 --- a/src/federation.ts +++ b/src/federation.ts @@ -1,4 +1,4 @@ -import { createFederation, Service, Application, Image } from "@fedify/fedify" +import { createFederation, Person, Application, Image, PropertyValue } from "@fedify/fedify" import { kv } from "./redis.ts" import { getLogger } from "https://jsr.io/@logtape/logtape/0.6.3/logtape/logger.ts" import { doQueryPlayer } from "./graphql/stratz.ts" @@ -45,7 +45,7 @@ async function actorDispatcher(ctx: any, handle: string) { return null } - return new Service({ + return new Person({ id, preferredUsername: id.href, // Akkoma expects URL to be equal to ID @@ -59,7 +59,25 @@ async function actorDispatcher(ctx: any, handle: string) { icon: new Image({ url: new URL(player.avatar), mediaType: "image/jpeg" - }) + }), + attachments: [ + new PropertyValue({ + name: "Steam", + value: `https://steamcommunity.com/profiles/[U:1:${player.id}]`, + }), + new PropertyValue({ + name: "Dota profile", + value: `https://stratz.com/players/${player.id}`, + }), + new PropertyValue({ + name: "OpenDota", + value: `https://www.opendota.com/players/${player.id}`, + }), + new PropertyValue({ + name: "DOTABUFF", + value: `https://www.dotabuff.com/players/${player.id}`, + }), + ] }) } From ac6a1492c5c2166b14f1db6aab970b48aba898eb Mon Sep 17 00:00:00 2001 From: Stefano Pigozzi Date: Sat, 19 Oct 2024 05:16:13 +0200 Subject: [PATCH 7/7] Make guild profiles retrievable --- deno.json | 3 ++- deno.lock | 1 + src/federation.ts | 55 +++++++++++++++++++++++++++++++++++++++---- src/graphql/stratz.ts | 33 ++++++++++++++++++++++++-- 4 files changed, 85 insertions(+), 7 deletions(-) diff --git a/deno.json b/deno.json index 72b9c7f..5944e6e 100644 --- a/deno.json +++ b/deno.json @@ -6,7 +6,8 @@ "@hongminhee/x-forwarded-fetch": "jsr:@hongminhee/x-forwarded-fetch@^0.2.0", "@logtape/logtape": "jsr:@logtape/logtape@^0.6.3", "@opentelemetry/api": "npm:@opentelemetry/api@^1.9.0", - "@std/assert": "jsr:@std/assert@1" + "@std/assert": "jsr:@std/assert@1", + "@@x/escape": "https://deno.land/x/escape@1.3.0/mod.ts" }, "unstable": [ "temporal" diff --git a/deno.lock b/deno.lock index 6c220c6..16ac9f1 100644 --- a/deno.lock +++ b/deno.lock @@ -367,6 +367,7 @@ "https://esm.sh/v135/@types/extract-files@latest/isExtractableFile~.d.ts": "https://esm.sh/v135/@types/extract-files@13.0.1/isExtractableFile~.d.ts" }, "remote": { + "https://deno.land/x/escape@1.3.0/mod.ts": "cd9ff4e962fcafc310858edc8b839065fea328da42b5bf1727a2d760a65c4c2d", "https://deno.land/x/graphql_deno@v15.0.0/lib/error/GraphQLError.js": "18adbba7aa651770e0876d0c7df4e6e2ab647a9f09d4b5c107c57d6fa157be9d", "https://deno.land/x/graphql_deno@v15.0.0/lib/error/formatError.js": "aec87433c501df6d6272b64974e8edf53b2ed192e66782b827328d635ed55df8", "https://deno.land/x/graphql_deno@v15.0.0/lib/error/index.js": "7557dcea8830550f82dd7b1984fdc216e14327d094f501bd2a03f80bf609a768", diff --git a/src/federation.ts b/src/federation.ts index 66ae0cf..563dad2 100644 --- a/src/federation.ts +++ b/src/federation.ts @@ -1,7 +1,8 @@ -import { createFederation, Person, Application, Image, PropertyValue } from "@fedify/fedify" +import { createFederation, Person, Application, Image, PropertyValue, Organization, Group } from "@fedify/fedify" import { kv } from "./redis.ts" import { getLogger } from "https://jsr.io/@logtape/logtape/0.6.3/logtape/logger.ts" -import { doQueryPlayer } from "./graphql/stratz.ts" +import { doQueryGuild, doQueryPlayer } from "./graphql/stratz.ts" +import { escapeHtml } from "@@x/escape" const l = getLogger(["dotino-veloce", "federation"]) @@ -9,6 +10,7 @@ l.debug`Creating federation object...` export const federation = createFederation({ kv }) const userMatcher = /u([0-9]+)/ +const guildMatcher = /g([0-9]+)/ l.debug`Creating actor dispatcher...` // deno-lint-ignore require-await @@ -55,7 +57,7 @@ async function actorDispatcher(ctx: any, handle: string) { // https://akkoma.dev/AkkomaGang/akkoma/src/commit/f1018867097e6f293d8b2b5b6935f0a7ebf99bd0/lib/pleroma/web/activity_pub/object_validators/user_validator.ex#L72 inbox: ctx.getInboxUri(handle), - name: `[TEST] ${player.name}`, + name: `[TEST] ${escapeHtml(player.name)}`, icon: new Image({ url: new URL(player.avatar), mediaType: "image/jpeg" @@ -66,7 +68,7 @@ async function actorDispatcher(ctx: any, handle: string) { value: `https://steamcommunity.com/profiles/[U:1:${player.id}]`, }), new PropertyValue({ - name: "Dota profile", + name: "STRATZ", value: `https://stratz.com/players/${player.id}`, }), new PropertyValue({ @@ -81,6 +83,51 @@ async function actorDispatcher(ctx: any, handle: string) { }) } + const guildId = Number.parseInt(handle.match(guildMatcher)?.[1] as any) + if(Number.isFinite(guildId)) { + l.info`Dispatching guild with Guild ID: ${guildId}` + + const guild = await doQueryGuild(guildId) + + if(guild === null) { + l.warn`No guild was found with ID: ${guildId}` + return null + } + + return new Group({ + id, + preferredUsername: id.href, + // Akkoma expects URL to be equal to ID + // https://akkoma.dev/AkkomaGang/akkoma/src/commit/f1018867097e6f293d8b2b5b6935f0a7ebf99bd0/lib/pleroma/object/fetcher.ex#L287 + url: id, + // Akkoma requires inboxes to be setup to display profiles + // https://akkoma.dev/AkkomaGang/akkoma/src/commit/f1018867097e6f293d8b2b5b6935f0a7ebf99bd0/lib/pleroma/web/activity_pub/object_validators/user_validator.ex#L72 + inbox: ctx.getInboxUri(handle), + + name: `[TEST] ${escapeHtml(guild.name)}`, + summary: escapeHtml(guild.description), + icon: new Image({ + url: new URL(`https://steamusercontent-a.akamaihd.net/ugc/${guild.logo}`), + mediaType: "image/jpeg" + }), + published: Temporal.Instant.fromEpochMilliseconds(guild.createdDateTime * 1000), + attachments: [ + new PropertyValue({ + name: "Tag", + value: `[${escapeHtml(guild.tag)}]`, + }), + new PropertyValue({ + name: "Message of the day", + value: escapeHtml(guild.motd), + }), + new PropertyValue({ + name: "STRATZ", + value: `https://stratz.com/guilds/${guild.id}`, + }), + ] + }) + } + l.warn`No dispatcher was found for handle: ${handle}` return null diff --git a/src/graphql/stratz.ts b/src/graphql/stratz.ts index b2bd3a2..6bf4e65 100644 --- a/src/graphql/stratz.ts +++ b/src/graphql/stratz.ts @@ -50,7 +50,7 @@ export async function doQueryPlayer(steamId: number): Promise<{ avatar: string, } | null> { l.info`Querying player ${steamId} on the Stratz API...` - const player = await doQuery( + const response = await doQuery( graphql` query ($steamId: Long!) { player (steamAccountId: $steamId) { @@ -66,5 +66,34 @@ export async function doQueryPlayer(steamId: number): Promise<{ `, {steamId} ) - return player?.player?.steamAccount ?? null + return response?.player?.steamAccount ?? null +} + +export async function doQueryGuild(guildId: number): Promise<{ + id: number, + motd: string, + name: string, + tag: string, + logo: string, + description: string, + createdDateTime: number, +} | null> { + l.info`Querying guild ${guildId} on the Stratz API...` + const response = await doQuery( + graphql` + query ($guildId: Int!) { + guild(id: $guildId) { + id, + motd, + name, + tag, + logo, + description, + createdDateTime, + } + } + `, + {guildId} + ) + return response?.guild ?? null }