valo_api.responses package

Submodules

valo_api.responses.account_details module

Classes:

AccountCardV1(id, small, large, wide)

AccountDetailsV1(puuid, region, ...[, card, ...])

class AccountCardV1(id: str, small: str, large: str, wide: str)

Bases: DictStruct

Attributes:

id

small

large

wide

id: str
small: str
large: str
wide: str
class AccountDetailsV1(puuid: str, region: str, account_level: int, name: str, tag: str, card: AccountCardV1 | None = None, last_update: str | None = None, last_update_raw: int | None = None)

Bases: DictStruct

Attributes:

puuid

region

account_level

name

tag

card

last_update

last_update_raw

puuid: str
region: str
account_level: int
name: str
tag: str
card: Optional[AccountCardV1]
last_update: Optional[str]
last_update_raw: Optional[int]

valo_api.responses.competitive_updates_raw module

Classes:

CompetitiveMatchRaw(MatchID, MapID, ...)

CompetitiveUpdatesRawV1(Version, Subject, ...)

class CompetitiveMatchRaw(MatchID: str, MapID: str, SeasonID: str, MatchStartTime: int, TierAfterUpdate: int, TierBeforeUpdate: int, RankedRatingAfterUpdate: int, RankedRatingBeforeUpdate: int, RankedRatingEarned: int, RankedRatingPerformanceBonus: int, CompetitiveMovement: str, AFKPenalty: int)

Bases: DictStruct

Attributes:

MatchID

MapID

SeasonID

MatchStartTime

TierAfterUpdate

TierBeforeUpdate

RankedRatingAfterUpdate

RankedRatingBeforeUpdate

RankedRatingEarned

RankedRatingPerformanceBonus

CompetitiveMovement

AFKPenalty

MatchID: str
MapID: str
SeasonID: str
MatchStartTime: int
TierAfterUpdate: int
TierBeforeUpdate: int
RankedRatingAfterUpdate: int
RankedRatingBeforeUpdate: int
RankedRatingEarned: int
RankedRatingPerformanceBonus: int
CompetitiveMovement: str
AFKPenalty: int
class CompetitiveUpdatesRawV1(Version: int, Subject: str, Matches: List[CompetitiveMatchRaw])

Bases: DictStruct

Attributes:

Version

Subject

Matches

Version: int
Subject: str
Matches: List[CompetitiveMatchRaw]

valo_api.responses.content module

Classes:

Entity(name, id, assetName[, assetPath, ...])

Act(id, parentId, type, name, isActive[, ...])

ContentV1(version, characters, maps, ...)

class Entity(name: str, id: str, assetName: str, assetPath: str | None = None, localizedNames: Dict[str, str] | None = None)

Bases: DictStruct

Attributes:

name

id

assetName

assetPath

localizedNames

name: str
id: str
assetName: str
assetPath: Optional[str]
localizedNames: Optional[Dict[str, str]]
class Act(id: str, parentId: str, type: str, name: str, isActive: bool, localizedNames: Dict[str, str] | None = None)

Bases: DictStruct

Attributes:

id

parentId

type

name

isActive

localizedNames

id: str
parentId: str
type: str
name: str
isActive: bool
localizedNames: Optional[Dict[str, str]]
class ContentV1(version: str, characters: List[Entity], maps: List[Entity], chromas: List[Entity], skins: List[Entity], skinLevels: List[Entity], equips: List[Entity], gameModes: List[Entity], sprays: List[Entity], sprayLevels: List[Entity], charms: List[Entity], charmLevels: List[Entity], playerCards: List[Entity], playerTitles: List[Entity], acts: List[Act], ceremonies: List[Entity])

Bases: DictStruct

Attributes:

version

characters

maps

chromas

skins

skinLevels

equips

gameModes

sprays

sprayLevels

charms

charmLevels

playerCards

playerTitles

acts

ceremonies

version: str
characters: List[Entity]
maps: List[Entity]
chromas: List[Entity]
skins: List[Entity]
skinLevels: List[Entity]
equips: List[Entity]
gameModes: List[Entity]
sprays: List[Entity]
sprayLevels: List[Entity]
charms: List[Entity]
charmLevels: List[Entity]
playerCards: List[Entity]
playerTitles: List[Entity]
acts: List[Act]
ceremonies: List[Entity]

valo_api.responses.error_response module

Classes:

Error([code, message, details])

ErrorResponse([status, errors, headers])

class Error(code: int | None = None, message: str | None = None, details: str | None = None)

Bases: DictStruct

Attributes:

code

message

details

code: Optional[int]
message: Optional[str]
details: Optional[str]
class ErrorResponse(status: int | None = None, errors: List[Error] | None = None, headers: Dict[str, str] | None = None)

Bases: DictStruct

Attributes:

status

errors

headers

status: Optional[int]
errors: Optional[List[Error]]
headers: Optional[Dict[str, str]]

valo_api.responses.leaderboard module

Classes:

LeaderboardPlayerV1(PlayerCardID, TitleID, ...)

LeaderboardPlayerV2(PlayerCardID, TitleID, ...)

LeaderboardV2(total_players, ...[, ...])

class LeaderboardPlayerV1(PlayerCardID: str, TitleID: str, IsBanned: bool, IsAnonymized: bool, puuid: str, gameName: str, tagLine: str, leaderboardRank: int, rankedRating: int, numberOfWins: int, competitiveTier: int)

Bases: DictStruct

Attributes:

PlayerCardID

TitleID

IsBanned

IsAnonymized

puuid

gameName

tagLine

leaderboardRank

rankedRating

numberOfWins

competitiveTier

PlayerCardID: str
TitleID: str
IsBanned: bool
IsAnonymized: bool
puuid: str
gameName: str
tagLine: str
leaderboardRank: int
rankedRating: int
numberOfWins: int
competitiveTier: int
class LeaderboardPlayerV2(PlayerCardID: str, TitleID: str, IsBanned: bool, IsAnonymized: bool, puuid: str, gameName: str, tagLine: str, leaderboardRank: int, rankedRating: int, numberOfWins: int, competitiveTier: int)

Bases: DictStruct

Attributes:

PlayerCardID

TitleID

IsBanned

IsAnonymized

puuid

gameName

tagLine

leaderboardRank

rankedRating

numberOfWins

competitiveTier

PlayerCardID: str
TitleID: str
IsBanned: bool
IsAnonymized: bool
puuid: str
gameName: str
tagLine: str
leaderboardRank: int
rankedRating: int
numberOfWins: int
competitiveTier: int
class LeaderboardV2(total_players: int, radiant_threshold: int, immortal_3_threshold: int, immortal_2_threshold: int, immortal_1_threshold: int, players: List[LeaderboardPlayerV2 | None], last_update: int | None = None, next_update: int | None = None)

