@voxary/valorant-client 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -31,6 +31,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Agent: () => Agent,
+  CustomGameMap: () => CustomGameMap,
+  CustomGameMode: () => CustomGameMode,
+  CustomGameTeam: () => CustomGameTeam,
+  MEMBERSHIP_KEY: () => MEMBERSHIP_KEY,
   MissingContextError: () => MissingContextError,
   MissingParameterError: () => MissingParameterError,
   ValorantApiError: () => ValorantApiError,
@@ -41,6 +46,9 @@ __export(index_exports, {
   ValorantNetworkError: () => ValorantNetworkError,
   ValorantRateLimitError: () => ValorantRateLimitError,
   ValorantValidationError: () => ValorantValidationError,
+  agentName: () => agentName,
+  customGameMapName: () => customGameMapName,
+  customGameModeName: () => customGameModeName,
   fetchTransport: () => fetchTransport,
   isRegion: () => isRegion,
   localTransport: () => localTransport,
@@ -48,18 +56,25 @@ __export(index_exports, {
   parseLockfile: () => parseLockfile,
   readLockfile: () => readLockfile,
   registry: () => registry,
-  shardForRegion: () => shardForRegion
+  shardForRegion: () => shardForRegion,
+  teamOfPlayer: () => teamOfPlayer
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/api/groups/pvp.ts
-var import_valorant_api_types = require("valorant-api-types");
+var import_valorant_api_types10 = require("valorant-api-types");
 
 // src/endpoints/riot/account.ts
 var import_zod = require("zod");
 
 // 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 onSharedHost(endpoint2) {
+  return { ...endpoint2, type: "shared" };
+}
 
 // src/endpoints/riot/account.ts
 var dailyTicketEndpoint = {
@@ -342,8 +357,105 @@ var bloomlinePlayerEndpoint = {
   }) }
 };
 
-// src/endpoints/riot/chat.ts
+// src/endpoints/riot/agentSelect.ts
+var import_valorant_api_types = require("valorant-api-types");
 var import_zod2 = require("zod");
+var agentSelect = import_zod2.z.object({
+  ID: import_zod2.z.string(),
+  Version: import_zod2.z.number(),
+  Teams: import_zod2.z.array(import_zod2.z.object({
+    TeamID: import_zod2.z.string(),
+    TeamNumber: import_zod2.z.number(),
+    Players: import_zod2.z.array(import_zod2.z.object({
+      Subject: import_zod2.z.string(),
+      CharacterID: import_zod2.z.string(),
+      CharacterSelectionState: import_zod2.z.string(),
+      PregamePlayerState: import_zod2.z.string(),
+      CompetitiveTier: import_zod2.z.number(),
+      PlayerIdentity: import_zod2.z.object({
+        Subject: import_zod2.z.string(),
+        PlayerCardID: import_zod2.z.string(),
+        PlayerTitleID: import_zod2.z.string(),
+        AccountLevel: import_zod2.z.number(),
+        PreferredLevelBorderID: import_zod2.z.string(),
+        Incognito: import_zod2.z.boolean(),
+        HideAccountLevel: import_zod2.z.boolean()
+      }),
+      SeasonalBadgeInfo: import_zod2.z.object({
+        SeasonID: import_zod2.z.string(),
+        NumberOfWins: import_zod2.z.number(),
+        Rank: import_zod2.z.number(),
+        LeaderboardRank: import_zod2.z.number()
+      }),
+      IsCaptain: import_zod2.z.boolean(),
+      PlatformType: import_zod2.z.string(),
+      PremierPrestige: import_zod2.z.object({})
+    }))
+  })),
+  AllyTeam: import_zod2.z.object({
+    TeamID: import_zod2.z.string(),
+    TeamNumber: import_zod2.z.number(),
+    Players: import_zod2.z.array(import_zod2.z.object({
+      Subject: import_zod2.z.string(),
+      CharacterID: import_zod2.z.string(),
+      CharacterSelectionState: import_zod2.z.string(),
+      PregamePlayerState: import_zod2.z.string(),
+      CompetitiveTier: import_zod2.z.number(),
+      PlayerIdentity: import_zod2.z.object({
+        Subject: import_zod2.z.string(),
+        PlayerCardID: import_zod2.z.string(),
+        PlayerTitleID: import_zod2.z.string(),
+        AccountLevel: import_zod2.z.number(),
+        PreferredLevelBorderID: import_zod2.z.string(),
+        Incognito: import_zod2.z.boolean(),
+        HideAccountLevel: import_zod2.z.boolean()
+      }),
+      SeasonalBadgeInfo: import_zod2.z.object({
+        SeasonID: import_zod2.z.string(),
+        NumberOfWins: import_zod2.z.number(),
+        Rank: import_zod2.z.number(),
+        LeaderboardRank: import_zod2.z.number()
+      }),
+      IsCaptain: import_zod2.z.boolean(),
+      PlatformType: import_zod2.z.string(),
+      PremierPrestige: import_zod2.z.object({})
+    }))
+  }),
+  EnemyTeamSize: import_zod2.z.number(),
+  EnemyTeamLockCount: import_zod2.z.number(),
+  PregameState: import_zod2.z.string(),
+  LastUpdated: import_zod2.z.string(),
+  MapID: import_zod2.z.string(),
+  CastedVotes: import_zod2.z.object({}),
+  MapSelectStep: import_zod2.z.number(),
+  Team1: import_zod2.z.string(),
+  GamePodID: import_zod2.z.string(),
+  Mode: import_zod2.z.string(),
+  VoiceSessionID: import_zod2.z.string(),
+  MUCName: import_zod2.z.string(),
+  TeamMatchToken: import_zod2.z.string(),
+  QueueID: import_zod2.z.string(),
+  ProvisioningFlowID: import_zod2.z.string(),
+  IsRanked: import_zod2.z.boolean(),
+  PhaseTimeRemainingNS: import_zod2.z.number(),
+  StepTimeRemainingNS: import_zod2.z.number(),
+  altModesFlagADA: import_zod2.z.boolean(),
+  GameRules: import_zod2.z.object({
+    AccoladesEnabled: import_zod2.z.string(),
+    AllowGameModifiers: import_zod2.z.string(),
+    IsOvertimeWinByTwo: import_zod2.z.string(),
+    PlayOutAllRounds: import_zod2.z.string(),
+    ReplayRecordMatch: import_zod2.z.string(),
+    SkipMatchHistory: import_zod2.z.string(),
+    TournamentMode: import_zod2.z.string()
+  })
+});
+var selectCharacterEndpoint = withResponse(import_valorant_api_types.endpoints.selectCharacterEndpoint, agentSelect);
+var lockCharacterEndpoint = withResponse(import_valorant_api_types.endpoints.lockCharacterEndpoint, agentSelect);
+
+// src/endpoints/riot/chat.ts
+var import_valorant_api_types2 = require("valorant-api-types");
+var import_zod3 = require("zod");
 var chatSettingsEndpoint = {
   name: "Settings",
   description: "Get chat settings",
@@ -351,37 +463,37 @@ var chatSettingsEndpoint = {
   type: "local",
   suffix: "chat/v1/settings",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod2.z.object({
-    bounceDockIconEnabled: import_zod2.z.boolean(),
-    "chat-status-message": import_zod2.z.string(),
-    chatFilterDisabled: import_zod2.z.boolean(),
-    chatGBG: import_zod2.z.boolean(),
-    chatGroupDiscord: import_zod2.z.boolean(),
-    chatGroupMobile: import_zod2.z.boolean(),
-    chatGroupOffline: import_zod2.z.boolean(),
-    chatWindow: import_zod2.z.object({
-      detached: import_zod2.z.boolean(),
-      height: import_zod2.z.number(),
-      left: import_zod2.z.number(),
-      top: import_zod2.z.number(),
-      width: import_zod2.z.number()
+  responses: { "200": import_zod3.z.object({
+    bounceDockIconEnabled: import_zod3.z.boolean(),
+    "chat-status-message": import_zod3.z.string(),
+    chatFilterDisabled: import_zod3.z.boolean(),
+    chatGBG: import_zod3.z.boolean(),
+    chatGroupDiscord: import_zod3.z.boolean(),
+    chatGroupMobile: import_zod3.z.boolean(),
+    chatGroupOffline: import_zod3.z.boolean(),
+    chatWindow: import_zod3.z.object({
+      detached: import_zod3.z.boolean(),
+      height: import_zod3.z.number(),
+      left: import_zod3.z.number(),
+      top: import_zod3.z.number(),
+      width: import_zod3.z.number()
     }),
-    chatWindowDockedHeight: import_zod2.z.number(),
-    "closed-conversations": import_zod2.z.object({
-      "ff822fdf-71a3-54ac-814e-7ac752ba428d@eu1.pvp.net": import_zod2.z.number()
+    chatWindowDockedHeight: import_zod3.z.number(),
+    "closed-conversations": import_zod3.z.object({
+      "ff822fdf-71a3-54ac-814e-7ac752ba428d@eu1.pvp.net": import_zod3.z.number()
     }),
-    friendRequestToastsDisabled: import_zod2.z.boolean(),
-    "hidden-conversations": import_zod2.z.object({}),
-    linkClickWarningEnabled: import_zod2.z.boolean(),
-    messageNotificationsEnabled: import_zod2.z.boolean(),
-    moreUnreadsEnabled: import_zod2.z.boolean(),
-    "muted-conversations": import_zod2.z.object({}),
-    recentlyPlayedFirstOpen: import_zod2.z.boolean(),
-    recentlyPlayedOpen: import_zod2.z.boolean(),
-    "roster-group-collapsed": import_zod2.z.object({}),
-    showWhenTypingEnabled: import_zod2.z.boolean(),
-    sortBy: import_zod2.z.string(),
-    usePlayerPreferences: import_zod2.z.boolean()
+    friendRequestToastsDisabled: import_zod3.z.boolean(),
+    "hidden-conversations": import_zod3.z.object({}),
+    linkClickWarningEnabled: import_zod3.z.boolean(),
+    messageNotificationsEnabled: import_zod3.z.boolean(),
+    moreUnreadsEnabled: import_zod3.z.boolean(),
+    "muted-conversations": import_zod3.z.object({}),
+    recentlyPlayedFirstOpen: import_zod3.z.boolean(),
+    recentlyPlayedOpen: import_zod3.z.boolean(),
+    "roster-group-collapsed": import_zod3.z.object({}),
+    showWhenTypingEnabled: import_zod3.z.boolean(),
+    sortBy: import_zod3.z.string(),
+    usePlayerPreferences: import_zod3.z.boolean()
   }) }
 };
 var chatTournamentInfoEndpoint = {
@@ -391,11 +503,26 @@ var chatTournamentInfoEndpoint = {
   type: "local",
   suffix: "chat/v6/conversations/ares-tournaments",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod2.z.object({}) }
-};
+  responses: { "200": import_zod3.z.object({}) }
+};
+var chatParticipantsEndpoint = withResponse(import_valorant_api_types2.endpoints.chatParticipantsEndpoint, import_zod3.z.object({
+  participants: import_zod3.z.array(import_zod3.z.object({
+    activePlatform: import_zod3.z.string().nullable(),
+    cid: import_zod3.z.string(),
+    game_name: import_zod3.z.string(),
+    game_tag: import_zod3.z.string(),
+    isInteractionAllowed: import_zod3.z.boolean(),
+    muted: import_zod3.z.boolean(),
+    name: import_zod3.z.string(),
+    pid: import_zod3.z.string(),
+    puuid: import_zod3.z.string(),
+    region: import_zod3.z.string()
+  }))
+}));
 
 // src/endpoints/riot/contracts.ts
-var import_zod3 = require("zod");
+var import_valorant_api_types3 = require("valorant-api-types");
+var import_zod4 = require("zod");
 var activeRecruitmentEventEndpoint = {
   name: "Active Recruitment Event",
   description: "The current agent recruitment event.",
@@ -403,29 +530,90 @@ var activeRecruitmentEventEndpoint = {
   type: "pd",
   suffix: "contracts/v1/agents/activeRecruitmentEvent",
   riotRequirements: player,
-  responses: { "200": import_zod3.z.object({
-    AgentID: import_zod3.z.string(),
-    CounterID: import_zod3.z.string(),
-    MilestoneThreshold: import_zod3.z.number(),
-    StartDate: import_zod3.z.string(),
-    EndDate: import_zod3.z.string(),
-    IsActive: import_zod3.z.boolean(),
-    includedPlatforms: import_zod3.z.object({
-      console: import_zod3.z.object({
-        developmentOnly: import_zod3.z.boolean()
+  responses: { "200": import_zod4.z.object({
+    AgentID: import_zod4.z.string(),
+    CounterID: import_zod4.z.string(),
+    MilestoneThreshold: import_zod4.z.number(),
+    StartDate: import_zod4.z.string(),
+    EndDate: import_zod4.z.string(),
+    IsActive: import_zod4.z.boolean(),
+    includedPlatforms: import_zod4.z.object({
+      console: import_zod4.z.object({
+        developmentOnly: import_zod4.z.boolean()
       }),
-      mobile: import_zod3.z.object({
-        developmentOnly: import_zod3.z.boolean()
+      mobile: import_zod4.z.object({
+        developmentOnly: import_zod4.z.boolean()
       }),
-      pc: import_zod3.z.object({
-        developmentOnly: import_zod3.z.boolean()
+      pc: import_zod4.z.object({
+        developmentOnly: import_zod4.z.boolean()
       })
     })
   }) }
 };
+var contractsEndpoint = withResponse(import_valorant_api_types3.endpoints.contractsEndpoint, import_zod4.z.object({
+  Version: import_zod4.z.number(),
+  Subject: import_zod4.z.string(),
+  Contracts: import_zod4.z.array(import_zod4.z.object({
+    ContractDefinitionID: import_zod4.z.string(),
+    ContractProgression: import_zod4.z.object({
+      Version: import_zod4.z.number(),
+      TotalProgressionEarned: import_zod4.z.number()
+    }),
+    ProgressionLevelReached: import_zod4.z.number(),
+    ProgressionTowardsNextLevel: import_zod4.z.number()
+  })),
+  ActiveRecruitmentEventProgress: import_zod4.z.object({
+    AgentID: import_zod4.z.string(),
+    Version: import_zod4.z.number(),
+    CounterID: import_zod4.z.string(),
+    ProgressionEarned: import_zod4.z.number()
+  }),
+  Missions: import_zod4.z.array(import_zod4.z.object({
+    ID: import_zod4.z.string(),
+    Objectives: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.number()),
+    Complete: import_zod4.z.boolean(),
+    ExpirationTime: import_zod4.z.string()
+  })),
+  MissionMetadata: import_zod4.z.object({
+    WeeklyCheckpoint: import_zod4.z.string(),
+    WeeklyRefillTime: import_zod4.z.string()
+  }),
+  BTEMilestone: import_zod4.z.number()
+}));
+
+// src/endpoints/riot/currentGame.ts
+var import_valorant_api_types4 = require("valorant-api-types");
+var import_zod5 = require("zod");
+var currentGameLoadoutsEndpoint = withResponse(import_valorant_api_types4.endpoints.currentGameLoadoutsEndpoint, import_zod5.z.object({
+  Loadouts: import_zod5.z.array(import_zod5.z.object({
+    CharacterID: import_zod5.z.string(),
+    Loadout: import_zod5.z.object({
+      Subject: import_zod5.z.string(),
+      Expressions: import_zod5.z.object({
+        AESSelections: import_zod5.z.array(import_zod5.z.object({
+          AssetID: import_zod5.z.string(),
+          TypeID: import_zod5.z.string()
+        }))
+      }),
+      DynamicOptions: import_zod5.z.object({}),
+      Items: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.object({
+        ID: import_zod5.z.string(),
+        TypeID: import_zod5.z.string(),
+        Sockets: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.object({
+          ID: import_zod5.z.string(),
+          Item: import_zod5.z.object({
+            ID: import_zod5.z.string(),
+            TypeID: import_zod5.z.string()
+          })
+        }))
+      }))
+    }),
+    Subject: import_zod5.z.string()
+  }))
+}));
 
 // src/endpoints/riot/esports.ts
-var import_zod4 = require("zod");
+var import_zod6 = require("zod");
 var esportsLiveEventTimesEndpoint = {
   name: "Esports Live Event Times",
   description: "Live and upcoming esports matches, pick blocks and tournaments.",
@@ -433,11 +621,11 @@ var esportsLiveEventTimesEndpoint = {
   type: "pd",
   suffix: "esports-service/v2/liveEventTimes",
   riotRequirements: player,
-  responses: { "200": import_zod4.z.object({
-    Tournaments: import_zod4.z.array(import_zod4.z.object({
-      ID: import_zod4.z.string(),
-      StartTimeUTC: import_zod4.z.string(),
-      EndTimeUTC: import_zod4.z.string()
+  responses: { "200": import_zod6.z.object({
+    Tournaments: import_zod6.z.array(import_zod6.z.object({
+      ID: import_zod6.z.string(),
+      StartTimeUTC: import_zod6.z.string(),
+      EndTimeUTC: import_zod6.z.string()
     }))
   }) }
 };
@@ -448,7 +636,7 @@ var esportsUpcomingMatchesEndpoint = {
   type: "pd",
   suffix: "esports-service/v2/upcomingMatches",
   riotRequirements: player,
-  responses: { "200": import_zod4.z.object({}) }
+  responses: { "200": import_zod6.z.object({}) }
 };
 var esportsPickemLeaguesEndpoint = {
   name: "Esports Pickem Leagues",
@@ -457,67 +645,67 @@ var esportsPickemLeaguesEndpoint = {
   type: "pd",
   suffix: "esports-service/v1/pickem/leagues",
   riotRequirements: player,
-  responses: { "200": import_zod4.z.object({
-    PickemLeagues: import_zod4.z.array(import_zod4.z.object({
-      LeagueID: import_zod4.z.string(),
-      EldsLeagueID: import_zod4.z.string(),
-      Tournament: import_zod4.z.object({
-        ID: import_zod4.z.string(),
-        EldsTournamentID: import_zod4.z.string(),
-        LeagueID: import_zod4.z.string(),
-        PickBlocks: import_zod4.z.array(import_zod4.z.object({
-          ID: import_zod4.z.string(),
-          EldsTournamentID: import_zod4.z.string(),
-          Slug: import_zod4.z.object({
-            Slug: import_zod4.z.string()
+  responses: { "200": import_zod6.z.object({
+    PickemLeagues: import_zod6.z.array(import_zod6.z.object({
+      LeagueID: import_zod6.z.string(),
+      EldsLeagueID: import_zod6.z.string(),
+      Tournament: import_zod6.z.object({
+        ID: import_zod6.z.string(),
+        EldsTournamentID: import_zod6.z.string(),
+        LeagueID: import_zod6.z.string(),
+        PickBlocks: import_zod6.z.array(import_zod6.z.object({
+          ID: import_zod6.z.string(),
+          EldsTournamentID: import_zod6.z.string(),
+          Slug: import_zod6.z.object({
+            Slug: import_zod6.z.string()
           }),
-          PickOpenTime: import_zod4.z.string(),
-          PickCloseTime: import_zod4.z.string(),
-          State: import_zod4.z.string(),
-          OpenLevel: import_zod4.z.string(),
-          BlockType: import_zod4.z.string(),
-          PickBlockElements: import_zod4.z.array(import_zod4.z.object({
-            ID: import_zod4.z.string(),
-            PickBlockID: import_zod4.z.string(),
-            Section: import_zod4.z.object({
-              ID: import_zod4.z.string(),
-              EldsSectionID: import_zod4.z.string(),
-              CorrectPick: import_zod4.z.object({
-                Entries: import_zod4.z.array(import_zod4.z.object({
-                  Index: import_zod4.z.number(),
-                  Correctness: import_zod4.z.string(),
-                  ParticipantID: import_zod4.z.string(),
-                  Points: import_zod4.z.number(),
-                  Rank: import_zod4.z.number()
+          PickOpenTime: import_zod6.z.string(),
+          PickCloseTime: import_zod6.z.string(),
+          State: import_zod6.z.string(),
+          OpenLevel: import_zod6.z.string(),
+          BlockType: import_zod6.z.string(),
+          PickBlockElements: import_zod6.z.array(import_zod6.z.object({
+            ID: import_zod6.z.string(),
+            PickBlockID: import_zod6.z.string(),
+            Section: import_zod6.z.object({
+              ID: import_zod6.z.string(),
+              EldsSectionID: import_zod6.z.string(),
+              CorrectPick: import_zod6.z.object({
+                Entries: import_zod6.z.array(import_zod6.z.object({
+                  Index: import_zod6.z.number(),
+                  Correctness: import_zod6.z.string(),
+                  ParticipantID: import_zod6.z.string(),
+                  Points: import_zod6.z.number(),
+                  Rank: import_zod6.z.number()
                 })).nullable()
               })
             }),
-            Match: import_zod4.z.object({
-              ID: import_zod4.z.string(),
-              EldsMatchID: import_zod4.z.string(),
-              BaselinePoints: import_zod4.z.number(),
-              CorrectPick: import_zod4.z.string(),
-              ResultState: import_zod4.z.string()
+            Match: import_zod6.z.object({
+              ID: import_zod6.z.string(),
+              EldsMatchID: import_zod6.z.string(),
+              BaselinePoints: import_zod6.z.number(),
+              CorrectPick: import_zod6.z.string(),
+              ResultState: import_zod6.z.string()
             }),
-            PickOpenTime: import_zod4.z.string(),
-            PickCloseTime: import_zod4.z.string(),
-            State: import_zod4.z.string(),
-            DisplayOrder: import_zod4.z.number()
+            PickOpenTime: import_zod6.z.string(),
+            PickCloseTime: import_zod6.z.string(),
+            State: import_zod6.z.string(),
+            DisplayOrder: import_zod6.z.number()
           })),
-          CompletionStatus: import_zod4.z.string()
+          CompletionStatus: import_zod6.z.string()
         })),
-        Participants: import_zod4.z.array(import_zod4.z.object({
-          ID: import_zod4.z.string(),
-          EldsTeamID: import_zod4.z.string()
+        Participants: import_zod6.z.array(import_zod6.z.object({
+          ID: import_zod6.z.string(),
+          EldsTeamID: import_zod6.z.string()
         }))
       }),
-      Published: import_zod4.z.boolean()
+      Published: import_zod6.z.boolean()
     }))
   }) }
 };
 
 // src/endpoints/riot/local.ts
-var import_zod5 = require("zod");
+var import_zod7 = require("zod");
 var localLocaleEndpoint = {
   name: "Locale",
   description: "Get the current locale",
@@ -525,7 +713,7 @@ var localLocaleEndpoint = {
   type: "local",
   suffix: "riotclient/product-locales/products/valorant/patchlines/live",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod5.z.string() }
+  responses: { "200": import_zod7.z.string() }
 };
 var localAvailableLocalesEndpoint = {
   name: "Available Locales",
@@ -534,7 +722,7 @@ var localAvailableLocalesEndpoint = {
   type: "local",
   suffix: "rnet-product-registry/v4/available-product-locales/products/valorant/patchlines/live",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod5.z.array(import_zod5.z.string()) }
+  responses: { "200": import_zod7.z.array(import_zod7.z.string()) }
 };
 var localRiotStatusEndpoint = {
   name: "Riot Status",
@@ -543,7 +731,7 @@ var localRiotStatusEndpoint = {
   type: "local",
   suffix: "riot-status/v1/products/valorant/patchlines/live/deployments/{region}",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod5.z.string() }
+  responses: { "200": import_zod7.z.string() }
 };
 var localAccessTokenEndpoint = {
   name: "Access Token",
@@ -552,11 +740,11 @@ var localAccessTokenEndpoint = {
   type: "local",
   suffix: "rso-auth/v1/authorization/access-token",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod5.z.object({
-    clientId: import_zod5.z.string(),
-    expiry: import_zod5.z.number(),
-    scopes: import_zod5.z.array(import_zod5.z.string()),
-    token: import_zod5.z.string()
+  responses: { "200": import_zod7.z.object({
+    clientId: import_zod7.z.string(),
+    expiry: import_zod7.z.number(),
+    scopes: import_zod7.z.array(import_zod7.z.string()),
+    token: import_zod7.z.string()
   }) }
 };
 var localPluginStatusEndpoint = {
@@ -566,8 +754,8 @@ var localPluginStatusEndpoint = {
   type: "local",
   suffix: "plugin-manager/v1/status",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod5.z.object({
-    state: import_zod5.z.string()
+  responses: { "200": import_zod7.z.object({
+    state: import_zod7.z.string()
   }) }
 };
 var localRmsSessionEndpoint = {
@@ -577,10 +765,10 @@ var localRmsSessionEndpoint = {
   type: "local",
   suffix: "riot-messaging-service/v1/session",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod5.z.object({
-    state: import_zod5.z.string(),
-    token: import_zod5.z.string(),
-    tokenType: import_zod5.z.string()
+  responses: { "200": import_zod7.z.object({
+    state: import_zod7.z.string(),
+    token: import_zod7.z.string(),
+    tokenType: import_zod7.z.string()
   }) }
 };
 var localProcessInfoEndpoint = {
@@ -590,9 +778,9 @@ var localProcessInfoEndpoint = {
   type: "local",
   suffix: "process-control/v1/process",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod5.z.object({
-    pid: import_zod5.z.number(),
-    status: import_zod5.z.string()
+  responses: { "200": import_zod7.z.object({
+    pid: import_zod7.z.number(),
+    status: import_zod7.z.string()
   }) }
 };
 var localLogPathEndpoint = {
@@ -602,7 +790,7 @@ var localLogPathEndpoint = {
   type: "local",
   suffix: "product-session/v1/logs/path/VALORANT",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod5.z.string() }
+  responses: { "200": import_zod7.z.string() }
 };
 var localEulaEndpoint = {
   name: "Eula",
@@ -611,7 +799,7 @@ var localEulaEndpoint = {
   type: "local",
   suffix: "eula/v1/agreement/content",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod5.z.string() }
+  responses: { "200": import_zod7.z.string() }
 };
 var localPrivacyPolicyEndpoint = {
   name: "Privacy Policy",
@@ -620,11 +808,241 @@ var localPrivacyPolicyEndpoint = {
   type: "local",
   suffix: "eula/v1/privacy-policy/content",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod5.z.string() }
+  responses: { "200": import_zod7.z.string() }
 };
 
+// src/endpoints/riot/party.ts
+var import_valorant_api_types5 = require("valorant-api-types");
+var import_zod8 = require("zod");
+var customGameTeam = import_zod8.z.array(import_zod8.z.object({ Subject: import_zod8.z.string().describe("PUUID") }));
+var customGameParty = import_zod8.z.object({
+  ID: import_zod8.z.string(),
+  MUCName: import_zod8.z.string(),
+  VoiceRoomID: import_zod8.z.string(),
+  Version: import_zod8.z.number(),
+  ClientVersion: import_zod8.z.string(),
+  Members: import_zod8.z.array(import_zod8.z.object({
+    Subject: import_zod8.z.string(),
+    CompetitiveTier: import_zod8.z.number(),
+    PlayerIdentity: import_zod8.z.object({
+      Subject: import_zod8.z.string(),
+      PlayerCardID: import_zod8.z.string(),
+      PlayerTitleID: import_zod8.z.string(),
+      AccountLevel: import_zod8.z.number(),
+      PreferredLevelBorderID: import_zod8.z.string(),
+      Incognito: import_zod8.z.boolean(),
+      HideAccountLevel: import_zod8.z.boolean()
+    }),
+    IsOwner: import_zod8.z.boolean(),
+    QueueEligibleRemainingAccountLevels: import_zod8.z.number(),
+    Pings: import_zod8.z.array(import_zod8.z.object({
+      Ping: import_zod8.z.number(),
+      GamePodID: import_zod8.z.string()
+    })),
+    IsReady: import_zod8.z.boolean(),
+    IsModerator: import_zod8.z.boolean(),
+    UseBroadcastHUD: import_zod8.z.boolean(),
+    PlatformType: import_zod8.z.string(),
+    PremierPrestige: import_zod8.z.object({}),
+    JoinedAt: import_zod8.z.string()
+  })),
+  State: import_zod8.z.string(),
+  PreviousState: import_zod8.z.string(),
+  StateTransitionReason: import_zod8.z.string(),
+  Accessibility: import_zod8.z.string(),
+  CustomGameData: import_zod8.z.object({
+    Settings: import_zod8.z.object({
+      Map: import_zod8.z.string(),
+      Mode: import_zod8.z.string(),
+      UseBots: import_zod8.z.boolean(),
+      GamePod: import_zod8.z.string(),
+      GameRules: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).nullable(),
+      EsportsCustomLobbyName: import_zod8.z.string()
+    }),
+    Membership: import_zod8.z.object({
+      teamOne: customGameTeam,
+      teamTwo: customGameTeam,
+      teamSpectate: customGameTeam,
+      teamOneCoaches: customGameTeam,
+      teamTwoCoaches: customGameTeam
+    }),
+    MaxPartySize: import_zod8.z.number(),
+    AutobalanceEnabled: import_zod8.z.boolean(),
+    AutobalanceMinPlayers: import_zod8.z.number(),
+    HasRecoveryData: import_zod8.z.boolean()
+  }),
+  MatchmakingData: import_zod8.z.object({
+    QueueID: import_zod8.z.string(),
+    PreferredGamePods: import_zod8.z.array(import_zod8.z.string()),
+    SkillDisparityRRPenalty: import_zod8.z.number(),
+    MaxPartySize: import_zod8.z.number()
+  }),
+  QueueEntryTime: import_zod8.z.string(),
+  EstimatedQueueTimeSeconds: import_zod8.z.number(),
+  ErrorNotification: import_zod8.z.object({
+    ErrorType: import_zod8.z.string()
+  }).optional(),
+  RestrictedSeconds: import_zod8.z.number(),
+  EligibleQueues: import_zod8.z.array(import_zod8.z.string()),
+  CheatData: import_zod8.z.object({
+    GamePodOverride: import_zod8.z.string(),
+    ForcePostGameProcessing: import_zod8.z.boolean()
+  }),
+  InviteCode: import_zod8.z.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: import_zod8.z.object({ playerToPutOnTeam: import_zod8.z.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(import_valorant_api_types5.endpoints.partyGenerateCodeEndpoint, customGameParty);
+var partyDisableCodeEndpoint = withResponse(import_valorant_api_types5.endpoints.partyDisableCodeEndpoint, customGameParty);
+var setPartyAccessibilityEndpoint = withResponse(import_valorant_api_types5.endpoints.setPartyAccessibilityEndpoint, customGameParty);
+var startCustomGameEndpoint = withResponse(import_valorant_api_types5.endpoints.startCustomGameEndpoint, customGameParty);
+var setCustomGameSettingsEndpoint = withResponse(import_valorant_api_types5.endpoints.setCustomGameSettingsEndpoint, customGameParty);
+var partyEndpoint = withResponse(import_valorant_api_types5.endpoints.partyEndpoint, partyResponse);
+var changeQueueEndpoint = withResponse(import_valorant_api_types5.endpoints.changeQueueEndpoint, partyResponse);
+var enterMatchmakingQueueEndpoint = withResponse(import_valorant_api_types5.endpoints.enterMatchmakingQueueEndpoint, partyResponse);
+var leaveMatchmakingQueueEndpoint = withResponse(import_valorant_api_types5.endpoints.leaveMatchmakingQueueEndpoint, partyResponse);
+var partyDeclineEndpoint = withResponse(import_valorant_api_types5.endpoints.partyDeclineEndpoint, partyResponse);
+var partyInviteEndpoint = withResponse(import_valorant_api_types5.endpoints.partyInviteEndpoint, partyResponse);
+var partySetMemberReadyEndpoint = withResponse(import_valorant_api_types5.endpoints.partySetMemberReadyEndpoint, partyResponse);
+var refreshCompetitiveTierEndpoint = withResponse(import_valorant_api_types5.endpoints.refreshCompetitiveTierEndpoint, partyResponse);
+var refreshPlayerIdentityEndpoint = withResponse(import_valorant_api_types5.endpoints.refreshPlayerIdentityEndpoint, partyResponse);
+var refreshPingsEndpoint = withResponse(import_valorant_api_types5.endpoints.refreshPingsEndpoint, partyResponse);
+
+// src/endpoints/riot/pregame.ts
+var import_valorant_api_types6 = require("valorant-api-types");
+var import_zod9 = require("zod");
+var pregameMatchEndpoint = withResponse(import_valorant_api_types6.endpoints.pregameMatchEndpoint, import_zod9.z.object({
+  ID: import_zod9.z.string(),
+  Version: import_zod9.z.number(),
+  Teams: import_zod9.z.array(import_zod9.z.object({
+    TeamID: import_zod9.z.string(),
+    TeamNumber: import_zod9.z.number(),
+    Players: import_zod9.z.array(import_zod9.z.object({
+      Subject: import_zod9.z.string(),
+      CharacterID: import_zod9.z.string(),
+      CharacterSelectionState: import_zod9.z.string(),
+      PregamePlayerState: import_zod9.z.string(),
+      CompetitiveTier: import_zod9.z.number(),
+      PlayerIdentity: import_zod9.z.object({
+        Subject: import_zod9.z.string(),
+        PlayerCardID: import_zod9.z.string(),
+        PlayerTitleID: import_zod9.z.string(),
+        AccountLevel: import_zod9.z.number(),
+        PreferredLevelBorderID: import_zod9.z.string(),
+        Incognito: import_zod9.z.boolean(),
+        HideAccountLevel: import_zod9.z.boolean()
+      }),
+      SeasonalBadgeInfo: import_zod9.z.object({
+        SeasonID: import_zod9.z.string(),
+        NumberOfWins: import_zod9.z.number(),
+        Rank: import_zod9.z.number(),
+        LeaderboardRank: import_zod9.z.number()
+      }),
+      IsCaptain: import_zod9.z.boolean(),
+      PlatformType: import_zod9.z.string(),
+      PremierPrestige: import_zod9.z.object({})
+    }))
+  })),
+  AllyTeam: import_zod9.z.object({
+    TeamID: import_zod9.z.string(),
+    TeamNumber: import_zod9.z.number(),
+    Players: import_zod9.z.array(import_zod9.z.object({
+      Subject: import_zod9.z.string(),
+      CharacterID: import_zod9.z.string(),
+      CharacterSelectionState: import_zod9.z.string(),
+      PregamePlayerState: import_zod9.z.string(),
+      CompetitiveTier: import_zod9.z.number(),
+      PlayerIdentity: import_zod9.z.object({
+        Subject: import_zod9.z.string(),
+        PlayerCardID: import_zod9.z.string(),
+        PlayerTitleID: import_zod9.z.string(),
+        AccountLevel: import_zod9.z.number(),
+        PreferredLevelBorderID: import_zod9.z.string(),
+        Incognito: import_zod9.z.boolean(),
+        HideAccountLevel: import_zod9.z.boolean()
+      }),
+      SeasonalBadgeInfo: import_zod9.z.object({
+        SeasonID: import_zod9.z.string(),
+        NumberOfWins: import_zod9.z.number(),
+        Rank: import_zod9.z.number(),
+        LeaderboardRank: import_zod9.z.number()
+      }),
+      IsCaptain: import_zod9.z.boolean(),
+      PlatformType: import_zod9.z.string(),
+      PremierPrestige: import_zod9.z.object({})
+    }))
+  }),
+  EnemyTeamSize: import_zod9.z.number(),
+  EnemyTeamLockCount: import_zod9.z.number(),
+  PregameState: import_zod9.z.string(),
+  LastUpdated: import_zod9.z.string(),
+  MapID: import_zod9.z.string(),
+  CastedVotes: import_zod9.z.object({}),
+  MapSelectStep: import_zod9.z.number(),
+  Team1: import_zod9.z.string(),
+  GamePodID: import_zod9.z.string(),
+  Mode: import_zod9.z.string(),
+  VoiceSessionID: import_zod9.z.string(),
+  MUCName: import_zod9.z.string(),
+  TeamMatchToken: import_zod9.z.string(),
+  QueueID: import_zod9.z.string(),
+  ProvisioningFlowID: import_zod9.z.string(),
+  IsRanked: import_zod9.z.boolean(),
+  PhaseTimeRemainingNS: import_zod9.z.number(),
+  StepTimeRemainingNS: import_zod9.z.number(),
+  altModesFlagADA: import_zod9.z.boolean(),
+  /** Rules of the match by name. Only the rules the lobby set are present. */
+  GameRules: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.string())
+}));
+var pregameLoadoutsEndpoint = withResponse(import_valorant_api_types6.endpoints.pregameLoadoutsEndpoint, import_zod9.z.object({
+  Loadouts: import_zod9.z.array(import_zod9.z.object({
+    Subject: import_zod9.z.string(),
+    Expressions: import_zod9.z.object({
+      AESSelections: import_zod9.z.array(import_zod9.z.object({
+        AssetID: import_zod9.z.string(),
+        TypeID: import_zod9.z.string()
+      }))
+    }),
+    DynamicOptions: import_zod9.z.object({}),
+    Items: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.object({
+      ID: import_zod9.z.string(),
+      TypeID: import_zod9.z.string(),
+      Sockets: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.object({
+        ID: import_zod9.z.string(),
+        Item: import_zod9.z.object({
+          ID: import_zod9.z.string(),
+          TypeID: import_zod9.z.string()
+        })
+      }))
+    }))
+  })),
+  LoadoutsValid: import_zod9.z.boolean()
+}));
+
 // src/endpoints/riot/premier.ts
-var import_zod6 = require("zod");
+var import_zod10 = require("zod");
 var premierSeasonsEndpoint = {
   name: "Premier Seasons",
   description: "All Premier seasons of the shard. The affinity in the path is the region of the context.",
@@ -632,205 +1050,205 @@ var premierSeasonsEndpoint = {
   type: "pd",
   suffix: "premier/v1/affinities/{region}/premier-seasons",
   riotRequirements: player,
-  responses: { "200": import_zod6.z.object({
-    PremierSeasons: import_zod6.z.array(import_zod6.z.object({
-      ID: import_zod6.z.string(),
-      Name: import_zod6.z.string(),
-      PreviousPremierSeasonID: import_zod6.z.string(),
-      NextPremierSeasonID: import_zod6.z.string(),
-      IsActive: import_zod6.z.boolean(),
-      StartTime: import_zod6.z.string(),
-      EndTime: import_zod6.z.string(),
-      Events: import_zod6.z.array(import_zod6.z.object({
-        ID: import_zod6.z.string(),
-        Type: import_zod6.z.string(),
-        StartDateTime: import_zod6.z.string(),
-        EndDateTime: import_zod6.z.string(),
-        MapSelectionStrategy: import_zod6.z.string(),
-        MapPoolMapIDs: import_zod6.z.array(import_zod6.z.string()),
-        PointsRequiredToParticipate: import_zod6.z.number()
+  responses: { "200": import_zod10.z.object({
+    PremierSeasons: import_zod10.z.array(import_zod10.z.object({
+      ID: import_zod10.z.string(),
+      Name: import_zod10.z.string(),
+      PreviousPremierSeasonID: import_zod10.z.string(),
+      NextPremierSeasonID: import_zod10.z.string(),
+      IsActive: import_zod10.z.boolean(),
+      StartTime: import_zod10.z.string(),
+      EndTime: import_zod10.z.string(),
+      Events: import_zod10.z.array(import_zod10.z.object({
+        ID: import_zod10.z.string(),
+        Type: import_zod10.z.string(),
+        StartDateTime: import_zod10.z.string(),
+        EndDateTime: import_zod10.z.string(),
+        MapSelectionStrategy: import_zod10.z.string(),
+        MapPoolMapIDs: import_zod10.z.array(import_zod10.z.string()),
+        PointsRequiredToParticipate: import_zod10.z.number()
       })),
-      ScheduledEvents: import_zod6.z.array(import_zod6.z.object({
-        EventID: import_zod6.z.string(),
-        EventType: import_zod6.z.string(),
-        Conference: import_zod6.z.string(),
-        DivisionGroup: import_zod6.z.string(),
-        EventPresetName: import_zod6.z.string(),
-        StartDateTime: import_zod6.z.string(),
-        EndDateTime: import_zod6.z.string(),
-        TournamentRoundTimes: import_zod6.z.array(import_zod6.z.object({
-          StartDateTime: import_zod6.z.string(),
-          EndDateTime: import_zod6.z.string()
+      ScheduledEvents: import_zod10.z.array(import_zod10.z.object({
+        EventID: import_zod10.z.string(),
+        EventType: import_zod10.z.string(),
+        Conference: import_zod10.z.string(),
+        DivisionGroup: import_zod10.z.string(),
+        EventPresetName: import_zod10.z.string(),
+        StartDateTime: import_zod10.z.string(),
+        EndDateTime: import_zod10.z.string(),
+        TournamentRoundTimes: import_zod10.z.array(import_zod10.z.object({
+          StartDateTime: import_zod10.z.string(),
+          EndDateTime: import_zod10.z.string()
         }))
       })),
-      Conferences: import_zod6.z.array(import_zod6.z.object({
-        id: import_zod6.z.string(),
-        key: import_zod6.z.string(),
-        isSuper: import_zod6.z.boolean(),
-        gamePods: import_zod6.z.array(import_zod6.z.string()),
-        timezone: import_zod6.z.string(),
-        superConference: import_zod6.z.string().optional(),
-        leaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
-        leaderboardPromotionFinalizationDateTime: import_zod6.z.string()
+      Conferences: import_zod10.z.array(import_zod10.z.object({
+        id: import_zod10.z.string(),
+        key: import_zod10.z.string(),
+        isSuper: import_zod10.z.boolean(),
+        gamePods: import_zod10.z.array(import_zod10.z.string()),
+        timezone: import_zod10.z.string(),
+        superConference: import_zod10.z.string().optional(),
+        leaderboardPlayoffQualificationDateTime: import_zod10.z.string(),
+        leaderboardPromotionFinalizationDateTime: import_zod10.z.string()
       })),
-      Divisions: import_zod6.z.array(import_zod6.z.object({
-        Division: import_zod6.z.number(),
-        DivisionName: import_zod6.z.string(),
-        DivisionGroup: import_zod6.z.string(),
-        EventPresetName: import_zod6.z.string()
+      Divisions: import_zod10.z.array(import_zod10.z.object({
+        Division: import_zod10.z.number(),
+        DivisionName: import_zod10.z.string(),
+        DivisionGroup: import_zod10.z.string(),
+        EventPresetName: import_zod10.z.string()
       })),
-      DivisionThresholds: import_zod6.z.array(import_zod6.z.object({
-        playoffThresholdType: import_zod6.z.string(),
-        playoffThresholdValue: import_zod6.z.number(),
-        promotionThresholdType: import_zod6.z.string(),
-        promotionThresholdValue: import_zod6.z.number(),
-        shouldPromoteToSuperConference: import_zod6.z.boolean(),
-        skipReseedCriteria: import_zod6.z.string(),
-        conference: import_zod6.z.string().optional(),
-        division: import_zod6.z.number().optional(),
-        promotionConference: import_zod6.z.string().optional(),
-        skipReseedCriteriaValue: import_zod6.z.number().optional()
+      DivisionThresholds: import_zod10.z.array(import_zod10.z.object({
+        playoffThresholdType: import_zod10.z.string(),
+        playoffThresholdValue: import_zod10.z.number(),
+        promotionThresholdType: import_zod10.z.string(),
+        promotionThresholdValue: import_zod10.z.number(),
+        shouldPromoteToSuperConference: import_zod10.z.boolean(),
+        skipReseedCriteria: import_zod10.z.string(),
+        conference: import_zod10.z.string().optional(),
+        division: import_zod10.z.number().optional(),
+        promotionConference: import_zod10.z.string().optional(),
+        skipReseedCriteriaValue: import_zod10.z.number().optional()
       })),
-      EventPresets: import_zod6.z.object({
-        PRO: import_zod6.z.object({
-          EventPresetsByEventType: import_zod6.z.object({
-            LEAGUE: import_zod6.z.object({
-              EventPresetName: import_zod6.z.string(),
-              eventType: import_zod6.z.string(),
-              bestOfN: import_zod6.z.number(),
-              matchmakingStrategy: import_zod6.z.string(),
-              queueID: import_zod6.z.string(),
-              pointsConfig: import_zod6.z.object({
-                PointsForWin: import_zod6.z.number(),
-                PointsForLoss: import_zod6.z.number()
+      EventPresets: import_zod10.z.object({
+        PRO: import_zod10.z.object({
+          EventPresetsByEventType: import_zod10.z.object({
+            LEAGUE: import_zod10.z.object({
+              EventPresetName: import_zod10.z.string(),
+              eventType: import_zod10.z.string(),
+              bestOfN: import_zod10.z.number(),
+              matchmakingStrategy: import_zod10.z.string(),
+              queueID: import_zod10.z.string(),
+              pointsConfig: import_zod10.z.object({
+                PointsForWin: import_zod10.z.number(),
+                PointsForLoss: import_zod10.z.number()
               })
             }),
-            SCRIM: import_zod6.z.object({
-              EventPresetName: import_zod6.z.string(),
-              eventType: import_zod6.z.string(),
-              bestOfN: import_zod6.z.number(),
-              matchmakingStrategy: import_zod6.z.string(),
-              queueID: import_zod6.z.string(),
-              pointsConfig: import_zod6.z.object({
-                PointsForWin: import_zod6.z.number(),
-                PointsForLoss: import_zod6.z.number()
+            SCRIM: import_zod10.z.object({
+              EventPresetName: import_zod10.z.string(),
+              eventType: import_zod10.z.string(),
+              bestOfN: import_zod10.z.number(),
+              matchmakingStrategy: import_zod10.z.string(),
+              queueID: import_zod10.z.string(),
+              pointsConfig: import_zod10.z.object({
+                PointsForWin: import_zod10.z.number(),
+                PointsForLoss: import_zod10.z.number()
               })
             }),
-            TOURNAMENT: import_zod6.z.object({
-              EventPresetName: import_zod6.z.string(),
-              eventType: import_zod6.z.string(),
-              bestOfN: import_zod6.z.number(),
-              matchmakingStrategy: import_zod6.z.string(),
-              queueID: import_zod6.z.string(),
-              pointsConfig: import_zod6.z.object({
-                PointsForWin: import_zod6.z.number(),
-                PointsForLoss: import_zod6.z.number()
+            TOURNAMENT: import_zod10.z.object({
+              EventPresetName: import_zod10.z.string(),
+              eventType: import_zod10.z.string(),
+              bestOfN: import_zod10.z.number(),
+              matchmakingStrategy: import_zod10.z.string(),
+              queueID: import_zod10.z.string(),
+              pointsConfig: import_zod10.z.object({
+                PointsForWin: import_zod10.z.number(),
+                PointsForLoss: import_zod10.z.number()
               })
             })
           })
         }),
-        REGULAR: import_zod6.z.object({
-          EventPresetsByEventType: import_zod6.z.object({
-            LEAGUE: import_zod6.z.object({
-              EventPresetName: import_zod6.z.string(),
-              eventType: import_zod6.z.string(),
-              bestOfN: import_zod6.z.number(),
-              matchmakingStrategy: import_zod6.z.string(),
-              queueID: import_zod6.z.string(),
-              pointsConfig: import_zod6.z.object({
-                PointsForWin: import_zod6.z.number(),
-                PointsForLoss: import_zod6.z.number()
+        REGULAR: import_zod10.z.object({
+          EventPresetsByEventType: import_zod10.z.object({
+            LEAGUE: import_zod10.z.object({
+              EventPresetName: import_zod10.z.string(),
+              eventType: import_zod10.z.string(),
+              bestOfN: import_zod10.z.number(),
+              matchmakingStrategy: import_zod10.z.string(),
+              queueID: import_zod10.z.string(),
+              pointsConfig: import_zod10.z.object({
+                PointsForWin: import_zod10.z.number(),
+                PointsForLoss: import_zod10.z.number()
               })
             }),
-            SCRIM: import_zod6.z.object({
-              EventPresetName: import_zod6.z.string(),
-              eventType: import_zod6.z.string(),
-              bestOfN: import_zod6.z.number(),
-              matchmakingStrategy: import_zod6.z.string(),
-              queueID: import_zod6.z.string(),
-              pointsConfig: import_zod6.z.object({
-                PointsForWin: import_zod6.z.number(),
-                PointsForLoss: import_zod6.z.number()
+            SCRIM: import_zod10.z.object({
+              EventPresetName: import_zod10.z.string(),
+              eventType: import_zod10.z.string(),
+              bestOfN: import_zod10.z.number(),
+              matchmakingStrategy: import_zod10.z.string(),
+              queueID: import_zod10.z.string(),
+              pointsConfig: import_zod10.z.object({
+                PointsForWin: import_zod10.z.number(),
+                PointsForLoss: import_zod10.z.number()
               })
             }),
-            TOURNAMENT: import_zod6.z.object({
-              EventPresetName: import_zod6.z.string(),
-              eventType: import_zod6.z.string(),
-              bestOfN: import_zod6.z.number(),
-              matchmakingStrategy: import_zod6.z.string(),
-              queueID: import_zod6.z.string(),
-              pointsConfig: import_zod6.z.object({
-                PointsForWin: import_zod6.z.number(),
-                PointsForLoss: import_zod6.z.number()
+            TOURNAMENT: import_zod10.z.object({
+              EventPresetName: import_zod10.z.string(),
+              eventType: import_zod10.z.string(),
+              bestOfN: import_zod10.z.number(),
+              matchmakingStrategy: import_zod10.z.string(),
+              queueID: import_zod10.z.string(),
+              pointsConfig: import_zod10.z.object({
+                PointsForWin: import_zod10.z.number(),
+                PointsForLoss: import_zod10.z.number()
               })
             })
           })
         })
       }),
-      FlawlessPointRequirement: import_zod6.z.number(),
-      ChampionshipPointRequirement: import_zod6.z.number(),
-      ChampionshipEventID: import_zod6.z.string(),
-      EnrollmentPhaseStartDateTime: import_zod6.z.string(),
-      EnrollmentPhaseEndDateTime: import_zod6.z.string(),
-      LeaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
-      LeaderboardPromotionFinalizationDateTime: import_zod6.z.string(),
-      LeaderboardFinalizationDateTime: import_zod6.z.string(),
-      ContenderEligibilityExpiryDateTime: import_zod6.z.string(),
-      StageLockTime: import_zod6.z.string(),
-      ParticipationRewardsActIDs: import_zod6.z.array(import_zod6.z.string()),
-      ParticipationRewards: import_zod6.z.object({
-        EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
-          ItemTypeID: import_zod6.z.string(),
-          ItemID: import_zod6.z.string(),
-          Amount: import_zod6.z.number()
+      FlawlessPointRequirement: import_zod10.z.number(),
+      ChampionshipPointRequirement: import_zod10.z.number(),
+      ChampionshipEventID: import_zod10.z.string(),
+      EnrollmentPhaseStartDateTime: import_zod10.z.string(),
+      EnrollmentPhaseEndDateTime: import_zod10.z.string(),
+      LeaderboardPlayoffQualificationDateTime: import_zod10.z.string(),
+      LeaderboardPromotionFinalizationDateTime: import_zod10.z.string(),
+      LeaderboardFinalizationDateTime: import_zod10.z.string(),
+      ContenderEligibilityExpiryDateTime: import_zod10.z.string(),
+      StageLockTime: import_zod10.z.string(),
+      ParticipationRewardsActIDs: import_zod10.z.array(import_zod10.z.string()),
+      ParticipationRewards: import_zod10.z.object({
+        EntitlementRewards: import_zod10.z.array(import_zod10.z.object({
+          ItemTypeID: import_zod10.z.string(),
+          ItemID: import_zod10.z.string(),
+          Amount: import_zod10.z.number()
         }))
       }),
-      TournamentWinnerRewards: import_zod6.z.object({}),
-      DivisionWinnerRewards: import_zod6.z.object({
-        ADVANCED: import_zod6.z.object({
-          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
-            ItemTypeID: import_zod6.z.string(),
-            ItemID: import_zod6.z.string(),
-            Amount: import_zod6.z.number()
+      TournamentWinnerRewards: import_zod10.z.object({}),
+      DivisionWinnerRewards: import_zod10.z.object({
+        ADVANCED: import_zod10.z.object({
+          EntitlementRewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
           }))
         }).optional(),
-        CONTENDER: import_zod6.z.object({
-          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
-            ItemTypeID: import_zod6.z.string(),
-            ItemID: import_zod6.z.string(),
-            Amount: import_zod6.z.number()
+        CONTENDER: import_zod10.z.object({
+          EntitlementRewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
           }))
         }).optional(),
-        ELITE: import_zod6.z.object({
-          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
-            ItemTypeID: import_zod6.z.string(),
-            ItemID: import_zod6.z.string(),
-            Amount: import_zod6.z.number()
+        ELITE: import_zod10.z.object({
+          EntitlementRewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
           }))
         }).optional(),
-        INTERMEDIATE: import_zod6.z.object({
-          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
-            ItemTypeID: import_zod6.z.string(),
-            ItemID: import_zod6.z.string(),
-            Amount: import_zod6.z.number()
+        INTERMEDIATE: import_zod10.z.object({
+          EntitlementRewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
           }))
         }).optional(),
-        OPEN: import_zod6.z.object({
-          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
-            ItemTypeID: import_zod6.z.string(),
-            ItemID: import_zod6.z.string(),
-            Amount: import_zod6.z.number()
+        OPEN: import_zod10.z.object({
+          EntitlementRewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
           }))
         }).optional(),
-        INVITE: import_zod6.z.object({
-          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
-            ItemTypeID: import_zod6.z.string(),
-            ItemID: import_zod6.z.string(),
-            Amount: import_zod6.z.number()
+        INVITE: import_zod10.z.object({
+          EntitlementRewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
           }))
         }).optional()
       }),
-      RosterRecentActivityNumSeasons: import_zod6.z.number()
+      RosterRecentActivityNumSeasons: import_zod10.z.number()
     }))
   }) }
 };
@@ -841,154 +1259,154 @@ var premierActiveSeasonEndpoint = {
   type: "pd",
   suffix: "premier/v1/affinities/{region}/premier-seasons/active",
   riotRequirements: player,
-  responses: { "200": import_zod6.z.object({
-    ID: import_zod6.z.string(),
-    Name: import_zod6.z.string(),
-    PreviousPremierSeasonID: import_zod6.z.string(),
-    NextPremierSeasonID: import_zod6.z.string(),
-    IsActive: import_zod6.z.boolean(),
-    StartTime: import_zod6.z.string(),
-    EndTime: import_zod6.z.string(),
-    Events: import_zod6.z.array(import_zod6.z.object({
-      ID: import_zod6.z.string(),
-      Type: import_zod6.z.string(),
-      StartDateTime: import_zod6.z.string(),
-      EndDateTime: import_zod6.z.string(),
-      MapSelectionStrategy: import_zod6.z.string(),
-      MapPoolMapIDs: import_zod6.z.array(import_zod6.z.string()),
-      PointsRequiredToParticipate: import_zod6.z.number()
+  responses: { "200": import_zod10.z.object({
+    ID: import_zod10.z.string(),
+    Name: import_zod10.z.string(),
+    PreviousPremierSeasonID: import_zod10.z.string(),
+    NextPremierSeasonID: import_zod10.z.string(),
+    IsActive: import_zod10.z.boolean(),
+    StartTime: import_zod10.z.string(),
+    EndTime: import_zod10.z.string(),
+    Events: import_zod10.z.array(import_zod10.z.object({
+      ID: import_zod10.z.string(),
+      Type: import_zod10.z.string(),
+      StartDateTime: import_zod10.z.string(),
+      EndDateTime: import_zod10.z.string(),
+      MapSelectionStrategy: import_zod10.z.string(),
+      MapPoolMapIDs: import_zod10.z.array(import_zod10.z.string()),
+      PointsRequiredToParticipate: import_zod10.z.number()
     })),
-    ScheduledEvents: import_zod6.z.array(import_zod6.z.object({
-      EventID: import_zod6.z.string(),
-      EventType: import_zod6.z.string(),
-      Conference: import_zod6.z.string(),
-      DivisionGroup: import_zod6.z.string(),
-      EventPresetName: import_zod6.z.string(),
-      StartDateTime: import_zod6.z.string(),
-      EndDateTime: import_zod6.z.string(),
-      TournamentRoundTimes: import_zod6.z.array(import_zod6.z.object({
-        StartDateTime: import_zod6.z.string(),
-        EndDateTime: import_zod6.z.string()
+    ScheduledEvents: import_zod10.z.array(import_zod10.z.object({
+      EventID: import_zod10.z.string(),
+      EventType: import_zod10.z.string(),
+      Conference: import_zod10.z.string(),
+      DivisionGroup: import_zod10.z.string(),
+      EventPresetName: import_zod10.z.string(),
+      StartDateTime: import_zod10.z.string(),
+      EndDateTime: import_zod10.z.string(),
+      TournamentRoundTimes: import_zod10.z.array(import_zod10.z.object({
+        StartDateTime: import_zod10.z.string(),
+        EndDateTime: import_zod10.z.string()
       }))
     })),
-    Conferences: import_zod6.z.array(import_zod6.z.object({
-      id: import_zod6.z.string(),
-      key: import_zod6.z.string(),
-      isSuper: import_zod6.z.boolean(),
-      gamePods: import_zod6.z.array(import_zod6.z.string()),
-      timezone: import_zod6.z.string(),
-      superConference: import_zod6.z.string().optional(),
-      leaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
-      leaderboardPromotionFinalizationDateTime: import_zod6.z.string()
+    Conferences: import_zod10.z.array(import_zod10.z.object({
+      id: import_zod10.z.string(),
+      key: import_zod10.z.string(),
+      isSuper: import_zod10.z.boolean(),
+      gamePods: import_zod10.z.array(import_zod10.z.string()),
+      timezone: import_zod10.z.string(),
+      superConference: import_zod10.z.string().optional(),
+      leaderboardPlayoffQualificationDateTime: import_zod10.z.string(),
+      leaderboardPromotionFinalizationDateTime: import_zod10.z.string()
     })),
-    Divisions: import_zod6.z.array(import_zod6.z.object({
-      Division: import_zod6.z.number(),
-      DivisionName: import_zod6.z.string(),
-      DivisionGroup: import_zod6.z.string(),
-      EventPresetName: import_zod6.z.string()
+    Divisions: import_zod10.z.array(import_zod10.z.object({
+      Division: import_zod10.z.number(),
+      DivisionName: import_zod10.z.string(),
+      DivisionGroup: import_zod10.z.string(),
+      EventPresetName: import_zod10.z.string()
     })),
-    DivisionThresholds: import_zod6.z.array(import_zod6.z.object({
-      playoffThresholdType: import_zod6.z.string(),
-      playoffThresholdValue: import_zod6.z.number(),
-      promotionThresholdType: import_zod6.z.string(),
-      promotionThresholdValue: import_zod6.z.number(),
-      shouldPromoteToSuperConference: import_zod6.z.boolean(),
-      skipReseedCriteria: import_zod6.z.string(),
-      conference: import_zod6.z.string().optional(),
-      division: import_zod6.z.number().optional(),
-      promotionConference: import_zod6.z.string().optional(),
-      skipReseedCriteriaValue: import_zod6.z.number().optional()
+    DivisionThresholds: import_zod10.z.array(import_zod10.z.object({
+      playoffThresholdType: import_zod10.z.string(),
+      playoffThresholdValue: import_zod10.z.number(),
+      promotionThresholdType: import_zod10.z.string(),
+      promotionThresholdValue: import_zod10.z.number(),
+      shouldPromoteToSuperConference: import_zod10.z.boolean(),
+      skipReseedCriteria: import_zod10.z.string(),
+      conference: import_zod10.z.string().optional(),
+      division: import_zod10.z.number().optional(),
+      promotionConference: import_zod10.z.string().optional(),
+      skipReseedCriteriaValue: import_zod10.z.number().optional()
     })),
-    EventPresets: import_zod6.z.object({
-      PRO: import_zod6.z.object({
-        EventPresetsByEventType: import_zod6.z.object({
-          LEAGUE: import_zod6.z.object({
-            EventPresetName: import_zod6.z.string(),
-            eventType: import_zod6.z.string(),
-            bestOfN: import_zod6.z.number(),
-            matchmakingStrategy: import_zod6.z.string(),
-            queueID: import_zod6.z.string(),
-            pointsConfig: import_zod6.z.object({
-              PointsForWin: import_zod6.z.number(),
-              PointsForLoss: import_zod6.z.number()
+    EventPresets: import_zod10.z.object({
+      PRO: import_zod10.z.object({
+        EventPresetsByEventType: import_zod10.z.object({
+          LEAGUE: import_zod10.z.object({
+            EventPresetName: import_zod10.z.string(),
+            eventType: import_zod10.z.string(),
+            bestOfN: import_zod10.z.number(),
+            matchmakingStrategy: import_zod10.z.string(),
+            queueID: import_zod10.z.string(),
+            pointsConfig: import_zod10.z.object({
+              PointsForWin: import_zod10.z.number(),
+              PointsForLoss: import_zod10.z.number()
             })
           }),
-          SCRIM: import_zod6.z.object({
-            EventPresetName: import_zod6.z.string(),
-            eventType: import_zod6.z.string(),
-            bestOfN: import_zod6.z.number(),
-            matchmakingStrategy: import_zod6.z.string(),
-            queueID: import_zod6.z.string(),
-            pointsConfig: import_zod6.z.object({
-              PointsForWin: import_zod6.z.number(),
-              PointsForLoss: import_zod6.z.number()
+          SCRIM: import_zod10.z.object({
+            EventPresetName: import_zod10.z.string(),
+            eventType: import_zod10.z.string(),
+            bestOfN: import_zod10.z.number(),
+            matchmakingStrategy: import_zod10.z.string(),
+            queueID: import_zod10.z.string(),
+            pointsConfig: import_zod10.z.object({
+              PointsForWin: import_zod10.z.number(),
+              PointsForLoss: import_zod10.z.number()
             })
           }),
-          TOURNAMENT: import_zod6.z.object({
-            EventPresetName: import_zod6.z.string(),
-            eventType: import_zod6.z.string(),
-            bestOfN: import_zod6.z.number(),
-            matchmakingStrategy: import_zod6.z.string(),
-            queueID: import_zod6.z.string(),
-            pointsConfig: import_zod6.z.object({
-              PointsForWin: import_zod6.z.number(),
-              PointsForLoss: import_zod6.z.number()
+          TOURNAMENT: import_zod10.z.object({
+            EventPresetName: import_zod10.z.string(),
+            eventType: import_zod10.z.string(),
+            bestOfN: import_zod10.z.number(),
+            matchmakingStrategy: import_zod10.z.string(),
+            queueID: import_zod10.z.string(),
+            pointsConfig: import_zod10.z.object({
+              PointsForWin: import_zod10.z.number(),
+              PointsForLoss: import_zod10.z.number()
             })
           })
         })
       }),
-      REGULAR: import_zod6.z.object({
-        EventPresetsByEventType: import_zod6.z.object({
-          LEAGUE: import_zod6.z.object({
-            EventPresetName: import_zod6.z.string(),
-            eventType: import_zod6.z.string(),
-            bestOfN: import_zod6.z.number(),
-            matchmakingStrategy: import_zod6.z.string(),
-            queueID: import_zod6.z.string(),
-            pointsConfig: import_zod6.z.object({
-              PointsForWin: import_zod6.z.number(),
-              PointsForLoss: import_zod6.z.number()
+      REGULAR: import_zod10.z.object({
+        EventPresetsByEventType: import_zod10.z.object({
+          LEAGUE: import_zod10.z.object({
+            EventPresetName: import_zod10.z.string(),
+            eventType: import_zod10.z.string(),
+            bestOfN: import_zod10.z.number(),
+            matchmakingStrategy: import_zod10.z.string(),
+            queueID: import_zod10.z.string(),
+            pointsConfig: import_zod10.z.object({
+              PointsForWin: import_zod10.z.number(),
+              PointsForLoss: import_zod10.z.number()
             })
           }),
-          SCRIM: import_zod6.z.object({
-            EventPresetName: import_zod6.z.string(),
-            eventType: import_zod6.z.string(),
-            bestOfN: import_zod6.z.number(),
-            matchmakingStrategy: import_zod6.z.string(),
-            queueID: import_zod6.z.string(),
-            pointsConfig: import_zod6.z.object({
-              PointsForWin: import_zod6.z.number(),
-              PointsForLoss: import_zod6.z.number()
+          SCRIM: import_zod10.z.object({
+            EventPresetName: import_zod10.z.string(),
+            eventType: import_zod10.z.string(),
+            bestOfN: import_zod10.z.number(),
+            matchmakingStrategy: import_zod10.z.string(),
+            queueID: import_zod10.z.string(),
+            pointsConfig: import_zod10.z.object({
+              PointsForWin: import_zod10.z.number(),
+              PointsForLoss: import_zod10.z.number()
             })
           }),
-          TOURNAMENT: import_zod6.z.object({
-            EventPresetName: import_zod6.z.string(),
-            eventType: import_zod6.z.string(),
-            bestOfN: import_zod6.z.number(),
-            matchmakingStrategy: import_zod6.z.string(),
-            queueID: import_zod6.z.string(),
-            pointsConfig: import_zod6.z.object({
-              PointsForWin: import_zod6.z.number(),
-              PointsForLoss: import_zod6.z.number()
+          TOURNAMENT: import_zod10.z.object({
+            EventPresetName: import_zod10.z.string(),
+            eventType: import_zod10.z.string(),
+            bestOfN: import_zod10.z.number(),
+            matchmakingStrategy: import_zod10.z.string(),
+            queueID: import_zod10.z.string(),
+            pointsConfig: import_zod10.z.object({
+              PointsForWin: import_zod10.z.number(),
+              PointsForLoss: import_zod10.z.number()
             })
           })
         })
       })
     }),
-    FlawlessPointRequirement: import_zod6.z.number(),
-    ChampionshipPointRequirement: import_zod6.z.number(),
-    ChampionshipEventID: import_zod6.z.string(),
-    EnrollmentPhaseStartDateTime: import_zod6.z.string(),
-    EnrollmentPhaseEndDateTime: import_zod6.z.string(),
-    LeaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
-    LeaderboardPromotionFinalizationDateTime: import_zod6.z.string(),
-    LeaderboardFinalizationDateTime: import_zod6.z.string(),
-    ContenderEligibilityExpiryDateTime: import_zod6.z.string(),
-    StageLockTime: import_zod6.z.string(),
-    ParticipationRewards: import_zod6.z.object({}),
-    TournamentWinnerRewards: import_zod6.z.object({}),
-    DivisionWinnerRewards: import_zod6.z.object({}),
-    RosterRecentActivityNumSeasons: import_zod6.z.number()
+    FlawlessPointRequirement: import_zod10.z.number(),
+    ChampionshipPointRequirement: import_zod10.z.number(),
+    ChampionshipEventID: import_zod10.z.string(),
+    EnrollmentPhaseStartDateTime: import_zod10.z.string(),
+    EnrollmentPhaseEndDateTime: import_zod10.z.string(),
+    LeaderboardPlayoffQualificationDateTime: import_zod10.z.string(),
+    LeaderboardPromotionFinalizationDateTime: import_zod10.z.string(),
+    LeaderboardFinalizationDateTime: import_zod10.z.string(),
+    ContenderEligibilityExpiryDateTime: import_zod10.z.string(),
+    StageLockTime: import_zod10.z.string(),
+    ParticipationRewards: import_zod10.z.object({}),
+    TournamentWinnerRewards: import_zod10.z.object({}),
+    DivisionWinnerRewards: import_zod10.z.object({}),
+    RosterRecentActivityNumSeasons: import_zod10.z.number()
   }) }
 };
 var premierConferencesEndpoint = {
@@ -998,16 +1416,16 @@ var premierConferencesEndpoint = {
   type: "pd",
   suffix: "premier/v1/affinities/{region}/conferences",
   riotRequirements: player,
-  responses: { "200": import_zod6.z.object({
-    PremierConferences: import_zod6.z.array(import_zod6.z.object({
-      id: import_zod6.z.string(),
-      key: import_zod6.z.string(),
-      isSuper: import_zod6.z.boolean(),
-      gamePods: import_zod6.z.array(import_zod6.z.string()),
-      timezone: import_zod6.z.string(),
-      superConference: import_zod6.z.string().optional(),
-      leaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
-      leaderboardPromotionFinalizationDateTime: import_zod6.z.string()
+  responses: { "200": import_zod10.z.object({
+    PremierConferences: import_zod10.z.array(import_zod10.z.object({
+      id: import_zod10.z.string(),
+      key: import_zod10.z.string(),
+      isSuper: import_zod10.z.boolean(),
+      gamePods: import_zod10.z.array(import_zod10.z.string()),
+      timezone: import_zod10.z.string(),
+      superConference: import_zod10.z.string().optional(),
+      leaderboardPlayoffQualificationDateTime: import_zod10.z.string(),
+      leaderboardPromotionFinalizationDateTime: import_zod10.z.string()
     }))
   }) }
 };
@@ -1018,10 +1436,10 @@ var premierMatchLimitEndpoint = {
   type: "pd",
   suffix: "premier/v1/matchlimitinfo",
   riotRequirements: player,
-  responses: { "200": import_zod6.z.object({
-    leagueMatchLimit: import_zod6.z.number(),
-    tournamentLimit: import_zod6.z.number(),
-    timeUntilNextResetSeconds: import_zod6.z.number()
+  responses: { "200": import_zod10.z.object({
+    leagueMatchLimit: import_zod10.z.number(),
+    tournamentLimit: import_zod10.z.number(),
+    timeUntilNextResetSeconds: import_zod10.z.number()
   }) }
 };
 var premierEligibilityEndpoint = {
@@ -1031,12 +1449,12 @@ var premierEligibilityEndpoint = {
   type: "pd",
   suffix: "premier/v1/player/eligibility",
   riotRequirements: player,
-  responses: { "200": import_zod6.z.object({
-    subject: import_zod6.z.string(),
-    accountVerificationStatus: import_zod6.z.boolean(),
-    rankedPlacementCompletionStatus: import_zod6.z.boolean(),
-    matchLimitReached: import_zod6.z.boolean(),
-    isOnProvidedRoster: import_zod6.z.boolean()
+  responses: { "200": import_zod10.z.object({
+    subject: import_zod10.z.string(),
+    accountVerificationStatus: import_zod10.z.boolean(),
+    rankedPlacementCompletionStatus: import_zod10.z.boolean(),
+    matchLimitReached: import_zod10.z.boolean(),
+    isOnProvidedRoster: import_zod10.z.boolean()
   }) }
 };
 var premierPlayerV2Endpoint = {
@@ -1046,12 +1464,12 @@ var premierPlayerV2Endpoint = {
   type: "pd",
   suffix: "premier/v2/players/{puuid}",
   riotRequirements: player,
-  responses: { "200": import_zod6.z.object({
-    puuid: import_zod6.z.string(),
-    rosterId: import_zod6.z.string(),
-    version: import_zod6.z.number(),
-    createdAt: import_zod6.z.number(),
-    updatedAt: import_zod6.z.number()
+  responses: { "200": import_zod10.z.object({
+    puuid: import_zod10.z.string(),
+    rosterId: import_zod10.z.string(),
+    version: import_zod10.z.number(),
+    createdAt: import_zod10.z.number(),
+    updatedAt: import_zod10.z.number()
   }) }
 };
 var premierPlayerV3Endpoint = {
@@ -1061,39 +1479,150 @@ var premierPlayerV3Endpoint = {
   type: "pd",
   suffix: "premier/v3/players/{puuid}",
   riotRequirements: player,
-  responses: { "200": import_zod6.z.object({
-    puuid: import_zod6.z.string(),
-    rosterId: import_zod6.z.string(),
-    prestige: import_zod6.z.object({
-      earnedPrestige: import_zod6.z.boolean(),
-      earnedAura: import_zod6.z.boolean(),
-      showTag: import_zod6.z.boolean(),
-      showPlating: import_zod6.z.boolean(),
-      showAura: import_zod6.z.boolean()
+  responses: { "200": import_zod10.z.object({
+    puuid: import_zod10.z.string(),
+    rosterId: import_zod10.z.string(),
+    prestige: import_zod10.z.object({
+      earnedPrestige: import_zod10.z.boolean(),
+      earnedAura: import_zod10.z.boolean(),
+      showTag: import_zod10.z.boolean(),
+      showPlating: import_zod10.z.boolean(),
+      showAura: import_zod10.z.boolean()
     }),
-    contenderEligibilityExpiry: import_zod6.z.string(),
-    socialVersion: import_zod6.z.number(),
-    premierVersion: import_zod6.z.number(),
-    updatedAt: import_zod6.z.number(),
-    seasons: import_zod6.z.object({
-      "08d281c5-4426-3aaa-3316-ebaf5f2c858a": import_zod6.z.object({
-        seasonId: import_zod6.z.string(),
-        hasEarnedPrestigeAura: import_zod6.z.boolean(),
-        hasEarnedParticipation: import_zod6.z.boolean(),
-        hasEarnedDivisionWinner: import_zod6.z.boolean()
+    contenderEligibilityExpiry: import_zod10.z.string(),
+    socialVersion: import_zod10.z.number(),
+    premierVersion: import_zod10.z.number(),
+    updatedAt: import_zod10.z.number(),
+    seasons: import_zod10.z.object({
+      "08d281c5-4426-3aaa-3316-ebaf5f2c858a": import_zod10.z.object({
+        seasonId: import_zod10.z.string(),
+        hasEarnedPrestigeAura: import_zod10.z.boolean(),
+        hasEarnedParticipation: import_zod10.z.boolean(),
+        hasEarnedDivisionWinner: import_zod10.z.boolean()
       }),
-      "91be4c20-439d-8e24-f577-4ca8a98e8dc8": import_zod6.z.object({
-        seasonId: import_zod6.z.string(),
-        hasEarnedPrestigeAura: import_zod6.z.boolean(),
-        hasEarnedParticipation: import_zod6.z.boolean(),
-        hasEarnedDivisionWinner: import_zod6.z.boolean()
+      "91be4c20-439d-8e24-f577-4ca8a98e8dc8": import_zod10.z.object({
+        seasonId: import_zod10.z.string(),
+        hasEarnedPrestigeAura: import_zod10.z.boolean(),
+        hasEarnedParticipation: import_zod10.z.boolean(),
+        hasEarnedDivisionWinner: import_zod10.z.boolean()
       })
     })
   }) }
 };
 
+// src/endpoints/riot/presence.ts
+var import_valorant_api_types7 = require("valorant-api-types");
+var import_zod11 = require("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 = import_zod11.z.object({
+  isIdle: import_zod11.z.boolean(),
+  isValid: import_zod11.z.boolean(),
+  matchPresenceData: import_zod11.z.object({
+    gameScoreType: import_zod11.z.string(),
+    matchMap: import_zod11.z.string(),
+    provisioningFlow: import_zod11.z.string(),
+    queueId: import_zod11.z.string(),
+    sessionLoopState: import_zod11.z.string()
+  }),
+  maxPartySize: import_zod11.z.number(),
+  partyId: import_zod11.z.string(),
+  partyOwnerMatchScoreAllyTeam: import_zod11.z.number(),
+  partyOwnerMatchScoreEnemyTeam: import_zod11.z.number(),
+  partyPresenceData: import_zod11.z.object({
+    customGameName: import_zod11.z.string(),
+    customGameTeam: import_zod11.z.string(),
+    isPartyCrossPlayEnabled: import_zod11.z.boolean(),
+    isPartyOwner: import_zod11.z.boolean(),
+    isPlayerCrossPlayEnabled: import_zod11.z.boolean(),
+    maxPartySize: import_zod11.z.number(),
+    partyAccessibility: import_zod11.z.string(),
+    partyClientVersion: import_zod11.z.string(),
+    partyId: import_zod11.z.string(),
+    partyLFM: import_zod11.z.boolean(),
+    partyOwnerMatchMap: import_zod11.z.string(),
+    partyOwnerMatchScoreAllyTeam: import_zod11.z.number(),
+    partyOwnerMatchScoreEnemyTeam: import_zod11.z.number(),
+    partyOwnerProvisioningFlow: import_zod11.z.string(),
+    partyOwnerSessionLoopState: import_zod11.z.string(),
+    partyPrecisePlatformTypes: import_zod11.z.number(),
+    partySize: import_zod11.z.number(),
+    partyState: import_zod11.z.string(),
+    partyVersion: import_zod11.z.number(),
+    queueEntryTime: import_zod11.z.string(),
+    rosterId: import_zod11.z.string(),
+    tournamentId: import_zod11.z.string()
+  }),
+  partySize: import_zod11.z.number(),
+  playerPresenceData: import_zod11.z.object({
+    accountLevel: import_zod11.z.number(),
+    competitiveTier: import_zod11.z.number(),
+    leaderboardPosition: import_zod11.z.number(),
+    platformOverride: import_zod11.z.string(),
+    playerCardId: import_zod11.z.string(),
+    playerTitleId: import_zod11.z.string(),
+    tempValueAA: import_zod11.z.number()
+  }),
+  premierPresenceData: import_zod11.z.object({
+    division: import_zod11.z.number(),
+    plating: import_zod11.z.number(),
+    rosterId: import_zod11.z.string(),
+    rosterName: import_zod11.z.string(),
+    rosterTag: import_zod11.z.string(),
+    rosterType: import_zod11.z.string(),
+    score: import_zod11.z.number(),
+    showAura: import_zod11.z.boolean(),
+    showPlating: import_zod11.z.boolean(),
+    showTag: import_zod11.z.boolean()
+  }),
+  provisioningFlow: import_zod11.z.string(),
+  queueId: import_zod11.z.string()
+});
+function decodePresence(raw) {
+  if (!raw) return null;
+  try {
+    return valorantPresence.parse(JSON.parse(fromBase64(raw)));
+  } catch {
+    return null;
+  }
+}
+var presenceEndpoint = withResponse(import_valorant_api_types7.endpoints.presenceEndpoint, import_zod11.z.object({
+  presences: import_zod11.z.array(import_zod11.z.object({
+    activePlatform: import_zod11.z.string().nullable(),
+    basic: import_zod11.z.string(),
+    game_name: import_zod11.z.string(),
+    game_tag: import_zod11.z.string(),
+    msg: import_zod11.z.string().nullable(),
+    name: import_zod11.z.string(),
+    packedData: import_zod11.z.string().nullable(),
+    patchline: import_zod11.z.string().nullable(),
+    pid: import_zod11.z.string(),
+    platform: import_zod11.z.string().nullable(),
+    product: import_zod11.z.string(),
+    puuid: import_zod11.z.string(),
+    region: import_zod11.z.string(),
+    resource: import_zod11.z.string(),
+    state: import_zod11.z.string(),
+    summary: import_zod11.z.string(),
+    time: import_zod11.z.number(),
+    private: import_zod11.z.string().nullable().transform(decodePresence)
+  }))
+}));
+
 // src/endpoints/riot/pvp.ts
-var import_zod7 = require("zod");
+var import_valorant_api_types8 = require("valorant-api-types");
+var import_zod12 = require("zod");
 var playerLoadoutV3Endpoint = {
   name: "Player Loadout V3",
   description: "Current loadout. The v2 route used by `pvp.playerLoadout` answers 404 on current clients.",
@@ -1101,36 +1630,44 @@ var playerLoadoutV3Endpoint = {
   type: "pd",
   suffix: "personalization/v3/players/{puuid}/playerloadout",
   riotRequirements: player,
-  responses: { "200": import_zod7.z.object({
-    Subject: import_zod7.z.string(),
-    Version: import_zod7.z.number(),
-    Guns: import_zod7.z.array(import_zod7.z.object({
-      ID: import_zod7.z.string(),
-      SkinID: import_zod7.z.string(),
-      SkinLevelID: import_zod7.z.string(),
-      ChromaID: import_zod7.z.string(),
-      CharmInstanceID: import_zod7.z.string().optional(),
-      CharmID: import_zod7.z.string().optional(),
-      CharmLevelID: import_zod7.z.string().optional()
+  responses: { "200": import_zod12.z.object({
+    Subject: import_zod12.z.string(),
+    Version: import_zod12.z.number(),
+    Guns: import_zod12.z.array(import_zod12.z.object({
+      ID: import_zod12.z.string(),
+      SkinID: import_zod12.z.string(),
+      SkinLevelID: import_zod12.z.string(),
+      ChromaID: import_zod12.z.string(),
+      CharmInstanceID: import_zod12.z.string().optional(),
+      CharmID: import_zod12.z.string().optional(),
+      CharmLevelID: import_zod12.z.string().optional()
     })),
-    ActiveExpressions: import_zod7.z.array(import_zod7.z.object({
-      TypeID: import_zod7.z.string(),
-      AssetID: import_zod7.z.string()
+    ActiveExpressions: import_zod12.z.array(import_zod12.z.object({
+      TypeID: import_zod12.z.string(),
+      AssetID: import_zod12.z.string()
     })),
-    DynamicOptions: import_zod7.z.object({}),
-    Identity: import_zod7.z.object({
-      PlayerCardID: import_zod7.z.string(),
-      PlayerTitleID: import_zod7.z.string(),
-      AccountLevel: import_zod7.z.number(),
-      PreferredLevelBorderID: import_zod7.z.string(),
-      HideAccountLevel: import_zod7.z.boolean()
+    DynamicOptions: import_zod12.z.object({}),
+    Identity: import_zod12.z.object({
+      PlayerCardID: import_zod12.z.string(),
+      PlayerTitleID: import_zod12.z.string(),
+      AccountLevel: import_zod12.z.number(),
+      PreferredLevelBorderID: import_zod12.z.string(),
+      HideAccountLevel: import_zod12.z.boolean()
     }),
-    Incognito: import_zod7.z.boolean()
+    Incognito: import_zod12.z.boolean()
   }) }
 };
+var configEndpoint = withResponse(
+  { ...onSharedHost(import_valorant_api_types8.endpoints.configEndpoint), riotRequirements: player },
+  import_zod12.z.object({
+    LastApplication: import_zod12.z.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: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.string())
+  })
+);
 
 // src/endpoints/riot/restrictions.ts
-var import_zod8 = require("zod");
+var import_zod13 = require("zod");
 var avoidListEndpoint = {
   name: "Avoid List",
   description: "Players the account avoids in matchmaking.",
@@ -1138,8 +1675,8 @@ var avoidListEndpoint = {
   type: "pd",
   suffix: "restrictions/v1/avoidList",
   riotRequirements: player,
-  responses: { "200": import_zod8.z.object({
-    Subject: import_zod8.z.string()
+  responses: { "200": import_zod13.z.object({
+    Subject: import_zod13.z.string()
   }) }
 };
 var activeFutureInterventionsEndpoint = {
@@ -1149,13 +1686,14 @@ var activeFutureInterventionsEndpoint = {
   type: "pd",
   suffix: "restrictions/v1/activeFutureInterventions",
   riotRequirements: player,
-  responses: { "200": import_zod8.z.object({
-    Subject: import_zod8.z.string()
+  responses: { "200": import_zod13.z.object({
+    Subject: import_zod13.z.string()
   }) }
 };
 
 // src/endpoints/riot/store.ts
-var import_zod9 = require("zod");
+var import_valorant_api_types9 = require("valorant-api-types");
+var import_zod14 = require("zod");
 var agentStoreEndpoint = {
   name: "Agent Store",
   description: "Agents offered in the store.",
@@ -1163,24 +1701,24 @@ var agentStoreEndpoint = {
   type: "pd",
   suffix: "store/v1/storefronts/agent",
   riotRequirements: player,
-  responses: { "200": import_zod9.z.object({
-    AgentStore: import_zod9.z.object({
-      AgentStoreOffers: import_zod9.z.array(import_zod9.z.object({
-        AgentID: import_zod9.z.string(),
-        StoreOffers: import_zod9.z.array(import_zod9.z.object({
-          OfferID: import_zod9.z.string(),
-          IsDirectPurchase: import_zod9.z.boolean(),
-          StartDate: import_zod9.z.string(),
-          Cost: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.number()),
-          Rewards: import_zod9.z.array(import_zod9.z.object({
-            ItemTypeID: import_zod9.z.string(),
-            ItemID: import_zod9.z.string(),
-            Quantity: import_zod9.z.number()
+  responses: { "200": import_zod14.z.object({
+    AgentStore: import_zod14.z.object({
+      AgentStoreOffers: import_zod14.z.array(import_zod14.z.object({
+        AgentID: import_zod14.z.string(),
+        StoreOffers: import_zod14.z.array(import_zod14.z.object({
+          OfferID: import_zod14.z.string(),
+          IsDirectPurchase: import_zod14.z.boolean(),
+          StartDate: import_zod14.z.string(),
+          Cost: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.number()),
+          Rewards: import_zod14.z.array(import_zod14.z.object({
+            ItemTypeID: import_zod14.z.string(),
+            ItemID: import_zod14.z.string(),
+            Quantity: import_zod14.z.number()
           }))
         }))
       })),
-      CurrentFeaturedAgent: import_zod9.z.string(),
-      NextFeaturedAgent: import_zod9.z.string()
+      CurrentFeaturedAgent: import_zod14.z.string(),
+      NextFeaturedAgent: import_zod14.z.string()
     })
   }) }
 };
@@ -1191,20 +1729,27 @@ var allEntitlementsEndpoint = {
   type: "pd",
   suffix: "store/v1/entitlements/{puuid}",
   riotRequirements: player,
-  responses: { "200": import_zod9.z.object({
-    EntitlementsByTypes: import_zod9.z.array(import_zod9.z.object({
-      ItemTypeID: import_zod9.z.string(),
-      Entitlements: import_zod9.z.array(import_zod9.z.object({
-        TypeID: import_zod9.z.string(),
-        ItemID: import_zod9.z.string(),
-        InstanceID: import_zod9.z.string().optional()
+  responses: { "200": import_zod14.z.object({
+    EntitlementsByTypes: import_zod14.z.array(import_zod14.z.object({
+      ItemTypeID: import_zod14.z.string(),
+      Entitlements: import_zod14.z.array(import_zod14.z.object({
+        TypeID: import_zod14.z.string(),
+        ItemID: import_zod14.z.string(),
+        InstanceID: import_zod14.z.string().optional()
       }))
     }))
   }) }
 };
+var ownedItemsEndpoint = withResponse(import_valorant_api_types9.endpoints.ownedItemsEndpoint, import_zod14.z.object({
+  ItemTypeID: import_zod14.z.string(),
+  Entitlements: import_zod14.z.array(import_zod14.z.object({
+    TypeID: import_zod14.z.string(),
+    ItemID: import_zod14.z.string()
+  }))
+}));
 
 // src/endpoints/riot/storefront.ts
-var import_zod10 = require("zod");
+var import_zod15 = require("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.",
@@ -1214,266 +1759,266 @@ var storefrontV3Endpoint = {
   suffix: "store/v3/storefront/{puuid}",
   headers: /* @__PURE__ */ new Map([["Content-Type", "application/json"]]),
   riotRequirements: player,
-  responses: { "200": import_zod10.z.object({
-    FeaturedBundle: import_zod10.z.object({
-      Bundle: import_zod10.z.object({
-        ID: import_zod10.z.string(),
-        DataAssetID: import_zod10.z.string(),
-        CurrencyID: import_zod10.z.string(),
-        Items: import_zod10.z.array(import_zod10.z.object({
-          Item: import_zod10.z.object({
-            ItemTypeID: import_zod10.z.string(),
-            ItemID: import_zod10.z.string(),
-            Amount: import_zod10.z.number()
+  responses: { "200": import_zod15.z.object({
+    FeaturedBundle: import_zod15.z.object({
+      Bundle: import_zod15.z.object({
+        ID: import_zod15.z.string(),
+        DataAssetID: import_zod15.z.string(),
+        CurrencyID: import_zod15.z.string(),
+        Items: import_zod15.z.array(import_zod15.z.object({
+          Item: import_zod15.z.object({
+            ItemTypeID: import_zod15.z.string(),
+            ItemID: import_zod15.z.string(),
+            Amount: import_zod15.z.number()
           }),
-          BasePrice: import_zod10.z.number(),
-          CurrencyID: import_zod10.z.string(),
-          DiscountPercent: import_zod10.z.number(),
-          DiscountedPrice: import_zod10.z.number(),
-          IsPromoItem: import_zod10.z.boolean()
+          BasePrice: import_zod15.z.number(),
+          CurrencyID: import_zod15.z.string(),
+          DiscountPercent: import_zod15.z.number(),
+          DiscountedPrice: import_zod15.z.number(),
+          IsPromoItem: import_zod15.z.boolean()
         })),
-        ItemOffers: import_zod10.z.array(import_zod10.z.object({
-          BundleItemOfferID: import_zod10.z.string(),
-          Offer: import_zod10.z.object({
-            OfferID: import_zod10.z.string(),
-            IsDirectPurchase: import_zod10.z.boolean(),
-            StartDate: import_zod10.z.string(),
-            Cost: import_zod10.z.object({
-              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        ItemOffers: import_zod15.z.array(import_zod15.z.object({
+          BundleItemOfferID: import_zod15.z.string(),
+          Offer: import_zod15.z.object({
+            OfferID: import_zod15.z.string(),
+            IsDirectPurchase: import_zod15.z.boolean(),
+            StartDate: import_zod15.z.string(),
+            Cost: import_zod15.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
             }),
-            Rewards: import_zod10.z.array(import_zod10.z.object({
-              ItemTypeID: import_zod10.z.string(),
-              ItemID: import_zod10.z.string(),
-              Quantity: import_zod10.z.number()
+            Rewards: import_zod15.z.array(import_zod15.z.object({
+              ItemTypeID: import_zod15.z.string(),
+              ItemID: import_zod15.z.string(),
+              Quantity: import_zod15.z.number()
             }))
           }),
-          DiscountPercent: import_zod10.z.number(),
-          DiscountedCost: import_zod10.z.object({
-            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+          DiscountPercent: import_zod15.z.number(),
+          DiscountedCost: import_zod15.z.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
           })
         })),
-        TotalBaseCost: import_zod10.z.object({
-          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        TotalBaseCost: import_zod15.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
         }),
-        TotalDiscountedCost: import_zod10.z.object({
-          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        TotalDiscountedCost: import_zod15.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
         }),
-        TotalDiscountPercent: import_zod10.z.number(),
-        DurationRemainingInSeconds: import_zod10.z.number(),
-        WholesaleOnly: import_zod10.z.boolean(),
-        IsGiftable: import_zod10.z.number()
+        TotalDiscountPercent: import_zod15.z.number(),
+        DurationRemainingInSeconds: import_zod15.z.number(),
+        WholesaleOnly: import_zod15.z.boolean(),
+        IsGiftable: import_zod15.z.number()
       }),
-      Bundles: import_zod10.z.array(import_zod10.z.object({
-        ID: import_zod10.z.string(),
-        DataAssetID: import_zod10.z.string(),
-        CurrencyID: import_zod10.z.string(),
-        Items: import_zod10.z.array(import_zod10.z.object({
-          Item: import_zod10.z.object({
-            ItemTypeID: import_zod10.z.string(),
-            ItemID: import_zod10.z.string(),
-            Amount: import_zod10.z.number()
+      Bundles: import_zod15.z.array(import_zod15.z.object({
+        ID: import_zod15.z.string(),
+        DataAssetID: import_zod15.z.string(),
+        CurrencyID: import_zod15.z.string(),
+        Items: import_zod15.z.array(import_zod15.z.object({
+          Item: import_zod15.z.object({
+            ItemTypeID: import_zod15.z.string(),
+            ItemID: import_zod15.z.string(),
+            Amount: import_zod15.z.number()
           }),
-          BasePrice: import_zod10.z.number(),
-          CurrencyID: import_zod10.z.string(),
-          DiscountPercent: import_zod10.z.number(),
-          DiscountedPrice: import_zod10.z.number(),
-          IsPromoItem: import_zod10.z.boolean()
+          BasePrice: import_zod15.z.number(),
+          CurrencyID: import_zod15.z.string(),
+          DiscountPercent: import_zod15.z.number(),
+          DiscountedPrice: import_zod15.z.number(),
+          IsPromoItem: import_zod15.z.boolean()
         })),
-        ItemOffers: import_zod10.z.array(import_zod10.z.object({
-          BundleItemOfferID: import_zod10.z.string(),
-          Offer: import_zod10.z.object({
-            OfferID: import_zod10.z.string(),
-            IsDirectPurchase: import_zod10.z.boolean(),
-            StartDate: import_zod10.z.string(),
-            Cost: import_zod10.z.object({
-              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        ItemOffers: import_zod15.z.array(import_zod15.z.object({
+          BundleItemOfferID: import_zod15.z.string(),
+          Offer: import_zod15.z.object({
+            OfferID: import_zod15.z.string(),
+            IsDirectPurchase: import_zod15.z.boolean(),
+            StartDate: import_zod15.z.string(),
+            Cost: import_zod15.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
             }),
-            Rewards: import_zod10.z.array(import_zod10.z.object({
-              ItemTypeID: import_zod10.z.string(),
-              ItemID: import_zod10.z.string(),
-              Quantity: import_zod10.z.number()
+            Rewards: import_zod15.z.array(import_zod15.z.object({
+              ItemTypeID: import_zod15.z.string(),
+              ItemID: import_zod15.z.string(),
+              Quantity: import_zod15.z.number()
             }))
           }),
-          DiscountPercent: import_zod10.z.number(),
-          DiscountedCost: import_zod10.z.object({
-            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+          DiscountPercent: import_zod15.z.number(),
+          DiscountedCost: import_zod15.z.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
           })
         })),
-        TotalBaseCost: import_zod10.z.object({
-          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        TotalBaseCost: import_zod15.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
         }),
-        TotalDiscountedCost: import_zod10.z.object({
-          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        TotalDiscountedCost: import_zod15.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
         }),
-        TotalDiscountPercent: import_zod10.z.number(),
-        DurationRemainingInSeconds: import_zod10.z.number(),
-        WholesaleOnly: import_zod10.z.boolean(),
-        IsGiftable: import_zod10.z.number()
+        TotalDiscountPercent: import_zod15.z.number(),
+        DurationRemainingInSeconds: import_zod15.z.number(),
+        WholesaleOnly: import_zod15.z.boolean(),
+        IsGiftable: import_zod15.z.number()
       })),
-      FeaturedTileEntries: import_zod10.z.array(import_zod10.z.object({
-        Type: import_zod10.z.number(),
-        Entry: import_zod10.z.object({
-          Bundle: import_zod10.z.object({
-            ID: import_zod10.z.string(),
-            DataAssetID: import_zod10.z.string(),
-            CurrencyID: import_zod10.z.string(),
-            Items: import_zod10.z.array(import_zod10.z.object({
-              Item: import_zod10.z.object({
-                ItemTypeID: import_zod10.z.string(),
-                ItemID: import_zod10.z.string(),
-                Amount: import_zod10.z.number()
+      FeaturedTileEntries: import_zod15.z.array(import_zod15.z.object({
+        Type: import_zod15.z.number(),
+        Entry: import_zod15.z.object({
+          Bundle: import_zod15.z.object({
+            ID: import_zod15.z.string(),
+            DataAssetID: import_zod15.z.string(),
+            CurrencyID: import_zod15.z.string(),
+            Items: import_zod15.z.array(import_zod15.z.object({
+              Item: import_zod15.z.object({
+                ItemTypeID: import_zod15.z.string(),
+                ItemID: import_zod15.z.string(),
+                Amount: import_zod15.z.number()
               }),
-              BasePrice: import_zod10.z.number(),
-              CurrencyID: import_zod10.z.string(),
-              DiscountPercent: import_zod10.z.number(),
-              DiscountedPrice: import_zod10.z.number(),
-              IsPromoItem: import_zod10.z.boolean()
+              BasePrice: import_zod15.z.number(),
+              CurrencyID: import_zod15.z.string(),
+              DiscountPercent: import_zod15.z.number(),
+              DiscountedPrice: import_zod15.z.number(),
+              IsPromoItem: import_zod15.z.boolean()
             })),
-            ItemOffers: import_zod10.z.array(import_zod10.z.object({
-              BundleItemOfferID: import_zod10.z.string(),
-              Offer: import_zod10.z.object({
-                OfferID: import_zod10.z.string(),
-                IsDirectPurchase: import_zod10.z.boolean(),
-                StartDate: import_zod10.z.string(),
-                Cost: import_zod10.z.object({
-                  "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            ItemOffers: import_zod15.z.array(import_zod15.z.object({
+              BundleItemOfferID: import_zod15.z.string(),
+              Offer: import_zod15.z.object({
+                OfferID: import_zod15.z.string(),
+                IsDirectPurchase: import_zod15.z.boolean(),
+                StartDate: import_zod15.z.string(),
+                Cost: import_zod15.z.object({
+                  "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
                 }),
-                Rewards: import_zod10.z.array(import_zod10.z.object({
-                  ItemTypeID: import_zod10.z.string(),
-                  ItemID: import_zod10.z.string(),
-                  Quantity: import_zod10.z.number()
+                Rewards: import_zod15.z.array(import_zod15.z.object({
+                  ItemTypeID: import_zod15.z.string(),
+                  ItemID: import_zod15.z.string(),
+                  Quantity: import_zod15.z.number()
                 }))
               }),
-              DiscountPercent: import_zod10.z.number(),
-              DiscountedCost: import_zod10.z.object({
-                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+              DiscountPercent: import_zod15.z.number(),
+              DiscountedCost: import_zod15.z.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
               })
             })),
-            TotalBaseCost: import_zod10.z.object({
-              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            TotalBaseCost: import_zod15.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
             }),
-            TotalDiscountedCost: import_zod10.z.object({
-              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            TotalDiscountedCost: import_zod15.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
             }),
-            TotalDiscountPercent: import_zod10.z.number(),
-            DurationRemainingInSeconds: import_zod10.z.number(),
-            WholesaleOnly: import_zod10.z.boolean(),
-            IsGiftable: import_zod10.z.number()
+            TotalDiscountPercent: import_zod15.z.number(),
+            DurationRemainingInSeconds: import_zod15.z.number(),
+            WholesaleOnly: import_zod15.z.boolean(),
+            IsGiftable: import_zod15.z.number()
           })
         })
       })),
-      BundleRemainingDurationInSeconds: import_zod10.z.number()
+      BundleRemainingDurationInSeconds: import_zod15.z.number()
     }),
-    SkinsPanelLayout: import_zod10.z.object({
-      SingleItemOffers: import_zod10.z.array(import_zod10.z.string()),
-      SingleItemStoreOffers: import_zod10.z.array(import_zod10.z.object({
-        OfferID: import_zod10.z.string(),
-        IsDirectPurchase: import_zod10.z.boolean(),
-        StartDate: import_zod10.z.string(),
-        Cost: import_zod10.z.object({
-          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+    SkinsPanelLayout: import_zod15.z.object({
+      SingleItemOffers: import_zod15.z.array(import_zod15.z.string()),
+      SingleItemStoreOffers: import_zod15.z.array(import_zod15.z.object({
+        OfferID: import_zod15.z.string(),
+        IsDirectPurchase: import_zod15.z.boolean(),
+        StartDate: import_zod15.z.string(),
+        Cost: import_zod15.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
         }),
-        Rewards: import_zod10.z.array(import_zod10.z.object({
-          ItemTypeID: import_zod10.z.string(),
-          ItemID: import_zod10.z.string(),
-          Quantity: import_zod10.z.number()
+        Rewards: import_zod15.z.array(import_zod15.z.object({
+          ItemTypeID: import_zod15.z.string(),
+          ItemID: import_zod15.z.string(),
+          Quantity: import_zod15.z.number()
         }))
       })),
-      SingleItemOffersRemainingDurationInSeconds: import_zod10.z.number()
+      SingleItemOffersRemainingDurationInSeconds: import_zod15.z.number()
     }),
-    UpgradeCurrencyStore: import_zod10.z.object({
-      UpgradeCurrencyOffers: import_zod10.z.array(import_zod10.z.object({
-        OfferID: import_zod10.z.string(),
-        StorefrontItemID: import_zod10.z.string(),
-        Offer: import_zod10.z.object({
-          OfferID: import_zod10.z.string(),
-          IsDirectPurchase: import_zod10.z.boolean(),
-          StartDate: import_zod10.z.string(),
-          Cost: import_zod10.z.object({
-            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+    UpgradeCurrencyStore: import_zod15.z.object({
+      UpgradeCurrencyOffers: import_zod15.z.array(import_zod15.z.object({
+        OfferID: import_zod15.z.string(),
+        StorefrontItemID: import_zod15.z.string(),
+        Offer: import_zod15.z.object({
+          OfferID: import_zod15.z.string(),
+          IsDirectPurchase: import_zod15.z.boolean(),
+          StartDate: import_zod15.z.string(),
+          Cost: import_zod15.z.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
           }),
-          Rewards: import_zod10.z.array(import_zod10.z.object({
-            ItemTypeID: import_zod10.z.string(),
-            ItemID: import_zod10.z.string(),
-            Quantity: import_zod10.z.number()
+          Rewards: import_zod15.z.array(import_zod15.z.object({
+            ItemTypeID: import_zod15.z.string(),
+            ItemID: import_zod15.z.string(),
+            Quantity: import_zod15.z.number()
           }))
         }),
-        DiscountedPercent: import_zod10.z.number()
+        DiscountedPercent: import_zod15.z.number()
       }))
     }),
-    AccessoryStore: import_zod10.z.object({
-      AccessoryStoreOffers: import_zod10.z.array(import_zod10.z.object({
-        Offer: import_zod10.z.object({
-          OfferID: import_zod10.z.string(),
-          IsDirectPurchase: import_zod10.z.boolean(),
-          StartDate: import_zod10.z.string(),
-          Cost: import_zod10.z.object({
-            "85ca954a-41f2-ce94-9b45-8ca3dd39a00d": import_zod10.z.number()
+    AccessoryStore: import_zod15.z.object({
+      AccessoryStoreOffers: import_zod15.z.array(import_zod15.z.object({
+        Offer: import_zod15.z.object({
+          OfferID: import_zod15.z.string(),
+          IsDirectPurchase: import_zod15.z.boolean(),
+          StartDate: import_zod15.z.string(),
+          Cost: import_zod15.z.object({
+            "85ca954a-41f2-ce94-9b45-8ca3dd39a00d": import_zod15.z.number()
           }),
-          Rewards: import_zod10.z.array(import_zod10.z.object({
-            ItemTypeID: import_zod10.z.string(),
-            ItemID: import_zod10.z.string(),
-            Quantity: import_zod10.z.number()
+          Rewards: import_zod15.z.array(import_zod15.z.object({
+            ItemTypeID: import_zod15.z.string(),
+            ItemID: import_zod15.z.string(),
+            Quantity: import_zod15.z.number()
           }))
         }),
-        ContractID: import_zod10.z.string()
+        ContractID: import_zod15.z.string()
       })),
-      AccessoryStoreRemainingDurationInSeconds: import_zod10.z.number(),
-      StorefrontID: import_zod10.z.string()
+      AccessoryStoreRemainingDurationInSeconds: import_zod15.z.number(),
+      StorefrontID: import_zod15.z.string()
     }),
-    PluginStores: import_zod10.z.array(import_zod10.z.object({
-      PluginID: import_zod10.z.string(),
-      PluginOffers: import_zod10.z.object({
-        StoreOffers: import_zod10.z.array(import_zod10.z.object({
-          PurchaseInformation: import_zod10.z.object({
-            DataAssetID: import_zod10.z.string(),
-            OfferID: import_zod10.z.string(),
-            OfferType: import_zod10.z.number(),
-            StartDate: import_zod10.z.string(),
-            PrimaryCurrencyID: import_zod10.z.string(),
-            Cost: import_zod10.z.object({
-              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+    PluginStores: import_zod15.z.array(import_zod15.z.object({
+      PluginID: import_zod15.z.string(),
+      PluginOffers: import_zod15.z.object({
+        StoreOffers: import_zod15.z.array(import_zod15.z.object({
+          PurchaseInformation: import_zod15.z.object({
+            DataAssetID: import_zod15.z.string(),
+            OfferID: import_zod15.z.string(),
+            OfferType: import_zod15.z.number(),
+            StartDate: import_zod15.z.string(),
+            PrimaryCurrencyID: import_zod15.z.string(),
+            Cost: import_zod15.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
             }),
-            DiscountedCost: import_zod10.z.object({
-              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            DiscountedCost: import_zod15.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
             }),
-            DiscountedPercentage: import_zod10.z.number(),
-            WholesaleOnly: import_zod10.z.boolean(),
-            IsGiftable: import_zod10.z.number()
+            DiscountedPercentage: import_zod15.z.number(),
+            WholesaleOnly: import_zod15.z.boolean(),
+            IsGiftable: import_zod15.z.number()
           }),
-          SubOffers: import_zod10.z.array(import_zod10.z.object({
-            PurchaseInformation: import_zod10.z.object({
-              DataAssetID: import_zod10.z.string(),
-              OfferID: import_zod10.z.string(),
-              OfferType: import_zod10.z.number(),
-              StartDate: import_zod10.z.string(),
-              PrimaryCurrencyID: import_zod10.z.string(),
-              Cost: import_zod10.z.object({
-                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+          SubOffers: import_zod15.z.array(import_zod15.z.object({
+            PurchaseInformation: import_zod15.z.object({
+              DataAssetID: import_zod15.z.string(),
+              OfferID: import_zod15.z.string(),
+              OfferType: import_zod15.z.number(),
+              StartDate: import_zod15.z.string(),
+              PrimaryCurrencyID: import_zod15.z.string(),
+              Cost: import_zod15.z.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
               }),
-              DiscountedCost: import_zod10.z.object({
-                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+              DiscountedCost: import_zod15.z.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
               }),
-              DiscountedPercentage: import_zod10.z.number(),
-              Rewards: import_zod10.z.array(import_zod10.z.object({
-                ItemTypeID: import_zod10.z.string(),
-                ItemID: import_zod10.z.string(),
-                Quantity: import_zod10.z.number()
+              DiscountedPercentage: import_zod15.z.number(),
+              Rewards: import_zod15.z.array(import_zod15.z.object({
+                ItemTypeID: import_zod15.z.string(),
+                ItemID: import_zod15.z.string(),
+                Quantity: import_zod15.z.number()
               })),
-              WholesaleOnly: import_zod10.z.boolean(),
-              IsGiftable: import_zod10.z.number()
+              WholesaleOnly: import_zod15.z.boolean(),
+              IsGiftable: import_zod15.z.number()
             })
           }))
         })),
-        RemainingDurationInSeconds: import_zod10.z.number()
+        RemainingDurationInSeconds: import_zod15.z.number()
       }),
-      StartDate: import_zod10.z.string()
+      StartDate: import_zod15.z.string()
     }))
   }) }
 };
 
 // src/endpoints/riot/voice.ts
-var import_zod11 = require("zod");
+var import_zod16 = require("zod");
 var voiceAudioPropertiesEndpoint = {
   name: "Audio Properties",
   description: "Get audio properties such as if the microphone is in use",
@@ -1481,17 +2026,17 @@ var voiceAudioPropertiesEndpoint = {
   type: "local",
   suffix: "voice-chat/v1/audio-properties",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod11.z.object({
-    fastEnergyMeter: import_zod11.z.number(),
-    isLoopbackEnabled: import_zod11.z.boolean(),
-    isMicActive: import_zod11.z.boolean(),
-    isSpeakerActive: import_zod11.z.boolean(),
-    micEnergy: import_zod11.z.number(),
-    micVolume: import_zod11.z.number(),
-    noiseFloorMeter: import_zod11.z.number(),
-    speakerEnergy: import_zod11.z.number(),
-    speakerVolume: import_zod11.z.number(),
-    speechThresholdMeter: import_zod11.z.number()
+  responses: { "200": import_zod16.z.object({
+    fastEnergyMeter: import_zod16.z.number(),
+    isLoopbackEnabled: import_zod16.z.boolean(),
+    isMicActive: import_zod16.z.boolean(),
+    isSpeakerActive: import_zod16.z.boolean(),
+    micEnergy: import_zod16.z.number(),
+    micVolume: import_zod16.z.number(),
+    noiseFloorMeter: import_zod16.z.number(),
+    speakerEnergy: import_zod16.z.number(),
+    speakerVolume: import_zod16.z.number(),
+    speechThresholdMeter: import_zod16.z.number()
   }) }
 };
 var voiceCaptureDevicesEndpoint = {
@@ -1501,12 +2046,12 @@ var voiceCaptureDevicesEndpoint = {
   type: "local",
   suffix: "voice-chat/v2/devices/capture",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod11.z.array(import_zod11.z.object({
-    handle: import_zod11.z.string(),
-    is_current_device: import_zod11.z.boolean(),
-    is_default: import_zod11.z.boolean(),
-    is_effective_device: import_zod11.z.boolean(),
-    name: import_zod11.z.string()
+  responses: { "200": import_zod16.z.array(import_zod16.z.object({
+    handle: import_zod16.z.string(),
+    is_current_device: import_zod16.z.boolean(),
+    is_default: import_zod16.z.boolean(),
+    is_effective_device: import_zod16.z.boolean(),
+    name: import_zod16.z.string()
   })) }
 };
 var voiceRenderDevicesEndpoint = {
@@ -1516,116 +2061,113 @@ var voiceRenderDevicesEndpoint = {
   type: "local",
   suffix: "voice-chat/v2/devices/render",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod11.z.array(import_zod11.z.object({
-    handle: import_zod11.z.string(),
-    is_current_device: import_zod11.z.boolean(),
-    is_default: import_zod11.z.boolean(),
-    is_effective_device: import_zod11.z.boolean(),
-    name: import_zod11.z.string()
+  responses: { "200": import_zod16.z.array(import_zod16.z.object({
+    handle: import_zod16.z.string(),
+    is_current_device: import_zod16.z.boolean(),
+    is_default: import_zod16.z.boolean(),
+    is_effective_device: import_zod16.z.boolean(),
+    name: import_zod16.z.string()
   })) }
 };
 
 // src/api/groups/pvp.ts
 var pvp = {
-  content: import_valorant_api_types.endpoints.fetchContentEndpoint,
-  accountXp: import_valorant_api_types.endpoints.accountXPEndpoint,
-  playerLoadout: import_valorant_api_types.endpoints.playerLoadoutEndpoint,
-  setPlayerLoadout: import_valorant_api_types.endpoints.setPlayerLoadoutEndpoint,
-  playerMmr: import_valorant_api_types.endpoints.playerMMREndpoint,
-  matchHistory: import_valorant_api_types.endpoints.matchHistoryEndpoint,
-  matchDetails: import_valorant_api_types.endpoints.matchDetailsEndpoint,
-  competitiveUpdates: import_valorant_api_types.endpoints.competitiveUpdatesEndpoint,
-  leaderboard: import_valorant_api_types.endpoints.leaderboardEndpoint,
-  penalties: import_valorant_api_types.endpoints.penaltiesEndpoint,
-  config: import_valorant_api_types.endpoints.configEndpoint,
-  nameService: import_valorant_api_types.endpoints.nameServiceEndpoint,
+  content: import_valorant_api_types10.endpoints.fetchContentEndpoint,
+  accountXp: import_valorant_api_types10.endpoints.accountXPEndpoint,
+  setPlayerLoadout: import_valorant_api_types10.endpoints.setPlayerLoadoutEndpoint,
+  playerMmr: import_valorant_api_types10.endpoints.playerMMREndpoint,
+  matchHistory: import_valorant_api_types10.endpoints.matchHistoryEndpoint,
+  matchDetails: import_valorant_api_types10.endpoints.matchDetailsEndpoint,
+  competitiveUpdates: import_valorant_api_types10.endpoints.competitiveUpdatesEndpoint,
+  leaderboard: import_valorant_api_types10.endpoints.leaderboardEndpoint,
+  penalties: import_valorant_api_types10.endpoints.penaltiesEndpoint,
+  config: configEndpoint,
+  nameService: import_valorant_api_types10.endpoints.nameServiceEndpoint,
   playerLoadoutV3: playerLoadoutV3Endpoint
 };
 
 // src/api/groups/party.ts
-var import_valorant_api_types2 = require("valorant-api-types");
+var import_valorant_api_types11 = require("valorant-api-types");
 var party = {
-  get: import_valorant_api_types2.endpoints.partyEndpoint,
-  player: import_valorant_api_types2.endpoints.partyPlayerEndpoint,
-  removePlayer: import_valorant_api_types2.endpoints.partyRemovePlayerEndpoint,
-  setMemberReady: import_valorant_api_types2.endpoints.partySetMemberReadyEndpoint,
-  refreshCompetitiveTier: import_valorant_api_types2.endpoints.refreshCompetitiveTierEndpoint,
-  refreshPlayerIdentity: import_valorant_api_types2.endpoints.refreshPlayerIdentityEndpoint,
-  refreshPings: import_valorant_api_types2.endpoints.refreshPingsEndpoint,
-  changeQueue: import_valorant_api_types2.endpoints.changeQueueEndpoint,
-  startCustomGame: import_valorant_api_types2.endpoints.startCustomGameEndpoint,
-  enterMatchmakingQueue: import_valorant_api_types2.endpoints.enterMatchmakingQueueEndpoint,
-  leaveMatchmakingQueue: import_valorant_api_types2.endpoints.leaveMatchmakingQueueEndpoint,
-  setAccessibility: import_valorant_api_types2.endpoints.setPartyAccessibilityEndpoint,
-  setCustomGameSettings: import_valorant_api_types2.endpoints.setCustomGameSettingsEndpoint,
-  invite: import_valorant_api_types2.endpoints.partyInviteEndpoint,
-  requestToJoin: import_valorant_api_types2.endpoints.partyRequestEndpoint,
-  declineRequest: import_valorant_api_types2.endpoints.partyDeclineEndpoint,
-  customGameConfigs: import_valorant_api_types2.endpoints.customGameConfigsEndpoint,
-  chatToken: import_valorant_api_types2.endpoints.partyChatTokenEndpoint,
-  voiceToken: import_valorant_api_types2.endpoints.partyVoiceTokenEndpoint,
-  disableCode: import_valorant_api_types2.endpoints.partyDisableCodeEndpoint,
-  generateCode: import_valorant_api_types2.endpoints.partyGenerateCodeEndpoint,
-  joinByCode: import_valorant_api_types2.endpoints.partyJoinByCodeEndpoint
+  get: partyEndpoint,
+  player: import_valorant_api_types11.endpoints.partyPlayerEndpoint,
+  removePlayer: import_valorant_api_types11.endpoints.partyRemovePlayerEndpoint,
+  setMemberReady: partySetMemberReadyEndpoint,
+  refreshCompetitiveTier: refreshCompetitiveTierEndpoint,
+  refreshPlayerIdentity: refreshPlayerIdentityEndpoint,
+  refreshPings: refreshPingsEndpoint,
+  changeQueue: changeQueueEndpoint,
+  startCustomGame: startCustomGameEndpoint,
+  enterMatchmakingQueue: enterMatchmakingQueueEndpoint,
+  leaveMatchmakingQueue: leaveMatchmakingQueueEndpoint,
+  setAccessibility: setPartyAccessibilityEndpoint,
+  setCustomGameSettings: setCustomGameSettingsEndpoint,
+  invite: partyInviteEndpoint,
+  requestToJoin: import_valorant_api_types11.endpoints.partyRequestEndpoint,
+  declineRequest: partyDeclineEndpoint,
+  customGameConfigs: import_valorant_api_types11.endpoints.customGameConfigsEndpoint,
+  disableCode: partyDisableCodeEndpoint,
+  generateCode: partyGenerateCodeEndpoint,
+  joinByCode: import_valorant_api_types11.endpoints.partyJoinByCodeEndpoint,
+  setCustomGameTeam: setCustomGameTeamEndpoint,
+  getCustomGame: customGamePartyEndpoint
 };
 
 // src/api/groups/store.ts
-var import_valorant_api_types3 = require("valorant-api-types");
+var import_valorant_api_types12 = require("valorant-api-types");
 var store = {
-  prices: import_valorant_api_types3.endpoints.pricesEndpoint,
-  storefront: import_valorant_api_types3.endpoints.storefrontEndpoint,
-  wallet: import_valorant_api_types3.endpoints.walletEndpoint,
-  ownedItems: import_valorant_api_types3.endpoints.ownedItemsEndpoint,
+  wallet: import_valorant_api_types12.endpoints.walletEndpoint,
+  ownedItems: ownedItemsEndpoint,
   storefrontV3: storefrontV3Endpoint,
   agentStore: agentStoreEndpoint,
   allEntitlements: allEntitlementsEndpoint
 };
 
 // src/api/groups/pregame.ts
-var import_valorant_api_types4 = require("valorant-api-types");
+var import_valorant_api_types13 = require("valorant-api-types");
 var pregame = {
-  player: import_valorant_api_types4.endpoints.pregamePlayerEndpoint,
-  match: import_valorant_api_types4.endpoints.pregameMatchEndpoint,
-  loadouts: import_valorant_api_types4.endpoints.pregameLoadoutsEndpoint,
-  selectCharacter: import_valorant_api_types4.endpoints.selectCharacterEndpoint,
-  lockCharacter: import_valorant_api_types4.endpoints.lockCharacterEndpoint,
-  quit: import_valorant_api_types4.endpoints.pregameQuitEndpoint
+  player: import_valorant_api_types13.endpoints.pregamePlayerEndpoint,
+  match: pregameMatchEndpoint,
+  loadouts: pregameLoadoutsEndpoint,
+  selectCharacter: selectCharacterEndpoint,
+  lockCharacter: lockCharacterEndpoint,
+  quit: import_valorant_api_types13.endpoints.pregameQuitEndpoint
 };
 
 // src/api/groups/currentGame.ts
-var import_valorant_api_types5 = require("valorant-api-types");
+var import_valorant_api_types14 = require("valorant-api-types");
 var currentGame = {
-  player: import_valorant_api_types5.endpoints.currentGamePlayerEndpoint,
-  match: import_valorant_api_types5.endpoints.currentGameMatchEndpoint,
-  loadouts: import_valorant_api_types5.endpoints.currentGameLoadoutsEndpoint,
-  quit: import_valorant_api_types5.endpoints.currentGameQuitEndpoint
+  player: import_valorant_api_types14.endpoints.currentGamePlayerEndpoint,
+  match: import_valorant_api_types14.endpoints.currentGameMatchEndpoint,
+  loadouts: currentGameLoadoutsEndpoint,
+  quit: import_valorant_api_types14.endpoints.currentGameQuitEndpoint
 };
 
 // src/api/groups/contracts.ts
-var import_valorant_api_types6 = require("valorant-api-types");
+var import_valorant_api_types15 = require("valorant-api-types");
 var contracts = {
-  itemUpgrades: import_valorant_api_types6.endpoints.itemUpgradesEndpoint,
-  list: import_valorant_api_types6.endpoints.contractsEndpoint,
-  activate: import_valorant_api_types6.endpoints.activateContractEndpoint,
+  itemUpgrades: import_valorant_api_types15.endpoints.itemUpgradesEndpoint,
+  list: contractsEndpoint,
+  activate: import_valorant_api_types15.endpoints.activateContractEndpoint,
   activeRecruitmentEvent: activeRecruitmentEventEndpoint
 };
 
 // src/api/groups/local.ts
-var import_valorant_api_types7 = require("valorant-api-types");
+var import_valorant_api_types16 = require("valorant-api-types");
 var local = {
-  help: import_valorant_api_types7.endpoints.localHelpEndpoint,
-  sessions: import_valorant_api_types7.endpoints.sessionsEndpoint,
-  rsoUserInfo: import_valorant_api_types7.endpoints.rsoUserInfoEndpoint,
-  clientRegion: import_valorant_api_types7.endpoints.clientRegionEndpoint,
-  accountAlias: import_valorant_api_types7.endpoints.accountAliasEndpoint,
-  entitlementsToken: import_valorant_api_types7.endpoints.entitlementsTokenEndpoint,
-  chatSession: import_valorant_api_types7.endpoints.chatSessionEndpoint,
-  friends: import_valorant_api_types7.endpoints.friendsEndpoint,
-  sendFriendRequest: import_valorant_api_types7.endpoints.sendFriendRequestEndpoint,
-  removeFriendRequest: import_valorant_api_types7.endpoints.removeFriendRequestEndpoint,
-  presence: import_valorant_api_types7.endpoints.presenceEndpoint,
-  friendRequests: import_valorant_api_types7.endpoints.friendRequestsEndpoint,
-  swaggerDocs: import_valorant_api_types7.endpoints.localSwaggerDocsEndpoint,
+  help: import_valorant_api_types16.endpoints.localHelpEndpoint,
+  sessions: import_valorant_api_types16.endpoints.sessionsEndpoint,
+  rsoUserInfo: import_valorant_api_types16.endpoints.rsoUserInfoEndpoint,
+  clientRegion: import_valorant_api_types16.endpoints.clientRegionEndpoint,
+  accountAlias: import_valorant_api_types16.endpoints.accountAliasEndpoint,
+  entitlementsToken: import_valorant_api_types16.endpoints.entitlementsTokenEndpoint,
+  chatSession: import_valorant_api_types16.endpoints.chatSessionEndpoint,
+  friends: import_valorant_api_types16.endpoints.friendsEndpoint,
+  sendFriendRequest: import_valorant_api_types16.endpoints.sendFriendRequestEndpoint,
+  removeFriendRequest: import_valorant_api_types16.endpoints.removeFriendRequestEndpoint,
+  presence: presenceEndpoint,
+  friendRequests: import_valorant_api_types16.endpoints.friendRequestsEndpoint,
+  swaggerDocs: import_valorant_api_types16.endpoints.localSwaggerDocsEndpoint,
   eula: localEulaEndpoint,
   privacyPolicy: localPrivacyPolicyEndpoint,
   availableLocales: localAvailableLocalesEndpoint,
@@ -1639,15 +2181,15 @@ var local = {
 };
 
 // src/api/groups/chat.ts
-var import_valorant_api_types8 = require("valorant-api-types");
+var import_valorant_api_types17 = require("valorant-api-types");
 var chat = {
-  partyInfo: import_valorant_api_types8.endpoints.partyChatInfoEndpoint,
-  pregameInfo: import_valorant_api_types8.endpoints.pregameChatInfoEndpoint,
-  currentGameInfo: import_valorant_api_types8.endpoints.currentGameChatInfoEndpoint,
-  allInfo: import_valorant_api_types8.endpoints.allChatInfoEndpoint,
-  participants: import_valorant_api_types8.endpoints.chatParticipantsEndpoint,
-  send: import_valorant_api_types8.endpoints.sendChatEndpoint,
-  history: import_valorant_api_types8.endpoints.chatHistoryEndpoint,
+  partyInfo: import_valorant_api_types17.endpoints.partyChatInfoEndpoint,
+  pregameInfo: import_valorant_api_types17.endpoints.pregameChatInfoEndpoint,
+  currentGameInfo: import_valorant_api_types17.endpoints.currentGameChatInfoEndpoint,
+  allInfo: import_valorant_api_types17.endpoints.allChatInfoEndpoint,
+  participants: chatParticipantsEndpoint,
+  send: import_valorant_api_types17.endpoints.sendChatEndpoint,
+  history: import_valorant_api_types17.endpoints.chatHistoryEndpoint,
   settings: chatSettingsEndpoint,
   tournamentInfo: chatTournamentInfoEndpoint
 };
@@ -1695,24 +2237,24 @@ var account = {
 };
 
 // src/api/groups/auth.ts
-var import_valorant_api_types9 = require("valorant-api-types");
+var import_valorant_api_types18 = require("valorant-api-types");
 var auth = {
-  cookies: import_valorant_api_types9.endpoints.authCookiesEndpoint,
-  request: import_valorant_api_types9.endpoints.authRequestEndpoint,
-  multiFactor: import_valorant_api_types9.endpoints.multiFactorAuthenticationEndpoint,
-  cookieReauth: import_valorant_api_types9.endpoints.cookieReauthEndpoint,
-  entitlement: import_valorant_api_types9.endpoints.entitlementEndpoint,
-  playerInfo: import_valorant_api_types9.endpoints.playerInfoEndpoint,
-  riotGeo: import_valorant_api_types9.endpoints.riotGeoEndpoint,
-  pasToken: import_valorant_api_types9.endpoints.pasTokenEndpoint,
-  riotClientConfig: import_valorant_api_types9.endpoints.riotClientConfigEndpoint
+  cookies: import_valorant_api_types18.endpoints.authCookiesEndpoint,
+  request: import_valorant_api_types18.endpoints.authRequestEndpoint,
+  multiFactor: import_valorant_api_types18.endpoints.multiFactorAuthenticationEndpoint,
+  cookieReauth: import_valorant_api_types18.endpoints.cookieReauthEndpoint,
+  entitlement: import_valorant_api_types18.endpoints.entitlementEndpoint,
+  playerInfo: import_valorant_api_types18.endpoints.playerInfoEndpoint,
+  riotGeo: import_valorant_api_types18.endpoints.riotGeoEndpoint,
+  pasToken: import_valorant_api_types18.endpoints.pasTokenEndpoint,
+  riotClientConfig: import_valorant_api_types18.endpoints.riotClientConfigEndpoint
 };
 
 // src/endpoints/catalog/index.ts
-var import_zod14 = require("zod");
+var import_zod19 = require("zod");
 
 // src/endpoints/catalog/factory.ts
-var import_zod12 = require("zod");
+var import_zod17 = require("zod");
 
 // src/envelope.ts
 var enveloped = /* @__PURE__ */ new WeakSet();
@@ -1731,7 +2273,7 @@ function unwrapEnvelope(endpoint2, body) {
 var BASE = "https://valorant-api.com/v1/";
 function query(queryParams = []) {
   return new Map([
-    ["language", import_zod12.z.string().optional().describe("Language code such as `fr-FR`. Defaults to `en-US`.")],
+    ["language", import_zod17.z.string().optional().describe("Language code such as `fr-FR`. Defaults to `en-US`.")],
     ...queryParams
   ]);
 }
@@ -1748,16 +2290,16 @@ function endpoint(name, description, path, schema, queryParams = []) {
 }
 function collection(title, singular, path, schema, queryParams = []) {
   return {
-    list: endpoint(title, `List of ${title.toLowerCase()}`, path, import_zod12.z.array(schema), queryParams),
+    list: endpoint(title, `List of ${title.toLowerCase()}`, path, import_zod17.z.array(schema), queryParams),
     one: endpoint(singular, `One ${singular.toLowerCase()} by UUID`, `${path}/{uuid}`, schema)
   };
 }
 
 // src/endpoints/catalog/schemas.ts
-var import_zod13 = require("zod");
-var text = import_zod13.z.string().nullish();
-var asset = import_zod13.z.object({
-  uuid: import_zod13.z.string(),
+var import_zod18 = require("zod");
+var text = import_zod18.z.string().nullish();
+var asset = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
   displayName: text,
   displayIcon: text,
   assetPath: text
@@ -1765,70 +2307,70 @@ var asset = import_zod13.z.object({
 var agentSchema = asset.extend({
   description: text,
   developerName: text,
-  characterTags: import_zod13.z.array(import_zod13.z.string()).nullish(),
+  characterTags: import_zod18.z.array(import_zod18.z.string()).nullish(),
   displayIconSmall: text,
   bustPortrait: text,
   fullPortrait: text,
   killfeedPortrait: text,
   background: text,
-  isPlayableCharacter: import_zod13.z.boolean(),
-  role: import_zod13.z.object({ uuid: import_zod13.z.string(), displayName: text, description: text, displayIcon: text }).passthrough().nullish(),
-  abilities: import_zod13.z.array(import_zod13.z.object({ slot: import_zod13.z.string(), displayName: text, description: text, displayIcon: text }).passthrough()).nullish()
+  isPlayableCharacter: import_zod18.z.boolean(),
+  role: import_zod18.z.object({ uuid: import_zod18.z.string(), displayName: text, description: text, displayIcon: text }).passthrough().nullish(),
+  abilities: import_zod18.z.array(import_zod18.z.object({ slot: import_zod18.z.string(), displayName: text, description: text, displayIcon: text }).passthrough()).nullish()
 });
 var mapSchema = asset.extend({
   coordinates: text,
   listViewIcon: text,
   splash: text,
   mapUrl: text,
-  xMultiplier: import_zod13.z.number(),
-  yMultiplier: import_zod13.z.number(),
-  xScalarToAdd: import_zod13.z.number(),
-  yScalarToAdd: import_zod13.z.number(),
-  callouts: import_zod13.z.array(import_zod13.z.object({ regionName: import_zod13.z.string(), superRegionName: import_zod13.z.string(), location: import_zod13.z.object({ x: import_zod13.z.number(), y: import_zod13.z.number() }) }).passthrough()).nullish()
+  xMultiplier: import_zod18.z.number(),
+  yMultiplier: import_zod18.z.number(),
+  xScalarToAdd: import_zod18.z.number(),
+  yScalarToAdd: import_zod18.z.number(),
+  callouts: import_zod18.z.array(import_zod18.z.object({ regionName: import_zod18.z.string(), superRegionName: import_zod18.z.string(), location: import_zod18.z.object({ x: import_zod18.z.number(), y: import_zod18.z.number() }) }).passthrough()).nullish()
 });
 var weaponSchema = asset.extend({
-  category: import_zod13.z.string(),
-  defaultSkinUuid: import_zod13.z.string(),
+  category: import_zod18.z.string(),
+  defaultSkinUuid: import_zod18.z.string(),
   killStreamIcon: text,
-  weaponStats: import_zod13.z.object({}).passthrough().nullish(),
-  shopData: import_zod13.z.object({}).passthrough().nullish(),
-  skins: import_zod13.z.array(import_zod13.z.object({}).passthrough())
+  weaponStats: import_zod18.z.object({}).passthrough().nullish(),
+  shopData: import_zod18.z.object({}).passthrough().nullish(),
+  skins: import_zod18.z.array(import_zod18.z.object({}).passthrough())
 });
 var skinSchema = asset.extend({
-  themeUuid: import_zod13.z.string(),
+  themeUuid: import_zod18.z.string(),
   contentTierUuid: text,
   wallpaper: text,
-  chromas: import_zod13.z.array(asset.passthrough()),
-  levels: import_zod13.z.array(asset.passthrough())
+  chromas: import_zod18.z.array(asset.passthrough()),
+  levels: import_zod18.z.array(asset.passthrough())
 });
-var seasonSchema = import_zod13.z.object({
-  uuid: import_zod13.z.string(),
+var seasonSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
   displayName: text,
   type: text,
-  startTime: import_zod13.z.string(),
-  endTime: import_zod13.z.string(),
+  startTime: import_zod18.z.string(),
+  endTime: import_zod18.z.string(),
   parentUuid: text,
   assetPath: text
 }).passthrough();
-var versionSchema = import_zod13.z.object({
-  manifestId: import_zod13.z.string(),
-  branch: import_zod13.z.string(),
-  version: import_zod13.z.string(),
-  buildVersion: import_zod13.z.string(),
-  engineVersion: import_zod13.z.string(),
-  riotClientVersion: import_zod13.z.string().describe("Value of the X-Riot-ClientVersion header"),
-  riotClientBuild: import_zod13.z.string(),
-  buildDate: import_zod13.z.string()
+var versionSchema = import_zod18.z.object({
+  manifestId: import_zod18.z.string(),
+  branch: import_zod18.z.string(),
+  version: import_zod18.z.string(),
+  buildVersion: import_zod18.z.string(),
+  engineVersion: import_zod18.z.string(),
+  riotClientVersion: import_zod18.z.string().describe("Value of the X-Riot-ClientVersion header"),
+  riotClientBuild: import_zod18.z.string(),
+  buildDate: import_zod18.z.string()
 }).passthrough();
 
 // src/endpoints/catalog/index.ts
-var playable = [["isPlayableCharacter", import_zod14.z.boolean().optional().describe("Only return playable agents. Skips the duplicate Sova.")]];
+var playable = [["isPlayableCharacter", import_zod19.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", import_zod14.z.object({ uuid: import_zod14.z.string(), tiers: import_zod14.z.array(import_zod14.z.object({ tier: import_zod14.z.number(), tierName: text, division: text, color: text }).passthrough()) }).passthrough());
+var competitiveTiers = collection("Competitive Tiers", "Competitive Tier Set", "competitivetiers", import_zod19.z.object({ uuid: import_zod19.z.string(), tiers: import_zod19.z.array(import_zod19.z.object({ tier: import_zod19.z.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);
@@ -1839,11 +2381,11 @@ var gamemodeEquippables = collection("Gamemode Equippables", "Gamemode Equippabl
 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", import_zod14.z.object({ uuid: import_zod14.z.string(), displayName: text }).passthrough());
+var missions = collection("Missions", "Mission", "missions", import_zod19.z.object({ uuid: import_zod19.z.string(), displayName: text }).passthrough());
 var playerCards = collection("Player Cards", "Player Card", "playercards", asset);
-var playerTitles = collection("Player Titles", "Player Title", "playertitles", import_zod14.z.object({ uuid: import_zod14.z.string(), displayName: text, titleText: text }).passthrough());
+var playerTitles = collection("Player Titles", "Player Title", "playertitles", import_zod19.z.object({ uuid: import_zod19.z.string(), displayName: text, titleText: text }).passthrough());
 var seasons = collection("Seasons", "Season", "seasons", seasonSchema);
-var competitiveSeasons = collection("Competitive Seasons", "Competitive Season", "seasons/competitive", import_zod14.z.object({ uuid: import_zod14.z.string(), seasonUuid: import_zod14.z.string(), startTime: import_zod14.z.string(), endTime: import_zod14.z.string() }).passthrough());
+var competitiveSeasons = collection("Competitive Seasons", "Competitive Season", "seasons/competitive", import_zod19.z.object({ uuid: import_zod19.z.string(), seasonUuid: import_zod19.z.string(), startTime: import_zod19.z.string(), endTime: import_zod19.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);
@@ -1934,7 +2476,7 @@ var registry = {
 };
 
 // src/auth.ts
-var import_valorant_api_types10 = require("valorant-api-types");
+var import_valorant_api_types19 = require("valorant-api-types");
 
 // src/errors.ts
 var ValorantError = class extends Error {
@@ -2063,7 +2605,7 @@ function createAuthFlows(client) {
       return toLoginResult(data);
     },
     async reauthenticate(options) {
-      const response = await client.send(import_valorant_api_types10.endpoints.cookieReauthEndpoint);
+      const response = await client.send(import_valorant_api_types19.endpoints.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);
@@ -2095,7 +2637,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",
@@ -2255,7 +2797,7 @@ var localTransport = async (request) => {
 };
 
 // src/internal/body.ts
-var import_zod15 = require("zod");
+var import_zod20 = require("zod");
 function parseBody(text2) {
   if (text2 === "") return void 0;
   try {
@@ -2268,9 +2810,9 @@ function safeParse(schema, data) {
   try {
     return schema.safeParse(data);
   } catch (thrown) {
-    if (thrown instanceof import_zod15.ZodError) return { success: false, error: thrown };
+    if (thrown instanceof import_zod20.ZodError) return { success: false, error: thrown };
     const message = thrown instanceof Error ? thrown.message : String(thrown);
-    return { success: false, error: new import_zod15.ZodError([{ code: "custom", path: [], message: `Schema transform threw: ${message}` }]) };
+    return { success: false, error: new import_zod20.ZodError([{ code: "custom", path: [], message: `Schema transform threw: ${message}` }]) };
   }
 }
 
@@ -2331,6 +2873,181 @@ function toApiError(endpoint2, request, response) {
   return new ValorantApiError(...args);
 }
 
+// src/internal/normalize.ts
+var import_zod21 = require("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 import_zod21.z.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(":");
@@ -2358,7 +3075,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) });
       }
@@ -2367,9 +3083,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);
@@ -2388,7 +3104,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();
@@ -2414,8 +3130,20 @@ 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
-var import_valorant_api_types11 = require("valorant-api-types");
+var import_valorant_api_types20 = require("valorant-api-types");
 
 // src/types.ts
 function paramName(variable) {
@@ -2442,11 +3170,11 @@ function resolveBase(endpoint2, ctx) {
   switch (endpoint2.type) {
     case "pd":
     case "shared":
-      return (0, import_valorant_api_types11.typeToPrefix)({ type: endpoint2.type, shard: ctx.require("shard") });
+      return (0, import_valorant_api_types20.typeToPrefix)({ type: endpoint2.type, shard: ctx.require("shard") });
     case "glz":
-      return (0, import_valorant_api_types11.typeToPrefix)({ type: "glz", shard: ctx.require("shard"), region: ctx.require("region") });
+      return (0, import_valorant_api_types20.typeToPrefix)({ type: "glz", shard: ctx.require("shard"), region: ctx.require("region") });
     case "local":
-      return (0, import_valorant_api_types11.typeToPrefix)({ type: "local", port: ctx.require("localPort") });
+      return (0, import_valorant_api_types20.typeToPrefix)({ type: "local", port: ctx.require("localPort") });
     case "other":
       return "";
   }
@@ -2467,7 +3195,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");
@@ -2511,7 +3239,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 ?? {};
@@ -2563,6 +3291,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) {
@@ -2579,7 +3309,8 @@ var ValorantClient = class {
   }
   #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;
@@ -2598,10 +3329,53 @@ var ValorantClient = class {
   }
 };
 
+// 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
 __reExport(index_exports, require("valorant-api-types"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Agent,
+  CustomGameMap,
+  CustomGameMode,
+  CustomGameTeam,
+  MEMBERSHIP_KEY,
   MissingContextError,
   MissingParameterError,
   ValorantApiError,
@@ -2612,6 +3386,9 @@ __reExport(index_exports, require("valorant-api-types"), module.exports);
   ValorantNetworkError,
   ValorantRateLimitError,
   ValorantValidationError,
+  agentName,
+  customGameMapName,
+  customGameModeName,
   fetchTransport,
   isRegion,
   localTransport,
@@ -2620,6 +3397,7 @@ __reExport(index_exports, require("valorant-api-types"), module.exports);
   readLockfile,
   registry,
   shardForRegion,
+  teamOfPlayer,
   ...require("valorant-api-types")
 });
 //# sourceMappingURL=index.cjs.map