Variable wowConst

Type Declaration

• accountCollectionsIndex: (token: string) => ProtectedResource<AccountCollectionsIndexResponse>

• accountHeirloomsCollectionSummary: (token: string) => ProtectedResource<AccountHeirloomsCollectionSummaryResponse>

• accountMountsCollectionSummary: (token: string) => ProtectedResource<AccountMountsCollectionSummaryResponse>

• accountPetsCollectionSummary: (token: string) => ProtectedResource<AccountPetsCollectionSummaryResponse>

• accountProfileSummary: (token: string) => ProtectedResource<AccountProfileSummaryResponse>

• accountToysCollectionSummary: (token: string) => ProtectedResource<AccountToysCollectionSummaryResponse>

• accountTransmogsCollectionSummary: (token: string) => ProtectedResource<AccountTransmogsCollectionSummaryResponse>

• achievement: (
      achievementId: number,
  ) => {
      _responseType?: AchievementResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• achievementCategory: (
      achievementCategoryId: number,
  ) => {
      _responseType?: AchievementCategoryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• achievementCategoryIndex: () => {
      _responseType?: AchievementCategoryIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• achievementIndex: () => {
      _responseType?: AchievementIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• achievementMedia: (
      achievementId: number,
  ) => {
      _responseType?: AchievementMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• auctions: (
      connectedRealmId: number,
  ) => {
      _responseType?: AuctionHouseResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• azeriteEssence: (
      azeriteEssenceId: number,
  ) => {
      _responseType?: AzeriteEssenceResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• azeriteEssenceIndex: () => {
      _responseType?: AzeriteEssenceIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• azeriteEssenceMedia: (
      azeriteEssenceId: number,
  ) => {
      _responseType?: AzeriteEssenceMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• azeriteEssenceSearch: (
      options: AzeriteEssenceSearchParameters,
  ) => {
      _responseType?: SearchResponse<AzeriteEssenceSearchResponseItem>;
      namespace?: BlizzardNamespaces;
      parameters?: AzeriteEssenceSearchParameters;
      path: string;
  }

• characterAchievementsSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterAchievementsSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterAchievementStatistics: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterAchievementStatisticsResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterAppearanceSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterAppearanceResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterCollectionsIndex: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterCollectionsIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterCompletedQuests: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterCompletedQuestsResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterDungeons: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterDungeonsResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterEncountersSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterEncountersSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterEquipmentSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterEquipmentSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterHeirloomsCollectionSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterHeirloomsCollectionSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterHunterPetsSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterHunterPetsSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterMediaSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterMediaSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterMountsCollectionSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterMountsCollectionSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterMythicKeystoneProfileIndex: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterMythicKeystoneProfileIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterMythicKeystoneSeasonDetails: (
      realmSlug: string,
      characterName: string,
      seasonId: number,
  ) => {
      _responseType?: CharacterMythicKeystoneSeasonDetailsResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterPetsCollectionSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterPetsCollectionSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterProfessionsSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterProfessionsSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterProfileStatus: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterProfileStatusResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterProfileSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterProfileSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterPvpBracketStatistics: (
      realmSlug: string,
      characterName: string,
      bracketId: "2v2" | `shuffle-${string}-${string}` | "3v3" | "rbg",
  ) => {
      _responseType?: CharacterPvpBracketStatisticsResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterPvpSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterPvpSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterQuests: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterQuestsResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterRaids: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterRaidsResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterReputationsSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterReputationsSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterSoulbinds: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterSoulbindsResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterSpecializationsSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterSpecializationsSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterStatisticsSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterStatisticsSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterTitlesSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterTitlesSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterToysCollectionSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterToysCollectionSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• characterTransmogCollectionSummary: (
      realmSlug: string,
      characterName: string,
  ) => {
      _responseType?: CharacterTransmogCollectionSummaryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• commodities: () => {
      _responseType?: AuctionHouseCommoditiesResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• conduit: (
      conduitId: number,
  ) => {
      _responseType?: ConduitResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• conduitIndex: () => {
      _responseType?: ConduitIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• connectedRealm: (
      connectedRealmId: number,
  ) => {
      _responseType?: ConnectedRealmResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• connectedRealmIndex: () => {
      _responseType?: ConnectedRealmIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• connectedRealmSearch: (
      options: ConnectedRealmSearchParameters,
  ) => {
      _responseType?: SearchResponse<ConnectedRealmSearchResponseItem>;
      namespace?: BlizzardNamespaces;
      parameters?: ConnectedRealmSearchParameters;
      path: string;
  }

• covenant: (
      covenantId: number,
  ) => {
      _responseType?: CovenantResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• covenantIndex: () => {
      _responseType?: CovenantIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• covenantMedia: (
      covenantId: number,
  ) => {
      _responseType?: CovenantMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• creature: (
      creatureId: number,
  ) => {
      _responseType?: CreatureResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• creatureDisplayMedia: (
      creatureDisplayId: number,
  ) => {
      _responseType?: CreatureDisplayMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• creatureFamily: (
      creatureFamilyId: number,
  ) => {
      _responseType?: CreatureFamilyResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• creatureFamilyIndex: () => {
      _responseType?: CreatureFamilyIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• creatureFamilyMedia: (
      creatureFamilyId: number,
  ) => {
      _responseType?: CreatureFamilyMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• creatureSearch: (
      options: CreatureSearchParameters,
  ) => {
      _responseType?: SearchResponse<CreatureSearchResponseItem>;
      namespace?: BlizzardNamespaces;
      parameters?: Omit<CreatureSearchParameters, "name" | "locale">;
      path: string;
  }

• creatureType: (
      creatureTypeId: number,
  ) => {
      _responseType?: CreatureTypeResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• creatureTypeIndex: () => {
      _responseType?: CreatureTypeIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• guild: (
      realmSlug: string,
      nameSlug: string,
  ) => {
      _responseType?: GuildResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• guildAchievements: (
      realmSlug: string,
      nameSlug: string,
  ) => {
      _responseType?: GuildAchievementsResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• guildActivity: (
      realmSlug: string,
      nameSlug: string,
  ) => {
      _responseType?: GuildActivityResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• guildCrestBorder: (
      borderId: number,
  ) => {
      _responseType?: GuildCrestBorderEmblemResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• guildCrestComponentsIndex: () => {
      _responseType?: GuildCrestComponentsIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• guildCrestEmblem: (
      emblemId: number,
  ) => {
      _responseType?: GuildCrestBorderEmblemResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• guildRoster: (
      realmSlug: string,
      nameSlug: string,
  ) => {
      _responseType?: GuildRosterResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• heirloom: (
      heirloomId: number,
  ) => {
      _responseType?: HeirloomResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• heirloomIndex: () => {
      _responseType?: HeirloomIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• item: (
      itemId: number,
  ) => {
      _responseType?: ItemResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• itemClass: (
      itemClassId: number,
  ) => {
      _responseType?: ItemClassResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• itemClassIndex: () => {
      _responseType?: ItemClassIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• itemMedia: (
      itemId: number,
  ) => {
      _responseType?: ItemMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• itemSearch: (
      options: ItemSearchParameters,
  ) => {
      _responseType?: SearchResponse<ItemSearchResponseItem>;
      namespace?: BlizzardNamespaces;
      parameters?: Omit<ItemSearchParameters, "name" | "locale">;
      path: string;
  }

• itemSet: (
      itemSetId: number,
  ) => {
      _responseType?: ItemSetResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• itemSetIndex: () => {
      _responseType?: ItemSetIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• itemSubClass: (
      itemClassId: number,
      itemSubclassId: number,
  ) => {
      _responseType?: ItemSubClassResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• journalEncounter: (
      journalEncounterId: number,
  ) => {
      _responseType?: JournalEncounterResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• journalEncounterIndex: () => {
      _responseType?: JournalEncounterIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• journalEncounterSearch: (
      options: JournalEncounterSearchParameters,
  ) => {
      _responseType?: SearchResponse<JournalEncounterSearchResponseItem>;
      namespace?: BlizzardNamespaces;
      parameters?: Omit<
          JournalEncounterSearchParameters,
          "locale"
          | "instanceName",
      >;
      path: string;
  }

• journalExpansion: (
      journalExpansionId: number,
  ) => {
      _responseType?: JournalExpansionResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• journalExpansionIndex: () => {
      _responseType?: JournalExpansionIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• journalInstance: (
      journalInstanceId: number,
  ) => {
      _responseType?: JournalInstanceResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• journalInstanceIndex: () => {
      _responseType?: JournalInstanceIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• journalInstanceMedia: (
      journalInstanceId: number,
  ) => {
      _responseType?: JournalInstanceMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mediaSearch: (
      options: MediaSearchParameters,
  ) => {
      _responseType?: SearchResponse<MediaSearchResponseItem>;
      namespace?: BlizzardNamespaces;
      parameters?: MediaSearchParameters;
      path: string;
  }

• modifiedCraftingCategory: (
      modifiedCraftingCategoryId: number,
  ) => {
      _responseType?: ModifiedCraftingCategoryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• modifiedCraftingCategoryIndex: () => {
      _responseType?: ModifiedCraftingCategoryIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• modifiedCraftingIndex: () => {
      _responseType?: ModifiedCraftingIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• modifiedCraftingReagentSlotType: (
      modifiedCraftingReagentSlotTypeId: number,
  ) => {
      _responseType?: ModifiedCraftingReagentSlotTypeResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• modifiedCraftingReagentSlotTypeIndex: () => {
      _responseType?: ModifiedCraftingReagentSlotTypeIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mount: (
      mountId: number,
  ) => {
      _responseType?: MountResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mountIndex: () => {
      _responseType?: MountIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mountSearch: (
      options: MountSearchParameters,
  ) => {
      _responseType?: SearchResponse<MountSearchResponseItem>;
      namespace?: BlizzardNamespaces;
      parameters?: Omit<MountSearchParameters, "name" | "locale">;
      path: string;
  }

• mythicKeystoneAffix: (
      mythicKeystoneAffixId: number,
  ) => {
      _responseType?: MythicKeystoneAffixResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mythicKeystoneAffixIndex: () => {
      _responseType?: MythicKeystoneAffixIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mythicKeystoneAffixMedia: (
      mythicKeystoneAffixId: number,
  ) => {
      _responseType?: MythicKeystoneAffixMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mythicKeystoneDungeon: (
      mythicKeystoneDungeonId: number,
  ) => {
      _responseType?: MythicKeystoneDungeonResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mythicKeystoneDungeonIndex: () => {
      _responseType?: MythicKeystoneDungeonIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mythicKeystoneIndex: () => {
      _responseType?: MythicKeystoneIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mythicKeystoneLeaderboard: (
      connectedRealmId: number,
      dungeonId: number,
      period: number,
  ) => {
      _responseType?: MythicKeystoneLeaderboardResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mythicKeystoneLeaderboardIndex: (
      connectedRealmId: number,
  ) => {
      _responseType?: MythicKeystoneLeaderboardIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mythicKeystonePeriod: (
      mythicKeystonePeriodId: number,
  ) => {
      _responseType?: MythicKeystonePeriodResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mythicKeystonePeriodIndex: () => {
      _responseType?: MythicKeystonePeriodIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mythicKeystoneSeason: (
      mythicKeystoneSeasonId: number,
  ) => {
      _responseType?: MythicKeystoneSeasonResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mythicKeystoneSeasonIndex: () => {
      _responseType?: MythicKeystoneSeasonIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• mythicRaidLeaderboard: (
      raid: string,
      faction: "alliance" | "horde",
  ) => {
      _responseType?: MythicRaidLeaderboardResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• pet: (
      petId: number,
  ) => {
      _responseType?: PetResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• petAbility: (
      petAbilityId: number,
  ) => {
      _responseType?: PetAbilityResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• petAbilityIndex: () => {
      _responseType?: PetAbilityIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• petAbilityMedia: (
      petAbilityId: number,
  ) => {
      _responseType?: PetAbilityMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• petIndex: () => {
      _responseType?: PetIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• petMedia: (
      petId: number,
  ) => {
      _responseType?: PetMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• playableClass: (
      playableClassId: number,
  ) => {
      _responseType?: PlayableClassResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• playableClassIndex: () => {
      _responseType?: PlayableClassIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• playableClassMedia: (
      playableClassId: number,
  ) => {
      _responseType?: PlayableClassMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• playableRace: (
      playableRaceId: number,
  ) => {
      _responseType?: PlayableRaceResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• playableRaceIndex: () => {
      _responseType?: PlayableRaceIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• playableSpecialization: (
      specializationId: number,
  ) => {
      _responseType?: PlayableSpecializationResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• playableSpecializationIndex: () => {
      _responseType?: PlayableSpecializationIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• playableSpecializationMedia: (
      specializationId: number,
  ) => {
      _responseType?: PlayableSpecializationMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• powerType: (
      powerTypeId: number,
  ) => {
      _responseType?: PowerTypeResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• powerTypeIndex: () => {
      _responseType?: PowerTypeIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• profession: (
      professionId: number,
  ) => {
      _responseType?: ProfessionResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• professionIndex: () => {
      _responseType?: ProfessionIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• professionMedia: (
      professionId: number,
  ) => {
      _responseType?: ProfessionMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• professionSkillTier: (
      professionId: number,
      skillTierId: number,
  ) => {
      _responseType?: ProfessionSkillTierResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• protectedCharacterProfileSummary: (
      realmId: number,
      characterId: number,
      token: string,
  ) => ProtectedResource<ProtectedCharacterProfileSummaryResponse>

• pvpLeaderboard: (
      pvpSeasonId: number,
      bracket: string,
  ) => {
      _responseType?: PvpLeaderboardResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• pvpLeaderboardIndex: (
      pvpSeasonId: number,
  ) => {
      _responseType?: PvpLeaderboardIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• pvpRewardsIndex: (
      pvpSeasonId: number,
  ) => {
      _responseType?: PvpRewardsIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• pvpSeason: (
      pvpSeasonId: number,
  ) => {
      _responseType?: PvpSeasonResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• pvpSeasonIndex: () => {
      _responseType?: PvpSeasonIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• pvpTalent: (
      pvpTalentId: number,
  ) => {
      _responseType?: PvpTalentResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• pvpTalentIndex: () => {
      _responseType?: PvpTalentIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• pvpTalentSlots: (
      playableClassId: number,
  ) => {
      _responseType?: PvpTalentSlotsResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• pvpTier: (
      pvpTierId: number,
  ) => {
      _responseType?: PvpTierResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• pvpTierIndex: () => {
      _responseType?: PvpTierIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• pvpTierMedia: (
      pvpTierId: number,
  ) => {
      _responseType?: PvpTierMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• quest: (
      questId: number,
  ) => {
      _responseType?: QuestResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• questArea: (
      questAreaId: number,
  ) => {
      _responseType?: QuestAreaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• questAreaIndex: () => {
      _responseType?: QuestAreaIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• questCategory: (
      questCategoryId: number,
  ) => {
      _responseType?: QuestCategoryResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• questCategoryIndex: () => {
      _responseType?: QuestCategoryIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• questIndex: () => {
      _responseType?: QuestIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• questType: (
      questTypeId: number,
  ) => {
      _responseType?: QuestTypeResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• questTypeIndex: () => {
      _responseType?: QuestTypeIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• realm: (
      realmSlug: string,
  ) => {
      _responseType?: RealmResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• realmIndex: () => {
      _responseType?: RealmIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• realmSearch: (
      options: RealmSearchParameters,
  ) => {
      _responseType?: SearchResponse<RealmSearchResponseItem>;
      namespace?: BlizzardNamespaces;
      parameters?: RealmSearchParameters;
      path: string;
  }

• recipe: (
      recipeId: number,
  ) => {
      _responseType?: RecipeResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• recipeMedia: (
      recipeId: number,
  ) => {
      _responseType?: RecipeMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• region: (
      regionId: number,
  ) => {
      _responseType?: RegionResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• regionIndex: () => {
      _responseType?: RegionIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• reputationFaction: (
      reputationFactionId: number,
  ) => {
      _responseType?: ReputationFactionResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• reputationFactionIndex: () => {
      _responseType?: ReputationFactionIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• reputationTiers: (
      reputationTiersId: number,
  ) => {
      _responseType?: ReputationTiersResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• reputationTiersIndex: () => {
      _responseType?: ReputationTiersIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• soulbind: (
      soulbindId: number,
  ) => {
      _responseType?: SoulbindResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• soulbindIndex: () => {
      _responseType?: SoulbindIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• spell: (
      spellId: number,
  ) => {
      _responseType?: SpellResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• spellMedia: (
      spellId: number,
  ) => {
      _responseType?: SpellMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• spellSearch: (
      options: SpellSearchParameters,
  ) => {
      _responseType?: SearchResponse<SpellSearchResponseItem>;
      namespace?: BlizzardNamespaces;
      parameters?: Omit<SpellSearchParameters, "name" | "locale">;
      path: string;
  }

• talentIndex: () => {
      _responseType?: TalentIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• talentTree: (
      talentTreeId: number,
      specId: number,
  ) => {
      _responseType?: TalentTreeResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• talentTreeIndex: () => {
      _responseType?: TalentTreeIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• talentTreeNodes: (
      talentTreeId: number,
  ) => {
      _responseType?: TalentTreeNodesResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• techTalent: (
      techTalentId: number,
  ) => {
      _responseType?: TechTalentResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• techTalentIndex: () => {
      _responseType?: TechTalentIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• techTalentMedia: (
      techTalentId: number,
  ) => {
      _responseType?: TechTalentMediaResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• techTalentTree: (
      techTalentTreeId: number,
  ) => {
      _responseType?: TechTalentTreeResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• techTalentTreeIndex: () => {
      _responseType?: TechTalentTreeIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• title: (
      titleId: number,
  ) => {
      _responseType?: TitleResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• titleIndex: () => {
      _responseType?: TitleIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• toy: (
      toyId: number,
  ) => {
      _responseType?: ToyResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• toyIndex: () => {
      _responseType?: ToyIndexResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }

• wowToken: () => {
      _responseType?: WowTokenResponse;
      namespace?: BlizzardNamespaces;
      parameters?: Record<string, unknown>;
      path: string;
  }