Bases: DictStruct

Attributes:

total_players

radiant_threshold

immortal_3_threshold

immortal_2_threshold

immortal_1_threshold

players

last_update

next_update

total_players: int
radiant_threshold: int
immortal_3_threshold: int
immortal_2_threshold: int
immortal_1_threshold: int
players: List[Optional[LeaderboardPlayerV2]]
last_update: Optional[int]
next_update: Optional[int]

valo_api.responses.lifetime_match module

Classes:

LifetimeMatchMapV1(id, name)

LifetimeMatchSeasonV1(id, short)

LifetimeMatchMetaV1(map, version, ...[, ...])

LifetimeMatchCharacterV1(id, name)

LifetimeMatchShotsV1(head, body, leg)

LifetimeMatchDamageV1(made, received)

LifetimeMatchStatsV1(puuid, team, level, ...)

LifetimeMatchTeamsV1([blue, red])

LifetimeMatchV1(meta, stats, teams)

class LifetimeMatchMapV1(id: str, name: str)

Bases: DictStruct

Attributes:

id

name

id: str
name: str
class LifetimeMatchSeasonV1(id: str, short: str)

Bases: DictStruct

Attributes:

id

short

id: str
short: str
class LifetimeMatchMetaV1(map: LifetimeMatchMapV1, version: str, started_at: str, season: LifetimeMatchSeasonV1, cluster: str, region: str | None = None, mode: str | None = None)

Bases: DictStruct

Attributes:

map

version

started_at

season

cluster

region

mode

map: LifetimeMatchMapV1
version: str
started_at: str
season: LifetimeMatchSeasonV1
cluster: str
region: Optional[str]
mode: Optional[str]
class LifetimeMatchCharacterV1(id: str, name: str)

Bases: DictStruct

Attributes:

id

name

id: str
name: str
class LifetimeMatchShotsV1(head: int, body: int, leg: int)

Bases: DictStruct

Attributes:

head

body

leg

head: int
body: int
leg: int
class LifetimeMatchDamageV1(made: int, received: int)

Bases: DictStruct

Attributes:

made

received

made: int
received: int
class LifetimeMatchStatsV1(puuid: str, team: str, level: int, character: LifetimeMatchCharacterV1, tier: int, score: int, kills: int, deaths: int, assists: int, shots: LifetimeMatchShotsV1, damage: LifetimeMatchDamageV1)

Bases: DictStruct

Attributes:

puuid

team

level

character

tier

score

kills

deaths

assists

shots

damage

puuid: str
team: str
level: int
character: LifetimeMatchCharacterV1
tier: int
score: int
kills: int
deaths: int
assists: int
shots: LifetimeMatchShotsV1
damage: LifetimeMatchDamageV1
class LifetimeMatchTeamsV1(blue: int | None = None, red: int | None = None)

Bases: DictStruct

Attributes:

blue

red

blue: Optional[int]
red: Optional[int]
class LifetimeMatchV1(meta: LifetimeMatchMetaV1, stats: LifetimeMatchStatsV1, teams: LifetimeMatchTeamsV1)

Bases: DictStruct

Attributes:

meta

stats

teams

meta: LifetimeMatchMetaV1
stats: LifetimeMatchStatsV1
teams: LifetimeMatchTeamsV1

valo_api.responses.match_details_raw module

Classes:

MatchInfoRaw(matchId, mapId, gamePodId, ...)

PlayerPlatformInfoRaw(platformType, ...)

PlayerAbilityCastsRaw(grenadeCasts, ...)

PlayerStatsRaw(score, roundsPlayed, kills, ...)

PlayerRoundDamageRaw(round, receiver, damage)

PlayerBehaviorFactorsRaw(afkRounds[, ...])

PlayerBasicMovementRaw(idleTimeMillis, ...)

PlayerBasicGunSkillRaw(idleTimeMillis, ...)

PlayerAdaptiveBotsRaw(idleTimeMillis, ...)

PlayerAbilityRaw(idleTimeMillis, ...)

PlayerBombPlantRaw(idleTimeMillis, ...)

PlayerDefendBombSiteRaw(idleTimeMillis, ...)

PlayerSettingStatusRaw(...)

PlayerExperienceDetailsRaw(basicMovement, ...)

MatchPlayersRaw(subject, gameName, tagLine, ...)

MatchTeamRaw(teamId, won, roundsPlayed, ...)

PlayerLocationsRaw(subject, viewRadians, ...)

KillFinishingDamageRaw(damageType, ...)

PlayerKillsRaw(gameTime, roundTime, killer, ...)

PlayerDamageRaw(receiver, damage, legshots, ...)

PlayerEconomyRaw(loadoutValue, weapon, ...)

PlayerAbilityEffectsRaw(grenadeEffects, ...)

RoundPlayerStatsRaw(subject, kills, damage, ...)

PlayerScoreRaw(subject, score)

MatchRoundResultsRaw(roundNum, roundResult, ...)

MatchDetailsRawV1(matchInfo, players, bots, ...)

class MatchInfoRaw(matchId: str, mapId: str, gamePodId: str, gameLoopZone: str, gameServerAddress: str, gameVersion: str, gameLengthMillis: int, gameStartMillis: int, provisioningFlowID: str, isCompleted: bool, customGameName: str, forcePostProcessing: bool, queueID: str, gameMode: str, isRanked: bool, isMatchSampled: bool, seasonId: str, completionState: str, platformType: str, partyRRPenalties: Dict[str, float], shouldMatchDisablePenalties: bool | None = None)

Bases: DictStruct

Attributes:

matchId

mapId

gamePodId

gameLoopZone

gameServerAddress

gameVersion

gameLengthMillis

gameStartMillis

provisioningFlowID

isCompleted

customGameName

forcePostProcessing

queueID

gameMode

isRanked

isMatchSampled

seasonId

completionState

platformType

partyRRPenalties

shouldMatchDisablePenalties

matchId: str
mapId: str
gamePodId: str
gameLoopZone: str
gameServerAddress: str
gameVersion: str
gameLengthMillis: int
gameStartMillis: int
provisioningFlowID: str
isCompleted: bool
customGameName: str
forcePostProcessing: bool
queueID: str
gameMode: str
isRanked: bool
isMatchSampled: bool
seasonId: str
completionState: str
platformType: str
partyRRPenalties: Dict[str, float]
shouldMatchDisablePenalties: Optional[bool]
class PlayerPlatformInfoRaw(platformType: str, platformOS: str, platformOSVersion: str, platformChipset: str)

Bases: DictStruct

Attributes:

platformType

platformOS

platformOSVersion

platformChipset

platformType: str
platformOS: str
platformOSVersion: str
platformChipset: str
class PlayerAbilityCastsRaw(grenadeCasts: int, ability1Casts: int, ability2Casts: int, ultimateCasts: int)

