@voxary/valorant-client 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,771 +1,2419 @@
-// src/client.ts
-import { ZodError } from "zod";
+// src/api/groups/pvp.ts
+import { endpoints as e10 } from "valorant-api-types";
 
-// src/api/registry.ts
-import { endpoints as e } from "valorant-api-types";
-
-// src/extra/catalog.ts
+// src/endpoints/riot/account.ts
 import { z } from "zod";
 
-// src/envelope.ts
-var enveloped = /* @__PURE__ */ new WeakSet();
-function markEnveloped(endpoint2) {
-  enveloped.add(endpoint2);
-  return endpoint2;
+// src/endpoints/riot/shared.ts
+var player = { token: true, entitlement: true, clientVersion: true, clientPlatform: true };
+function withResponse(endpoint2, schema) {
+  return { ...endpoint2, responses: { "200": schema } };
 }
-function unwrapEnvelope(endpoint2, body) {
-  if (enveloped.has(endpoint2) && typeof body === "object" && body !== null && "data" in body) {
-    return body.data;
-  }
-  return body;
+function onSharedHost(endpoint2) {
+  return { ...endpoint2, type: "shared" };
 }
 
-// src/extra/catalog.ts
-var BASE = "https://valorant-api.com/v1/";
-var text = z.string().nullish();
-var asset = z.object({
-  uuid: z.string(),
-  displayName: text,
-  displayIcon: text,
-  assetPath: text
-}).passthrough();
-var agentSchema = asset.extend({
-  description: text,
-  developerName: text,
-  characterTags: z.array(z.string()).nullish(),
-  displayIconSmall: text,
-  bustPortrait: text,
-  fullPortrait: text,
-  killfeedPortrait: text,
-  background: text,
-  isPlayableCharacter: z.boolean(),
-  role: z.object({ uuid: z.string(), displayName: text, description: text, displayIcon: text }).passthrough().nullish(),
-  abilities: z.array(z.object({ slot: z.string(), displayName: text, description: text, displayIcon: text }).passthrough()).nullish()
-});
-var mapSchema = asset.extend({
-  coordinates: text,
-  listViewIcon: text,
-  splash: text,
-  mapUrl: text,
-  xMultiplier: z.number(),
-  yMultiplier: z.number(),
-  xScalarToAdd: z.number(),
-  yScalarToAdd: z.number(),
-  callouts: z.array(z.object({ regionName: z.string(), superRegionName: z.string(), location: z.object({ x: z.number(), y: z.number() }) }).passthrough()).nullish()
-});
-var weaponSchema = asset.extend({
-  category: z.string(),
-  defaultSkinUuid: z.string(),
-  killStreamIcon: text,
-  weaponStats: z.object({}).passthrough().nullish(),
-  shopData: z.object({}).passthrough().nullish(),
-  skins: z.array(z.object({}).passthrough())
-});
-var skinSchema = asset.extend({
-  themeUuid: z.string(),
-  contentTierUuid: text,
-  wallpaper: text,
-  chromas: z.array(asset.passthrough()),
-  levels: z.array(asset.passthrough())
-});
-var seasonSchema = z.object({
-  uuid: z.string(),
-  displayName: text,
-  type: text,
-  startTime: z.string(),
-  endTime: z.string(),
-  parentUuid: text,
-  assetPath: text
-}).passthrough();
-var versionSchema = z.object({
-  manifestId: z.string(),
-  branch: z.string(),
-  version: z.string(),
-  buildVersion: z.string(),
-  engineVersion: z.string(),
-  riotClientVersion: z.string().describe("Value of the X-Riot-ClientVersion header"),
-  riotClientBuild: z.string(),
-  buildDate: z.string()
-}).passthrough();
-function query(extra = []) {
-  return new Map([
-    ["language", z.string().optional().describe("Language code such as `fr-FR`. Defaults to `en-US`.")],
-    ...extra
-  ]);
-}
-function endpoint(name, description, path, schema, extra = []) {
-  return markEnveloped({
-    name,
-    description,
-    category: "Valorant-API.com",
-    type: "other",
-    suffix: `${BASE}${path}`,
-    query: query(extra),
-    responses: { "200": schema }
-  });
-}
-function collection(title, singular, path, schema, extra = []) {
-  return {
-    list: endpoint(title, `List of ${title.toLowerCase()}`, path, z.array(schema), extra),
-    one: endpoint(singular, `One ${singular.toLowerCase()} by UUID`, `${path}/{uuid}`, schema)
-  };
-}
-var playable = [["isPlayableCharacter", z.boolean().optional().describe("Only return playable agents. Skips the duplicate Sova.")]];
-var agents = collection("Agents", "Agent", "agents", agentSchema, playable);
-var buddies = collection("Buddies", "Buddy", "buddies", asset);
-var buddyLevels = collection("Buddy Levels", "Buddy Level", "buddies/levels", asset);
-var bundles = collection("Bundles", "Bundle", "bundles", asset);
-var ceremonies = collection("Ceremonies", "Ceremony", "ceremonies", asset);
-var competitiveTiers = collection("Competitive Tiers", "Competitive Tier Set", "competitivetiers", z.object({ uuid: z.string(), tiers: z.array(z.object({ tier: z.number(), tierName: text, division: text, color: text }).passthrough()) }).passthrough());
-var contentTiers = collection("Content Tiers", "Content Tier", "contenttiers", asset);
-var contracts = collection("Contracts", "Contract", "contracts", asset);
-var currencies = collection("Currencies", "Currency", "currencies", asset);
-var events = collection("Events", "Event", "events", asset);
-var flex = collection("Flex", "Flex Item", "flex", asset);
-var gamemodes = collection("Gamemodes", "Gamemode", "gamemodes", asset);
-var gamemodeEquippables = collection("Gamemode Equippables", "Gamemode Equippable", "gamemodes/equippables", asset);
-var gear = collection("Gear", "Gear Item", "gear", asset);
-var levelBorders = collection("Level Borders", "Level Border", "levelborders", asset);
-var maps = collection("Maps", "Map", "maps", mapSchema);
-var missions = collection("Missions", "Mission", "missions", z.object({ uuid: z.string(), displayName: text }).passthrough());
-var playerCards = collection("Player Cards", "Player Card", "playercards", asset);
-var playerTitles = collection("Player Titles", "Player Title", "playertitles", z.object({ uuid: z.string(), displayName: text, titleText: text }).passthrough());
-var seasons = collection("Seasons", "Season", "seasons", seasonSchema);
-var competitiveSeasons = collection("Competitive Seasons", "Competitive Season", "seasons/competitive", z.object({ uuid: z.string(), seasonUuid: z.string(), startTime: z.string(), endTime: z.string() }).passthrough());
-var sprays = collection("Sprays", "Spray", "sprays", asset);
-var sprayLevels = collection("Spray Levels", "Spray Level", "sprays/levels", asset);
-var themes = collection("Themes", "Theme", "themes", asset);
-var weapons = collection("Weapons", "Weapon", "weapons", weaponSchema);
-var weaponSkins = collection("Weapon Skins", "Weapon Skin", "weapons/skins", skinSchema);
-var weaponSkinChromas = collection("Weapon Skin Chromas", "Weapon Skin Chroma", "weapons/skinchromas", asset);
-var weaponSkinLevels = collection("Weapon Skin Levels", "Weapon Skin Level", "weapons/skinlevels", asset);
-var catalogEndpoints = {
-  agents: agents.list,
-  agent: agents.one,
-  buddies: buddies.list,
-  buddy: buddies.one,
-  buddyLevels: buddyLevels.list,
-  buddyLevel: buddyLevels.one,
-  bundles: bundles.list,
-  bundle: bundles.one,
-  ceremonies: ceremonies.list,
-  ceremony: ceremonies.one,
-  competitiveTiers: competitiveTiers.list,
-  competitiveTier: competitiveTiers.one,
-  contentTiers: contentTiers.list,
-  contentTier: contentTiers.one,
-  contracts: contracts.list,
-  contract: contracts.one,
-  currencies: currencies.list,
-  currency: currencies.one,
-  events: events.list,
-  event: events.one,
-  flex: flex.list,
-  flexItem: flex.one,
-  gamemodes: gamemodes.list,
-  gamemode: gamemodes.one,
-  gamemodeEquippables: gamemodeEquippables.list,
-  gamemodeEquippable: gamemodeEquippables.one,
-  gear: gear.list,
-  gearItem: gear.one,
-  levelBorders: levelBorders.list,
-  levelBorder: levelBorders.one,
-  maps: maps.list,
-  map: maps.one,
-  missions: missions.list,
-  mission: missions.one,
-  playerCards: playerCards.list,
-  playerCard: playerCards.one,
-  playerTitles: playerTitles.list,
-  playerTitle: playerTitles.one,
-  seasons: seasons.list,
-  season: seasons.one,
-  competitiveSeasons: competitiveSeasons.list,
-  competitiveSeason: competitiveSeasons.one,
-  sprays: sprays.list,
-  spray: sprays.one,
-  sprayLevels: sprayLevels.list,
-  sprayLevel: sprayLevels.one,
-  themes: themes.list,
-  theme: themes.one,
-  version: endpoint("Version", "Current game version and the matching client version", "version", versionSchema),
-  weapons: weapons.list,
-  weapon: weapons.one,
-  weaponSkins: weaponSkins.list,
-  weaponSkin: weaponSkins.one,
-  weaponSkinChromas: weaponSkinChromas.list,
-  weaponSkinChroma: weaponSkinChromas.one,
-  weaponSkinLevels: weaponSkinLevels.list,
-  weaponSkinLevel: weaponSkinLevels.one
+// src/endpoints/riot/account.ts
+var dailyTicketEndpoint = {
+  name: "Daily Ticket",
+  description: "Daily ticket rewards and the matches already counted.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "daily-ticket/v1/{puuid}",
+  riotRequirements: player,
+  responses: { "200": z.object({
+    Version: z.number(),
+    DailyRewards: z.object({
+      RemainingLifetimeSeconds: z.number(),
+      BonusMilestonesPending: z.number(),
+      Milestones: z.array(z.object({
+        Progress: z.number(),
+        BonusApplied: z.boolean()
+      }))
+    }),
+    ProcessedMatches: z.array(z.object({
+      ID: z.string(),
+      CreatedAt: z.string(),
+      DailyExpireTime: z.string(),
+      PreviousDailyExpireTime: z.string(),
+      ProgressBefore: z.number(),
+      ProgressAfter: z.number(),
+      XP: z.number(),
+      SoftCurrency: z.number(),
+      WasPenalized: z.boolean(),
+      BonusesApplied: z.number(),
+      DailyBonusState: z.array(z.boolean())
+    }))
+  }) }
+};
+var dailyTicketQueueConfigEndpoint = {
+  name: "Daily Ticket Queue Config",
+  description: "Which queues count for the daily ticket.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "daily-ticket/v1/queue-config",
+  riotRequirements: player,
+  responses: { "200": z.object({
+    default: z.object({
+      flatProgressPerMatch: z.number(),
+      progressPerRoundWin: z.boolean()
+    }),
+    queueOverrides: z.object({
+      abilitydraftarena: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      competitive: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_abilitydraftarena: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_competitive: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_dodgeball: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_fortcollins: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_hurm: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_newmap: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_skirmish2v2: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_skirmishascension1v1: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_skirmishascension2v2: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_snowball: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_spikerush: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_swiftplay: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_unrated: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_valaram: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      dodgeball: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      fortcollins: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      ggteam: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      hurm: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      newmap: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      premier: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      skirmish2v2: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      skirmishascension1v1: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      skirmishascension2v2: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      snowball: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      spikerush: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      swiftplay: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      unrated: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      valaram: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      })
+    })
+  }) }
+};
+var favoritesEndpoint = {
+  name: "Favorites",
+  description: "Favorited store content of the player.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "favorites/v1/players/{puuid}/favorites",
+  riotRequirements: player,
+  responses: { "200": z.object({
+    Subject: z.string(),
+    FavoritedContent: z.record(z.string(), z.object({
+      FavoriteID: z.string(),
+      ItemID: z.string()
+    }))
+  }) }
+};
+var goldstarsEndpoint = {
+  name: "Goldstars",
+  description: "Goldstar definitions. Field names are obfuscated by the game.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "goldstars/v1/goldstars",
+  riotRequirements: player,
+  responses: { "200": z.array(z.object({
+    id: z.string(),
+    tempT: z.number()
+  })) }
+};
+var goldstarsPlayerEndpoint = {
+  name: "Goldstars Player",
+  description: "Goldstars of a player. Field names are obfuscated by the game.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "goldstars/v1/players/{puuid}",
+  riotRequirements: player,
+  responses: { "200": z.object({
+    puuid: z.string(),
+    version: z.number(),
+    tempS: z.object({
+      "00000000-0000-0000-0000-000000000000": z.object({
+        tempS: z.string(),
+        tempA: z.record(z.string(), z.object({
+          id: z.string(),
+          tempC: z.number(),
+          tempB: z.number()
+        }))
+      }),
+      "8102cd81-43a0-d0d7-bd59-47b8fe9bed1b": z.object({
+        tempS: z.string(),
+        tempA: z.record(z.string(), z.object({
+          id: z.string(),
+          tempC: z.number(),
+          tempB: z.number()
+        }))
+      })
+    }),
+    tempM: z.array(z.object({
+      id: z.string(),
+      tempG: z.number(),
+      tempP: z.record(z.string(), z.object({
+        tempA: z.record(z.string(), z.object({
+          id: z.string(),
+          tempV: z.number(),
+          tempB: z.boolean()
+        }))
+      }))
+    }))
+  }) }
+};
+var bloomlineQueuesEndpoint = {
+  name: "Bloomline Queues",
+  description: "Queues handled by the `bloomline` service. The purpose of the service is not documented.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "bloomline/v0/config/valid-queues",
+  riotRequirements: player,
+  responses: { "200": z.object({
+    ProcessedQueues: z.array(z.string()),
+    PerformanceScoreQueues: z.array(z.string())
+  }) }
+};
+var bloomlinePlayerEndpoint = {
+  name: "Bloomline Player",
+  description: "Per-player data of the `bloomline` service. The purpose of the service is not documented.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "bloomline/v0/players/{puuid}",
+  riotRequirements: player,
+  responses: { "200": z.object({
+    Subject: z.string(),
+    Bonsais: z.array(z.object({
+      BonsaiID: z.string(),
+      HypeID: z.string().optional(),
+      BackgroundID: z.string().optional(),
+      ClipID: z.string().optional(),
+      BorderID: z.string().optional(),
+      Flourish: z.object({
+        ShortLevel: z.number().optional(),
+        PreviousShortLevel: z.number().optional(),
+        LongLevel: z.number().optional(),
+        FlourishID: z.string().optional(),
+        Points: z.number().optional(),
+        PointsVersion: z.number().optional()
+      }),
+      TrackProgressList: z.array(z.object({
+        TrackID: z.string(),
+        TrackLevel: z.number().optional()
+      }))
+    })),
+    LongGroupVersion: z.number()
+  }) }
 };
 
-// src/extra/riot.ts
+// src/endpoints/riot/agentSelect.ts
+import { endpoints as e } from "valorant-api-types";
 import { z as z2 } from "zod";
-var contractsActiveStoryEndpoint = {
-  name: "Active Story",
-  description: "Get the battlepass contracts",
-  queryName: "ContractDefinitions_FetchActiveStory",
-  category: "Contract Endpoints",
-  type: "pd",
-  suffix: "contract-definitions/v2/definitions/story",
-  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
-  responses: { "200": z2.unknown() }
-};
-var currentGameAllChatTokenEndpoint = {
-  name: "All Chat Token",
-  description: "Get a token for all chat",
-  queryName: "CoreGame_FetchAllChatMUCToken",
-  category: "Current Game Endpoints",
-  type: "glz",
-  suffix: "core-game/v1/matches/{in-progress match id}/allchatmuctoken",
-  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
-  responses: { "200": z2.unknown() }
-};
-var currentGameTeamChatTokenEndpoint = {
-  name: "Team Chat Token",
-  description: "Get a token for team chat",
-  queryName: "CoreGame_FetchTeamChatMUCToken",
-  category: "Current Game Endpoints",
-  type: "glz",
-  suffix: "core-game/v1/matches/{in-progress match id}/teamchatmuctoken",
-  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
-  responses: { "200": z2.unknown() }
-};
-var localAntiAddictionShutdownEndpoint = {
-  name: "Anti Addiction Shutdown",
-  description: "GET ANTI_ADDICTION_RNet_FetchShutdownPolicyState",
-  queryName: "ANTI_ADDICTION_RNet_FetchShutdownPolicyState",
-  category: "Local Endpoints",
+var agentSelect = z2.object({
+  ID: z2.string(),
+  Version: z2.number(),
+  Teams: z2.array(z2.object({
+    TeamID: z2.string(),
+    TeamNumber: z2.number(),
+    Players: z2.array(z2.object({
+      Subject: z2.string(),
+      CharacterID: z2.string(),
+      CharacterSelectionState: z2.string(),
+      PregamePlayerState: z2.string(),
+      CompetitiveTier: z2.number(),
+      PlayerIdentity: z2.object({
+        Subject: z2.string(),
+        PlayerCardID: z2.string(),
+        PlayerTitleID: z2.string(),
+        AccountLevel: z2.number(),
+        PreferredLevelBorderID: z2.string(),
+        Incognito: z2.boolean(),
+        HideAccountLevel: z2.boolean()
+      }),
+      SeasonalBadgeInfo: z2.object({
+        SeasonID: z2.string(),
+        NumberOfWins: z2.number(),
+        Rank: z2.number(),
+        LeaderboardRank: z2.number()
+      }),
+      IsCaptain: z2.boolean(),
+      PlatformType: z2.string(),
+      PremierPrestige: z2.object({})
+    }))
+  })),
+  AllyTeam: z2.object({
+    TeamID: z2.string(),
+    TeamNumber: z2.number(),
+    Players: z2.array(z2.object({
+      Subject: z2.string(),
+      CharacterID: z2.string(),
+      CharacterSelectionState: z2.string(),
+      PregamePlayerState: z2.string(),
+      CompetitiveTier: z2.number(),
+      PlayerIdentity: z2.object({
+        Subject: z2.string(),
+        PlayerCardID: z2.string(),
+        PlayerTitleID: z2.string(),
+        AccountLevel: z2.number(),
+        PreferredLevelBorderID: z2.string(),
+        Incognito: z2.boolean(),
+        HideAccountLevel: z2.boolean()
+      }),
+      SeasonalBadgeInfo: z2.object({
+        SeasonID: z2.string(),
+        NumberOfWins: z2.number(),
+        Rank: z2.number(),
+        LeaderboardRank: z2.number()
+      }),
+      IsCaptain: z2.boolean(),
+      PlatformType: z2.string(),
+      PremierPrestige: z2.object({})
+    }))
+  }),
+  EnemyTeamSize: z2.number(),
+  EnemyTeamLockCount: z2.number(),
+  PregameState: z2.string(),
+  LastUpdated: z2.string(),
+  MapID: z2.string(),
+  CastedVotes: z2.object({}),
+  MapSelectStep: z2.number(),
+  Team1: z2.string(),
+  GamePodID: z2.string(),
+  Mode: z2.string(),
+  VoiceSessionID: z2.string(),
+  MUCName: z2.string(),
+  TeamMatchToken: z2.string(),
+  QueueID: z2.string(),
+  ProvisioningFlowID: z2.string(),
+  IsRanked: z2.boolean(),
+  PhaseTimeRemainingNS: z2.number(),
+  StepTimeRemainingNS: z2.number(),
+  altModesFlagADA: z2.boolean(),
+  GameRules: z2.object({
+    AccoladesEnabled: z2.string(),
+    AllowGameModifiers: z2.string(),
+    IsOvertimeWinByTwo: z2.string(),
+    PlayOutAllRounds: z2.string(),
+    ReplayRecordMatch: z2.string(),
+    SkipMatchHistory: z2.string(),
+    TournamentMode: z2.string()
+  })
+});
+var selectCharacterEndpoint = withResponse(e.selectCharacterEndpoint, agentSelect);
+var lockCharacterEndpoint = withResponse(e.lockCharacterEndpoint, agentSelect);
+
+// src/endpoints/riot/chat.ts
+import { endpoints as e2 } from "valorant-api-types";
+import { z as z3 } from "zod";
+var chatSettingsEndpoint = {
+  name: "Settings",
+  description: "Get chat settings",
+  category: "Local Endpoints - Chat",
   type: "local",
-  suffix: "anti-addiction/v1/products/valorant/policies/shutdown/anti-addiction-state",
+  suffix: "chat/v1/settings",
   riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+  responses: { "200": z3.object({
+    bounceDockIconEnabled: z3.boolean(),
+    "chat-status-message": z3.string(),
+    chatFilterDisabled: z3.boolean(),
+    chatGBG: z3.boolean(),
+    chatGroupDiscord: z3.boolean(),
+    chatGroupMobile: z3.boolean(),
+    chatGroupOffline: z3.boolean(),
+    chatWindow: z3.object({
+      detached: z3.boolean(),
+      height: z3.number(),
+      left: z3.number(),
+      top: z3.number(),
+      width: z3.number()
+    }),
+    chatWindowDockedHeight: z3.number(),
+    "closed-conversations": z3.object({
+      "ff822fdf-71a3-54ac-814e-7ac752ba428d@eu1.pvp.net": z3.number()
+    }),
+    friendRequestToastsDisabled: z3.boolean(),
+    "hidden-conversations": z3.object({}),
+    linkClickWarningEnabled: z3.boolean(),
+    messageNotificationsEnabled: z3.boolean(),
+    moreUnreadsEnabled: z3.boolean(),
+    "muted-conversations": z3.object({}),
+    recentlyPlayedFirstOpen: z3.boolean(),
+    recentlyPlayedOpen: z3.boolean(),
+    "roster-group-collapsed": z3.object({}),
+    showWhenTypingEnabled: z3.boolean(),
+    sortBy: z3.string(),
+    usePlayerPreferences: z3.boolean()
+  }) }
 };
-var localAntiAddictionWarningEndpoint = {
-  name: "Anti Addiction Warning",
-  description: "GET ANTI_ADDICTION_RNet_FetchWarningMessagePolicyState",
-  queryName: "ANTI_ADDICTION_RNet_FetchWarningMessagePolicyState",
-  category: "Local Endpoints",
+var chatTournamentInfoEndpoint = {
+  name: "Tournament Info",
+  description: "Get in-tournament conversations",
+  category: "Local Endpoints - Chat",
   type: "local",
-  suffix: "anti-addiction/v1/products/valorant/policies/warningMessage/anti-addiction-state",
+  suffix: "chat/v6/conversations/ares-tournaments",
   riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+  responses: { "200": z3.object({}) }
 };
-var localClientConfigEndpoint = {
-  name: "Client Config",
-  description: "GET CLIENTCONFIG_RNET_GET_ValorantClientConfig",
-  queryName: "CLIENTCONFIG_RNET_GET_ValorantClientConfig",
-  category: "Local Endpoints",
-  type: "local",
-  suffix: "client-config/v2/namespace/valorant.client/player",
-  riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+var chatParticipantsEndpoint = withResponse(e2.chatParticipantsEndpoint, z3.object({
+  participants: z3.array(z3.object({
+    activePlatform: z3.string().nullable(),
+    cid: z3.string(),
+    game_name: z3.string(),
+    game_tag: z3.string(),
+    isInteractionAllowed: z3.boolean(),
+    muted: z3.boolean(),
+    name: z3.string(),
+    pid: z3.string(),
+    puuid: z3.string(),
+    region: z3.string()
+  }))
+}));
+
+// src/endpoints/riot/contracts.ts
+import { endpoints as e3 } from "valorant-api-types";
+import { z as z4 } from "zod";
+var activeRecruitmentEventEndpoint = {
+  name: "Active Recruitment Event",
+  description: "The current agent recruitment event.",
+  category: "Contract Endpoints",
+  type: "pd",
+  suffix: "contracts/v1/agents/activeRecruitmentEvent",
+  riotRequirements: player,
+  responses: { "200": z4.object({
+    AgentID: z4.string(),
+    CounterID: z4.string(),
+    MilestoneThreshold: z4.number(),
+    StartDate: z4.string(),
+    EndDate: z4.string(),
+    IsActive: z4.boolean(),
+    includedPlatforms: z4.object({
+      console: z4.object({
+        developmentOnly: z4.boolean()
+      }),
+      mobile: z4.object({
+        developmentOnly: z4.boolean()
+      }),
+      pc: z4.object({
+        developmentOnly: z4.boolean()
+      })
+    })
+  }) }
 };
-var localEulaEndpoint = {
-  name: "Eula",
-  description: "Get the EULA",
-  queryName: "LEGAL_INFO_RNet_EULA",
-  category: "Local Endpoints",
-  type: "local",
-  suffix: "eula/v1/agreement/content",
-  riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+var contractsEndpoint = withResponse(e3.contractsEndpoint, z4.object({
+  Version: z4.number(),
+  Subject: z4.string(),
+  Contracts: z4.array(z4.object({
+    ContractDefinitionID: z4.string(),
+    ContractProgression: z4.object({
+      Version: z4.number(),
+      TotalProgressionEarned: z4.number()
+    }),
+    ProgressionLevelReached: z4.number(),
+    ProgressionTowardsNextLevel: z4.number()
+  })),
+  ActiveRecruitmentEventProgress: z4.object({
+    AgentID: z4.string(),
+    Version: z4.number(),
+    CounterID: z4.string(),
+    ProgressionEarned: z4.number()
+  }),
+  Missions: z4.array(z4.object({
+    ID: z4.string(),
+    Objectives: z4.record(z4.string(), z4.number()),
+    Complete: z4.boolean(),
+    ExpirationTime: z4.string()
+  })),
+  MissionMetadata: z4.object({
+    WeeklyCheckpoint: z4.string(),
+    WeeklyRefillTime: z4.string()
+  }),
+  BTEMilestone: z4.number()
+}));
+
+// src/endpoints/riot/currentGame.ts
+import { endpoints as e4 } from "valorant-api-types";
+import { z as z5 } from "zod";
+var currentGameLoadoutsEndpoint = withResponse(e4.currentGameLoadoutsEndpoint, z5.object({
+  Loadouts: z5.array(z5.object({
+    CharacterID: z5.string(),
+    Loadout: z5.object({
+      Subject: z5.string(),
+      Expressions: z5.object({
+        AESSelections: z5.array(z5.object({
+          AssetID: z5.string(),
+          TypeID: z5.string()
+        }))
+      }),
+      DynamicOptions: z5.object({}),
+      Items: z5.record(z5.string(), z5.object({
+        ID: z5.string(),
+        TypeID: z5.string(),
+        Sockets: z5.record(z5.string(), z5.object({
+          ID: z5.string(),
+          Item: z5.object({
+            ID: z5.string(),
+            TypeID: z5.string()
+          })
+        }))
+      }))
+    }),
+    Subject: z5.string()
+  }))
+}));
+
+// src/endpoints/riot/esports.ts
+import { z as z6 } from "zod";
+var esportsLiveEventTimesEndpoint = {
+  name: "Esports Live Event Times",
+  description: "Live and upcoming esports matches, pick blocks and tournaments.",
+  category: "Esports Endpoints",
+  type: "pd",
+  suffix: "esports-service/v2/liveEventTimes",
+  riotRequirements: player,
+  responses: { "200": z6.object({
+    Tournaments: z6.array(z6.object({
+      ID: z6.string(),
+      StartTimeUTC: z6.string(),
+      EndTimeUTC: z6.string()
+    }))
+  }) }
 };
-var localPrivacyPolicyEndpoint = {
-  name: "Privacy Policy",
-  description: "Get privacy policy",
-  queryName: "LEGAL_INFO_RNet_Privacy",
-  category: "Local Endpoints",
-  type: "local",
-  suffix: "eula/v1/privacy-policy/content",
-  riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+var esportsUpcomingMatchesEndpoint = {
+  name: "Esports Upcoming Matches",
+  description: "Upcoming esports matches.",
+  category: "Esports Endpoints",
+  type: "pd",
+  suffix: "esports-service/v2/upcomingMatches",
+  riotRequirements: player,
+  responses: { "200": z6.object({}) }
 };
-var localAvailableLocalesEndpoint = {
-  name: "Available Locales",
-  description: "Get available locales",
-  queryName: "LOCALE_RNet_FetchAvailableLocales",
-  category: "Local Endpoints",
-  type: "local",
-  suffix: "rnet-product-registry/v4/available-product-locales/products/valorant/patchlines/live",
-  riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+var esportsPickemLeaguesEndpoint = {
+  name: "Esports Pickem Leagues",
+  description: "Pick'em leagues.",
+  category: "Esports Endpoints",
+  type: "pd",
+  suffix: "esports-service/v1/pickem/leagues",
+  riotRequirements: player,
+  responses: { "200": z6.object({
+    PickemLeagues: z6.array(z6.object({
+      LeagueID: z6.string(),
+      EldsLeagueID: z6.string(),
+      Tournament: z6.object({
+        ID: z6.string(),
+        EldsTournamentID: z6.string(),
+        LeagueID: z6.string(),
+        PickBlocks: z6.array(z6.object({
+          ID: z6.string(),
+          EldsTournamentID: z6.string(),
+          Slug: z6.object({
+            Slug: z6.string()
+          }),
+          PickOpenTime: z6.string(),
+          PickCloseTime: z6.string(),
+          State: z6.string(),
+          OpenLevel: z6.string(),
+          BlockType: z6.string(),
+          PickBlockElements: z6.array(z6.object({
+            ID: z6.string(),
+            PickBlockID: z6.string(),
+            Section: z6.object({
+              ID: z6.string(),
+              EldsSectionID: z6.string(),
+              CorrectPick: z6.object({
+                Entries: z6.array(z6.object({
+                  Index: z6.number(),
+                  Correctness: z6.string(),
+                  ParticipantID: z6.string(),
+                  Points: z6.number(),
+                  Rank: z6.number()
+                })).nullable()
+              })
+            }),
+            Match: z6.object({
+              ID: z6.string(),
+              EldsMatchID: z6.string(),
+              BaselinePoints: z6.number(),
+              CorrectPick: z6.string(),
+              ResultState: z6.string()
+            }),
+            PickOpenTime: z6.string(),
+            PickCloseTime: z6.string(),
+            State: z6.string(),
+            DisplayOrder: z6.number()
+          })),
+          CompletionStatus: z6.string()
+        })),
+        Participants: z6.array(z6.object({
+          ID: z6.string(),
+          EldsTeamID: z6.string()
+        }))
+      }),
+      Published: z6.boolean()
+    }))
+  }) }
 };
+
+// src/endpoints/riot/local.ts
+import { z as z7 } from "zod";
 var localLocaleEndpoint = {
   name: "Locale",
   description: "Get the current locale",
-  queryName: "LOCALE_RNet_FetchLocale",
   category: "Local Endpoints",
   type: "local",
   suffix: "riotclient/product-locales/products/valorant/patchlines/live",
   riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+  responses: { "200": z7.string() }
 };
-var localReporterFeedbackEndpoint = {
-  name: "Reporter Feedback",
-  description: "GET REPORTER_FEEDBACK_RNet_GetReporterFeedback",
-  queryName: "REPORTER_FEEDBACK_RNet_GetReporterFeedback",
-  category: "Local Endpoints",
-  type: "local",
-  suffix: "player-reporting/v1/reporter-feedback",
-  riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
-};
-var localCommandLineArgsEndpoint = {
-  name: "Command Line Args",
-  description: "Gets the command-line args provided to the Riot client",
-  queryName: "Riot Client Command-Line Args",
+var localAvailableLocalesEndpoint = {
+  name: "Available Locales",
+  description: "Get available locales",
   category: "Local Endpoints",
   type: "local",
-  suffix: "riotclient/command-line-args",
+  suffix: "rnet-product-registry/v4/available-product-locales/products/valorant/patchlines/live",
   riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+  responses: { "200": z7.array(z7.string()) }
 };
 var localRiotStatusEndpoint = {
   name: "Riot Status",
   description: "Get game status information such as maintenances and incidents Response is an escaped JSON string.",
-  queryName: "RiotStatus_RNet_FetchStatus",
   category: "Local Endpoints",
   type: "local",
   suffix: "riot-status/v1/products/valorant/patchlines/live/deployments/{region}",
   riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
-};
-var localRiotWarningEndpoint = {
-  name: "Riot Warning",
-  description: "GET RIOT_WARNING_RNet_GetRiotWarning",
-  queryName: "RIOT_WARNING_RNet_GetRiotWarning",
-  category: "Local Endpoints",
-  type: "local",
-  suffix: "ga-warning/v1/warnings",
-  riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
-};
-var localClientAuthorizationsEndpoint = {
-  name: "Client Authorizations",
-  description: "Gets tokens in use by the client",
-  queryName: "RSO_RNet_FetchClientAuthorizations",
-  category: "Local Endpoints",
-  type: "local",
-  suffix: "rso-auth/v2/authorizations/valorant-client",
-  riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+  responses: { "200": z7.string() }
 };
 var localAccessTokenEndpoint = {
   name: "Access Token",
   description: "Gets a Riot access token",
-  queryName: "RSO_RNet_GetAccessToken",
   category: "Local Endpoints",
   type: "local",
   suffix: "rso-auth/v1/authorization/access-token",
   riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
-};
-var localUserInfoTokenEndpoint = {
-  name: "User Info Token",
-  description: "GET RSO_RNet_GetUserInfoToken",
-  queryName: "RSO_RNet_GetUserInfoToken",
-  category: "Local Endpoints",
-  type: "local",
-  suffix: "rso-auth/v1/userinfo/valorant-client",
-  riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
-};
-var chatSettingsEndpoint = {
-  name: "Settings",
-  description: "Get chat settings",
-  queryName: "TEXT_CHAT_RNet_FetchSettings",
-  category: "Local Endpoints - Chat",
-  type: "local",
-  suffix: "chat/v1/settings",
-  riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
-};
-var chatTournamentInfoEndpoint = {
-  name: "Tournament Info",
-  description: "Get in-tournament conversations",
-  queryName: "TEXT_CHAT_RNet_GetMUCInfos - tournaments",
-  category: "Local Endpoints - Chat",
-  type: "local",
-  suffix: "chat/v6/conversations/ares-tournaments",
-  riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+  responses: { "200": z7.object({
+    clientId: z7.string(),
+    expiry: z7.number(),
+    scopes: z7.array(z7.string()),
+    token: z7.string()
+  }) }
 };
 var localPluginStatusEndpoint = {
   name: "Plugin Status",
   description: "Gets plugin status",
-  queryName: "URNetClient_CheckPluginStatus",
   category: "Local Endpoints",
   type: "local",
   suffix: "plugin-manager/v1/status",
   riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+  responses: { "200": z7.object({
+    state: z7.string()
+  }) }
 };
 var localRmsSessionEndpoint = {
   name: "Rms Session",
   description: "Gets the token for Riot Messaging Service",
-  queryName: "URNetClient_CheckRMSSession",
   category: "Local Endpoints",
   type: "local",
   suffix: "riot-messaging-service/v1/session",
   riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+  responses: { "200": z7.object({
+    state: z7.string(),
+    token: z7.string(),
+    tokenType: z7.string()
+  }) }
 };
 var localProcessInfoEndpoint = {
   name: "Process Info",
   description: "Gets the Valorant process ID",
-  queryName: "URNetClient_GetProcessInfo",
   category: "Local Endpoints",
   type: "local",
   suffix: "process-control/v1/process",
   riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+  responses: { "200": z7.object({
+    pid: z7.number(),
+    status: z7.string()
+  }) }
 };
 var localLogPathEndpoint = {
   name: "Log Path",
   description: "Gets the Valorant log path",
-  queryName: "Valorant Log Path",
   category: "Local Endpoints",
   type: "local",
   suffix: "product-session/v1/logs/path/VALORANT",
   riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+  responses: { "200": z7.string() }
+};
+var localEulaEndpoint = {
+  name: "Eula",
+  description: "Get the EULA",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "eula/v1/agreement/content",
+  riotRequirements: { localAuth: true },
+  responses: { "200": z7.string() }
+};
+var localPrivacyPolicyEndpoint = {
+  name: "Privacy Policy",
+  description: "Get privacy policy",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "eula/v1/privacy-policy/content",
+  riotRequirements: { localAuth: true },
+  responses: { "200": z7.string() }
+};
+
+// src/endpoints/riot/party.ts
+import { endpoints as e5 } from "valorant-api-types";
+import { z as z8 } from "zod";
+var customGameTeam = z8.array(z8.object({ Subject: z8.string().describe("PUUID") }));
+var customGameParty = z8.object({
+  ID: z8.string(),
+  MUCName: z8.string(),
+  VoiceRoomID: z8.string(),
+  Version: z8.number(),
+  ClientVersion: z8.string(),
+  Members: z8.array(z8.object({
+    Subject: z8.string(),
+    CompetitiveTier: z8.number(),
+    PlayerIdentity: z8.object({
+      Subject: z8.string(),
+      PlayerCardID: z8.string(),
+      PlayerTitleID: z8.string(),
+      AccountLevel: z8.number(),
+      PreferredLevelBorderID: z8.string(),
+      Incognito: z8.boolean(),
+      HideAccountLevel: z8.boolean()
+    }),
+    IsOwner: z8.boolean(),
+    QueueEligibleRemainingAccountLevels: z8.number(),
+    Pings: z8.array(z8.object({
+      Ping: z8.number(),
+      GamePodID: z8.string()
+    })),
+    IsReady: z8.boolean(),
+    IsModerator: z8.boolean(),
+    UseBroadcastHUD: z8.boolean(),
+    PlatformType: z8.string(),
+    PremierPrestige: z8.object({}),
+    JoinedAt: z8.string()
+  })),
+  State: z8.string(),
+  PreviousState: z8.string(),
+  StateTransitionReason: z8.string(),
+  Accessibility: z8.string(),
+  CustomGameData: z8.object({
+    Settings: z8.object({
+      Map: z8.string(),
+      Mode: z8.string(),
+      UseBots: z8.boolean(),
+      GamePod: z8.string(),
+      GameRules: z8.record(z8.string(), z8.string()).nullable(),
+      EsportsCustomLobbyName: z8.string()
+    }),
+    Membership: z8.object({
+      teamOne: customGameTeam,
+      teamTwo: customGameTeam,
+      teamSpectate: customGameTeam,
+      teamOneCoaches: customGameTeam,
+      teamTwoCoaches: customGameTeam
+    }),
+    MaxPartySize: z8.number(),
+    AutobalanceEnabled: z8.boolean(),
+    AutobalanceMinPlayers: z8.number(),
+    HasRecoveryData: z8.boolean()
+  }),
+  MatchmakingData: z8.object({
+    QueueID: z8.string(),
+    PreferredGamePods: z8.array(z8.string()),
+    SkillDisparityRRPenalty: z8.number(),
+    MaxPartySize: z8.number()
+  }),
+  QueueEntryTime: z8.string(),
+  EstimatedQueueTimeSeconds: z8.number(),
+  ErrorNotification: z8.object({
+    ErrorType: z8.string()
+  }).optional(),
+  RestrictedSeconds: z8.number(),
+  EligibleQueues: z8.array(z8.string()),
+  CheatData: z8.object({
+    GamePodOverride: z8.string(),
+    ForcePostGameProcessing: z8.boolean()
+  }),
+  InviteCode: z8.string()
+});
+var setCustomGameTeamEndpoint = {
+  name: "Set Custom Game Team",
+  description: "Moves a player to a team of the custom game. Only the party owner can move other players. `team` is `TeamOne` or `TeamTwo`. Resolves to the updated party, whose `CustomGameData.Membership` lists the players of each team.",
+  queryName: "Party_ChangeTeamInCustomGame",
+  category: "Party Endpoints",
+  type: "glz",
+  method: "POST",
+  suffix: "parties/v1/parties/{party id}/customgamemembership/{team}",
+  headers: /* @__PURE__ */ new Map([["Content-Type", "application/json"]]),
+  body: z8.object({ playerToPutOnTeam: z8.string().describe("PUUID of the player to move") }),
+  riotRequirements: player,
+  responses: { "200": customGameParty }
+};
+var customGamePartyEndpoint = {
+  name: "Custom Game Party",
+  description: "The party of a custom game lobby: members, teams (`CustomGameData.Membership`), map, mode and rules. Typed for custom game lobbies. `party.get` is the general version.",
+  queryName: "Party_FetchParty",
+  category: "Party Endpoints",
+  type: "glz",
+  suffix: "parties/v1/parties/{party id}",
+  riotRequirements: player,
+  responses: { "200": customGameParty }
+};
+var partyResponse = customGameParty.extend({ CustomGameData: customGameParty.shape.CustomGameData.optional() });
+var partyGenerateCodeEndpoint = withResponse(e5.partyGenerateCodeEndpoint, customGameParty);
+var partyDisableCodeEndpoint = withResponse(e5.partyDisableCodeEndpoint, customGameParty);
+var setPartyAccessibilityEndpoint = withResponse(e5.setPartyAccessibilityEndpoint, customGameParty);
+var startCustomGameEndpoint = withResponse(e5.startCustomGameEndpoint, customGameParty);
+var setCustomGameSettingsEndpoint = withResponse(e5.setCustomGameSettingsEndpoint, customGameParty);
+var partyEndpoint = withResponse(e5.partyEndpoint, partyResponse);
+var changeQueueEndpoint = withResponse(e5.changeQueueEndpoint, partyResponse);
+var enterMatchmakingQueueEndpoint = withResponse(e5.enterMatchmakingQueueEndpoint, partyResponse);
+var leaveMatchmakingQueueEndpoint = withResponse(e5.leaveMatchmakingQueueEndpoint, partyResponse);
+var partyDeclineEndpoint = withResponse(e5.partyDeclineEndpoint, partyResponse);
+var partyInviteEndpoint = withResponse(e5.partyInviteEndpoint, partyResponse);
+var partySetMemberReadyEndpoint = withResponse(e5.partySetMemberReadyEndpoint, partyResponse);
+var refreshCompetitiveTierEndpoint = withResponse(e5.refreshCompetitiveTierEndpoint, partyResponse);
+var refreshPlayerIdentityEndpoint = withResponse(e5.refreshPlayerIdentityEndpoint, partyResponse);
+var refreshPingsEndpoint = withResponse(e5.refreshPingsEndpoint, partyResponse);
+
+// src/endpoints/riot/pregame.ts
+import { endpoints as e6 } from "valorant-api-types";
+import { z as z9 } from "zod";
+var pregameMatchEndpoint = withResponse(e6.pregameMatchEndpoint, z9.object({
+  ID: z9.string(),
+  Version: z9.number(),
+  Teams: z9.array(z9.object({
+    TeamID: z9.string(),
+    TeamNumber: z9.number(),
+    Players: z9.array(z9.object({
+      Subject: z9.string(),
+      CharacterID: z9.string(),
+      CharacterSelectionState: z9.string(),
+      PregamePlayerState: z9.string(),
+      CompetitiveTier: z9.number(),
+      PlayerIdentity: z9.object({
+        Subject: z9.string(),
+        PlayerCardID: z9.string(),
+        PlayerTitleID: z9.string(),
+        AccountLevel: z9.number(),
+        PreferredLevelBorderID: z9.string(),
+        Incognito: z9.boolean(),
+        HideAccountLevel: z9.boolean()
+      }),
+      SeasonalBadgeInfo: z9.object({
+        SeasonID: z9.string(),
+        NumberOfWins: z9.number(),
+        Rank: z9.number(),
+        LeaderboardRank: z9.number()
+      }),
+      IsCaptain: z9.boolean(),
+      PlatformType: z9.string(),
+      PremierPrestige: z9.object({})
+    }))
+  })),
+  AllyTeam: z9.object({
+    TeamID: z9.string(),
+    TeamNumber: z9.number(),
+    Players: z9.array(z9.object({
+      Subject: z9.string(),
+      CharacterID: z9.string(),
+      CharacterSelectionState: z9.string(),
+      PregamePlayerState: z9.string(),
+      CompetitiveTier: z9.number(),
+      PlayerIdentity: z9.object({
+        Subject: z9.string(),
+        PlayerCardID: z9.string(),
+        PlayerTitleID: z9.string(),
+        AccountLevel: z9.number(),
+        PreferredLevelBorderID: z9.string(),
+        Incognito: z9.boolean(),
+        HideAccountLevel: z9.boolean()
+      }),
+      SeasonalBadgeInfo: z9.object({
+        SeasonID: z9.string(),
+        NumberOfWins: z9.number(),
+        Rank: z9.number(),
+        LeaderboardRank: z9.number()
+      }),
+      IsCaptain: z9.boolean(),
+      PlatformType: z9.string(),
+      PremierPrestige: z9.object({})
+    }))
+  }),
+  EnemyTeamSize: z9.number(),
+  EnemyTeamLockCount: z9.number(),
+  PregameState: z9.string(),
+  LastUpdated: z9.string(),
+  MapID: z9.string(),
+  CastedVotes: z9.object({}),
+  MapSelectStep: z9.number(),
+  Team1: z9.string(),
+  GamePodID: z9.string(),
+  Mode: z9.string(),
+  VoiceSessionID: z9.string(),
+  MUCName: z9.string(),
+  TeamMatchToken: z9.string(),
+  QueueID: z9.string(),
+  ProvisioningFlowID: z9.string(),
+  IsRanked: z9.boolean(),
+  PhaseTimeRemainingNS: z9.number(),
+  StepTimeRemainingNS: z9.number(),
+  altModesFlagADA: z9.boolean(),
+  /** Rules of the match by name. Only the rules the lobby set are present. */
+  GameRules: z9.record(z9.string(), z9.string())
+}));
+var pregameLoadoutsEndpoint = withResponse(e6.pregameLoadoutsEndpoint, z9.object({
+  Loadouts: z9.array(z9.object({
+    Subject: z9.string(),
+    Expressions: z9.object({
+      AESSelections: z9.array(z9.object({
+        AssetID: z9.string(),
+        TypeID: z9.string()
+      }))
+    }),
+    DynamicOptions: z9.object({}),
+    Items: z9.record(z9.string(), z9.object({
+      ID: z9.string(),
+      TypeID: z9.string(),
+      Sockets: z9.record(z9.string(), z9.object({
+        ID: z9.string(),
+        Item: z9.object({
+          ID: z9.string(),
+          TypeID: z9.string()
+        })
+      }))
+    }))
+  })),
+  LoadoutsValid: z9.boolean()
+}));
+
+// src/endpoints/riot/premier.ts
+import { z as z10 } from "zod";
+var premierSeasonsEndpoint = {
+  name: "Premier Seasons",
+  description: "All Premier seasons of the shard. The affinity in the path is the region of the context.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/affinities/{region}/premier-seasons",
+  riotRequirements: player,
+  responses: { "200": z10.object({
+    PremierSeasons: z10.array(z10.object({
+      ID: z10.string(),
+      Name: z10.string(),
+      PreviousPremierSeasonID: z10.string(),
+      NextPremierSeasonID: z10.string(),
+      IsActive: z10.boolean(),
+      StartTime: z10.string(),
+      EndTime: z10.string(),
+      Events: z10.array(z10.object({
+        ID: z10.string(),
+        Type: z10.string(),
+        StartDateTime: z10.string(),
+        EndDateTime: z10.string(),
+        MapSelectionStrategy: z10.string(),
+        MapPoolMapIDs: z10.array(z10.string()),
+        PointsRequiredToParticipate: z10.number()
+      })),
+      ScheduledEvents: z10.array(z10.object({
+        EventID: z10.string(),
+        EventType: z10.string(),
+        Conference: z10.string(),
+        DivisionGroup: z10.string(),
+        EventPresetName: z10.string(),
+        StartDateTime: z10.string(),
+        EndDateTime: z10.string(),
+        TournamentRoundTimes: z10.array(z10.object({
+          StartDateTime: z10.string(),
+          EndDateTime: z10.string()
+        }))
+      })),
+      Conferences: z10.array(z10.object({
+        id: z10.string(),
+        key: z10.string(),
+        isSuper: z10.boolean(),
+        gamePods: z10.array(z10.string()),
+        timezone: z10.string(),
+        superConference: z10.string().optional(),
+        leaderboardPlayoffQualificationDateTime: z10.string(),
+        leaderboardPromotionFinalizationDateTime: z10.string()
+      })),
+      Divisions: z10.array(z10.object({
+        Division: z10.number(),
+        DivisionName: z10.string(),
+        DivisionGroup: z10.string(),
+        EventPresetName: z10.string()
+      })),
+      DivisionThresholds: z10.array(z10.object({
+        playoffThresholdType: z10.string(),
+        playoffThresholdValue: z10.number(),
+        promotionThresholdType: z10.string(),
+        promotionThresholdValue: z10.number(),
+        shouldPromoteToSuperConference: z10.boolean(),
+        skipReseedCriteria: z10.string(),
+        conference: z10.string().optional(),
+        division: z10.number().optional(),
+        promotionConference: z10.string().optional(),
+        skipReseedCriteriaValue: z10.number().optional()
+      })),
+      EventPresets: z10.object({
+        PRO: z10.object({
+          EventPresetsByEventType: z10.object({
+            LEAGUE: z10.object({
+              EventPresetName: z10.string(),
+              eventType: z10.string(),
+              bestOfN: z10.number(),
+              matchmakingStrategy: z10.string(),
+              queueID: z10.string(),
+              pointsConfig: z10.object({
+                PointsForWin: z10.number(),
+                PointsForLoss: z10.number()
+              })
+            }),
+            SCRIM: z10.object({
+              EventPresetName: z10.string(),
+              eventType: z10.string(),
+              bestOfN: z10.number(),
+              matchmakingStrategy: z10.string(),
+              queueID: z10.string(),
+              pointsConfig: z10.object({
+                PointsForWin: z10.number(),
+                PointsForLoss: z10.number()
+              })
+            }),
+            TOURNAMENT: z10.object({
+              EventPresetName: z10.string(),
+              eventType: z10.string(),
+              bestOfN: z10.number(),
+              matchmakingStrategy: z10.string(),
+              queueID: z10.string(),
+              pointsConfig: z10.object({
+                PointsForWin: z10.number(),
+                PointsForLoss: z10.number()
+              })
+            })
+          })
+        }),
+        REGULAR: z10.object({
+          EventPresetsByEventType: z10.object({
+            LEAGUE: z10.object({
+              EventPresetName: z10.string(),
+              eventType: z10.string(),
+              bestOfN: z10.number(),
+              matchmakingStrategy: z10.string(),
+              queueID: z10.string(),
+              pointsConfig: z10.object({
+                PointsForWin: z10.number(),
+                PointsForLoss: z10.number()
+              })
+            }),
+            SCRIM: z10.object({
+              EventPresetName: z10.string(),
+              eventType: z10.string(),
+              bestOfN: z10.number(),
+              matchmakingStrategy: z10.string(),
+              queueID: z10.string(),
+              pointsConfig: z10.object({
+                PointsForWin: z10.number(),
+                PointsForLoss: z10.number()
+              })
+            }),
+            TOURNAMENT: z10.object({
+              EventPresetName: z10.string(),
+              eventType: z10.string(),
+              bestOfN: z10.number(),
+              matchmakingStrategy: z10.string(),
+              queueID: z10.string(),
+              pointsConfig: z10.object({
+                PointsForWin: z10.number(),
+                PointsForLoss: z10.number()
+              })
+            })
+          })
+        })
+      }),
+      FlawlessPointRequirement: z10.number(),
+      ChampionshipPointRequirement: z10.number(),
+      ChampionshipEventID: z10.string(),
+      EnrollmentPhaseStartDateTime: z10.string(),
+      EnrollmentPhaseEndDateTime: z10.string(),
+      LeaderboardPlayoffQualificationDateTime: z10.string(),
+      LeaderboardPromotionFinalizationDateTime: z10.string(),
+      LeaderboardFinalizationDateTime: z10.string(),
+      ContenderEligibilityExpiryDateTime: z10.string(),
+      StageLockTime: z10.string(),
+      ParticipationRewardsActIDs: z10.array(z10.string()),
+      ParticipationRewards: z10.object({
+        EntitlementRewards: z10.array(z10.object({
+          ItemTypeID: z10.string(),
+          ItemID: z10.string(),
+          Amount: z10.number()
+        }))
+      }),
+      TournamentWinnerRewards: z10.object({}),
+      DivisionWinnerRewards: z10.object({
+        ADVANCED: z10.object({
+          EntitlementRewards: z10.array(z10.object({
+            ItemTypeID: z10.string(),
+            ItemID: z10.string(),
+            Amount: z10.number()
+          }))
+        }).optional(),
+        CONTENDER: z10.object({
+          EntitlementRewards: z10.array(z10.object({
+            ItemTypeID: z10.string(),
+            ItemID: z10.string(),
+            Amount: z10.number()
+          }))
+        }).optional(),
+        ELITE: z10.object({
+          EntitlementRewards: z10.array(z10.object({
+            ItemTypeID: z10.string(),
+            ItemID: z10.string(),
+            Amount: z10.number()
+          }))
+        }).optional(),
+        INTERMEDIATE: z10.object({
+          EntitlementRewards: z10.array(z10.object({
+            ItemTypeID: z10.string(),
+            ItemID: z10.string(),
+            Amount: z10.number()
+          }))
+        }).optional(),
+        OPEN: z10.object({
+          EntitlementRewards: z10.array(z10.object({
+            ItemTypeID: z10.string(),
+            ItemID: z10.string(),
+            Amount: z10.number()
+          }))
+        }).optional(),
+        INVITE: z10.object({
+          EntitlementRewards: z10.array(z10.object({
+            ItemTypeID: z10.string(),
+            ItemID: z10.string(),
+            Amount: z10.number()
+          }))
+        }).optional()
+      }),
+      RosterRecentActivityNumSeasons: z10.number()
+    }))
+  }) }
+};
+var premierActiveSeasonEndpoint = {
+  name: "Premier Active Season",
+  description: "The Premier season that is running now.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/affinities/{region}/premier-seasons/active",
+  riotRequirements: player,
+  responses: { "200": z10.object({
+    ID: z10.string(),
+    Name: z10.string(),
+    PreviousPremierSeasonID: z10.string(),
+    NextPremierSeasonID: z10.string(),
+    IsActive: z10.boolean(),
+    StartTime: z10.string(),
+    EndTime: z10.string(),
+    Events: z10.array(z10.object({
+      ID: z10.string(),
+      Type: z10.string(),
+      StartDateTime: z10.string(),
+      EndDateTime: z10.string(),
+      MapSelectionStrategy: z10.string(),
+      MapPoolMapIDs: z10.array(z10.string()),
+      PointsRequiredToParticipate: z10.number()
+    })),
+    ScheduledEvents: z10.array(z10.object({
+      EventID: z10.string(),
+      EventType: z10.string(),
+      Conference: z10.string(),
+      DivisionGroup: z10.string(),
+      EventPresetName: z10.string(),
+      StartDateTime: z10.string(),
+      EndDateTime: z10.string(),
+      TournamentRoundTimes: z10.array(z10.object({
+        StartDateTime: z10.string(),
+        EndDateTime: z10.string()
+      }))
+    })),
+    Conferences: z10.array(z10.object({
+      id: z10.string(),
+      key: z10.string(),
+      isSuper: z10.boolean(),
+      gamePods: z10.array(z10.string()),
+      timezone: z10.string(),
+      superConference: z10.string().optional(),
+      leaderboardPlayoffQualificationDateTime: z10.string(),
+      leaderboardPromotionFinalizationDateTime: z10.string()
+    })),
+    Divisions: z10.array(z10.object({
+      Division: z10.number(),
+      DivisionName: z10.string(),
+      DivisionGroup: z10.string(),
+      EventPresetName: z10.string()
+    })),
+    DivisionThresholds: z10.array(z10.object({
+      playoffThresholdType: z10.string(),
+      playoffThresholdValue: z10.number(),
+      promotionThresholdType: z10.string(),
+      promotionThresholdValue: z10.number(),
+      shouldPromoteToSuperConference: z10.boolean(),
+      skipReseedCriteria: z10.string(),
+      conference: z10.string().optional(),
+      division: z10.number().optional(),
+      promotionConference: z10.string().optional(),
+      skipReseedCriteriaValue: z10.number().optional()
+    })),
+    EventPresets: z10.object({
+      PRO: z10.object({
+        EventPresetsByEventType: z10.object({
+          LEAGUE: z10.object({
+            EventPresetName: z10.string(),
+            eventType: z10.string(),
+            bestOfN: z10.number(),
+            matchmakingStrategy: z10.string(),
+            queueID: z10.string(),
+            pointsConfig: z10.object({
+              PointsForWin: z10.number(),
+              PointsForLoss: z10.number()
+            })
+          }),
+          SCRIM: z10.object({
+            EventPresetName: z10.string(),
+            eventType: z10.string(),
+            bestOfN: z10.number(),
+            matchmakingStrategy: z10.string(),
+            queueID: z10.string(),
+            pointsConfig: z10.object({
+              PointsForWin: z10.number(),
+              PointsForLoss: z10.number()
+            })
+          }),
+          TOURNAMENT: z10.object({
+            EventPresetName: z10.string(),
+            eventType: z10.string(),
+            bestOfN: z10.number(),
+            matchmakingStrategy: z10.string(),
+            queueID: z10.string(),
+            pointsConfig: z10.object({
+              PointsForWin: z10.number(),
+              PointsForLoss: z10.number()
+            })
+          })
+        })
+      }),
+      REGULAR: z10.object({
+        EventPresetsByEventType: z10.object({
+          LEAGUE: z10.object({
+            EventPresetName: z10.string(),
+            eventType: z10.string(),
+            bestOfN: z10.number(),
+            matchmakingStrategy: z10.string(),
+            queueID: z10.string(),
+            pointsConfig: z10.object({
+              PointsForWin: z10.number(),
+              PointsForLoss: z10.number()
+            })
+          }),
+          SCRIM: z10.object({
+            EventPresetName: z10.string(),
+            eventType: z10.string(),
+            bestOfN: z10.number(),
+            matchmakingStrategy: z10.string(),
+            queueID: z10.string(),
+            pointsConfig: z10.object({
+              PointsForWin: z10.number(),
+              PointsForLoss: z10.number()
+            })
+          }),
+          TOURNAMENT: z10.object({
+            EventPresetName: z10.string(),
+            eventType: z10.string(),
+            bestOfN: z10.number(),
+            matchmakingStrategy: z10.string(),
+            queueID: z10.string(),
+            pointsConfig: z10.object({
+              PointsForWin: z10.number(),
+              PointsForLoss: z10.number()
+            })
+          })
+        })
+      })
+    }),
+    FlawlessPointRequirement: z10.number(),
+    ChampionshipPointRequirement: z10.number(),
+    ChampionshipEventID: z10.string(),
+    EnrollmentPhaseStartDateTime: z10.string(),
+    EnrollmentPhaseEndDateTime: z10.string(),
+    LeaderboardPlayoffQualificationDateTime: z10.string(),
+    LeaderboardPromotionFinalizationDateTime: z10.string(),
+    LeaderboardFinalizationDateTime: z10.string(),
+    ContenderEligibilityExpiryDateTime: z10.string(),
+    StageLockTime: z10.string(),
+    ParticipationRewards: z10.object({}),
+    TournamentWinnerRewards: z10.object({}),
+    DivisionWinnerRewards: z10.object({}),
+    RosterRecentActivityNumSeasons: z10.number()
+  }) }
+};
+var premierConferencesEndpoint = {
+  name: "Premier Conferences",
+  description: "Premier conferences of the region.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/affinities/{region}/conferences",
+  riotRequirements: player,
+  responses: { "200": z10.object({
+    PremierConferences: z10.array(z10.object({
+      id: z10.string(),
+      key: z10.string(),
+      isSuper: z10.boolean(),
+      gamePods: z10.array(z10.string()),
+      timezone: z10.string(),
+      superConference: z10.string().optional(),
+      leaderboardPlayoffQualificationDateTime: z10.string(),
+      leaderboardPromotionFinalizationDateTime: z10.string()
+    }))
+  }) }
+};
+var premierMatchLimitEndpoint = {
+  name: "Premier Match Limit",
+  description: "How many Premier matches can still be played and when the limit resets.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/matchlimitinfo",
+  riotRequirements: player,
+  responses: { "200": z10.object({
+    leagueMatchLimit: z10.number(),
+    tournamentLimit: z10.number(),
+    timeUntilNextResetSeconds: z10.number()
+  }) }
+};
+var premierEligibilityEndpoint = {
+  name: "Premier Eligibility",
+  description: "Whether the player can join a Premier roster.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/player/eligibility",
+  riotRequirements: player,
+  responses: { "200": z10.object({
+    subject: z10.string(),
+    accountVerificationStatus: z10.boolean(),
+    rankedPlacementCompletionStatus: z10.boolean(),
+    matchLimitReached: z10.boolean(),
+    isOnProvidedRoster: z10.boolean()
+  }) }
+};
+var premierPlayerV2Endpoint = {
+  name: "Premier Player V2",
+  description: "Premier membership of a player: roster id and pending invites.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v2/players/{puuid}",
+  riotRequirements: player,
+  responses: { "200": z10.object({
+    puuid: z10.string(),
+    rosterId: z10.string(),
+    version: z10.number(),
+    createdAt: z10.number(),
+    updatedAt: z10.number()
+  }) }
+};
+var premierPlayerV3Endpoint = {
+  name: "Premier Player V3",
+  description: "Like v2, with prestige and contender eligibility.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v3/players/{puuid}",
+  riotRequirements: player,
+  responses: { "200": z10.object({
+    puuid: z10.string(),
+    rosterId: z10.string(),
+    prestige: z10.object({
+      earnedPrestige: z10.boolean(),
+      earnedAura: z10.boolean(),
+      showTag: z10.boolean(),
+      showPlating: z10.boolean(),
+      showAura: z10.boolean()
+    }),
+    contenderEligibilityExpiry: z10.string(),
+    socialVersion: z10.number(),
+    premierVersion: z10.number(),
+    updatedAt: z10.number(),
+    seasons: z10.object({
+      "08d281c5-4426-3aaa-3316-ebaf5f2c858a": z10.object({
+        seasonId: z10.string(),
+        hasEarnedPrestigeAura: z10.boolean(),
+        hasEarnedParticipation: z10.boolean(),
+        hasEarnedDivisionWinner: z10.boolean()
+      }),
+      "91be4c20-439d-8e24-f577-4ca8a98e8dc8": z10.object({
+        seasonId: z10.string(),
+        hasEarnedPrestigeAura: z10.boolean(),
+        hasEarnedParticipation: z10.boolean(),
+        hasEarnedDivisionWinner: z10.boolean()
+      })
+    })
+  }) }
+};
+
+// src/endpoints/riot/presence.ts
+import { endpoints as e7 } from "valorant-api-types";
+import { z as z11 } from "zod";
+
+// src/internal/base64.ts
+function toBase64(text2) {
+  return Buffer.from(text2, "utf8").toString("base64");
+}
+function fromBase64(encoded) {
+  return Buffer.from(encoded, "base64").toString("utf8");
+}
+function basicAuth(user, password) {
+  return `Basic ${toBase64(`${user}:${password}`)}`;
+}
+
+// src/endpoints/riot/presence.ts
+var valorantPresence = z11.object({
+  isIdle: z11.boolean(),
+  isValid: z11.boolean(),
+  matchPresenceData: z11.object({
+    gameScoreType: z11.string(),
+    matchMap: z11.string(),
+    provisioningFlow: z11.string(),
+    queueId: z11.string(),
+    sessionLoopState: z11.string()
+  }),
+  maxPartySize: z11.number(),
+  partyId: z11.string(),
+  partyOwnerMatchScoreAllyTeam: z11.number(),
+  partyOwnerMatchScoreEnemyTeam: z11.number(),
+  partyPresenceData: z11.object({
+    customGameName: z11.string(),
+    customGameTeam: z11.string(),
+    isPartyCrossPlayEnabled: z11.boolean(),
+    isPartyOwner: z11.boolean(),
+    isPlayerCrossPlayEnabled: z11.boolean(),
+    maxPartySize: z11.number(),
+    partyAccessibility: z11.string(),
+    partyClientVersion: z11.string(),
+    partyId: z11.string(),
+    partyLFM: z11.boolean(),
+    partyOwnerMatchMap: z11.string(),
+    partyOwnerMatchScoreAllyTeam: z11.number(),
+    partyOwnerMatchScoreEnemyTeam: z11.number(),
+    partyOwnerProvisioningFlow: z11.string(),
+    partyOwnerSessionLoopState: z11.string(),
+    partyPrecisePlatformTypes: z11.number(),
+    partySize: z11.number(),
+    partyState: z11.string(),
+    partyVersion: z11.number(),
+    queueEntryTime: z11.string(),
+    rosterId: z11.string(),
+    tournamentId: z11.string()
+  }),
+  partySize: z11.number(),
+  playerPresenceData: z11.object({
+    accountLevel: z11.number(),
+    competitiveTier: z11.number(),
+    leaderboardPosition: z11.number(),
+    platformOverride: z11.string(),
+    playerCardId: z11.string(),
+    playerTitleId: z11.string(),
+    tempValueAA: z11.number()
+  }),
+  premierPresenceData: z11.object({
+    division: z11.number(),
+    plating: z11.number(),
+    rosterId: z11.string(),
+    rosterName: z11.string(),
+    rosterTag: z11.string(),
+    rosterType: z11.string(),
+    score: z11.number(),
+    showAura: z11.boolean(),
+    showPlating: z11.boolean(),
+    showTag: z11.boolean()
+  }),
+  provisioningFlow: z11.string(),
+  queueId: z11.string()
+});
+function decodePresence(raw) {
+  if (!raw) return null;
+  try {
+    return valorantPresence.parse(JSON.parse(fromBase64(raw)));
+  } catch {
+    return null;
+  }
+}
+var presenceEndpoint = withResponse(e7.presenceEndpoint, z11.object({
+  presences: z11.array(z11.object({
+    activePlatform: z11.string().nullable(),
+    basic: z11.string(),
+    game_name: z11.string(),
+    game_tag: z11.string(),
+    msg: z11.string().nullable(),
+    name: z11.string(),
+    packedData: z11.string().nullable(),
+    patchline: z11.string().nullable(),
+    pid: z11.string(),
+    platform: z11.string().nullable(),
+    product: z11.string(),
+    puuid: z11.string(),
+    region: z11.string(),
+    resource: z11.string(),
+    state: z11.string(),
+    summary: z11.string(),
+    time: z11.number(),
+    private: z11.string().nullable().transform(decodePresence)
+  }))
+}));
+
+// src/endpoints/riot/pvp.ts
+import { endpoints as e8 } from "valorant-api-types";
+import { z as z12 } from "zod";
+var playerLoadoutV3Endpoint = {
+  name: "Player Loadout V3",
+  description: "Current loadout. The v2 route used by `pvp.playerLoadout` answers 404 on current clients.",
+  category: "PVP Endpoints",
+  type: "pd",
+  suffix: "personalization/v3/players/{puuid}/playerloadout",
+  riotRequirements: player,
+  responses: { "200": z12.object({
+    Subject: z12.string(),
+    Version: z12.number(),
+    Guns: z12.array(z12.object({
+      ID: z12.string(),
+      SkinID: z12.string(),
+      SkinLevelID: z12.string(),
+      ChromaID: z12.string(),
+      CharmInstanceID: z12.string().optional(),
+      CharmID: z12.string().optional(),
+      CharmLevelID: z12.string().optional()
+    })),
+    ActiveExpressions: z12.array(z12.object({
+      TypeID: z12.string(),
+      AssetID: z12.string()
+    })),
+    DynamicOptions: z12.object({}),
+    Identity: z12.object({
+      PlayerCardID: z12.string(),
+      PlayerTitleID: z12.string(),
+      AccountLevel: z12.number(),
+      PreferredLevelBorderID: z12.string(),
+      HideAccountLevel: z12.boolean()
+    }),
+    Incognito: z12.boolean()
+  }) }
+};
+var configEndpoint = withResponse(
+  { ...onSharedHost(e8.configEndpoint), riotRequirements: player },
+  z12.object({
+    LastApplication: z12.string().datetime({ offset: true }).transform((value) => new Date(value)),
+    /** Game settings by name. Every value is a string, and the set of names changes with each patch. */
+    Collapsed: z12.record(z12.string(), z12.string())
+  })
+);
+
+// src/endpoints/riot/restrictions.ts
+import { z as z13 } from "zod";
+var avoidListEndpoint = {
+  name: "Avoid List",
+  description: "Players the account avoids in matchmaking.",
+  category: "Restriction Endpoints",
+  type: "pd",
+  suffix: "restrictions/v1/avoidList",
+  riotRequirements: player,
+  responses: { "200": z13.object({
+    Subject: z13.string()
+  }) }
+};
+var activeFutureInterventionsEndpoint = {
+  name: "Active Future Interventions",
+  description: "Upcoming or active restrictions of the account, by category.",
+  category: "Restriction Endpoints",
+  type: "pd",
+  suffix: "restrictions/v1/activeFutureInterventions",
+  riotRequirements: player,
+  responses: { "200": z13.object({
+    Subject: z13.string()
+  }) }
 };
+
+// src/endpoints/riot/store.ts
+import { endpoints as e9 } from "valorant-api-types";
+import { z as z14 } from "zod";
+var agentStoreEndpoint = {
+  name: "Agent Store",
+  description: "Agents offered in the store.",
+  category: "Store Endpoints",
+  type: "pd",
+  suffix: "store/v1/storefronts/agent",
+  riotRequirements: player,
+  responses: { "200": z14.object({
+    AgentStore: z14.object({
+      AgentStoreOffers: z14.array(z14.object({
+        AgentID: z14.string(),
+        StoreOffers: z14.array(z14.object({
+          OfferID: z14.string(),
+          IsDirectPurchase: z14.boolean(),
+          StartDate: z14.string(),
+          Cost: z14.record(z14.string(), z14.number()),
+          Rewards: z14.array(z14.object({
+            ItemTypeID: z14.string(),
+            ItemID: z14.string(),
+            Quantity: z14.number()
+          }))
+        }))
+      })),
+      CurrentFeaturedAgent: z14.string(),
+      NextFeaturedAgent: z14.string()
+    })
+  }) }
+};
+var allEntitlementsEndpoint = {
+  name: "All Entitlements",
+  description: "Everything the player owns, grouped by item type. This is the call without an item type, which is the shape `store.ownedItems` describes.",
+  category: "Store Endpoints",
+  type: "pd",
+  suffix: "store/v1/entitlements/{puuid}",
+  riotRequirements: player,
+  responses: { "200": z14.object({
+    EntitlementsByTypes: z14.array(z14.object({
+      ItemTypeID: z14.string(),
+      Entitlements: z14.array(z14.object({
+        TypeID: z14.string(),
+        ItemID: z14.string(),
+        InstanceID: z14.string().optional()
+      }))
+    }))
+  }) }
+};
+var ownedItemsEndpoint = withResponse(e9.ownedItemsEndpoint, z14.object({
+  ItemTypeID: z14.string(),
+  Entitlements: z14.array(z14.object({
+    TypeID: z14.string(),
+    ItemID: z14.string()
+  }))
+}));
+
+// src/endpoints/riot/storefront.ts
+import { z as z15 } from "zod";
+var storefrontV3Endpoint = {
+  name: "Storefront V3",
+  description: "Get the current storefront of the player: featured bundles, the daily skin offers, accessories and night market plugins. Replaces the v2 storefront endpoint, which now answers 404.",
+  category: "Store Endpoints",
+  type: "pd",
+  method: "POST",
+  suffix: "store/v3/storefront/{puuid}",
+  headers: /* @__PURE__ */ new Map([["Content-Type", "application/json"]]),
+  riotRequirements: player,
+  responses: { "200": z15.object({
+    FeaturedBundle: z15.object({
+      Bundle: z15.object({
+        ID: z15.string(),
+        DataAssetID: z15.string(),
+        CurrencyID: z15.string(),
+        Items: z15.array(z15.object({
+          Item: z15.object({
+            ItemTypeID: z15.string(),
+            ItemID: z15.string(),
+            Amount: z15.number()
+          }),
+          BasePrice: z15.number(),
+          CurrencyID: z15.string(),
+          DiscountPercent: z15.number(),
+          DiscountedPrice: z15.number(),
+          IsPromoItem: z15.boolean()
+        })),
+        ItemOffers: z15.array(z15.object({
+          BundleItemOfferID: z15.string(),
+          Offer: z15.object({
+            OfferID: z15.string(),
+            IsDirectPurchase: z15.boolean(),
+            StartDate: z15.string(),
+            Cost: z15.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+            }),
+            Rewards: z15.array(z15.object({
+              ItemTypeID: z15.string(),
+              ItemID: z15.string(),
+              Quantity: z15.number()
+            }))
+          }),
+          DiscountPercent: z15.number(),
+          DiscountedCost: z15.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+          })
+        })),
+        TotalBaseCost: z15.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+        }),
+        TotalDiscountedCost: z15.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+        }),
+        TotalDiscountPercent: z15.number(),
+        DurationRemainingInSeconds: z15.number(),
+        WholesaleOnly: z15.boolean(),
+        IsGiftable: z15.number()
+      }),
+      Bundles: z15.array(z15.object({
+        ID: z15.string(),
+        DataAssetID: z15.string(),
+        CurrencyID: z15.string(),
+        Items: z15.array(z15.object({
+          Item: z15.object({
+            ItemTypeID: z15.string(),
+            ItemID: z15.string(),
+            Amount: z15.number()
+          }),
+          BasePrice: z15.number(),
+          CurrencyID: z15.string(),
+          DiscountPercent: z15.number(),
+          DiscountedPrice: z15.number(),
+          IsPromoItem: z15.boolean()
+        })),
+        ItemOffers: z15.array(z15.object({
+          BundleItemOfferID: z15.string(),
+          Offer: z15.object({
+            OfferID: z15.string(),
+            IsDirectPurchase: z15.boolean(),
+            StartDate: z15.string(),
+            Cost: z15.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+            }),
+            Rewards: z15.array(z15.object({
+              ItemTypeID: z15.string(),
+              ItemID: z15.string(),
+              Quantity: z15.number()
+            }))
+          }),
+          DiscountPercent: z15.number(),
+          DiscountedCost: z15.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+          })
+        })),
+        TotalBaseCost: z15.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+        }),
+        TotalDiscountedCost: z15.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+        }),
+        TotalDiscountPercent: z15.number(),
+        DurationRemainingInSeconds: z15.number(),
+        WholesaleOnly: z15.boolean(),
+        IsGiftable: z15.number()
+      })),
+      FeaturedTileEntries: z15.array(z15.object({
+        Type: z15.number(),
+        Entry: z15.object({
+          Bundle: z15.object({
+            ID: z15.string(),
+            DataAssetID: z15.string(),
+            CurrencyID: z15.string(),
+            Items: z15.array(z15.object({
+              Item: z15.object({
+                ItemTypeID: z15.string(),
+                ItemID: z15.string(),
+                Amount: z15.number()
+              }),
+              BasePrice: z15.number(),
+              CurrencyID: z15.string(),
+              DiscountPercent: z15.number(),
+              DiscountedPrice: z15.number(),
+              IsPromoItem: z15.boolean()
+            })),
+            ItemOffers: z15.array(z15.object({
+              BundleItemOfferID: z15.string(),
+              Offer: z15.object({
+                OfferID: z15.string(),
+                IsDirectPurchase: z15.boolean(),
+                StartDate: z15.string(),
+                Cost: z15.object({
+                  "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+                }),
+                Rewards: z15.array(z15.object({
+                  ItemTypeID: z15.string(),
+                  ItemID: z15.string(),
+                  Quantity: z15.number()
+                }))
+              }),
+              DiscountPercent: z15.number(),
+              DiscountedCost: z15.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+              })
+            })),
+            TotalBaseCost: z15.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+            }),
+            TotalDiscountedCost: z15.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+            }),
+            TotalDiscountPercent: z15.number(),
+            DurationRemainingInSeconds: z15.number(),
+            WholesaleOnly: z15.boolean(),
+            IsGiftable: z15.number()
+          })
+        })
+      })),
+      BundleRemainingDurationInSeconds: z15.number()
+    }),
+    SkinsPanelLayout: z15.object({
+      SingleItemOffers: z15.array(z15.string()),
+      SingleItemStoreOffers: z15.array(z15.object({
+        OfferID: z15.string(),
+        IsDirectPurchase: z15.boolean(),
+        StartDate: z15.string(),
+        Cost: z15.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+        }),
+        Rewards: z15.array(z15.object({
+          ItemTypeID: z15.string(),
+          ItemID: z15.string(),
+          Quantity: z15.number()
+        }))
+      })),
+      SingleItemOffersRemainingDurationInSeconds: z15.number()
+    }),
+    UpgradeCurrencyStore: z15.object({
+      UpgradeCurrencyOffers: z15.array(z15.object({
+        OfferID: z15.string(),
+        StorefrontItemID: z15.string(),
+        Offer: z15.object({
+          OfferID: z15.string(),
+          IsDirectPurchase: z15.boolean(),
+          StartDate: z15.string(),
+          Cost: z15.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+          }),
+          Rewards: z15.array(z15.object({
+            ItemTypeID: z15.string(),
+            ItemID: z15.string(),
+            Quantity: z15.number()
+          }))
+        }),
+        DiscountedPercent: z15.number()
+      }))
+    }),
+    AccessoryStore: z15.object({
+      AccessoryStoreOffers: z15.array(z15.object({
+        Offer: z15.object({
+          OfferID: z15.string(),
+          IsDirectPurchase: z15.boolean(),
+          StartDate: z15.string(),
+          Cost: z15.object({
+            "85ca954a-41f2-ce94-9b45-8ca3dd39a00d": z15.number()
+          }),
+          Rewards: z15.array(z15.object({
+            ItemTypeID: z15.string(),
+            ItemID: z15.string(),
+            Quantity: z15.number()
+          }))
+        }),
+        ContractID: z15.string()
+      })),
+      AccessoryStoreRemainingDurationInSeconds: z15.number(),
+      StorefrontID: z15.string()
+    }),
+    PluginStores: z15.array(z15.object({
+      PluginID: z15.string(),
+      PluginOffers: z15.object({
+        StoreOffers: z15.array(z15.object({
+          PurchaseInformation: z15.object({
+            DataAssetID: z15.string(),
+            OfferID: z15.string(),
+            OfferType: z15.number(),
+            StartDate: z15.string(),
+            PrimaryCurrencyID: z15.string(),
+            Cost: z15.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+            }),
+            DiscountedCost: z15.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+            }),
+            DiscountedPercentage: z15.number(),
+            WholesaleOnly: z15.boolean(),
+            IsGiftable: z15.number()
+          }),
+          SubOffers: z15.array(z15.object({
+            PurchaseInformation: z15.object({
+              DataAssetID: z15.string(),
+              OfferID: z15.string(),
+              OfferType: z15.number(),
+              StartDate: z15.string(),
+              PrimaryCurrencyID: z15.string(),
+              Cost: z15.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+              }),
+              DiscountedCost: z15.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z15.number()
+              }),
+              DiscountedPercentage: z15.number(),
+              Rewards: z15.array(z15.object({
+                ItemTypeID: z15.string(),
+                ItemID: z15.string(),
+                Quantity: z15.number()
+              })),
+              WholesaleOnly: z15.boolean(),
+              IsGiftable: z15.number()
+            })
+          }))
+        })),
+        RemainingDurationInSeconds: z15.number()
+      }),
+      StartDate: z15.string()
+    }))
+  }) }
+};
+
+// src/endpoints/riot/voice.ts
+import { z as z16 } from "zod";
 var voiceAudioPropertiesEndpoint = {
   name: "Audio Properties",
   description: "Get audio properties such as if the microphone is in use",
-  queryName: "VOICE_CHAT_RNet_FetchAudioProperties",
   category: "Local Endpoints - Voice",
   type: "local",
   suffix: "voice-chat/v1/audio-properties",
   riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+  responses: { "200": z16.object({
+    fastEnergyMeter: z16.number(),
+    isLoopbackEnabled: z16.boolean(),
+    isMicActive: z16.boolean(),
+    isSpeakerActive: z16.boolean(),
+    micEnergy: z16.number(),
+    micVolume: z16.number(),
+    noiseFloorMeter: z16.number(),
+    speakerEnergy: z16.number(),
+    speakerVolume: z16.number(),
+    speechThresholdMeter: z16.number()
+  }) }
 };
 var voiceCaptureDevicesEndpoint = {
   name: "Capture Devices",
   description: "Get microphone input device info",
-  queryName: "VOICE_CHAT_RNet_FetchCaptureDevices",
   category: "Local Endpoints - Voice",
   type: "local",
   suffix: "voice-chat/v2/devices/capture",
   riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
-};
-var voicePushToTalkEndpoint = {
-  name: "Push To Talk",
-  description: "GET VOICE_CHAT_RNet_FetchPTTSettings",
-  queryName: "VOICE_CHAT_RNet_FetchPTTSettings",
-  category: "Local Endpoints - Voice",
-  type: "local",
-  suffix: "voice-chat/v2/push-to-talk/valorant",
-  riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+  responses: { "200": z16.array(z16.object({
+    handle: z16.string(),
+    is_current_device: z16.boolean(),
+    is_default: z16.boolean(),
+    is_effective_device: z16.boolean(),
+    name: z16.string()
+  })) }
 };
 var voiceRenderDevicesEndpoint = {
   name: "Render Devices",
   description: "Get audio output devices",
-  queryName: "VOICE_CHAT_RNet_FetchRenderDevices",
   category: "Local Endpoints - Voice",
   type: "local",
   suffix: "voice-chat/v2/devices/render",
   riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+  responses: { "200": z16.array(z16.object({
+    handle: z16.string(),
+    is_current_device: z16.boolean(),
+    is_default: z16.boolean(),
+    is_effective_device: z16.boolean(),
+    name: z16.string()
+  })) }
 };