Bases: DictStruct

Attributes:

grenadeCasts

ability1Casts

ability2Casts

ultimateCasts

grenadeCasts: int
ability1Casts: int
ability2Casts: int
ultimateCasts: int
class PlayerStatsRaw(score: int, roundsPlayed: int, kills: int, deaths: int, assists: int, playtimeMillis: int, abilityCasts: PlayerAbilityCastsRaw | None = None)

Bases: DictStruct

Attributes:

score

roundsPlayed

kills

deaths

assists

playtimeMillis

abilityCasts

score: int
roundsPlayed: int
kills: int
deaths: int
assists: int
playtimeMillis: int
abilityCasts: Optional[PlayerAbilityCastsRaw]
class PlayerRoundDamageRaw(round: int, receiver: str, damage: int)

Bases: DictStruct

Attributes:

round

receiver

damage

round: int
receiver: str
damage: int
class PlayerBehaviorFactorsRaw(afkRounds: float, damageParticipationOutgoing: int | None = None, friendlyFireIncoming: int | None = None, friendlyFireOutgoing: float | None = None, stayedInSpawnRounds: float | None = None)

Bases: DictStruct

Attributes:

afkRounds

damageParticipationOutgoing

friendlyFireIncoming

friendlyFireOutgoing

stayedInSpawnRounds

afkRounds: float
damageParticipationOutgoing: Optional[int]
friendlyFireIncoming: Optional[int]
friendlyFireOutgoing: Optional[float]
stayedInSpawnRounds: Optional[float]
class PlayerBasicMovementRaw(idleTimeMillis: int, objectiveCompleteTimeMillis: int)

Bases: DictStruct

Attributes:

idleTimeMillis

objectiveCompleteTimeMillis

idleTimeMillis: int
objectiveCompleteTimeMillis: int
class PlayerBasicGunSkillRaw(idleTimeMillis: int, objectiveCompleteTimeMillis: int)

Bases: DictStruct

Attributes:

idleTimeMillis

objectiveCompleteTimeMillis

idleTimeMillis: int
objectiveCompleteTimeMillis: int
class PlayerAdaptiveBotsRaw(idleTimeMillis: int, objectiveCompleteTimeMillis: int, adaptiveBotAverageDurationMillisAllAttempts: int, adaptiveBotAverageDurationMillisFirstAttempt: int, killDetailsFirstAttempt: dict | None)

Bases: DictStruct

Attributes:

idleTimeMillis

objectiveCompleteTimeMillis

adaptiveBotAverageDurationMillisAllAttempts

adaptiveBotAverageDurationMillisFirstAttempt

killDetailsFirstAttempt

idleTimeMillis: int
objectiveCompleteTimeMillis: int
adaptiveBotAverageDurationMillisAllAttempts: int
adaptiveBotAverageDurationMillisFirstAttempt: int
killDetailsFirstAttempt: Optional[dict]
class PlayerAbilityRaw(idleTimeMillis: int, objectiveCompleteTimeMillis: int)

Bases: DictStruct

Attributes:

idleTimeMillis

objectiveCompleteTimeMillis

idleTimeMillis: int
objectiveCompleteTimeMillis: int
class PlayerBombPlantRaw(idleTimeMillis: int, objectiveCompleteTimeMillis: int)

Bases: DictStruct

Attributes:

idleTimeMillis

objectiveCompleteTimeMillis

idleTimeMillis: int
objectiveCompleteTimeMillis: int
class PlayerDefendBombSiteRaw(idleTimeMillis: int, objectiveCompleteTimeMillis: int, success: bool)

Bases: DictStruct

Attributes:

idleTimeMillis

objectiveCompleteTimeMillis

success

idleTimeMillis: int
objectiveCompleteTimeMillis: int
success: bool
class PlayerSettingStatusRaw(isMouseSensitivityDefault: bool, isCrosshairDefault: bool)

Bases: DictStruct

Attributes:

isMouseSensitivityDefault

isCrosshairDefault

isMouseSensitivityDefault: bool
isCrosshairDefault: bool
class PlayerExperienceDetailsRaw(basicMovement: PlayerBasicMovementRaw, basicGunSkill: PlayerBasicGunSkillRaw, adaptiveBots: PlayerAdaptiveBotsRaw, ability: PlayerAbilityRaw, bombPlant: PlayerBombPlantRaw, defendBombSite: PlayerDefendBombSiteRaw, settingStatus: PlayerSettingStatusRaw)

Bases: DictStruct

Attributes:

basicMovement

basicGunSkill

adaptiveBots

ability

bombPlant

defendBombSite

settingStatus

basicMovement: PlayerBasicMovementRaw
basicGunSkill: PlayerBasicGunSkillRaw
adaptiveBots: PlayerAdaptiveBotsRaw
ability: PlayerAbilityRaw
bombPlant: PlayerBombPlantRaw
defendBombSite: PlayerDefendBombSiteRaw
settingStatus: PlayerSettingStatusRaw
class MatchPlayersRaw(subject: str, gameName: str, tagLine: str, platformInfo: PlayerPlatformInfoRaw, teamId: str, partyId: str, characterId: str, stats: PlayerStatsRaw, competitiveTier: int, playerCard: str, playerTitle: str, accountLevel: int, behaviorFactors: PlayerBehaviorFactorsRaw, newPlayerExperienceDetails: PlayerExperienceDetailsRaw, roundDamage: List[PlayerRoundDamageRaw] | None = None, sessionPlaytimeMinutes: int | None = None)

Bases: DictStruct

Attributes:

subject

gameName

tagLine

platformInfo

teamId

partyId

characterId

stats

competitiveTier

playerCard

playerTitle

accountLevel

behaviorFactors

newPlayerExperienceDetails

roundDamage

sessionPlaytimeMinutes

subject: str
gameName: str
tagLine: str
platformInfo: PlayerPlatformInfoRaw
teamId: str
partyId: str
characterId: str
stats: PlayerStatsRaw
competitiveTier: int
playerCard: str
playerTitle: str
accountLevel: int
behaviorFactors: PlayerBehaviorFactorsRaw
newPlayerExperienceDetails: PlayerExperienceDetailsRaw
roundDamage: Optional[List[PlayerRoundDamageRaw]]
sessionPlaytimeMinutes: Optional[int]
class MatchTeamRaw(teamId: str, won: bool, roundsPlayed: int, numPoints: int)

Bases: DictStruct

Attributes:

teamId

won

roundsPlayed

numPoints

teamId: str
won: bool
roundsPlayed: int
numPoints: int
class PlayerLocationsRaw(subject: str, viewRadians: float, location: Location)

Bases: DictStruct

Attributes:

subject

viewRadians

location

subject: str
viewRadians: float
location: Location
class KillFinishingDamageRaw(damageType: str, damageItem: str, isSecondaryFireMode: bool)

Bases: DictStruct

Attributes:

damageType

damageItem

isSecondaryFireMode

damageType: str
damageItem: str
isSecondaryFireMode: bool
class PlayerKillsRaw(gameTime: int, roundTime: int, killer: str, victim: str, victimLocation: Location, assistants: List[str], playerLocations: List[PlayerLocationsRaw], finishingDamage: KillFinishingDamageRaw)

Bases: DictStruct

Attributes:

gameTime

roundTime

killer

victim

victimLocation

assistants

playerLocations

finishingDamage

gameTime: int
roundTime: int
killer: str
victim: str
victimLocation: Location
assistants: List[str]
playerLocations: List[PlayerLocationsRaw]
finishingDamage: KillFinishingDamageRaw
class PlayerDamageRaw(receiver: str, damage: int, legshots: int, bodyshots: int, headshots: int)

Bases: DictStruct

Attributes:

receiver

damage

legshots

bodyshots

headshots

receiver: str
damage: int
legshots: int
bodyshots: int
headshots: int
class PlayerEconomyRaw(loadoutValue: int, weapon: str, armor: str, remaining: int, spent: int, subject: str | None = None)

Bases: DictStruct

Attributes:

loadoutValue

weapon

armor

remaining

spent

subject

loadoutValue: int
weapon: str
armor: str
remaining: int
spent: int
subject: Optional[str]
class PlayerAbilityEffectsRaw(grenadeEffects: dict | None, ability1Effects: dict | None, ability2Effects: dict | None, ultimateEffects: dict | None)

Bases: DictStruct

Attributes:

grenadeEffects

ability1Effects

ability2Effects

ultimateEffects

grenadeEffects: Optional[dict]
ability1Effects: Optional[dict]
ability2Effects: Optional[dict]
ultimateEffects: Optional[dict]
class RoundPlayerStatsRaw(subject: str, kills: List[PlayerKillsRaw], damage: List[PlayerDamageRaw], score: int, economy: PlayerEconomyRaw, ability: PlayerAbilityEffectsRaw, wasAfk: bool, wasPenalized: bool, stayedInSpawn: bool)

Bases: DictStruct

Attributes:

subject

kills

damage

score

economy

ability

wasAfk

wasPenalized

stayedInSpawn

subject: str
kills: List[PlayerKillsRaw]
damage: List[PlayerDamageRaw]
score: int
economy: PlayerEconomyRaw
ability: PlayerAbilityEffectsRaw
wasAfk: bool
wasPenalized: bool
stayedInSpawn: bool
class PlayerScoreRaw(subject: str, score: int)

Bases: DictStruct

Attributes:

subject

score

subject: str
score: int
class MatchRoundResultsRaw(roundNum: int, roundResult: str, roundCeremony: str, winningTeam: str, plantRoundTime: int, plantLocation: Location, plantSite: str, defuseRoundTime: int, defuseLocation: Location, playerStats: List[RoundPlayerStatsRaw], roundResultCode: str, bombPlanter: str | None = None, bombDefuser: str | None = None, playerEconomies: List[PlayerEconomyRaw] | None = None, playerScores: List[PlayerScoreRaw] | None = None, plantPlayerLocations: List[PlayerLocationsRaw] | None = None, defusePlayerLocations: List[PlayerLocationsRaw] | None = None)

Bases: DictStruct

Attributes:

roundNum

roundResult

roundCeremony

winningTeam

plantRoundTime

plantLocation

plantSite

defuseRoundTime

defuseLocation

playerStats

roundResultCode

bombPlanter

bombDefuser

playerEconomies

playerScores

plantPlayerLocations

defusePlayerLocations

roundNum: int
roundResult: str
roundCeremony: str
winningTeam: str
plantRoundTime: int
plantLocation: Location
plantSite: str
defuseRoundTime: int
defuseLocation: Location
playerStats: List[RoundPlayerStatsRaw]
roundResultCode: str
bombPlanter: Optional[str]
bombDefuser: Optional[str]
playerEconomies: Optional[List[PlayerEconomyRaw]]
playerScores: Optional[List[PlayerScoreRaw]]
plantPlayerLocations: Optional[List[PlayerLocationsRaw]]
defusePlayerLocations: Optional[List[PlayerLocationsRaw]]
class MatchDetailsRawV1(matchInfo: MatchInfoRaw, players: List[MatchPlayersRaw], bots: List[dict], coaches: List[dict], teams: List[MatchTeamRaw], roundResults: List[MatchRoundResultsRaw] | None, kills: List[PlayerKillsRaw])

Bases: DictStruct

Attributes:

matchInfo

players

bots

coaches

teams

roundResults

kills

matchInfo: MatchInfoRaw
players: List[MatchPlayersRaw]
bots: List[dict]
coaches: List[dict]
teams: List[MatchTeamRaw]
roundResults: Optional[List[MatchRoundResultsRaw]]
kills: List[PlayerKillsRaw]

valo_api.responses.match_history module

Classes:

MatchMetadataV3(map, game_version, ...)

MatchPlayerSessionPlaytimeV3([minutes, ...])

MatchFriendlyFireV3([incoming, outgoing])

MatchPlayerBehaviorV3(afk_rounds, friendly_fire)

MatchPlayerOSV3(name, version)

MatchPlayerPlatformV3(type, os)

MatchPlayerAbilityCastsV3([c_cast, q_cast, ...])

MatchPlayerAbilityCasts2V3([c_casts, ...])

MatchPlayerAssetsCardV3(small, large, wide)

MatchPlayerAssetsAgentV3(small, bust, full, ...)

MatchPlayerAssetsV3(card, agent)

MatchPlayerStatsV3(score, kills, deaths, assists)

MatchPlayerEconomyReportV3(overall, average)

MatchPlayerEconomyV3(spent, loadout_value)

MatchPlayerV3(puuid, name, tag, team, level, ...)

MatchPlayersV3(all_players, red, blue)

MatchTeamV3([has_won, rounds_won, rounds_lost])

MatchTeamsV3(red, blue)

Location(x, y)

MatchRoundPlanterV3(puuid, display_name, team)

MatchRoundPlayerLocationV3(player_puuid, ...)

MatchRoundPlantEventV3([plant_location, ...])

MatchRoundDefuseEventV3([defuse_location, ...])

MatchRoundDamageEventV3(receiver_puuid, ...)

WeaponAssets([display_icon, killfeed_icon])

MatchRoundAssistantV3(assistant_puuid, ...)

MatchRoundKillEventV3(kill_time_in_round, ...)

Weapon(assets[, id, name])