-var voiceSessionsEndpoint = {
-  name: "Sessions",
-  description: "GET VOICE_CHAT_RNet_FetchSessions",
-  queryName: "VOICE_CHAT_RNet_FetchSessions",
-  category: "Local Endpoints - Voice",
-  type: "local",
-  suffix: "voice-chat/v3/sessions/valorant",
-  riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+
+// src/api/groups/pvp.ts
+var pvp = {
+  content: e10.fetchContentEndpoint,
+  accountXp: e10.accountXPEndpoint,
+  setPlayerLoadout: e10.setPlayerLoadoutEndpoint,
+  playerMmr: e10.playerMMREndpoint,
+  matchHistory: e10.matchHistoryEndpoint,
+  matchDetails: e10.matchDetailsEndpoint,
+  competitiveUpdates: e10.competitiveUpdatesEndpoint,
+  leaderboard: e10.leaderboardEndpoint,
+  penalties: e10.penaltiesEndpoint,
+  config: configEndpoint,
+  nameService: e10.nameServiceEndpoint,
+  playerLoadoutV3: playerLoadoutV3Endpoint
 };
-var voiceSettingsEndpoint = {
-  name: "Settings",
-  description: "GET VOICE_CHAT_RNet_FetchSettings",
-  queryName: "VOICE_CHAT_RNet_FetchSettings",
-  category: "Local Endpoints - Voice",
-  type: "local",
-  suffix: "voice-chat/v3/settings/valorant",
-  riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+
+// src/api/groups/party.ts
+import { endpoints as e11 } from "valorant-api-types";
+var party = {
+  get: partyEndpoint,
+  player: e11.partyPlayerEndpoint,
+  removePlayer: e11.partyRemovePlayerEndpoint,
+  setMemberReady: partySetMemberReadyEndpoint,
+  refreshCompetitiveTier: refreshCompetitiveTierEndpoint,
+  refreshPlayerIdentity: refreshPlayerIdentityEndpoint,
+  refreshPings: refreshPingsEndpoint,
+  changeQueue: changeQueueEndpoint,
+  startCustomGame: startCustomGameEndpoint,
+  enterMatchmakingQueue: enterMatchmakingQueueEndpoint,
+  leaveMatchmakingQueue: leaveMatchmakingQueueEndpoint,
+  setAccessibility: setPartyAccessibilityEndpoint,
+  setCustomGameSettings: setCustomGameSettingsEndpoint,
+  invite: partyInviteEndpoint,
+  requestToJoin: e11.partyRequestEndpoint,
+  declineRequest: partyDeclineEndpoint,
+  customGameConfigs: e11.customGameConfigsEndpoint,
+  disableCode: partyDisableCodeEndpoint,
+  generateCode: partyGenerateCodeEndpoint,
+  joinByCode: e11.partyJoinByCodeEndpoint,
+  setCustomGameTeam: setCustomGameTeamEndpoint,
+  getCustomGame: customGamePartyEndpoint
 };
-var pregameChatTokenEndpoint = {
-  name: "Chat Token",
-  description: "Get a chat token",
-  queryName: "Pregame_FetchChatToken",
-  category: "Pre-Game Endpoints",
-  type: "glz",
-  suffix: "pregame/v1/matches/{pre-game match id}/chattoken",
-  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
-  responses: { "200": z2.unknown() }
-};
-var pregameVoiceTokenEndpoint = {
-  name: "Voice Token",
-  description: "Get a voice token",
-  queryName: "Pregame_FetchVoiceToken",
-  category: "Pre-Game Endpoints",
-  type: "glz",
-  suffix: "pregame/v1/matches/{pre-game match id}/voicetoken",
-  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
-  responses: { "200": z2.unknown() }
-};
-var sessionGetEndpoint = {
-  name: "Get",
-  description: "Get information about the current game session",
-  queryName: "Session_Get",
-  category: "Session Endpoints",
-  type: "glz",
-  suffix: "session/v1/sessions/{puuid}",
-  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
-  responses: { "200": z2.unknown() }
-};
-var sessionReconnectEndpoint = {
-  name: "Reconnect",
-  description: "GET Session_ReConnect",
-  queryName: "Session_ReConnect",
-  category: "Session Endpoints",
-  type: "glz",
-  suffix: "session/v1/sessions/{puuid}/reconnect",
-  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
-  responses: { "200": z2.unknown() }
-};
-var storeOrderEndpoint = {
-  name: "Order",
-  description: "GET Store_GetOrder",
-  queryName: "Store_GetOrder",
-  category: "Store Endpoints",
-  type: "pd",
-  suffix: "store/v1/order/{order id}",
-  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
-  responses: { "200": z2.unknown() }
-};
-var localPlayerSettingsEndpoint = {
-  name: "Player Settings",
-  description: "Get client settings",
-  queryName: "RiotKV_RNet_GetSettings",
-  category: "Local Endpoints",
-  type: "local",
-  suffix: "player-preferences/v1/data-json/Ares.PlayerSettings",
-  riotRequirements: { localAuth: true },
-  responses: { "200": z2.unknown() }
+
+// src/api/groups/store.ts
+import { endpoints as e12 } from "valorant-api-types";
+var store = {
+  wallet: e12.walletEndpoint,
+  ownedItems: ownedItemsEndpoint,
+  storefrontV3: storefrontV3Endpoint,
+  agentStore: agentStoreEndpoint,
+  allEntitlements: allEntitlementsEndpoint
 };
 
-// src/extra/store.ts
-import { z as z3 } from "zod";
-var offerSchema = z3.object({
-  OfferID: z3.string(),
-  IsDirectPurchase: z3.boolean(),
-  StartDate: z3.string(),
-  Cost: z3.record(z3.string(), z3.number()),
-  Rewards: z3.array(z3.object({
-    ItemTypeID: z3.string(),
-    ItemID: z3.string(),
-    Quantity: z3.number()
-  }).passthrough())
+// src/api/groups/pregame.ts
+import { endpoints as e13 } from "valorant-api-types";
+var pregame = {
+  player: e13.pregamePlayerEndpoint,
+  match: pregameMatchEndpoint,
+  loadouts: pregameLoadoutsEndpoint,
+  selectCharacter: selectCharacterEndpoint,
+  lockCharacter: lockCharacterEndpoint,
+  quit: e13.pregameQuitEndpoint
+};
+
+// src/api/groups/currentGame.ts
+import { endpoints as e14 } from "valorant-api-types";
+var currentGame = {
+  player: e14.currentGamePlayerEndpoint,
+  match: e14.currentGameMatchEndpoint,
+  loadouts: currentGameLoadoutsEndpoint,
+  quit: e14.currentGameQuitEndpoint
+};
+
+// src/api/groups/contracts.ts
+import { endpoints as e15 } from "valorant-api-types";
+var contracts = {
+  itemUpgrades: e15.itemUpgradesEndpoint,
+  list: contractsEndpoint,
+  activate: e15.activateContractEndpoint,
+  activeRecruitmentEvent: activeRecruitmentEventEndpoint
+};
+
+// src/api/groups/local.ts
+import { endpoints as e16 } from "valorant-api-types";
+var local = {
+  help: e16.localHelpEndpoint,
+  sessions: e16.sessionsEndpoint,
+  rsoUserInfo: e16.rsoUserInfoEndpoint,
+  clientRegion: e16.clientRegionEndpoint,
+  accountAlias: e16.accountAliasEndpoint,
+  entitlementsToken: e16.entitlementsTokenEndpoint,
+  chatSession: e16.chatSessionEndpoint,
+  friends: e16.friendsEndpoint,
+  sendFriendRequest: e16.sendFriendRequestEndpoint,
+  removeFriendRequest: e16.removeFriendRequestEndpoint,
+  presence: presenceEndpoint,
+  friendRequests: e16.friendRequestsEndpoint,
+  swaggerDocs: e16.localSwaggerDocsEndpoint,
+  eula: localEulaEndpoint,
+  privacyPolicy: localPrivacyPolicyEndpoint,
+  availableLocales: localAvailableLocalesEndpoint,
+  locale: localLocaleEndpoint,
+  riotStatus: localRiotStatusEndpoint,
+  accessToken: localAccessTokenEndpoint,
+  pluginStatus: localPluginStatusEndpoint,
+  rmsSession: localRmsSessionEndpoint,
+  processInfo: localProcessInfoEndpoint,
+  logPath: localLogPathEndpoint
+};
+
+// src/api/groups/chat.ts
+import { endpoints as e17 } from "valorant-api-types";
+var chat = {
+  partyInfo: e17.partyChatInfoEndpoint,
+  pregameInfo: e17.pregameChatInfoEndpoint,
+  currentGameInfo: e17.currentGameChatInfoEndpoint,
+  allInfo: e17.allChatInfoEndpoint,
+  participants: chatParticipantsEndpoint,
+  send: e17.sendChatEndpoint,
+  history: e17.chatHistoryEndpoint,
+  settings: chatSettingsEndpoint,
+  tournamentInfo: chatTournamentInfoEndpoint
+};
+
+// src/api/groups/voice.ts
+var voice = {
+  audioProperties: voiceAudioPropertiesEndpoint,
+  captureDevices: voiceCaptureDevicesEndpoint,
+  renderDevices: voiceRenderDevicesEndpoint
+};
+
+// src/api/groups/premier.ts
+var premier = {
+  seasons: premierSeasonsEndpoint,
+  activeSeason: premierActiveSeasonEndpoint,
+  conferences: premierConferencesEndpoint,
+  matchLimit: premierMatchLimitEndpoint,
+  eligibility: premierEligibilityEndpoint,
+  playerV2: premierPlayerV2Endpoint,
+  playerV3: premierPlayerV3Endpoint
+};
+
+// src/api/groups/esports.ts
+var esports = {
+  liveEventTimes: esportsLiveEventTimesEndpoint,
+  upcomingMatches: esportsUpcomingMatchesEndpoint,
+  pickemLeagues: esportsPickemLeaguesEndpoint
+};
+
+// src/api/groups/restrictions.ts
+var restrictions = {
+  avoidList: avoidListEndpoint,
+  activeFutureInterventions: activeFutureInterventionsEndpoint
+};
+
+// src/api/groups/account.ts
+var account = {
+  dailyTicket: dailyTicketEndpoint,
+  dailyTicketQueueConfig: dailyTicketQueueConfigEndpoint,
+  favorites: favoritesEndpoint,
+  goldstars: goldstarsEndpoint,
+  goldstarsPlayer: goldstarsPlayerEndpoint,
+  bloomlineQueues: bloomlineQueuesEndpoint,
+  bloomlinePlayer: bloomlinePlayerEndpoint
+};
+
+// src/api/groups/auth.ts
+import { endpoints as e18 } from "valorant-api-types";
+var auth = {
+  cookies: e18.authCookiesEndpoint,
+  request: e18.authRequestEndpoint,
+  multiFactor: e18.multiFactorAuthenticationEndpoint,
+  cookieReauth: e18.cookieReauthEndpoint,
+  entitlement: e18.entitlementEndpoint,
+  playerInfo: e18.playerInfoEndpoint,
+  riotGeo: e18.riotGeoEndpoint,
+  pasToken: e18.pasTokenEndpoint,
+  riotClientConfig: e18.riotClientConfigEndpoint
+};
+
+// src/endpoints/catalog/index.ts
+import { z as z19 } from "zod";
+
+// src/endpoints/catalog/factory.ts
+import { z as z17 } from "zod";
+
+// src/envelope.ts
+var enveloped = /* @__PURE__ */ new WeakSet();
+function markEnveloped(endpoint2) {
+  enveloped.add(endpoint2);
+  return endpoint2;
+}
+function unwrapEnvelope(endpoint2, body) {
+  if (enveloped.has(endpoint2) && typeof body === "object" && body !== null && "data" in body) {
+    return body.data;
+  }
+  return body;
+}
+
+// src/endpoints/catalog/factory.ts
+var BASE = "https://valorant-api.com/v1/";
+function query(queryParams = []) {
+  return new Map([
+    ["language", z17.string().optional().describe("Language code such as `fr-FR`. Defaults to `en-US`.")],
+    ...queryParams
+  ]);
+}
+function endpoint(name, description, path, schema, queryParams = []) {
+  return markEnveloped({
+    name,
+    description,
+    category: "Valorant-API.com",
+    type: "other",
+    suffix: `${BASE}${path}`,
+    query: query(queryParams),
+    responses: { "200": schema }
+  });
+}
+function collection(title, singular, path, schema, queryParams = []) {
+  return {
+    list: endpoint(title, `List of ${title.toLowerCase()}`, path, z17.array(schema), queryParams),
+    one: endpoint(singular, `One ${singular.toLowerCase()} by UUID`, `${path}/{uuid}`, schema)
+  };
+}
+
+// src/endpoints/catalog/schemas.ts
+import { z as z18 } from "zod";
+var text = z18.string().nullish();
+var asset = z18.object({
+  uuid: z18.string(),
+  displayName: text,
+  displayIcon: text,
+  assetPath: text
+}).passthrough();
+var agentSchema = asset.extend({
+  description: text,
+  developerName: text,
+  characterTags: z18.array(z18.string()).nullish(),
+  displayIconSmall: text,
+  bustPortrait: text,
+  fullPortrait: text,
+  killfeedPortrait: text,
+  background: text,
+  isPlayableCharacter: z18.boolean(),
+  role: z18.object({ uuid: z18.string(), displayName: text, description: text, displayIcon: text }).passthrough().nullish(),
+  abilities: z18.array(z18.object({ slot: z18.string(), displayName: text, description: text, displayIcon: text }).passthrough()).nullish()
+});
+var mapSchema = asset.extend({
+  coordinates: text,
+  listViewIcon: text,
+  splash: text,
+  mapUrl: text,
+  xMultiplier: z18.number(),
+  yMultiplier: z18.number(),
+  xScalarToAdd: z18.number(),
+  yScalarToAdd: z18.number(),
+  callouts: z18.array(z18.object({ regionName: z18.string(), superRegionName: z18.string(), location: z18.object({ x: z18.number(), y: z18.number() }) }).passthrough()).nullish()
+});
+var weaponSchema = asset.extend({
+  category: z18.string(),
+  defaultSkinUuid: z18.string(),
+  killStreamIcon: text,
+  weaponStats: z18.object({}).passthrough().nullish(),
+  shopData: z18.object({}).passthrough().nullish(),
+  skins: z18.array(z18.object({}).passthrough())
+});
+var skinSchema = asset.extend({
+  themeUuid: z18.string(),
+  contentTierUuid: text,
+  wallpaper: text,
+  chromas: z18.array(asset.passthrough()),
+  levels: z18.array(asset.passthrough())
+});
+var seasonSchema = z18.object({
+  uuid: z18.string(),
+  displayName: text,
+  type: text,
+  startTime: z18.string(),
+  endTime: z18.string(),
+  parentUuid: text,
+  assetPath: text
 }).passthrough();
-var bundleSchema = z3.object({
-  ID: z3.string(),
-  DataAssetID: z3.string(),
-  CurrencyID: z3.string(),
-  Items: z3.array(z3.unknown()),
-  ItemOffers: z3.array(z3.unknown()).nullish(),
-  TotalBaseCost: z3.record(z3.string(), z3.number()).nullish(),
-  TotalDiscountedCost: z3.record(z3.string(), z3.number()).nullish(),
-  TotalDiscountPercent: z3.number(),
-  DurationRemainingInSeconds: z3.number(),
-  WholesaleOnly: z3.boolean()
+var versionSchema = z18.object({
+  manifestId: z18.string(),
+  branch: z18.string(),
+  version: z18.string(),
+  buildVersion: z18.string(),
+  engineVersion: z18.string(),
+  riotClientVersion: z18.string().describe("Value of the X-Riot-ClientVersion header"),
+  riotClientBuild: z18.string(),
+  buildDate: z18.string()
 }).passthrough();
-var storefrontV3Endpoint = {
-  name: "Storefront V3",
-  description: "Get the current storefront of the player: featured bundles, the daily skin offers, accessories and night market plugins. Replaces the v2 storefront endpoint, which now answers 404.",
-  queryName: "Store_GetStorefrontV3",
-  category: "Store Endpoints",
-  type: "pd",
-  method: "POST",
-  suffix: "store/v3/storefront/{puuid}",
-  headers: /* @__PURE__ */ new Map([["Content-Type", "application/json"]]),
-  riotRequirements: {
-    token: true,
-    entitlement: true,
-    clientPlatform: true,
-    clientVersion: true
-  },
-  responses: {
-    "200": z3.object({
-      FeaturedBundle: z3.object({
-        Bundle: bundleSchema,
-        Bundles: z3.array(bundleSchema),
-        BundleRemainingDurationInSeconds: z3.number()
-      }).passthrough(),
-      SkinsPanelLayout: z3.object({
-        SingleItemOffers: z3.array(z3.string()),
-        SingleItemStoreOffers: z3.array(offerSchema),
-        SingleItemOffersRemainingDurationInSeconds: z3.number()
-      }).passthrough(),
-      UpgradeCurrencyStore: z3.object({
-        UpgradeCurrencyOffers: z3.array(z3.object({ OfferID: z3.string(), StorefrontItemID: z3.string() }).passthrough())
-      }).passthrough(),
-      AccessoryStore: z3.object({
-        AccessoryStoreOffers: z3.array(z3.object({ Offer: offerSchema, ContractID: z3.string() }).passthrough()),
-        AccessoryStoreRemainingDurationInSeconds: z3.number(),
-        StorefrontID: z3.string()
-      }).passthrough(),
-      BonusStore: z3.object({
-        BonusStoreOffers: z3.array(z3.unknown()),
-        BonusStoreRemainingDurationInSeconds: z3.number()
-      }).passthrough().optional().describe("Only present while the night market is active"),
-      PluginStores: z3.array(z3.object({ PluginID: z3.string(), PluginOffers: z3.unknown(), StartDate: z3.string() }).passthrough()).optional()
-    }).passthrough()
-  }
+
+// src/endpoints/catalog/index.ts
+var playable = [["isPlayableCharacter", z19.boolean().optional().describe("Only return playable agents. Skips the duplicate Sova.")]];
+var agents = collection("Agents", "Agent", "agents", agentSchema, playable);
+var buddies = collection("Buddies", "Buddy", "buddies", asset);
+var buddyLevels = collection("Buddy Levels", "Buddy Level", "buddies/levels", asset);
+var bundles = collection("Bundles", "Bundle", "bundles", asset);
+var ceremonies = collection("Ceremonies", "Ceremony", "ceremonies", asset);
+var competitiveTiers = collection("Competitive Tiers", "Competitive Tier Set", "competitivetiers", z19.object({ uuid: z19.string(), tiers: z19.array(z19.object({ tier: z19.number(), tierName: text, division: text, color: text }).passthrough()) }).passthrough());
+var contentTiers = collection("Content Tiers", "Content Tier", "contenttiers", asset);
+var contracts2 = collection("Contracts", "Contract", "contracts", asset);
+var currencies = collection("Currencies", "Currency", "currencies", asset);
+var events = collection("Events", "Event", "events", asset);
+var flex = collection("Flex", "Flex Item", "flex", asset);
+var gamemodes = collection("Gamemodes", "Gamemode", "gamemodes", asset);
+var gamemodeEquippables = collection("Gamemode Equippables", "Gamemode Equippable", "gamemodes/equippables", asset);
+var gear = collection("Gear", "Gear Item", "gear", asset);
+var levelBorders = collection("Level Borders", "Level Border", "levelborders", asset);
+var maps = collection("Maps", "Map", "maps", mapSchema);
+var missions = collection("Missions", "Mission", "missions", z19.object({ uuid: z19.string(), displayName: text }).passthrough());
+var playerCards = collection("Player Cards", "Player Card", "playercards", asset);
+var playerTitles = collection("Player Titles", "Player Title", "playertitles", z19.object({ uuid: z19.string(), displayName: text, titleText: text }).passthrough());
+var seasons = collection("Seasons", "Season", "seasons", seasonSchema);
+var competitiveSeasons = collection("Competitive Seasons", "Competitive Season", "seasons/competitive", z19.object({ uuid: z19.string(), seasonUuid: z19.string(), startTime: z19.string(), endTime: z19.string() }).passthrough());
+var sprays = collection("Sprays", "Spray", "sprays", asset);
+var sprayLevels = collection("Spray Levels", "Spray Level", "sprays/levels", asset);
+var themes = collection("Themes", "Theme", "themes", asset);
+var weapons = collection("Weapons", "Weapon", "weapons", weaponSchema);
+var weaponSkins = collection("Weapon Skins", "Weapon Skin", "weapons/skins", skinSchema);
+var weaponSkinChromas = collection("Weapon Skin Chromas", "Weapon Skin Chroma", "weapons/skinchromas", asset);
+var weaponSkinLevels = collection("Weapon Skin Levels", "Weapon Skin Level", "weapons/skinlevels", asset);
+var catalogEndpoints = {
+  agents: agents.list,
+  agent: agents.one,
+  buddies: buddies.list,
+  buddy: buddies.one,
+  buddyLevels: buddyLevels.list,
+  buddyLevel: buddyLevels.one,
+  bundles: bundles.list,
+  bundle: bundles.one,
+  ceremonies: ceremonies.list,
+  ceremony: ceremonies.one,
+  competitiveTiers: competitiveTiers.list,
+  competitiveTier: competitiveTiers.one,
+  contentTiers: contentTiers.list,
+  contentTier: contentTiers.one,
+  contracts: contracts2.list,
+  contract: contracts2.one,
+  currencies: currencies.list,
+  currency: currencies.one,
+  events: events.list,
+  event: events.one,
+  flex: flex.list,
+  flexItem: flex.one,
+  gamemodes: gamemodes.list,
+  gamemode: gamemodes.one,
+  gamemodeEquippables: gamemodeEquippables.list,
+  gamemodeEquippable: gamemodeEquippables.one,
+  gear: gear.list,
+  gearItem: gear.one,
+  levelBorders: levelBorders.list,
+  levelBorder: levelBorders.one,
+  maps: maps.list,
+  map: maps.one,
+  missions: missions.list,
+  mission: missions.one,
+  playerCards: playerCards.list,
+  playerCard: playerCards.one,
+  playerTitles: playerTitles.list,
+  playerTitle: playerTitles.one,
+  seasons: seasons.list,
+  season: seasons.one,
+  competitiveSeasons: competitiveSeasons.list,
+  competitiveSeason: competitiveSeasons.one,
+  sprays: sprays.list,
+  spray: sprays.one,
+  sprayLevels: sprayLevels.list,
+  sprayLevel: sprayLevels.one,
+  themes: themes.list,
+  theme: themes.one,
+  version: endpoint("Version", "Current game version and the matching client version", "version", versionSchema),
+  weapons: weapons.list,
+  weapon: weapons.one,
+  weaponSkins: weaponSkins.list,
+  weaponSkin: weaponSkins.one,
+  weaponSkinChromas: weaponSkinChromas.list,
+  weaponSkinChroma: weaponSkinChromas.one,
+  weaponSkinLevels: weaponSkinLevels.list,
+  weaponSkinLevel: weaponSkinLevels.one
 };
 
+// src/api/groups/catalog.ts
+var catalog = catalogEndpoints;
+
 // src/api/registry.ts
 var registry = {
-  pvp: {
-    content: e.fetchContentEndpoint,
-    accountXp: e.accountXPEndpoint,
-    playerLoadout: e.playerLoadoutEndpoint,
-    setPlayerLoadout: e.setPlayerLoadoutEndpoint,
-    playerMmr: e.playerMMREndpoint,
-    matchHistory: e.matchHistoryEndpoint,
-    matchDetails: e.matchDetailsEndpoint,
-    competitiveUpdates: e.competitiveUpdatesEndpoint,
-    leaderboard: e.leaderboardEndpoint,
-    penalties: e.penaltiesEndpoint,
-    config: e.configEndpoint,
-    nameService: e.nameServiceEndpoint
-  },
-  party: {
-    get: e.partyEndpoint,
-    player: e.partyPlayerEndpoint,
-    removePlayer: e.partyRemovePlayerEndpoint,
-    setMemberReady: e.partySetMemberReadyEndpoint,
-    refreshCompetitiveTier: e.refreshCompetitiveTierEndpoint,
-    refreshPlayerIdentity: e.refreshPlayerIdentityEndpoint,
-    refreshPings: e.refreshPingsEndpoint,
-    changeQueue: e.changeQueueEndpoint,
-    startCustomGame: e.startCustomGameEndpoint,
-    enterMatchmakingQueue: e.enterMatchmakingQueueEndpoint,
-    leaveMatchmakingQueue: e.leaveMatchmakingQueueEndpoint,
-    setAccessibility: e.setPartyAccessibilityEndpoint,
-    setCustomGameSettings: e.setCustomGameSettingsEndpoint,
-    invite: e.partyInviteEndpoint,
-    requestToJoin: e.partyRequestEndpoint,
-    declineRequest: e.partyDeclineEndpoint,
-    customGameConfigs: e.customGameConfigsEndpoint,
-    chatToken: e.partyChatTokenEndpoint,
-    voiceToken: e.partyVoiceTokenEndpoint,
-    disableCode: e.partyDisableCodeEndpoint,
-    generateCode: e.partyGenerateCodeEndpoint,
-    joinByCode: e.partyJoinByCodeEndpoint
-  },
-  store: {
-    prices: e.pricesEndpoint,
-    storefront: e.storefrontEndpoint,
-    wallet: e.walletEndpoint,
-    ownedItems: e.ownedItemsEndpoint,
-    storefrontV3: storefrontV3Endpoint,
-    order: storeOrderEndpoint
-  },
-  pregame: {
-    player: e.pregamePlayerEndpoint,
-    match: e.pregameMatchEndpoint,
-    loadouts: e.pregameLoadoutsEndpoint,
-    selectCharacter: e.selectCharacterEndpoint,
-    lockCharacter: e.lockCharacterEndpoint,
-    quit: e.pregameQuitEndpoint,
-    chatToken: pregameChatTokenEndpoint,
-    voiceToken: pregameVoiceTokenEndpoint
-  },
-  currentGame: {
-    player: e.currentGamePlayerEndpoint,
-    match: e.currentGameMatchEndpoint,
-    loadouts: e.currentGameLoadoutsEndpoint,
-    quit: e.currentGameQuitEndpoint,
-    allChatToken: currentGameAllChatTokenEndpoint,
-    teamChatToken: currentGameTeamChatTokenEndpoint
-  },
-  contracts: {
-    itemUpgrades: e.itemUpgradesEndpoint,
-    list: e.contractsEndpoint,
-    activate: e.activateContractEndpoint,
-    activeStory: contractsActiveStoryEndpoint
-  },
-  local: {
-    help: e.localHelpEndpoint,
-    sessions: e.sessionsEndpoint,
-    rsoUserInfo: e.rsoUserInfoEndpoint,
-    clientRegion: e.clientRegionEndpoint,
-    accountAlias: e.accountAliasEndpoint,
-    entitlementsToken: e.entitlementsTokenEndpoint,
-    chatSession: e.chatSessionEndpoint,
-    friends: e.friendsEndpoint,
-    sendFriendRequest: e.sendFriendRequestEndpoint,
-    removeFriendRequest: e.removeFriendRequestEndpoint,
-    presence: e.presenceEndpoint,
-    friendRequests: e.friendRequestsEndpoint,
-    swaggerDocs: e.localSwaggerDocsEndpoint,
-    antiAddictionShutdown: localAntiAddictionShutdownEndpoint,
-    antiAddictionWarning: localAntiAddictionWarningEndpoint,
-    clientConfig: localClientConfigEndpoint,
-    eula: localEulaEndpoint,
-    privacyPolicy: localPrivacyPolicyEndpoint,
-    availableLocales: localAvailableLocalesEndpoint,
-    locale: localLocaleEndpoint,
-    reporterFeedback: localReporterFeedbackEndpoint,
-    commandLineArgs: localCommandLineArgsEndpoint,
-    riotStatus: localRiotStatusEndpoint,
-    riotWarning: localRiotWarningEndpoint,
-    clientAuthorizations: localClientAuthorizationsEndpoint,
-    accessToken: localAccessTokenEndpoint,
-    userInfoToken: localUserInfoTokenEndpoint,
-    pluginStatus: localPluginStatusEndpoint,
-    rmsSession: localRmsSessionEndpoint,
-    processInfo: localProcessInfoEndpoint,
-    logPath: localLogPathEndpoint,
-    playerSettings: localPlayerSettingsEndpoint
-  },
-  chat: {
-    partyInfo: e.partyChatInfoEndpoint,
-    pregameInfo: e.pregameChatInfoEndpoint,
-    currentGameInfo: e.currentGameChatInfoEndpoint,
-    allInfo: e.allChatInfoEndpoint,
-    participants: e.chatParticipantsEndpoint,
-    send: e.sendChatEndpoint,
-    history: e.chatHistoryEndpoint,
-    settings: chatSettingsEndpoint,
-    tournamentInfo: chatTournamentInfoEndpoint
-  },
-  session: {
-    get: sessionGetEndpoint,
-    reconnect: sessionReconnectEndpoint
-  },
-  voice: {
-    audioProperties: voiceAudioPropertiesEndpoint,
-    captureDevices: voiceCaptureDevicesEndpoint,
-    renderDevices: voiceRenderDevicesEndpoint,
-    pushToTalk: voicePushToTalkEndpoint,
-    sessions: voiceSessionsEndpoint,
-    settings: voiceSettingsEndpoint
-  },
-  auth: {
-    cookies: e.authCookiesEndpoint,
-    request: e.authRequestEndpoint,
-    multiFactor: e.multiFactorAuthenticationEndpoint,
-    cookieReauth: e.cookieReauthEndpoint,
-    entitlement: e.entitlementEndpoint,
-    playerInfo: e.playerInfoEndpoint,
-    riotGeo: e.riotGeoEndpoint,
-    pasToken: e.pasTokenEndpoint,
-    riotClientConfig: e.riotClientConfigEndpoint
-  },
-  catalog: catalogEndpoints
+  pvp,
+  party,
+  store,
+  pregame,
+  currentGame,
+  contracts,
+  local,
+  chat,
+  voice,
+  premier,
+  esports,
+  restrictions,
+  account,
+  auth,
+  catalog
 };
 
 // src/auth.ts
-import { endpoints as e2 } from "valorant-api-types";
+import { endpoints as e19 } from "valorant-api-types";
 
 // src/errors.ts
 var ValorantError = class extends Error {
@@ -894,7 +2542,7 @@ function createAuthFlows(client) {
       return toLoginResult(data);
     },
     async reauthenticate(options) {
-      const response = await client.send(e2.cookieReauthEndpoint);
+      const response = await client.send(e19.cookieReauthEndpoint);
       const tokens = parseAuthRedirect(response.headers.get("location") ?? "");
       if (tokens === void 0) throw new ValorantError("Cookie reauthentication failed: the session cookies are missing or expired, log in again");
       applyTokens(tokens);
@@ -926,7 +2574,7 @@ function createAuthFlows(client) {
 }
 
 // src/context.ts
-var DEFAULT_PLATFORM = btoa(JSON.stringify({
+var DEFAULT_PLATFORM = toBase64(JSON.stringify({
   platformType: "PC",
   platformOS: "Windows",
   platformOSVersion: "10.0.19042.1.256.64bit",
@@ -1085,6 +2733,258 @@ var localTransport = async (request) => {
   });
 };
 
+// src/internal/body.ts
+import { ZodError } from "zod";
+function parseBody(text2) {
+  if (text2 === "") return void 0;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+function safeParse(schema, data) {
+  try {
+    return schema.safeParse(data);
+  } catch (thrown) {
+    if (thrown instanceof ZodError) return { success: false, error: thrown };
+    const message = thrown instanceof Error ? thrown.message : String(thrown);
+    return { success: false, error: new ZodError([{ code: "custom", path: [], message: `Schema transform threw: ${message}` }]) };
+  }
+}
+
+// src/internal/cookies.ts
+function storeCookies(context, setCookies) {
+  for (const line of setCookies) {
+    const [pair = "", ...attributes] = line.split(";").map((part) => part.trim());
+    const separator = pair.indexOf("=");
+    if (separator <= 0) continue;
+    const name = pair.slice(0, separator);
+    const value = pair.slice(separator + 1);
+    const expired = value === "" || attributes.some((a) => a.toLowerCase() === "max-age=0");
+    context.setCookie(name, expired ? void 0 : value);
+  }
+}
+
+// src/internal/retry.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var IDEMPOTENT = /* @__PURE__ */ new Set(["GET", "HEAD", "PUT", "DELETE"]);
+function isIdempotent(method) {
+  return IDEMPOTENT.has(method);
+}
+function isRetryableStatus(status, method) {
+  return RETRYABLE_STATUS.has(status) && (status === 429 || isIdempotent(method));
+}
+function parseRetryAfter(value) {
+  if (value === null) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return seconds * 1e3;
+  const date = Date.parse(value);
+  return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+function backoff(attempt, retry) {
+  const base = retry?.baseDelayMs ?? 500;
+  const max = retry?.maxDelayMs ?? 8e3;
+  return Math.min(max, base * 2 ** attempt) * (0.5 + Math.random() / 2);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(done, ms);
+    signal?.addEventListener("abort", done, { once: true });
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    }
+  });
+}
+
+// src/internal/failure.ts
+function toApiError(endpoint2, request, response) {
+  const body = parseBody(response.text);
+  const args = [response.status, endpoint2.name, request.url, body, response.headers];
+  if (response.status === 429) return new ValorantRateLimitError(...args, parseRetryAfter(response.headers.get("retry-after")));
+  const needsToken = endpoint2.riotRequirements?.token === true;
+  const badClaims = typeof body === "object" && body !== null && body.errorCode === "BAD_CLAIMS";
+  if (needsToken && (response.status === 401 || response.status === 400 && badClaims)) return new ValorantAuthError(...args);
+  return new ValorantApiError(...args);
+}
+
+// src/internal/normalize.ts
+import { z as z20 } from "zod";
+var cache = /* @__PURE__ */ new WeakMap();
+var children = {
+  ZodObject: (def, map) => {
+    const shape = def["shape"]();
+    return { ...def, shape: () => Object.fromEntries(Object.entries(shape).map(([key, value]) => [key, map(value)])) };
+  },
+  ZodArray: (def, map) => ({ ...def, type: map(def["type"]) }),
+  ZodOptional: (def, map) => ({ ...def, innerType: map(def["innerType"]) }),
+  ZodNullable: (def, map) => ({ ...def, innerType: map(def["innerType"]) }),
+  ZodDefault: (def, map) => ({ ...def, innerType: map(def["innerType"]) }),
+  ZodCatch: (def, map) => ({ ...def, innerType: map(def["innerType"]) }),
+  ZodReadonly: (def, map) => ({ ...def, innerType: map(def["innerType"]) }),
+  ZodBranded: (def, map) => ({ ...def, type: map(def["type"]) }),
+  ZodEffects: (def, map) => ({ ...def, schema: map(def["schema"]) }),
+  ZodUnion: (def, map) => ({ ...def, options: def["options"].map(map) }),
+  ZodIntersection: (def, map) => ({ ...def, left: map(def["left"]), right: map(def["right"]) }),
+  ZodRecord: (def, map) => ({ ...def, keyType: map(def["keyType"]), valueType: map(def["valueType"]) }),
+  ZodTuple: (def, map) => ({ ...def, items: def["items"].map(map) }),
+  ZodDiscriminatedUnion: (def, map) => {
+    const optionsMap = new Map([...def["optionsMap"]].map(([key, option]) => [key, map(option)]));
+    return { ...def, options: [...optionsMap.values()], optionsMap };
+  }
+};
+function lenientPc(literal) {
+  return z20.preprocess((value) => typeof value === "string" ? value.toUpperCase() : value, literal);
+}
+function normalizePlatformLiterals(schema) {
+  const known = cache.get(schema);
+  if (known) return known;
+  const def = schema._def;
+  let result = schema;
+  if (def.typeName === "ZodLiteral" && def["value"] === "PC") {
+    result = lenientPc(schema);
+  } else if (def.typeName === "ZodLazy") {
+    const getter = def["getter"];
+    result = new schema.constructor({ ...def, getter: () => normalizePlatformLiterals(getter()) });
+  } else if (def.typeName && children[def.typeName]) {
+    const Type = schema.constructor;
+    result = new Type(children[def.typeName](def, normalizePlatformLiterals));
+  }
+  cache.set(schema, result);
+  return result;
+}
+
+// src/lobby/mappings.ts
+var CustomGameTeam = {
+  Defenders: "TeamOne",
+  Attackers: "TeamTwo",
+  Spectators: "TeamSpectate",
+  DefenderCoaches: "TeamOneCoaches",
+  AttackerCoaches: "TeamTwoCoaches"
+};
+var MEMBERSHIP_KEY = {
+  TeamOne: "teamOne",
+  TeamTwo: "teamTwo",
+  TeamSpectate: "teamSpectate",
+  TeamOneCoaches: "teamOneCoaches",
+  TeamTwoCoaches: "teamTwoCoaches"
+};
+var CustomGameMap = {
+  Ascent: "/Game/Maps/Ascent/Ascent",
+  Split: "/Game/Maps/Bonsai/Bonsai",
+  Fracture: "/Game/Maps/Canyon/Canyon",
+  Bind: "/Game/Maps/Duality/Duality",
+  Breeze: "/Game/Maps/Foxtrot/Foxtrot",
+  Abyss: "/Game/Maps/Infinity/Infinity",
+  Lotus: "/Game/Maps/Jam/Jam",
+  Sunset: "/Game/Maps/Juliett/Juliett",
+  Pearl: "/Game/Maps/Pitt/Pitt",
+  Summit: "/Game/Maps/Plummet/Plummet",
+  Icebox: "/Game/Maps/Port/Port",
+  Corrode: "/Game/Maps/Rook/Rook",
+  Haven: "/Game/Maps/Triad/Triad"
+};
+var CustomGameMode = {
+  Standard: "/Game/GameModes/Bomb/BombGameMode.BombGameMode_C",
+  SpikeRush: "/Game/GameModes/QuickBomb/QuickBombGameMode.QuickBombGameMode_C",
+  Deathmatch: "/Game/GameModes/Deathmatch/DeathmatchGameMode.DeathmatchGameMode_C",
+  Escalation: "/Game/GameModes/GunGame/GunGameTeamsGameMode.GunGameTeamsGameMode_C",
+  Skirmish: "/Game/GameModes/Skirmish/SkirmishGameMode.SkirmishGameMode_C"
+};
+var RULE_KEY = {
+  allowGameModifiers: "AllowGameModifiers",
+  playOutAllRounds: "PlayOutAllRounds",
+  skipMatchHistory: "SkipMatchHistory",
+  tournamentMode: "TournamentMode",
+  overtimeWinByTwo: "IsOvertimeWinByTwo"
+};
+function reverse(table) {
+  return new Map(Object.entries(table).map(([name, value]) => [value, name]));
+}
+var mapNames = reverse(CustomGameMap);
+var modeNames = reverse(CustomGameMode);
+function customGameMapName(path) {
+  return mapNames.get(path);
+}
+function customGameModeName(path) {
+  return modeNames.get(path);
+}
+function teamOfPlayer(membership, puuid) {
+  for (const team of Object.values(CustomGameTeam)) {
+    if (membership[MEMBERSHIP_KEY[team]]?.some((member) => member.Subject === puuid)) return team;
+  }
+  return void 0;
+}
+
+// src/lobby/flows.ts
+var DEFAULT_RULES = {
+  AllowGameModifiers: "false",
+  PlayOutAllRounds: "false",
+  SkipMatchHistory: "false",
+  TournamentMode: "false",
+  IsOvertimeWinByTwo: "false"
+};
+function ruleStrings(rules) {
+  const out = {};
+  for (const [name, key] of Object.entries(RULE_KEY)) {
+    const value = rules?.[name];
+    if (value !== void 0) out[key] = value ? "true" : "false";
+  }
+  return out;
+}
+function currentRules(gameRules) {
+  const out = {};
+  for (const key of Object.keys(DEFAULT_RULES)) {
+    const value = gameRules?.[key];
+    if (value === "true" || value === "false") out[key] = value;
+  }
+  return out;
+}
+function createPartyFlows(client) {
+  async function partyIdOf(target) {
+    if (target.partyId !== void 0) return target.partyId;
+    return (await client.party.player({ validation: "off" })).CurrentPartyID;
+  }
+  return {
+    async assignToTeam(team, options = {}) {
+      const partyId = await partyIdOf(options);
+      const puuid = options.puuid ?? client.context.require("puuid");
+      return client.party.setCustomGameTeam({ params: { partyId, team }, body: { playerToPutOnTeam: puuid } });
+    },
+    async configureLobby(options) {
+      const partyId = await partyIdOf(options);
+      const { Settings: current } = (await client.party.getCustomGame({ params: { partyId }, validation: "off" })).CustomGameData;
+      await client.party.setCustomGameSettings({
+        params: { partyId },
+        validation: "off",
+        body: {
+          Map: options.map ?? current.Map,
+          Mode: options.mode ?? current.Mode,
+          UseBots: current.UseBots,
+          GamePod: options.gamePod ?? current.GamePod,
+          GameRules: { ...DEFAULT_RULES, ...currentRules(current.GameRules), ...ruleStrings(options.rules) }
+        }
+      });
+      return (await client.party.getCustomGame({ params: { partyId } })).CustomGameData.Settings;
+    }
+  };
+}
+
+// src/internal/gamelog.ts
+var VERSION_LINE = /CI server version: (release-[\w.]+-shipping-\d+-\d+)/;
+async function readInstalledClientVersion(logPath) {
+  const { readFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const file = logPath ?? join(process.env["LOCALAPPDATA"] ?? "", "VALORANT", "Saved", "Logs", "ShooterGame.log");
+  try {
+    return VERSION_LINE.exec(await readFile(file, "latin1"))?.[1];
+  } catch {
+    return void 0;
+  }
+}
+
 // src/local.ts
 function parseLockfile(content) {
   const [name, pid, port, password, protocol] = content.trim().split(":");
@@ -1112,7 +3012,6 @@ function createLocalFlows(client) {
       const sessions = await client.local.sessions();
       const valorant = Object.values(sessions).find((session) => session.productId === "valorant");
       if (valorant) {
-        ctx.set("clientVersion", valorant.version);
         const region = launchArgument(valorant.launchConfiguration.arguments, "ares-deployment");
         if (region !== void 0 && isRegion(region)) ctx.update({ region, shard: shardForRegion(region) });
       }
@@ -1121,9 +3020,9 @@ function createLocalFlows(client) {
         const affinity = Object.values(info.affinity ?? {}).find(isRegion);
         if (affinity !== void 0) ctx.applyAffinity(affinity);
       }
-      if (!ctx.has("clientVersion") && options?.fetchClientVersion !== false) {
-        await client.auth.fetchClientVersion().catch(() => void 0);
-      }
+      const installed = await readInstalledClientVersion(options?.gameLogPath);
+      if (installed !== void 0) ctx.set("clientVersion", installed);
+      else if (options?.fetchClientVersion !== false) await client.auth.fetchClientVersion().catch(() => void 0);
     },
     async events() {
       return openEventStream(ctx);
@@ -1142,7 +3041,7 @@ async function openEventStream(ctx) {
     throw new ValorantError('The local event stream needs the optional "ws" package: npm install ws', { cause });
   }
   const socket = new WebSocket(`wss://127.0.0.1:${ctx.require("localPort")}`, {
-    headers: { Authorization: `Basic ${btoa(`riot:${ctx.require("localPassword")}`)}` },
+    headers: { Authorization: basicAuth("riot", ctx.require("localPassword")) },
     rejectUnauthorized: false
   });
   const listeners = /* @__PURE__ */ new Set();
@@ -1168,6 +3067,18 @@ async function openEventStream(ctx) {
   };
 }
 
+// src/pregame/flows.ts
+function createPregameFlows(client) {
+  return {
+    async pickAgent(agent, options = {}) {
+      const preGameMatchId = options.matchId ?? (await client.pregame.player({ validation: "off" })).MatchID;
+      const params = { preGameMatchId, agentId: agent };
+      const selected = await client.pregame.selectCharacter({ params });
+      return options.lock ? client.pregame.lockCharacter({ params }) : selected;
+    }
+  };
+}
+
 // src/request.ts
 import { typeToPrefix } from "valorant-api-types";
 
@@ -1221,7 +3132,7 @@ function resolveHeaders(endpoint2, input, ctx, url) {
   const userAgent = ctx.get("userAgent");
   if (userAgent) headers["User-Agent"] = userAgent;
   if (need.token) headers["Authorization"] = `Bearer ${ctx.require("accessToken")}`;
-  if (need.localAuth) headers["Authorization"] = `Basic ${btoa(`riot:${ctx.require("localPassword")}`)}`;
+  if (need.localAuth) headers["Authorization"] = basicAuth("riot", ctx.require("localPassword"));
   if (need.entitlement) headers["X-Riot-Entitlements-JWT"] = ctx.require("entitlementToken");
   if (need.clientVersion) headers["X-Riot-ClientVersion"] = ctx.require("clientVersion");
   if (need.clientPlatform) headers["X-Riot-ClientPlatform"] = ctx.require("clientPlatform");
@@ -1250,8 +3161,6 @@ function buildRequest(endpoint2, input, ctx) {
 }
 
 // src/client.ts
-var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
-var IDEMPOTENT = /* @__PURE__ */ new Set(["GET", "HEAD", "PUT", "DELETE"]);
 var ValorantClient = class {
   context;
   #options;
@@ -1267,7 +3176,7 @@ var ValorantClient = class {
     const input = options;
     const validation = input.validation ?? this.#options.validation ?? "loose";
     if (validation === "strict" && endpoint2.body !== void 0 && input.body !== void 0) {
-      const parsed = endpoint2.body.safeParse(input.body);
+      const parsed = normalizePlatformLiterals(endpoint2.body).safeParse(input.body);
       if (!parsed.success) throw new ValorantValidationError("request", endpoint2.name, parsed.error, input.body);
     }
     const retry = this.#options.retry === false ? void 0 : this.#options.retry ?? {};
@@ -1280,13 +3189,13 @@ var ValorantClient = class {
       try {
         response = await this.#transportFor(endpoint2)({ ...request, signal: this.#signal(input) });
       } catch (cause) {
-        if (canRetry && IDEMPOTENT.has(request.method) && input.signal?.aborted !== true) {
+        if (canRetry && isIdempotent(request.method) && input.signal?.aborted !== true) {
           await sleep(backoff(attempt, retry), input.signal);
           continue;
         }
         throw new ValorantNetworkError(`${endpoint2.name} could not reach ${new URL(request.url).host}`, request.url, { cause });
       }
-      if (isAuthHost(request.url)) this.#storeCookies(response.setCookies);
+      if (isAuthHost(request.url)) storeCookies(this.context, response.setCookies);
       this.#options.logger?.debug?.(`${request.method} ${request.url} -> ${response.status}`);
       if (response.status < 400) {
         return {
@@ -1295,13 +3204,13 @@ var ValorantClient = class {
           data: this.#parseResponse(endpoint2, response, validation)
         };
       }
-      const error = this.#toError(endpoint2, request, response);
+      const error = toApiError(endpoint2, request, response);
       if (error instanceof ValorantAuthError && this.#options.refreshTokens && !refreshed) {
         refreshed = true;
         await this.#refreshOnce();
         continue;
       }
-      if (canRetry && RETRYABLE_STATUS.has(response.status) && (response.status === 429 || IDEMPOTENT.has(request.method))) {
+      if (canRetry && isRetryableStatus(response.status, request.method)) {
         const retryAfter = error instanceof ValorantRateLimitError ? error.retryAfterMs : void 0;
         await sleep(retryAfter ?? backoff(attempt, retry), input.signal);
         continue;
@@ -1319,6 +3228,8 @@ var ValorantClient = class {
     }
     Object.assign(api["auth"], createAuthFlows(this));
     Object.assign(api["local"], createLocalFlows(this));
+    Object.assign(api["party"], createPartyFlows(this));
+    Object.assign(api["pregame"], createPregameFlows(this));
     return api;
   }
   #transportFor(endpoint2) {
@@ -1333,20 +3244,10 @@ var ValorantClient = class {
     const timeout = AbortSignal.timeout(input.timeoutMs ?? this.#options.timeoutMs ?? 15e3);
     return input.signal ? AbortSignal.any([input.signal, timeout]) : timeout;
   }
-  #storeCookies(setCookies) {
-    for (const line of setCookies) {
-      const [pair = "", ...attributes] = line.split(";").map((part) => part.trim());
-      const separator = pair.indexOf("=");
-      if (separator <= 0) continue;
-      const name = pair.slice(0, separator);
-      const value = pair.slice(separator + 1);
-      const expired = value === "" || attributes.some((a) => a.toLowerCase() === "max-age=0");
-      this.context.setCookie(name, expired ? void 0 : value);
-    }
-  }
   #parseResponse(endpoint2, response, validation) {
     const data = unwrapEnvelope(endpoint2, parseBody(response.text));
-    const schema = endpoint2.responses?.[String(response.status)];
+    const published = endpoint2.responses?.[String(response.status)];
+    const schema = published && normalizePlatformLiterals(published);
     if (schema === void 0 || validation === "off") return data;
     const parsed = safeParse(schema, data);
     if (parsed.success) return parsed.data;
@@ -1357,15 +3258,6 @@ var ValorantClient = class {
     }
     return data;
   }
-  #toError(endpoint2, request, response) {
-    const body = parseBody(response.text);
-    const args = [response.status, endpoint2.name, request.url, body, response.headers];
-    if (response.status === 429) return new ValorantRateLimitError(...args, parseRetryAfter(response.headers.get("retry-after")));
-    const needsToken = endpoint2.riotRequirements?.token === true;
-    const badClaims = typeof body === "object" && body !== null && body.errorCode === "BAD_CLAIMS";
-    if (needsToken && (response.status === 401 || response.status === 400 && badClaims)) return new ValorantAuthError(...args);
-    return new ValorantApiError(...args);
-  }
   #refreshOnce() {
     this.#refreshing ??= Promise.resolve(this.#options.refreshTokens(this)).finally(() => {
       this.#refreshing = void 0;
@@ -1373,50 +3265,53 @@ var ValorantClient = class {
     return this.#refreshing;
   }
 };
-function safeParse(schema, data) {
-  try {
-    return schema.safeParse(data);
-  } catch (thrown) {
-    if (thrown instanceof ZodError) return { success: false, error: thrown };
-    const message = thrown instanceof Error ? thrown.message : String(thrown);
-    return { success: false, error: new ZodError([{ code: "custom", path: [], message: `Schema transform threw: ${message}` }]) };
-  }
-}
-function parseBody(text2) {
-  if (text2 === "") return void 0;
-  try {
-    return JSON.parse(text2);
-  } catch {
-    return text2;
-  }
-}
-function parseRetryAfter(value) {
-  if (value === null) return void 0;
-  const seconds = Number(value);
-  if (Number.isFinite(seconds)) return seconds * 1e3;
-  const date = Date.parse(value);
-  return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
-}
-function backoff(attempt, retry) {
-  const base = retry?.baseDelayMs ?? 500;
-  const max = retry?.maxDelayMs ?? 8e3;
-  return Math.min(max, base * 2 ** attempt) * (0.5 + Math.random() / 2);
-}
-function sleep(ms, signal) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(done, ms);
-    signal?.addEventListener("abort", done, { once: true });
-    function done() {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", done);
-      resolve();
-    }
-  });
+
+// src/pregame/agents.ts
+var Agent = {
+  Astra: "41fb69c1-4189-7b37-f117-bcaf1e96f1bf",
+  Breach: "5f8d3a7f-467b-97f3-062c-13acf203c006",
+  Brimstone: "9f0d8ba9-4140-b941-57d3-a7ad57c6b417",
+  Chamber: "22697a3d-45bf-8dd7-4fec-84a9e28c69d7",
+  Clove: "1dbf2edd-4729-0984-3115-daa5eed44993",
+  Cypher: "117ed9e3-49f3-6512-3ccf-0cada7e3823b",
+  Deadlock: "cc8b64c8-4b25-4ff9-6e7f-37b4da43d235",
+  Fade: "dade69b4-4f5a-8528-247b-219e5a1facd6",
+  Gekko: "e370fa57-4757-3604-3648-499e1f642d3f",
+  Harbor: "95b78ed7-4637-86d9-7e41-71ba8c293152",
+  Hush: "ddd5a15c-4fbe-42fa-3789-11a55ca5ee04",
+  Iso: "0e38b510-41a8-5780-5e8f-568b2a4f2d6c",
+  Jett: "add6443a-41bd-e414-f6ad-e58d267f4e95",
+  KayO: "601dbbe7-43ce-be57-2a40-4abd24953621",
+  Killjoy: "1e58de9c-4950-5125-93e9-a0aee9f98746",
+  Miks: "7c8a4701-4de6-9355-b254-e09bc2a34b72",
+  Neon: "bb2a4828-46eb-8cd1-e765-15848195d751",
+  Omen: "8e253930-4c05-31dd-1b6c-968525494517",
+  Phoenix: "eb93336a-449b-9c1b-0a54-a891f7921d69",
+  Raze: "f94c3b30-42be-e959-889c-5aa313dba261",
+  Reyna: "a3bfb853-43b2-7238-a4f1-ad90e9e46bcc",
+  Sage: "569fdd95-4d10-43ab-ca70-79becc718b46",
+  Skye: "6f2a04ca-43e0-be17-7f36-b3908627744d",
+  Sova: "320b2a48-4d9b-a075-30f1-1f93a9b638fa",
+  Tejo: "b444168c-4e35-8076-db47-ef9bf368f384",
+  Veto: "92eeef5d-43b5-1d4a-8d03-b3927a09034b",
+  Viper: "707eab51-4836-f488-046a-cda6bf494859",
+  Vyse: "efba5359-4016-a1e5-7626-b1ae76895940",
+  Waylay: "df1cb487-4902-002e-5c17-d28e83e78588",
+  Yoru: "7f94d92c-4234-0a36-9646-3a87eb8b5c89"
+};
+var names = new Map(Object.entries(Agent).map(([name, id]) => [id, name]));
+function agentName(id) {
+  return names.get(id);
 }
 
 // src/index.ts
 export * from "valorant-api-types";
 export {
+  Agent,
+  CustomGameMap,
+  CustomGameMode,
+  CustomGameTeam,
+  MEMBERSHIP_KEY,
   MissingContextError,
   MissingParameterError,
   ValorantApiError,
@@ -1427,6 +3322,9 @@ export {
   ValorantNetworkError,
   ValorantRateLimitError,
   ValorantValidationError,
+  agentName,
+  customGameMapName,
+  customGameModeName,
   fetchTransport,
   isRegion,
   localTransport,
@@ -1434,6 +3332,7 @@ export {
   parseLockfile,
   readLockfile,
   registry,
-  shardForRegion
+  shardForRegion,
+  teamOfPlayer
 };
 //# sourceMappingURL=index.js.map