Armor(assets[, id, name])

MatchPlayerEconomyFullV3(loadout_value, ...)

MatchRoundPlayerStatsV3(ability_casts, ...)

MatchRoundV3(winning_team, end_type, ...)

MatchHistoryPointV3(metadata, players, ...)

class MatchMetadataV3(map: str, game_version: str, game_length: int, game_start: int, game_start_patched: str, rounds_played: int, mode: str, season_id: str, platform: str, matchid: str, region: str, cluster: str, queue: str)

Bases: DictStruct

Attributes:

map

game_version

game_length

game_start

game_start_patched

rounds_played

mode

season_id

platform

matchid

region

cluster

queue

map: str
game_version: str
game_length: int
game_start: int
game_start_patched: str
rounds_played: int
mode: str
season_id: str
platform: str
matchid: str
region: str
cluster: str
queue: str
class MatchPlayerSessionPlaytimeV3(minutes: int | None = None, seconds: int | None = None, milliseconds: int | None = None)

Bases: DictStruct

Attributes:

minutes

seconds

milliseconds

minutes: Optional[int]
seconds: Optional[int]
milliseconds: Optional[int]
class MatchFriendlyFireV3(incoming: float | None = None, outgoing: float | None = None)

Bases: DictStruct

Attributes:

incoming

outgoing

incoming: Optional[float]
outgoing: Optional[float]
class MatchPlayerBehaviorV3(afk_rounds: float, friendly_fire: MatchFriendlyFireV3, rounds_in_spawn: float | None = None)

Bases: DictStruct

Attributes:

afk_rounds

friendly_fire

rounds_in_spawn

afk_rounds: float
friendly_fire: MatchFriendlyFireV3
rounds_in_spawn: Optional[float]
class MatchPlayerOSV3(name: str, version: str)

Bases: DictStruct

Attributes:

name

version

name: str
version: str
class MatchPlayerPlatformV3(type: str, os: MatchPlayerOSV3)

Bases: DictStruct

Attributes:

type

os

type: str
os: MatchPlayerOSV3
class MatchPlayerAbilityCastsV3(c_cast: int | None = None, q_cast: int | None = None, e_cast: int | None = None, x_cast: int | None = None)

Bases: DictStruct

Attributes:

c_cast

q_cast

e_cast

x_cast

c_cast: Optional[int]
q_cast: Optional[int]
e_cast: Optional[int]
x_cast: Optional[int]
class MatchPlayerAbilityCasts2V3(c_casts: int | None = None, q_casts: int | None = None, e_cast: int | None = None, x_cast: int | None = None)

Bases: DictStruct

Attributes:

c_casts

q_casts

e_cast

x_cast

c_casts: Optional[int]
q_casts: Optional[int]
e_cast: Optional[int]
x_cast: Optional[int]
class MatchPlayerAssetsCardV3(small: str, large: str, wide: str)

Bases: DictStruct

Attributes:

small

large

wide

small: str
large: str
wide: str
class MatchPlayerAssetsAgentV3(small: str, bust: str, full: str, killfeed: str)

Bases: DictStruct

Attributes:

small

bust

full

killfeed

small: str
bust: str
full: str
killfeed: str
class MatchPlayerAssetsV3(card: MatchPlayerAssetsCardV3, agent: MatchPlayerAssetsAgentV3)

Bases: DictStruct

Attributes:

card

agent

card: MatchPlayerAssetsCardV3
agent: MatchPlayerAssetsAgentV3
class MatchPlayerStatsV3(score: int, kills: int, deaths: int, assists: int, bodyshots: int | None = None, headshots: int | None = None, legshots: int | None = None)

Bases: DictStruct

Attributes:

score

kills

deaths

assists

bodyshots

headshots

legshots

score: int
kills: int
deaths: int
assists: int
bodyshots: Optional[int]
headshots: Optional[int]
legshots: Optional[int]
class MatchPlayerEconomyReportV3(overall: int, average: float)

Bases: DictStruct

Attributes:

overall

average

overall: int
average: float
class MatchPlayerEconomyV3(spent: MatchPlayerEconomyReportV3, loadout_value: MatchPlayerEconomyReportV3)

Bases: DictStruct

Attributes:

spent

loadout_value

spent: MatchPlayerEconomyReportV3
loadout_value: MatchPlayerEconomyReportV3
class MatchPlayerV3(puuid: str, name: str, tag: str, team: str, level: int, character: str, currenttier: int, currenttier_patched: str, player_card: str, player_title: str, party_id: str, session_playtime: MatchPlayerSessionPlaytimeV3, behavior: MatchPlayerBehaviorV3, platform: MatchPlayerPlatformV3, ability_casts: MatchPlayerAbilityCastsV3, assets: MatchPlayerAssetsV3, stats: MatchPlayerStatsV3, economy: MatchPlayerEconomyV3, damage_made: int | None = None, damage_received: int | None = None)

Bases: DictStruct

Attributes:

puuid

name

tag

team

level

character

currenttier

currenttier_patched

player_card

player_title

party_id

session_playtime

behavior

platform

ability_casts

assets

stats

economy

damage_made

damage_received

puuid: str
name: str
tag: str
team: str
level: int
character: str
currenttier: int
currenttier_patched: str
player_card: str
player_title: str
party_id: str
session_playtime: MatchPlayerSessionPlaytimeV3
behavior: MatchPlayerBehaviorV3
platform: MatchPlayerPlatformV3
ability_casts: MatchPlayerAbilityCastsV3
assets: MatchPlayerAssetsV3
stats: MatchPlayerStatsV3
economy: MatchPlayerEconomyV3
damage_made: Optional[int]
damage_received: Optional[int]
class MatchPlayersV3(all_players: List[MatchPlayerV3], red: List[MatchPlayerV3], blue: List[MatchPlayerV3])

Bases: DictStruct

Attributes:

all_players

red

blue

all_players: List[MatchPlayerV3]
red: List[MatchPlayerV3]
blue: List[MatchPlayerV3]
class MatchTeamV3(has_won: bool | None = None, rounds_won: int | None = None, rounds_lost: int | None = None)

Bases: DictStruct

Attributes:

has_won

rounds_won

rounds_lost

has_won: Optional[bool]
rounds_won: Optional[int]
rounds_lost: Optional[int]
class MatchTeamsV3(red: MatchTeamV3, blue: MatchTeamV3)

Bases: DictStruct

Attributes:

red

blue

red: MatchTeamV3
blue: MatchTeamV3
class Location(x: int, y: int)

Bases: DictStruct

Attributes:

x

y

x: int
y: int
class MatchRoundPlanterV3(puuid: str, display_name: str, team: str)

Bases: DictStruct

Attributes:

puuid

display_name

team

puuid: str
display_name: str
team: str
class MatchRoundPlayerLocationV3(player_puuid: str, player_display_name: str, player_team: str, location: Location, view_radians: float)

Bases: DictStruct

Attributes:

player_puuid

player_display_name

player_team

location

view_radians

player_puuid: str
player_display_name: str
player_team: str
location: Location
view_radians: float
class MatchRoundPlantEventV3(plant_location: Location | None = None, planted_by: MatchRoundPlanterV3 | None = None, plant_site: str | None = None, plant_time_in_round: int | None = None, player_locations_on_plant: List[MatchRoundPlayerLocationV3] | None = None)

Bases: DictStruct

Attributes:

plant_location

planted_by

plant_site

plant_time_in_round

player_locations_on_plant

plant_location: Optional[Location]
planted_by: Optional[MatchRoundPlanterV3]
plant_site: Optional[str]
plant_time_in_round: Optional[int]
player_locations_on_plant: Optional[List[MatchRoundPlayerLocationV3]]
class MatchRoundDefuseEventV3(defuse_location: Location | None = None, defused_by: MatchRoundPlanterV3 | None = None, defuse_time_in_round: int | None = None, player_locations_on_defuse: List[MatchRoundPlayerLocationV3] | None = None)

Bases: DictStruct

Attributes:

defuse_location

defused_by

defuse_time_in_round

player_locations_on_defuse

defuse_location: Optional[Location]
defused_by: Optional[MatchRoundPlanterV3]
defuse_time_in_round: Optional[int]
player_locations_on_defuse: Optional[List[MatchRoundPlayerLocationV3]]
class MatchRoundDamageEventV3(receiver_puuid: str, receiver_display_name: str, receiver_team: str, bodyshots: int, damage: int, headshots: int, legshots: int)

Bases: DictStruct

Attributes:

receiver_puuid

receiver_display_name

receiver_team

bodyshots

damage

headshots

legshots

receiver_puuid: str
receiver_display_name: str
receiver_team: str
bodyshots: int
damage: int
headshots: int
legshots: int
class WeaponAssets(display_icon: str | None = None, killfeed_icon: str | None = None)

Bases: DictStruct

Attributes:

display_icon

killfeed_icon

display_icon: Optional[str]
killfeed_icon: Optional[str]
class MatchRoundAssistantV3(assistant_puuid: str, assistant_display_name: str, assistant_team: str)

Bases: DictStruct

Attributes:

assistant_puuid

assistant_display_name

assistant_team

assistant_puuid: str
assistant_display_name: str
assistant_team: str
class MatchRoundKillEventV3(kill_time_in_round: int, kill_time_in_match: int, victim_puuid: str, victim_display_name: str, victim_team: str, victim_death_location: Location, damage_weapon_id: str, damage_weapon_assets: WeaponAssets, secondary_fire_mode: bool, player_locations_on_kill: List[MatchRoundPlayerLocationV3], assistants: List[MatchRoundAssistantV3], killer_puuid: str | None = None, killer_display_name: str | None = None, killer_team: str | None = None, damage_weapon_name: str | None = None)

Bases: DictStruct

Attributes:

kill_time_in_round

kill_time_in_match

victim_puuid

victim_display_name

victim_team

victim_death_location

damage_weapon_id

damage_weapon_assets

secondary_fire_mode

player_locations_on_kill

assistants

killer_puuid

killer_display_name

killer_team

damage_weapon_name

kill_time_in_round: int
kill_time_in_match: int
victim_puuid: str
victim_display_name: str
victim_team: str
victim_death_location: Location
damage_weapon_id: str
damage_weapon_assets: WeaponAssets
secondary_fire_mode: bool
player_locations_on_kill: List[MatchRoundPlayerLocationV3]
assistants: List[MatchRoundAssistantV3]
killer_puuid: Optional[str]
killer_display_name: Optional[str]
killer_team: Optional[str]
damage_weapon_name: Optional[str]
class Weapon(assets: WeaponAssets, id: str | None = None, name: str | None = None)

Bases: DictStruct

Attributes:

assets

id

name

assets: WeaponAssets
id: Optional[str]
name: Optional[str]
class Armor(assets: WeaponAssets, id: str | None = None, name: str | None = None)

Bases: Weapon

class MatchPlayerEconomyFullV3(loadout_value: int, weapon: Weapon, armor: Armor, remaining: int, spent: int)

Bases: DictStruct

Attributes:

loadout_value

weapon

armor

remaining

spent

loadout_value: int
weapon: Weapon
armor: Armor
remaining: int
spent: int
class MatchRoundPlayerStatsV3(ability_casts: MatchPlayerAbilityCasts2V3, player_puuid: str, player_display_name: str, player_team: str, damage_events: List[MatchRoundDamageEventV3], damage: int, bodyshots: int, headshots: int, legshots: int, kill_events: List[MatchRoundKillEventV3], kills: int, score: int, economy: MatchPlayerEconomyFullV3, was_afk: bool, was_penalized: bool, stayed_in_spawn: bool)

Bases: DictStruct

Attributes:

ability_casts

player_puuid

player_display_name

player_team

damage_events

damage

bodyshots

headshots

legshots

kill_events

kills

score

economy

was_afk

was_penalized

stayed_in_spawn

ability_casts: MatchPlayerAbilityCasts2V3
player_puuid: str
player_display_name: str
player_team: str
damage_events: List[MatchRoundDamageEventV3]
damage: int
bodyshots: int
headshots: int
legshots: int
kill_events: List[MatchRoundKillEventV3]
kills: int
score: int
economy: MatchPlayerEconomyFullV3
was_afk: bool
was_penalized: bool
stayed_in_spawn: bool
class MatchRoundV3(winning_team: str, end_type: str, bomb_planted: bool, bomb_defused: bool, plant_events: MatchRoundPlantEventV3, defuse_events: MatchRoundDefuseEventV3, player_stats: List[MatchRoundPlayerStatsV3])

Bases: DictStruct

Attributes:

winning_team

end_type

bomb_planted

bomb_defused

plant_events

defuse_events

player_stats

winning_team: str
end_type: str
bomb_planted: bool
bomb_defused: bool
plant_events: MatchRoundPlantEventV3
defuse_events: MatchRoundDefuseEventV3
player_stats: List[MatchRoundPlayerStatsV3]
class MatchHistoryPointV3(metadata: MatchMetadataV3, players: MatchPlayersV3, teams: MatchTeamsV3, rounds: List[MatchRoundV3], kills: List[MatchRoundKillEventV3])

Bases: DictStruct

Attributes:

metadata

players

teams

rounds

kills

metadata: MatchMetadataV3
players: MatchPlayersV3
teams: MatchTeamsV3
rounds: List[MatchRoundV3]
kills: List[MatchRoundKillEventV3]

valo_api.responses.match_history_raw module

Classes:

MatchRaw(MatchID, GameStartTime, QueueID)

MatchHistoryRawV1(Subject, BeginIndex, ...)

class MatchRaw(MatchID: str, GameStartTime: int, QueueID: str)

Bases: DictStruct

Attributes:

MatchID

GameStartTime

QueueID

MatchID: str
GameStartTime: int
QueueID: str
class MatchHistoryRawV1(Subject: str, BeginIndex: int, EndIndex: int, Total: int, History: List[MatchRaw])

Bases: DictStruct

Attributes:

Subject

BeginIndex

EndIndex

Total

History

Subject: str
BeginIndex: int
EndIndex: int
Total: int
History: List[MatchRaw]

valo_api.responses.mmr_details module

Classes:

MMRDetailsV1(name, tag, elo, old[, ...])

CurrentDataV2(old[, currenttier, ...])

HighestRankV2(old, tier, patched_tier[, season])

ActRankWinV2(patched_tier, tier)

SeasonDataV2([wins, number_of_games, ...])

MMRDetailsV2(name, tag, current_data, ...)

class MMRDetailsV1(name: str, tag: str, elo: int, old: bool, currenttier: int | None = None, currenttierpatched: str | None = None, ranking_in_tier: int | None = None, mmr_change_to_last_game: int | None = None)

Bases: DictStruct

Attributes:

name

tag

elo

old

currenttier

currenttierpatched

ranking_in_tier

mmr_change_to_last_game

name: str
tag: str
elo: int
old: bool
currenttier: Optional[int]
currenttierpatched: Optional[str]
ranking_in_tier: Optional[int]
mmr_change_to_last_game: Optional[int]
class CurrentDataV2(old: bool, currenttier: int | None = None, currenttierpatched: str | None = None, ranking_in_tier: int | None = None, mmr_change_to_last_game: int | None = None, elo: int | None = None, games_needed_for_rating: int | None = None)

Bases: DictStruct

Attributes:

old

currenttier

currenttierpatched

ranking_in_tier

mmr_change_to_last_game

elo

games_needed_for_rating

old: bool
currenttier: Optional[int]
currenttierpatched: Optional[str]
ranking_in_tier: Optional[int]
mmr_change_to_last_game: Optional[int]
elo: Optional[int]
games_needed_for_rating: Optional[int]
class HighestRankV2(old: bool, tier: int, patched_tier: str, season: str | None = None)

Bases: DictStruct

Attributes:

old

tier

patched_tier

season

old: bool
tier: int
patched_tier: str
season: Optional[str]
class ActRankWinV2(patched_tier: str, tier: int)

Bases: DictStruct

Attributes:

patched_tier

tier

patched_tier: str
tier: int
class SeasonDataV2(wins: int | None = None, number_of_games: int | None = None, final_rank: int | None = None, final_rank_patched: str | None = None, act_rank_wins: List[ActRankWinV2] | None = None, old: bool | None = None, error: str | None = None)

Bases: DictStruct

Attributes:

wins

number_of_games

final_rank

final_rank_patched

act_rank_wins

old

error

wins: Optional[int]
number_of_games: Optional[int]
final_rank: Optional[int]
final_rank_patched: Optional[str]
act_rank_wins: Optional[List[ActRankWinV2]]
old: Optional[bool]
error: Optional[str]
class MMRDetailsV2(name: str, tag: str, current_data: CurrentDataV2, highest_rank: HighestRankV2, by_season: Dict[str, SeasonDataV2])

Bases: DictStruct

Attributes:

name

tag

current_data

highest_rank

by_season

name: str
tag: str
current_data: CurrentDataV2
highest_rank: HighestRankV2
by_season: Dict[str, SeasonDataV2]

valo_api.responses.mmr_history module

Classes:

MMRHistoryPointImagesV1([small, large, ...])

MMRHistoryPointMapV1(name, id)

MMRHistoryPointV1(currenttier, ...)

class MMRHistoryPointImagesV1(small: str | None = None, large: str | None = None, triangle_down: str | None = None, triangle_up: str | None = None)

Bases: DictStruct

Attributes:

small

large

triangle_down

triangle_up

small: Optional[str]
large: Optional[str]
triangle_down: Optional[str]
triangle_up: Optional[str]
class MMRHistoryPointMapV1(name: str, id: str)

Bases: DictStruct

Attributes:

name

id

name: str
id: str
class MMRHistoryPointV1(currenttier: int, currenttierpatched: str, images: MMRHistoryPointImagesV1, match_id: str, map: MMRHistoryPointMapV1, season_id: str, ranking_in_tier: int, mmr_change_to_last_game: int, elo: int, date: str, date_raw: int)

Bases: DictStruct

Attributes:

currenttier

currenttierpatched

images

match_id

map

season_id

ranking_in_tier

mmr_change_to_last_game

elo

date

date_raw

currenttier: int
currenttierpatched: str
images: MMRHistoryPointImagesV1
match_id: str
map: MMRHistoryPointMapV1
season_id: str
ranking_in_tier: int
mmr_change_to_last_game: int
elo: int
date: str
date_raw: int

valo_api.responses.mmr_raw module

Classes:

SeasonInfoRaw(SeasonID, NumberOfWins, ...[, ...])

QueueSkill(TotalGamesNeededForRating, ...)

QueueSkills([competitive, custom, ...])

MMRRawV1(Version, Subject, ...)

class SeasonInfoRaw(SeasonID: str, NumberOfWins: int, NumberOfWinsWithPlacements: int, NumberOfGames: int, Rank: int, CapstoneWins: int, LeaderboardRank: int, CompetitiveTier: int, RankedRating: int, GamesNeededForRating: int, TotalWinsNeededForRank: int, WinsByTier: Dict[str, int] | None = None)

Bases: DictStruct

Attributes:

SeasonID

NumberOfWins

NumberOfWinsWithPlacements

NumberOfGames

Rank

CapstoneWins

LeaderboardRank

CompetitiveTier

RankedRating

GamesNeededForRating

TotalWinsNeededForRank

WinsByTier

SeasonID: str
NumberOfWins: int
NumberOfWinsWithPlacements: int
NumberOfGames: int
Rank: int
CapstoneWins: int
LeaderboardRank: int
CompetitiveTier: int
RankedRating: int
GamesNeededForRating: int
TotalWinsNeededForRank: int
WinsByTier: Optional[Dict[str, int]]
class QueueSkill(TotalGamesNeededForRating: int, TotalGamesNeededForLeaderboard: int, CurrentSeasonGamesNeededForRating: int, SeasonalInfoBySeasonID: Dict[str, SeasonInfoRaw] | None)

Bases: DictStruct

Attributes:

TotalGamesNeededForRating

TotalGamesNeededForLeaderboard

CurrentSeasonGamesNeededForRating

SeasonalInfoBySeasonID

TotalGamesNeededForRating: int
TotalGamesNeededForLeaderboard: int
CurrentSeasonGamesNeededForRating: int
SeasonalInfoBySeasonID: Optional[Dict[str, SeasonInfoRaw]]
class QueueSkills(competitive: QueueSkill | None = None, custom: QueueSkill | None = None, deathmatch: QueueSkill | None = None, onefa: QueueSkill | None = None, seeding: QueueSkill | None = None, spikerush: QueueSkill | None = None, unrated: QueueSkill | None = None)

Bases: DictStruct

Attributes:

competitive

custom

deathmatch

onefa

seeding

spikerush

unrated

competitive: Optional[QueueSkill]
custom: Optional[QueueSkill]
deathmatch: Optional[QueueSkill]
onefa: Optional[QueueSkill]
seeding: Optional[QueueSkill]
spikerush: Optional[QueueSkill]
unrated: Optional[QueueSkill]
class MMRRawV1(Version: int, Subject: str, NewPlayerExperienceFinished: bool, QueueSkills: QueueSkills, LatestCompetitiveUpdate: CompetitiveMatchRaw | None, IsLeaderboardAnonymized: bool, IsActRankBadgeHidden: bool)

Bases: DictStruct

Attributes:

Version

Subject

NewPlayerExperienceFinished

QueueSkills

LatestCompetitiveUpdate

IsLeaderboardAnonymized

IsActRankBadgeHidden

Version: int
Subject: str
NewPlayerExperienceFinished: bool
QueueSkills: QueueSkills
LatestCompetitiveUpdate: Optional[CompetitiveMatchRaw]
IsLeaderboardAnonymized: bool
IsActRankBadgeHidden: bool

valo_api.responses.status module

Classes:

MaintenanceStatusTitleV1(locale, content)

MaintenanceUpdateV1(publish_locations, ...)

MaintenancePointV1(updated_at, created_at, ...)

StatusV1(maintenances, incidents)

class MaintenanceStatusTitleV1(locale: str, content: str)

Bases: DictStruct

Attributes:

locale

content

locale: str
content: str
class MaintenanceUpdateV1(publish_locations: List[str], updated_at: str, created_at: str, id: int, publish: bool, translations: List[MaintenanceStatusTitleV1], author: str | None = None)

Bases: DictStruct

Attributes:

publish_locations

updated_at

created_at

id

publish

translations

author

publish_locations: List[str]
updated_at: str
created_at: str
id: int
publish: bool
translations: List[MaintenanceStatusTitleV1]
author: Optional[str]
class MaintenancePointV1(updated_at: str | None, created_at: str | None, archive_at: str | None, titles: List[MaintenanceStatusTitleV1], maintenance_status: str | None, id: int, incident_severity: str | None, updates: List[MaintenanceUpdateV1], platforms: List[str])

Bases: DictStruct

Attributes:

updated_at

created_at

archive_at

titles

maintenance_status

id

incident_severity

updates

platforms

updated_at: Optional[str]
created_at: Optional[str]
archive_at: Optional[str]
titles: List[MaintenanceStatusTitleV1]
maintenance_status: Optional[str]
id: int
incident_severity: Optional[str]
updates: List[MaintenanceUpdateV1]
platforms: List[str]
class StatusV1(maintenances: List[MaintenancePointV1], incidents: List[MaintenancePointV1])

Bases: DictStruct

Attributes:

maintenances

incidents

maintenances: List[MaintenancePointV1]
incidents: List[MaintenancePointV1]

valo_api.responses.store_offers module

Classes:

RewardInfoV1(ItemTypeID, ItemID, Quantity)

OfferV1(OfferID, IsDirectPurchase, ...)

OfferIDsV1(OfferID, StorefrontItemID)

StoreOffersV1(Offers, UpgradeCurrencyOffers)

ContentTierV2(name, dev_name, icon)

OfferV2(offer_id, cost, name, type[, icon, ...])

StoreOffersV2(offers)

class RewardInfoV1(ItemTypeID: str, ItemID: str, Quantity: int)

Bases: DictStruct

Attributes:

ItemTypeID

ItemID

Quantity

ItemTypeID: str
ItemID: str
Quantity: int
class OfferV1(OfferID: str, IsDirectPurchase: bool, StartDate: str, Cost: Dict[str, int], Rewards: List[RewardInfoV1])

Bases: DictStruct

Attributes:

OfferID

IsDirectPurchase

StartDate

Cost

Rewards

OfferID: str
IsDirectPurchase: bool
StartDate: str
Cost: Dict[str, int]
Rewards: List[RewardInfoV1]
class OfferIDsV1(OfferID: str, StorefrontItemID: str)

Bases: DictStruct

Attributes:

OfferID

StorefrontItemID

OfferID: str
StorefrontItemID: str
class StoreOffersV1(Offers: List[OfferV1], UpgradeCurrencyOffers: List[OfferIDsV1])

Bases: DictStruct

Attributes:

Offers

UpgradeCurrencyOffers

Offers: List[OfferV1]
UpgradeCurrencyOffers: List[OfferIDsV1]
class ContentTierV2(name: str, dev_name: str, icon: str)

Bases: DictStruct

Attributes:

name

dev_name

icon

name: str
dev_name: str
icon: str
class OfferV2(offer_id: str, cost: int, name: str, type: str, icon: str | None = None, skin_id: str | None = None, content_tier: ContentTierV2 | None = None)

Bases: DictStruct

Attributes:

offer_id

cost

name

type

icon

skin_id

content_tier

offer_id: str
cost: int
name: str
type: str
icon: Optional[str]
skin_id: Optional[str]
content_tier: Optional[ContentTierV2]
class StoreOffersV2(offers: List[OfferV2])

Bases: DictStruct

Attributes:

offers

offers: List[OfferV2]

valo_api.responses.version_info module

Classes:

VersionInfoV1(region, branch, build_date, ...)

class VersionInfoV1(region: str, branch: str, build_date: str, build_ver: str, last_checked: str, version: int, version_for_api: str)

Bases: DictStruct

Attributes:

region

branch

build_date

build_ver

last_checked

version

version_for_api

region: str
branch: str
build_date: str
build_ver: str
last_checked: str
version: int
version_for_api: str

valo_api.responses.website module

Classes:

WebsiteBannerV1(banner_url, category, date, ...)

class WebsiteBannerV1(banner_url: str, category: str, date: str, title: str, url: str, external_link: str | None = None)

Bases: DictStruct

Attributes:

banner_url

category

date

title

url

external_link

banner_url: str
category: str
date: str
title: str
url: str

Module contents