nhle-api 0.5.3 → 0.5.4

package/lib/index.cjs

@@ -8,24 +8,25 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/api/gamecenter/index.ts
-var gamecenter_exports = {};
-__export(gamecenter_exports, {
-  draft: () => draft_exports,
-  game: () => game_exports,
-  misc: () => misc_exports,
-  player: () => player_exports,
-  score: () => score,
-  scoreboard: () => scoreboard,
-  team: () => team_exports
+// src/api/edge-adv/index.ts
+var edge_adv_exports2 = {};
+__export(edge_adv_exports2, {
+  byTheNumbers: () => byTheNumbers,
+  goalies: () => goalies_exports,
+  skaters: () => skaters_exports,
+  teams: () => teams_exports
 });
 
-// src/api/gamecenter/draft.ts
-var draft_exports = {};
-__export(draft_exports, {
-  picks: () => picks,
-  rankings: () => rankings,
-  tracker: () => tracker
+// src/api/edge-adv/goalies.ts
+var goalies_exports = {};
+__export(goalies_exports, {
+  compare: () => compare,
+  leaders: () => leaders,
+  player: () => player,
+  saveLocation: () => saveLocation,
+  savePercentage: () => savePercentage,
+  savePercentage5v5: () => savePercentage5v5,
+  top10: () => top10
 });
 
 // src/config/env.ts
@@ -316,16 +317,13 @@ var ErrorHandler = class {
 };
 new ErrorHandler();
 
-// src/client/types.ts
-var API_BASE_URLS = {
-  "edge-adv": "https://api-web.nhle.com/v1",
-  "edge-stats": "https://api.nhle.com/stats/rest",
-  default: "https://api-web.nhle.com/v1"
-};
-
 // src/client/index.ts
+var BASE_URLS = {
+  gamecenter: "https://api-web.nhle.com/v1",
+  edgeStats: "https://api.nhle.com/stats/rest"
+};
 var DEFAULT_CONFIG = {
-  baseUrl: "https://api-web.nhle.com/v1",
+  baseUrl: BASE_URLS.gamecenter,
   timeout: envConfig.timeout,
   headers: {
     Accept: "application/json"
@@ -342,11 +340,7 @@ var NHLClient = class {
    */
   constructor(baseURL, errorConfig) {
     this.config = { ...DEFAULT_CONFIG };
-    if (baseURL && baseURL in API_BASE_URLS) {
-      this.config.baseUrl = API_BASE_URLS[baseURL];
-    } else if (baseURL) {
-      this.config.baseUrl = baseURL;
-    }
+    if (baseURL) this.config.baseUrl = baseURL;
     this.errorHandler = new ErrorHandler(errorConfig);
   }
   /**
@@ -393,14 +387,14 @@ var NHLClient = class {
           endpoint: url
         });
         this.errorHandler.log(error);
-        return { status: "error", error };
+        return { success: false, error };
       }
-      return { data: await response.json(), status: "success" };
+      return { data: await response.json(), success: true };
     } catch (error) {
       clearTimeout(timeoutId);
       if (error instanceof NHLError) {
         this.errorHandler.log(error);
-        return { status: "error", error };
+        return { success: false, error };
       }
       let nhlError;
       if (error instanceof Error && error.name === "AbortError") {
@@ -418,7 +412,7 @@ var NHLClient = class {
         });
       }
       this.errorHandler.log(nhlError);
-      return { status: "error", error: nhlError };
+      return { success: false, error: nhlError };
     }
   }
   /**
@@ -432,45 +426,8 @@ var NHLClient = class {
 function createNHLClient(baseURL, errorConfig) {
   return new NHLClient(baseURL, errorConfig);
 }
-var nhlClient = createNHLClient("default");
-createNHLClient("edge-stats");
-var client_default = nhlClient;
-
-// src/utils/date.ts
-var NHL_TIMEZONE = "America/New_York";
-var getDate = (date) => new Intl.DateTimeFormat("en-CA", {
-  timeZone: NHL_TIMEZONE,
-  year: "numeric",
-  month: "2-digit",
-  day: "2-digit"
-}).format(date);
-var getCurrentDate = () => getDate(/* @__PURE__ */ new Date());
-var getYear = (date) => new Intl.DateTimeFormat("en-CA", {
-  timeZone: NHL_TIMEZONE,
-  year: "numeric"
-}).format(date);
-var getCurrentYear = () => getYear(/* @__PURE__ */ new Date());
-var getSeason = (date) => {
-  const format = new Intl.DateTimeFormat("en-CA", {
-    timeZone: NHL_TIMEZONE,
-    year: "numeric",
-    month: "numeric"
-  }).formatToParts(date instanceof Date ? date : new Date(date));
-  const month = format.find((part) => part.type === "month")?.value;
-  const year = format.find((part) => part.type === "year")?.value;
-  if (!year) {
-    throw new Error("Invalid date provided, could not extract year");
-  }
-  if (month && parseInt(month, 10) < 7) {
-    console.log(month, parseInt(month, 10) < 7);
-    return `${parseInt(year, 10) - 1}${year}`;
-  }
-  return `${year}${parseInt(year, 10) + 1}`;
-};
-var getCurrentSeason = () => getSeason(/* @__PURE__ */ new Date());
-/* @__PURE__ */ new Date(
-  `${getCurrentSeason().slice(4, 8)}-06-30`
-);
+var nhlClient = createNHLClient(BASE_URLS.gamecenter);
+createNHLClient(BASE_URLS.edgeStats);
 
 // src/constants/edge-adv.ts
 var edge_adv_exports = {};
@@ -962,6 +919,41 @@ var TEAM_ID_RANGE = { MIN: 1, MAX: 59 };
 // src/constants/index.ts
 var EDGE = { ...edge_adv_exports, ...edge_stats_exports };
 
+// src/utils/date.ts
+var NHL_TIMEZONE = "America/New_York";
+var getDate = (date) => new Intl.DateTimeFormat("en-CA", {
+  timeZone: NHL_TIMEZONE,
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit"
+}).format(date);
+var getCurrentDate = () => getDate(/* @__PURE__ */ new Date());
+var getYear = (date) => new Intl.DateTimeFormat("en-CA", {
+  timeZone: NHL_TIMEZONE,
+  year: "numeric"
+}).format(date);
+var getCurrentYear = () => getYear(/* @__PURE__ */ new Date());
+var getSeason = (date) => {
+  const format = new Intl.DateTimeFormat("en-CA", {
+    timeZone: NHL_TIMEZONE,
+    year: "numeric",
+    month: "numeric"
+  }).formatToParts(date instanceof Date ? date : new Date(date));
+  const month = format.find((part) => part.type === "month")?.value;
+  const year = format.find((part) => part.type === "year")?.value;
+  if (!year) {
+    throw new Error("Invalid date provided, could not extract year");
+  }
+  if (month && parseInt(month, 10) < 7) {
+    return `${parseInt(year, 10) - 1}${year}`;
+  }
+  return `${year}${parseInt(year, 10) + 1}`;
+};
+var getCurrentSeason = () => getSeason(/* @__PURE__ */ new Date());
+/* @__PURE__ */ new Date(
+  `${getCurrentSeason().slice(4, 8)}-06-30`
+);
+
 // src/utils/schemas.ts
 function isParseError(value) {
   return value instanceof arktype.type.errors;
@@ -1040,27 +1032,27 @@ var PlayerId = arktype.type("number").atLeast(nhl_exports.PLAYER_ID_RANGE.MIN).a
     return v >= nhl_exports.PLAYER_ID_RANGE.MIN && v <= nhl_exports.PLAYER_ID_RANGE.MAX;
   })
 ).pipe((v) => v.toString()).describe("a valid NHL player ID");
-arktype.type.enumerated(
+var SaveLocationCategory = arktype.type.enumerated(
   ...Object.keys(
     EDGE.SaveLocationCategoryEnum
   )
 ).pipe((v) => EDGE.SaveLocationCategoryEnum[v]);
-arktype.type.enumerated(
+var ShotLocationSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.ShotLocationSortEnum
   )
 ).pipe((v) => EDGE.ShotLocationSortEnum[v]);
-arktype.type.enumerated(
+var SaveLocationSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.SaveLocationSortEnum
   )
 ).pipe((v) => EDGE.SaveLocationSortEnum[v]);
-arktype.type.enumerated(
+var SavePercentage5v5Sort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.SavePercentage5v5SortEnum
   )
 ).pipe((v) => EDGE.SavePercentage5v5SortEnum[v]);
-arktype.type.enumerated(
+var SavePercentageSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.SavePercentageSortEnum
   )
@@ -1075,27 +1067,27 @@ var SkatersStrength = arktype.type.enumerated(
     EDGE.SkatersStrengthEnum
   )
 ).pipe((v) => EDGE.SkatersStrengthEnum[v]);
-arktype.type.enumerated(
+var ShotSpeedSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.ShotSpeedSortEnum
   )
 ).pipe((v) => EDGE.ShotSpeedSortEnum[v]);
-arktype.type.enumerated(
+var SkatingSpeedSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.SkatingSpeedSortEnum
   )
 ).pipe((v) => EDGE.SkatingSpeedSortEnum[v]);
-arktype.type.enumerated(
+var SkatingDistanceSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.SkatingDistanceSortEnum
   )
 );
-arktype.type.enumerated(
+var ShotLocationCategory = arktype.type.enumerated(
   ...Object.keys(
     EDGE.ShotLocationCategoryEnum
   )
 ).pipe((v) => EDGE.ShotLocationCategoryEnum[v]);
-arktype.type.enumerated(
+var ZoneTimeSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.ZoneTimeSortEnum
   )
@@ -1106,14 +1098,14 @@ var BaseParams = arktype.type({
     (v) => v ?? nhl_exports.GameTypeEnum.REG
   )
 });
-BaseParams.merge({
+var PlayerParams = BaseParams.merge({
   playerId: PlayerId,
   season: Season
 });
-BaseParams.merge({
+var TeamParams = BaseParams.merge({
   teamId: TeamId
 });
-BaseParams.merge({
+var top10Params = BaseParams.merge({
   position: PositionFilter.default("ALL"),
   strength: SkatersStrength.default("ALL")
 });
@@ -1146,85 +1138,791 @@ var ScheduleParams = arktype.type({
 });
 
 // src/utils/utils.ts
-function route(template, params) {
-  let route2 = template;
+function resolvePath(template, params) {
+  let resolvedPath = template;
   for (const [key, value] of Object.entries(params)) {
     if (value === void 0) continue;
-    route2 = route2.replace(`{${key}}`, String(value));
+    resolvedPath = resolvedPath.replace(`{${key}}`, String(value));
   }
-  return route2;
+  return resolvedPath;
+}
+
+// src/api/edge-adv/paths.ts
+var goaliesPaths = {
+  /** Goalie detail page. */
+  player: "edge/goalie-detail/{playerId}/{season}/{gameType}",
+  /** Goalie comparison data. */
+  compare: "edge/goalie-comparison/{playerId}/{season}/{gameType}",
+  /** Goalie leaders landing page. */
+  leaders: "edge/goalie-landing/{season}/{gameType}",
+  /** Goalie 5v5 save percentage statistics. */
+  savePercentage5v5: "edge/goalie-5v5-detail/{playerId}/{season}/{gameType}",
+  /** Goalie save percentage statistics. */
+  savePercentage: "edge/goalie-save-percentage-detail/{playerId}/{season}/{gameType}",
+  /** Goalie shot location analysis. */
+  saveLocation: "edge/goalie-shot-location-detail/{playerId}/{season}/{gameType}",
+  /** Goalie top 10 leaders. */
+  top10: {
+    /** Top 10 goalies by save percentage. */
+    SavePercentage: "edge/goalie-5v5-top-10/{sortBy}/{season}/{gameType}",
+    /** Top 10 goalies by 5v5 save percentage. */
+    SavePercentage5v5: "edge/goalie-edge-save-pctg-top-10/{sortBy}/{season}/{gameType}",
+    /** Top 10 goalies by shot location. */
+    SaveLocation: "edge/goalie-shot-location-top-10/{category}/{sortBy}/{season}/{gameType}"
+  }
+};
+var skatersPaths = {
+  /** Skater detail page. */
+  player: "skater-detail/{playerId}/{season}/{gameType}",
+  /** Skater comparison data. */
+  compare: "skater-comparison/{playerId}/{season}/{gameType}",
+  /** Skater leaders landing page. */
+  leaders: "skater-landing/{season}/{gameType}",
+  /** Skater shot location analysis. */
+  shotLocation: "skater-shot-location-detail/{playerId}/{season}/{gameType}",
+  /** Skater shot speed analysis. */
+  shotSpeed: "skater-shot-speed-detail/{playerId}/{season}/{gameType}",
+  /** Skater skating distance analysis. */
+  skatingDistance: "skater-skating-distance-detail/{playerId}/{season}/{gameType}",
+  /** Skater skating speed analysis. */
+  skatingSpeed: "skater-skating-speed-detail/{playerId}/{season}/{gameType}",
+  /** Skater zone time analysis. */
+  zoneTime: "skater-zone-time/{playerId}/{season}/{gameType}",
+  /** Skater top 10 leaders. */
+  top10: {
+    /** Top 10 skaters by shot location. */
+    shotLocation: "skater-shot-location-top-10/{position}/{category}/{sortBy}/{season}/{gameType}",
+    /** Top 10 skaters by shot speed. */
+    shotSpeed: "skater-shot-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
+    /** Top 10 skaters by skating distance. */
+    skatingDistance: "skater-distance-top-10/{position}/{strength}/{sortBy}/{season}/{gameType}",
+    /** Top 10 skaters by skating speed. */
+    skatingSpeed: "skater-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
+    /** Top 10 skaters by zone time. */
+    zoneTime: "skater-zone-time-top-10/{position}/{strength}/{sortBy}/{season}/{gameType}"
+  }
+};
+var teamsPaths = {
+  /** Team statistics detail page. */
+  stats: "edge/team-comparison/{teamId}/{season}/{gameType}",
+  /** Team comparison data. */
+  compare: "edge/team-detail/{teamId}/{season}/{gameType}",
+  /** Team leaders landing page. */
+  leaders: "edge/team-landing/{season}/{gameType}",
+  /** Team shot location analysis. */
+  shotLocation: "edge/team-shot-location-detail/{teamId}/{season}/{gameType}",
+  /** Team shot speed analysis. */
+  shotSpeed: "edge/team-shot-location-top-10/{position}/{category}/{sortBy}/{season}/{gameType}",
+  /** Team skating distance analysis. */
+  skatingDistance: "edge/team-shot-speed-detail/{teamId}/{season}/{gameType}",
+  /** Team skating speed analysis. */
+  skatingSpeed: "edge/team-shot-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
+  /** Team zone time analysis. */
+  zoneTime: "edge/team-skating-distance-detail/{teamId}/{season}/{gameType}",
+  /** Team top 10 leaders. */
+  top10: {
+    /** Top 10 teams by shot location. */
+    shotLocation: "edge/team-skating-distance-top-10/{position}/{strength}/{sortBy}/{season}/{gameType}",
+    /** Top 10 teams by shot speed. */
+    shotSpeed: "edge/team-skating-speed-detail/{teamId}/{season}/{gameType}",
+    /** Top 10 teams by skating distance. */
+    skatingDistance: "edge/team-skating-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
+    /** Top 10 teams by skating speed. */
+    skatingSpeed: "edge/team-zone-time-details/{teamId}/{season}/{gameType}",
+    /** Top 10 teams by zone time. */
+    zoneTime: "edge/team-zone-time-top-10/{strength}/{sortBy}/{season}/{gameType}"
+  }
+};
+var summaryPaths = {
+  /** By the numbers summary. */
+  byTheNumbers: "edge/by-the-numbers/now"
+};
+
+// src/api/edge-adv/goalies.ts
+async function player(playerId, season, gameType) {
+  const parsed = PlayerParams({ playerId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: goaliesPaths.player
+      })
+    );
+  const path = resolvePath(goaliesPaths.player, parsed);
+  return nhlClient.get(path);
+}
+async function compare(playerId, season, gameType) {
+  const parsed = PlayerParams({ playerId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: goaliesPaths.compare
+      })
+    );
+  const path = resolvePath(goaliesPaths.compare, parsed);
+  return nhlClient.get(path);
+}
+async function leaders(season, gameType) {
+  const parsed = BaseParams({ season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: goaliesPaths.leaders
+      })
+    );
+  const path = resolvePath(goaliesPaths.leaders, parsed);
+  return nhlClient.get(path);
+}
+async function savePercentage5v5(playerId, season, gameType) {
+  const parsed = PlayerParams({ playerId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: goaliesPaths.savePercentage5v5
+      })
+    );
+  const path = resolvePath(goaliesPaths.savePercentage5v5, parsed);
+  return nhlClient.get(path);
+}
+async function savePercentage(playerId, season, gameType) {
+  const parsed = PlayerParams({ playerId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: goaliesPaths.savePercentage
+      })
+    );
+  const path = resolvePath(goaliesPaths.savePercentage, parsed);
+  return nhlClient.get(path);
+}
+async function saveLocation(playerId, season, gameType) {
+  const parsed = PlayerParams({ playerId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: goaliesPaths.saveLocation
+      })
+    );
+  const path = resolvePath(goaliesPaths.saveLocation, parsed);
+  return nhlClient.get(path);
+}
+var top10 = {
+  savePercentage: top10SavePercentage,
+  savePercentage5v5: top10SavePercentage5v5,
+  saveLocation: top10SaveLocation
+};
+async function top10SavePercentage(season, gameType, sortBy) {
+  const Parser = BaseParams.merge({
+    sortBy: SavePercentageSort.default("GAMES")
+  });
+  const parsed = Parser({ season, gameType, sortBy });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: goaliesPaths.top10.SavePercentage
+      })
+    );
+  const path = resolvePath(goaliesPaths.top10.SavePercentage, parsed);
+  return nhlClient.get(path);
+}
+async function top10SavePercentage5v5(season, gameType, sortBy) {
+  const Parser = BaseParams.merge({
+    sortBy: SavePercentage5v5Sort.default("5v5-SV%")
+  });
+  const parsed = Parser({ season, gameType, sortBy });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: goaliesPaths.top10.SavePercentage5v5
+      })
+    );
+  const path = resolvePath(goaliesPaths.top10.SavePercentage5v5, parsed);
+  return nhlClient.get(path);
+}
+async function top10SaveLocation(season, gameType, category, sortBy) {
+  const Parser = BaseParams.merge({
+    category: SaveLocationCategory.default("SV%"),
+    sortBy: SaveLocationSort.default("ALL")
+  });
+  const parsed = Parser({
+    season,
+    gameType,
+    category,
+    sortBy
+  });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: goaliesPaths.top10.SaveLocation
+      })
+    );
+  const path = resolvePath(goaliesPaths.top10.SaveLocation, parsed);
+  return nhlClient.get(path);
+}
+
+// src/api/edge-adv/skaters.ts
+var skaters_exports = {};
+__export(skaters_exports, {
+  comparison: () => comparison,
+  detail: () => detail,
+  leaders: () => leaders2,
+  shotLocation: () => shotLocation,
+  shotSpeed: () => shotSpeed,
+  skatingDistance: () => skatingDistance,
+  skatingSpeed: () => skatingSpeed,
+  top10: () => top102,
+  zoneTime: () => zoneTime
+});
+async function detail(playerId, season, gameType) {
+  const parsed = PlayerParams({ playerId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: skatersPaths.player
+      })
+    );
+  const path = resolvePath(skatersPaths.player, parsed);
+  return nhlClient.get(path);
+}
+async function shotLocation(playerId, season, gameType) {
+  const parsed = PlayerParams({ playerId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: skatersPaths.shotLocation
+      })
+    );
+  const path = resolvePath(skatersPaths.shotLocation, parsed);
+  return nhlClient.get(path);
+}
+async function shotSpeed(playerId, season, gameType) {
+  const parsed = PlayerParams({ playerId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: skatersPaths.shotSpeed
+      })
+    );
+  const path = resolvePath(skatersPaths.shotSpeed, parsed);
+  return nhlClient.get(path);
+}
+async function skatingDistance(playerId, season, gameType) {
+  const parsed = PlayerParams({ playerId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: skatersPaths.skatingDistance
+      })
+    );
+  const path = resolvePath(skatersPaths.skatingDistance, parsed);
+  return nhlClient.get(path);
+}
+async function skatingSpeed(playerId, season, gameType) {
+  const parsed = PlayerParams({ playerId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: skatersPaths.skatingSpeed
+      })
+    );
+  const path = resolvePath(skatersPaths.skatingSpeed, parsed);
+  return nhlClient.get(path);
+}
+async function zoneTime(playerId, season, gameType) {
+  const parsed = PlayerParams({ playerId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: skatersPaths.zoneTime
+      })
+    );
+  const path = resolvePath(skatersPaths.zoneTime, parsed);
+  return nhlClient.get(path);
+}
+async function comparison(playerId, season, gameType) {
+  const parsed = PlayerParams({ playerId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: skatersPaths.compare
+      })
+    );
+  const path = resolvePath(skatersPaths.compare, parsed);
+  return nhlClient.get(path);
+}
+async function leaders2(season, gameType) {
+  const parsed = BaseParams({ season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: skatersPaths.leaders
+      })
+    );
+  const path = resolvePath(skatersPaths.leaders, parsed);
+  return nhlClient.get(path);
+}
+var top102 = {
+  distance: top10Distance,
+  shotLocation: top10ShotLocation,
+  shotSpeed: top10ShotSpeed,
+  speed: top10Speed,
+  zoneTime: top10ZoneTime
+};
+async function top10Distance(season, gameType, position, strength, sortBy) {
+  const parsed = top10Params.merge({
+    sortBy: SkatingDistanceSort.default("TOTAL")
+  })({
+    season,
+    gameType,
+    position,
+    strength,
+    sortBy
+  });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: skatersPaths.top10.skatingDistance
+      })
+    );
+  const path = resolvePath(skatersPaths.top10.skatingDistance, parsed);
+  return nhlClient.get(path);
+}
+async function top10ShotLocation(season, gameType, position, category, sortBy) {
+  const parsed = top10Params.merge({
+    category: ShotLocationCategory.default("G"),
+    sortBy: ShotLocationSort.default("ALL")
+  })({
+    season,
+    gameType,
+    position,
+    category,
+    sortBy
+  });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: skatersPaths.top10.shotLocation
+      })
+    );
+  const path = resolvePath(skatersPaths.top10.shotLocation, parsed);
+  return nhlClient.get(path);
+}
+async function top10ShotSpeed(season, gameType, position, sortBy) {
+  const parsed = top10Params.merge({
+    sortBy: ShotSpeedSort.default("MAX")
+  })({
+    season,
+    gameType,
+    position,
+    sortBy
+  });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: skatersPaths.top10.shotSpeed
+      })
+    );
+  const path = resolvePath(skatersPaths.top10.shotSpeed, parsed);
+  return nhlClient.get(path);
+}
+async function top10Speed(season, gameType, position, sortBy) {
+  const parsed = top10Params.merge({
+    sortBy: SkatingSpeedSort.default("TOP")
+  })({
+    season,
+    gameType,
+    position,
+    sortBy
+  });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: skatersPaths.top10.skatingSpeed
+      })
+    );
+  const path = resolvePath(skatersPaths.top10.skatingSpeed, parsed);
+  return nhlClient.get(path);
+}
+async function top10ZoneTime(season, gameType, position, strength, sortBy) {
+  const parsed = top10Params.merge({
+    sortBy: ZoneTimeSort.default("OZ")
+  })({
+    season,
+    gameType,
+    position,
+    strength,
+    sortBy
+  });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: skatersPaths.top10.zoneTime
+      })
+    );
+  const path = resolvePath(skatersPaths.top10.zoneTime, parsed);
+  return nhlClient.get(path);
 }
 
-// src/api/gamecenter/_paths.ts
-var _teamPaths = {
+// src/api/edge-adv/summary.ts
+async function byTheNumbers() {
+  return nhlClient.get(summaryPaths.byTheNumbers);
+}
+
+// src/api/edge-adv/teams.ts
+var teams_exports = {};
+__export(teams_exports, {
+  compare: () => compare2,
+  leaders: () => leaders3,
+  shotLocation: () => shotLocation2,
+  shotSpeed: () => shotSpeed2,
+  skatingDistance: () => skatingDistance2,
+  skatingSpeed: () => skatingSpeed2,
+  stats: () => stats,
+  top10: () => top103,
+  zoneTime: () => zoneTime2
+});
+async function stats(teamId, season, gameType) {
+  const parsed = TeamParams({ teamId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: teamsPaths.stats
+      })
+    );
+  const path = resolvePath(teamsPaths.stats, parsed);
+  return nhlClient.get(path);
+}
+async function compare2(teamId, season, gameType) {
+  gameType ??= "REG";
+  const parsed = TeamParams({ teamId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: teamsPaths.compare
+      })
+    );
+  const path = resolvePath(teamsPaths.compare, parsed);
+  return nhlClient.get(path);
+}
+async function leaders3(season, gameType) {
+  const parsed = BaseParams({ season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: teamsPaths.leaders
+      })
+    );
+  const path = resolvePath(teamsPaths.leaders, parsed);
+  return nhlClient.get(path);
+}
+async function shotLocation2(teamId, season, gameType) {
+  const parsed = TeamParams({ teamId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: teamsPaths.shotLocation
+      })
+    );
+  const path = resolvePath(teamsPaths.shotLocation, parsed);
+  return nhlClient.get(path);
+}
+async function shotSpeed2(teamId, season, gameType) {
+  const parsed = TeamParams({ teamId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: teamsPaths.shotSpeed
+      })
+    );
+  const path = resolvePath(teamsPaths.shotSpeed, parsed);
+  return nhlClient.get(path);
+}
+async function skatingDistance2(teamId, season, gameType) {
+  const parsed = TeamParams({ teamId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: teamsPaths.skatingDistance
+      })
+    );
+  const path = resolvePath(teamsPaths.skatingDistance, parsed);
+  return nhlClient.get(path);
+}
+async function skatingSpeed2(teamId, season, gameType) {
+  const parsed = TeamParams({ teamId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: teamsPaths.skatingSpeed
+      })
+    );
+  const path = resolvePath(teamsPaths.skatingSpeed, parsed);
+  return nhlClient.get(path);
+}
+async function zoneTime2(teamId, season, gameType) {
+  const parsed = TeamParams({ teamId, season, gameType });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: teamsPaths.zoneTime
+      })
+    );
+  const path = resolvePath(teamsPaths.zoneTime, parsed);
+  return nhlClient.get(path);
+}
+var top103 = {
+  shotLocation: top10ShotLocation2,
+  shotSpeed: top10ShotSpeed2,
+  skatingDistance: top10SkatingDistance,
+  skatingSpeed: top10SkatingSpeed,
+  zoneTime: top10ZoneTime2
+};
+async function top10ShotLocation2(season, gameType, position, category, sortBy) {
+  const Parser = BaseParams.merge({
+    position: PositionFilter.default("ALL"),
+    category: ShotLocationCategory.default("G"),
+    sortBy: ShotLocationSort.default("ALL")
+  });
+  const parsed = Parser({
+    season,
+    gameType,
+    position,
+    category,
+    sortBy
+  });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: teamsPaths.shotLocation
+      })
+    );
+  const path = resolvePath(teamsPaths.top10.shotLocation, parsed);
+  return nhlClient.get(path);
+}
+async function top10ShotSpeed2(season, gameType, position, sortBy) {
+  const Parser = BaseParams.merge({
+    position: PositionFilter.default("ALL"),
+    sortBy: ShotSpeedSort.default("MAX")
+  });
+  const parsed = Parser({
+    season,
+    gameType,
+    position,
+    sortBy
+  });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: teamsPaths.shotSpeed
+      })
+    );
+  const path = resolvePath(teamsPaths.top10.shotSpeed, parsed);
+  return nhlClient.get(path);
+}
+async function top10SkatingDistance(season, gameType, position, strength, sortBy) {
+  const Parser = BaseParams.merge({
+    position: PositionFilter.default("ALL"),
+    strength: SkatersStrength.default("ALL"),
+    sortBy: SkatingDistanceSort.default("TOTAL")
+  });
+  const parsed = Parser({
+    season,
+    gameType,
+    position,
+    strength,
+    sortBy
+  });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: teamsPaths.skatingDistance
+      })
+    );
+  const path = resolvePath(teamsPaths.top10.skatingDistance, parsed);
+  return nhlClient.get(path);
+}
+async function top10SkatingSpeed(season, gameType, position, sortBy) {
+  const Parser = BaseParams.merge({
+    position: PositionFilter.default("ALL"),
+    sortBy: SkatingSpeedSort.default("TOP")
+  });
+  const parsed = Parser({
+    season,
+    gameType,
+    position,
+    sortBy
+  });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: teamsPaths.skatingSpeed
+      })
+    );
+  const path = resolvePath(teamsPaths.top10.skatingSpeed, parsed);
+  return nhlClient.get(path);
+}
+async function top10ZoneTime2(season, gameType, strength, sortBy) {
+  const Parser = BaseParams.merge({
+    strength: SkatersStrength.default("ALL"),
+    sortBy: ZoneTimeSort.default("OZ")
+  });
+  const parsed = Parser({
+    season,
+    gameType,
+    strength,
+    sortBy
+  });
+  if (isParseError(parsed))
+    return Promise.reject(
+      new NHLError(parsed.summary, "VALIDATION", {
+        endpoint: teamsPaths.zoneTime
+      })
+    );
+  const path = resolvePath(teamsPaths.top10.zoneTime, parsed);
+  return nhlClient.get(path);
+}
+
+// src/api/gamecenter/index.ts
+var gamecenter_exports = {};
+__export(gamecenter_exports, {
+  draft: () => draft_exports,
+  game: () => game_exports,
+  misc: () => misc_exports,
+  player: () => player_exports,
+  score: () => score,
+  scoreboard: () => scoreboard,
+  team: () => team_exports
+});
+
+// src/api/gamecenter/draft.ts
+var draft_exports = {};
+__export(draft_exports, {
+  picks: () => picks,
+  rankings: () => rankings,
+  tracker: () => tracker
+});
+
+// src/api/gamecenter/paths.ts
+var teamPaths = {
+  /** Team roster seasons. */
   rosterSeasons: "roster-season/{team}",
+  /** Team roster for a specific season. */
   roster: "roster/{team}/{season}",
+  /** Team prospects. */
   prospects: "prospects/{team}",
+  /** Team club statistics for a specific season and game type. */
   clubStats: "club-stats/{team}/{season}/{gameType}",
+  /** Team club statistics summary for a season. */
   clubStatsSeason: "club-stats-season/{team}",
+  /** League standings for a specific date. */
   standings: "standings/{date}",
+  /** League standings summary for a season. */
   standingsSeason: "standings-season",
+  /** Team schedule data. */
   clubSchedule: {
+    /** Team schedule for a season. */
     season: "club-schedule-season/{team}/{season}",
+    /** Team schedule for a specific month. */
     month: "club-schedule/{team}/month/{month}",
+    /** Team schedule for a specific week. */
     week: "club-schedule/{team}/week/{date}"
   }
 };
-var _scorePaths = {
+var scorePaths = {
+  /** Game scores for a specific date. */
   score: "score/{date}",
+  /** Scoreboard data. */
   scoreboard: {
+    /** Current scoreboard. */
     now: "scoreboard/now",
+    /** Scoreboard for a specific team. */
     byTeam: "scoreboard/{team}/now",
+    /** Scoreboard for a specific date. */
     byDate: "scoreboard/{date}"
   }
 };
-var _playerPaths = {
+var playerPaths = {
+  /** Player landing page data. */
   landing: "player/{playerId}/landing",
+  /** Player game log for a season and game type. */
   gameLog: "player/{playerId}/game-log/{season}/{gameType}",
+  /** Current player spotlight. */
   spotlight: "player-spotlight",
+  /** Player statistics leaders. */
   statsLeaders: {
+    /** Skater statistics leaders. */
     skaters: "skater-stats-leaders/{season}/{gameType}",
+    /** Goalie statistics leaders. */
     goalies: "goalie-stats-leaders/{season}/{gameType}"
   },
+  /** Player search functionality. */
   playerSearch: "https://search.d3.nhle.com/api/v1/search/player"
 };
-var _miscPaths = {
+var miscPaths = {
+  /** Current season information. */
   season: "season",
+  /** Playoff series metadata for a specific year and series. */
   metaPlayoffSeries: "meta/playoff-series/{year}/{seriesLetter}",
+  /** Game metadata. */
   metaGame: "meta/game/{gameId}",
+  /** Location lookup by postal code. */
   postalLookup: "postal-lookup/{postalCode}",
+  /** Location information. */
   location: "location",
+  /** Partner game for a specific country. */
   partnerGame: "partner-game/{countryCode}/now"
 };
-var _gamePaths = {
+var gamePaths = {
+  /** Game schedule for a specific date. */
   schedule: "schedule/{date}",
+  /** Game schedule calendar for a specific date. */
   scheduleCalendar: "schedule-calendar/{date}",
+  /** Playoff bracket for a specific year. */
   playoffBracket: "playoff-bracket/{year}",
+  /** Playoff series carousel for a season. */
   playoffSeries: "playoff-series/carousel/{season}",
+  /** Playoff series schedule. */
   playoffSeriesSchedule: "schedule/playoff-series/{season}/{seriesLetter}",
+  /** Game center data with multiple views. */
   gamecenter: {
+    /** Play-by-play data for a game. */
     playByPlay: "gamecenter/{gameId}/play-by-play",
+    /** Right rail reports for a game. */
     reports: "gamecenter/{gameId}/right-rail",
+    /** Game landing page. */
     landing: "gamecenter/{gameId}/landing",
+    /** Game box score. */
     boxscore: "gamecenter/{gameId}/boxscore"
   },
+  /** Web Stat Center (WSC) data. */
   wsc: {
+    /** Game story from WSC. */
     gameStory: "wsc/game-story/{gameId}",
+    /** Play-by-play from WSC. */
     playByPlay: "wsc/play-by-play/{gameId}"
   },
+  /** PPT replay data. */
   pptReplay: {
+    /** Goal replay. */
     goal: "ppt-replay/goal/{gameId}/{eventId}",
+    /** Event replay. */
     event: "ppt-replay/{gameId}/{eventId}"
   },
+  /** Where to watch information. */
   whereToWatch: "where-to-watch",
+  /** Network TV schedule for a specific date. */
   networkTVSchedule: "network/tv-schedule/{date}"
 };
-var _draftPaths = {
+var draftPaths = {
+  /** Draft picks data. */
   draftPicks: {
+    /** Draft picks by year and round. */
     byYearAndRound: "draft/picks/{year}/{round}",
+    /** All draft picks for a year. */
     byYear: "draft/picks/{year}/all"
   },
+  /** Draft rankings for a year and type. */
   draftRankings: "draft/rankings/{year}/{type}",
+  /** Current draft tracker. */
   draftTracker: "draft-tracker/picks/now"
 };
 
@@ -1233,18 +1931,22 @@ async function picks(year, round) {
   const parsed = DraftParams({ year, round });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _draftPaths.draftPicks.byYearAndRound
+        endpoint: draftPaths.draftPicks.byYearAndRound
       })
     };
   }
-  if (parsed.year && !parsed.round)
-    return client_default.get(route(_draftPaths.draftPicks.byYear, parsed));
-  return client_default.get(route(_draftPaths.draftPicks.byYearAndRound, parsed));
+  let path = "";
+  if (parsed.year && !parsed.round) {
+    path = resolvePath(draftPaths.draftPicks.byYear, parsed);
+  } else {
+    path = resolvePath(draftPaths.draftPicks.byYearAndRound, parsed);
+  }
+  return nhlClient.get(path);
 }
 async function tracker() {
-  return client_default.get(_draftPaths.draftTracker);
+  return nhlClient.get(draftPaths.draftTracker);
 }
 function rankings(year) {
   const DraftRankingsEnum = {
@@ -1257,18 +1959,14 @@ function rankings(year) {
     const parsedYear = Year(year ?? getCurrentYear());
     if (isParseError(parsedYear)) {
       return {
-        status: "error",
+        success: false,
         error: new ValidationError(parsedYear.summary, {
-          endpoint: _draftPaths.draftRankings
+          endpoint: draftPaths.draftRankings
         })
       };
     }
-    return client_default.get(
-      route(_draftPaths.draftRankings, {
-        year: parsedYear,
-        type: type2
-      })
-    );
+    const path = resolvePath(draftPaths.draftRankings, { year: parsedYear, type: type2 });
+    return nhlClient.get(path);
   };
   return {
     /**
@@ -1297,7 +1995,7 @@ function rankings(year) {
      */
     all: async () => {
       const unwrapAPIResponse = (apiResponse) => {
-        if (apiResponse.status === "success") {
+        if (apiResponse.success) {
           return apiResponse.data;
         }
         throw apiResponse.error;
@@ -1311,13 +2009,13 @@ function rankings(year) {
       try {
         const dataOnly = response.map((r) => unwrapAPIResponse(r));
         const newResponse = {
-          status: "success",
+          success: true,
           data: dataOnly
         };
         return newResponse;
       } catch (error) {
         return {
-          status: "error",
+          success: false,
           error
         };
       }
@@ -1346,57 +2044,57 @@ async function playByPlay(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _gamePaths.gamecenter.playByPlay
+        endpoint: gamePaths.gamecenter.playByPlay
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.gamecenter.playByPlay, { gameId: parsedGameId })
-  );
+  const path = resolvePath(gamePaths.gamecenter.playByPlay, {
+    gameId: parsedGameId
+  });
+  return nhlClient.get(path);
 }
 async function reports(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _gamePaths.gamecenter.reports
+        endpoint: gamePaths.gamecenter.reports
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.gamecenter.reports, { gameId: parsedGameId })
-  );
+  const path = resolvePath(gamePaths.gamecenter.reports, { gameId: parsedGameId });
+  return nhlClient.get(path);
 }
 async function landing(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _gamePaths.gamecenter.landing
+        endpoint: gamePaths.gamecenter.landing
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.gamecenter.landing, { gameId: parsedGameId })
-  );
+  const path = resolvePath(gamePaths.gamecenter.landing, { gameId: parsedGameId });
+  return nhlClient.get(path);
 }
 async function boxscore(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _gamePaths.gamecenter.boxscore
+        endpoint: gamePaths.gamecenter.boxscore
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.gamecenter.boxscore, { gameId: parsedGameId })
-  );
+  const path = resolvePath(gamePaths.gamecenter.boxscore, {
+    gameId: parsedGameId
+  });
+  return nhlClient.get(path);
 }
 var wsc = {
   gameStory: wscGameStory,
@@ -1406,29 +2104,27 @@ async function wscGameStory(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _gamePaths.wsc.gameStory
+        endpoint: gamePaths.wsc.gameStory
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.wsc.gameStory, { gameId: parsedGameId })
-  );
+  const path = resolvePath(gamePaths.wsc.gameStory, { gameId: parsedGameId });
+  return nhlClient.get(path);
 }
 async function wscPlayByPlay(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _gamePaths.wsc.playByPlay
+        endpoint: gamePaths.wsc.playByPlay
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.wsc.playByPlay, { gameId: parsedGameId })
-  );
+  const path = resolvePath(gamePaths.wsc.playByPlay, { gameId: parsedGameId });
+  return nhlClient.get(path);
 }
 var pptReplay = {
   goal: pptReplayGoal,
@@ -1438,77 +2134,79 @@ async function pptReplayGoal(gameId, eventId) {
   const parsed = GameIdAndEventId({ gameId, eventId });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _gamePaths.pptReplay.goal
+        endpoint: gamePaths.pptReplay.goal
       })
     };
   }
-  return client_default.get(route(_gamePaths.pptReplay.goal, { gameId, eventId }));
+  const path = resolvePath(gamePaths.pptReplay.goal, { gameId, eventId });
+  return nhlClient.get(path);
 }
 async function pptReplayEvent(gameId, eventId) {
   const parsed = GameIdAndEventId({ gameId, eventId });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _gamePaths.pptReplay.event
+        endpoint: gamePaths.pptReplay.event
       })
     };
   }
-  return client_default.get(route(_gamePaths.pptReplay.event, { gameId, eventId }));
+  const path = resolvePath(gamePaths.pptReplay.event, { gameId, eventId });
+  return nhlClient.get(path);
 }
 async function schedule(date) {
   const parsedDate = NHLDate(date ?? getCurrentDate());
   if (isParseError(parsedDate)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedDate.summary, {
-        endpoint: _gamePaths.schedule
+        endpoint: gamePaths.schedule
       })
     };
   }
-  return client_default.get(route(_gamePaths.schedule, { date: parsedDate }));
+  const path = resolvePath(gamePaths.schedule, { date: parsedDate });
+  return nhlClient.get(path);
 }
 async function scheduleCalendar(date) {
   const parsedDate = NHLDate(date);
   if (isParseError(parsedDate)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedDate.summary, {
-        endpoint: _gamePaths.scheduleCalendar
+        endpoint: gamePaths.scheduleCalendar
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.scheduleCalendar, { date: parsedDate })
-  );
+  const path = resolvePath(gamePaths.scheduleCalendar, { date: parsedDate });
+  return nhlClient.get(path);
 }
 async function playoffBracket(year) {
   const parsedYear = Year(year ?? getCurrentYear());
   if (isParseError(parsedYear)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedYear.summary, {
-        endpoint: _gamePaths.playoffBracket
+        endpoint: gamePaths.playoffBracket
       })
     };
   }
-  return client_default.get(route(_gamePaths.playoffBracket, { year: parsedYear }));
+  const path = resolvePath(gamePaths.playoffBracket, { year: parsedYear });
+  return nhlClient.get(path);
 }
 async function playoffSeries(season) {
   const parsedSeason = Season(season ?? getCurrentSeason());
   if (isParseError(parsedSeason)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedSeason.summary, {
-        endpoint: _gamePaths.playoffSeries
+        endpoint: gamePaths.playoffSeries
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.playoffSeries, { season: parsedSeason })
-  );
+  const path = resolvePath(gamePaths.playoffSeries, { season: parsedSeason });
+  return nhlClient.get(path);
 }
 async function playoffSeriesSchedule(seriesLetter, season) {
   const parsed = SeriesAndSeasonParams({
@@ -1517,30 +2215,31 @@ async function playoffSeriesSchedule(seriesLetter, season) {
   });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _gamePaths.playoffSeriesSchedule
+        endpoint: gamePaths.playoffSeriesSchedule
       })
     };
   }
-  return client_default.get(route(_gamePaths.playoffSeriesSchedule, parsed));
+  const path = resolvePath(gamePaths.playoffSeriesSchedule, parsed);
+  return nhlClient.get(path);
 }
 async function whereToWatch() {
-  return client_default.get(_gamePaths.whereToWatch);
+  const path = resolvePath(gamePaths.whereToWatch, {});
+  return nhlClient.get(path);
 }
 async function networkTVSchedule(date) {
   const parsedDate = NHLDate(date ?? getCurrentDate());
   if (isParseError(parsedDate)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedDate.summary, {
-        endpoint: _gamePaths.networkTVSchedule
+        endpoint: gamePaths.networkTVSchedule
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.networkTVSchedule, { date: parsedDate })
-  );
+  const path = resolvePath(gamePaths.networkTVSchedule, { date: parsedDate });
+  return nhlClient.get(path);
 }
 
 // src/api/gamecenter/misc.ts
@@ -1553,7 +2252,7 @@ __export(misc_exports, {
   seasons: () => seasons
 });
 async function seasons() {
-  return client_default.get(_miscPaths.season);
+  return nhlClient.get(miscPaths.season);
 }
 var meta = {
   game: metaGame,
@@ -1563,56 +2262,60 @@ async function metaGame(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _miscPaths.metaGame
+        endpoint: miscPaths.metaGame
       })
     };
   }
-  return client_default.get(route(_miscPaths.metaGame, { gameId: parsedGameId }));
+  const path = resolvePath(miscPaths.metaGame, { gameId: parsedGameId });
+  return nhlClient.get(path);
 }
 async function metaPlayoffSeries(seriesLetter, year) {
   const parsed = SeriesParams({ year, seriesLetter });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _miscPaths.metaPlayoffSeries
+        endpoint: miscPaths.metaPlayoffSeries
       })
     };
   }
-  return client_default.get(route(_miscPaths.metaPlayoffSeries, parsed));
+  const path = resolvePath(miscPaths.metaPlayoffSeries, parsed);
+  return nhlClient.get(path);
 }
 async function postalLookup(postalCode) {
   const parsedPostalCode = PostalCode(postalCode);
   if (isParseError(parsedPostalCode)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedPostalCode.summary, {
-        endpoint: _miscPaths.postalLookup
+        endpoint: miscPaths.postalLookup
       })
     };
   }
-  return client_default.get(
-    route(_miscPaths.postalLookup, { postalCode: parsedPostalCode })
-  );
+  const path = resolvePath(miscPaths.postalLookup, {
+    postalCode: parsedPostalCode
+  });
+  return nhlClient.get(path);
 }
 async function location() {
-  return client_default.get(_miscPaths.location);
+  return nhlClient.get(miscPaths.location);
 }
 async function partnerGame(countryCode) {
   const parsedCountryCode = CountryCode(countryCode);
   if (isParseError(parsedCountryCode)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedCountryCode.summary, {
-        endpoint: _miscPaths.partnerGame
+        endpoint: miscPaths.partnerGame
       })
     };
   }
-  return client_default.get(
-    route(_miscPaths.partnerGame, { countryCode: parsedCountryCode })
-  );
+  const path = resolvePath(miscPaths.partnerGame, {
+    countryCode: parsedCountryCode
+  });
+  return nhlClient.get(path);
 }
 
 // src/api/gamecenter/player.ts
@@ -1624,21 +2327,20 @@ __export(player_exports, {
   spotlight: () => spotlight,
   statsLeaders: () => statsLeaders
 });
-var nhlPlayerSearch = createNHLClient(_playerPaths.playerSearch);
+var nhlPlayerSearch = createNHLClient(playerPaths.playerSearch);
 var searchUrlParams = { culture: "en", q: "" };
 async function landing2(playerId) {
   const parsedPlayerId = PlayerId(playerId);
   if (isParseError(parsedPlayerId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedPlayerId.summary, {
-        endpoint: _playerPaths.landing
+        endpoint: playerPaths.landing
       })
     };
   }
-  return client_default.get(
-    route(_playerPaths.landing, { playerId: parsedPlayerId })
-  );
+  const path = resolvePath(playerPaths.landing, { playerId: parsedPlayerId });
+  return nhlClient.get(path);
 }
 async function gameLog(playerId, season, gameType) {
   const Parser = BaseParams.merge({
@@ -1647,16 +2349,17 @@ async function gameLog(playerId, season, gameType) {
   const parsed = Parser({ playerId, season, gameType });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _playerPaths.gameLog
+        endpoint: playerPaths.gameLog
       })
     };
   }
-  return client_default.get(route(_playerPaths.gameLog, parsed));
+  const path = resolvePath(playerPaths.gameLog, parsed);
+  return nhlClient.get(path);
 }
 async function spotlight() {
-  return client_default.get(_playerPaths.spotlight);
+  return nhlClient.get(playerPaths.spotlight);
 }
 async function search(query) {
   return nhlPlayerSearch.get("", {
@@ -1672,25 +2375,27 @@ async function statsLeadersSkaters(season, gameType) {
   const parsed = BaseParams({ season, gameType });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _playerPaths.statsLeaders.skaters
+        endpoint: playerPaths.statsLeaders.skaters
       })
     };
   }
-  return client_default.get(route(_playerPaths.statsLeaders.skaters, parsed));
+  const path = resolvePath(playerPaths.statsLeaders.skaters, parsed);
+  return nhlClient.get(path);
 }
 async function statsLeadersGoalies(season, gameType) {
   const parsed = BaseParams({ season, gameType });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _playerPaths.statsLeaders.goalies
+        endpoint: playerPaths.statsLeaders.goalies
       })
     };
   }
-  return client_default.get(route(_playerPaths.statsLeaders.goalies, parsed));
+  const path = resolvePath(playerPaths.statsLeaders.goalies, parsed);
+  return nhlClient.get(path);
 }
 
 // src/api/gamecenter/score.ts
@@ -1698,44 +2403,43 @@ async function score(date) {
   const parsed = NHLDate(date ?? getCurrentDate());
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _scorePaths.score
+        endpoint: scorePaths.score
       })
     };
   }
-  return client_default.get(route(_scorePaths.score, { date: parsed }));
+  const path = resolvePath(scorePaths.score, { date: parsed });
+  return nhlClient.get(path);
 }
 async function scoreboard() {
-  return client_default.get(_scorePaths.scoreboard.now);
+  return nhlClient.get(scorePaths.scoreboard.now);
 }
 scoreboard.team = async (team) => {
   const parsed = TeamAbbrev(team);
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _scorePaths.scoreboard.byTeam
+        endpoint: scorePaths.scoreboard.byTeam
       })
     };
   }
-  return client_default.get(
-    route(_scorePaths.scoreboard.byTeam, { team: parsed })
-  );
+  const path = resolvePath(scorePaths.scoreboard.byTeam, { team: parsed });
+  return nhlClient.get(path);
 };
 scoreboard.date = async (date) => {
   const parsed = NHLDate(date);
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _scorePaths.scoreboard.byDate
+        endpoint: scorePaths.scoreboard.byDate
       })
     };
   }
-  return client_default.get(
-    route(_scorePaths.scoreboard.byDate, { date: parsed })
-  );
+  const path = resolvePath(scorePaths.scoreboard.byDate, { date: parsed });
+  return nhlClient.get(path);
 };
 
 // src/api/gamecenter/team.ts
@@ -1747,122 +2451,131 @@ __export(team_exports, {
   schedule: () => schedule2,
   standings: () => standings,
   standingsSeason: () => standingsSeason,
-  stats: () => stats,
+  stats: () => stats2,
   statsSeason: () => statsSeason
 });
 async function rosterSeasons(team) {
   const parsed = TeamAbbrev(team);
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.rosterSeasons
+        endpoint: teamPaths.rosterSeasons
       })
     };
   }
-  return client_default.get(route(_teamPaths.rosterSeasons, { team: parsed }));
+  const path = resolvePath(teamPaths.rosterSeasons, { team: parsed });
+  return nhlClient.get(path);
 }
 async function roster(team, season) {
   const parsed = TeamAndSeasonParams({ team, season });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.roster
+        endpoint: teamPaths.roster
       })
     };
   }
-  return client_default.get(route(_teamPaths.roster, parsed));
+  const path = resolvePath(teamPaths.roster, parsed);
+  return nhlClient.get(path);
 }
 async function prospects(team) {
   const parsed = TeamAbbrev(team);
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.prospects
+        endpoint: teamPaths.prospects
       })
     };
   }
-  return client_default.get(route(_teamPaths.prospects, { team: parsed }));
+  const path = resolvePath(teamPaths.prospects, { team: parsed });
+  return nhlClient.get(path);
 }
-async function stats(team, season, gameType) {
+async function stats2(team, season, gameType) {
   const Parser = BaseParams.merge({
     team: TeamAbbrev
   });
   const parsed = Parser({ team, season, gameType });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.clubStats
+        endpoint: teamPaths.clubStats
       })
     };
   }
-  return client_default.get(route(_teamPaths.clubStats, parsed));
+  const path = resolvePath(teamPaths.clubStats, parsed);
+  return nhlClient.get(path);
 }
 async function statsSeason(team) {
   const parsed = TeamAbbrev(team);
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.clubStatsSeason
+        endpoint: teamPaths.clubStatsSeason
       })
     };
   }
-  return client_default.get(route(_teamPaths.clubStatsSeason, { team: parsed }));
+  const path = resolvePath(teamPaths.clubStatsSeason, { team: parsed });
+  return nhlClient.get(path);
 }
 async function standings(date) {
   const parsed = NHLDate(date ?? getCurrentDate());
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.standings
+        endpoint: teamPaths.standings
       })
     };
   }
-  return client_default.get(route(_teamPaths.standings, { date: parsed }));
+  const path = resolvePath(teamPaths.standings, { date: parsed });
+  return nhlClient.get(path);
 }
 async function standingsSeason() {
-  return client_default.get(_teamPaths.standingsSeason);
+  return nhlClient.get(teamPaths.standingsSeason);
 }
 async function scheduleWeek(team, date) {
   const parsed = ScheduleParams({ team, date, month: void 0 });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.clubSchedule.week
+        endpoint: teamPaths.clubSchedule.week
       })
     };
   }
-  return client_default.get(route(_teamPaths.clubSchedule.week, parsed));
+  const path = resolvePath(teamPaths.clubSchedule.week, parsed);
+  return nhlClient.get(path);
 }
 async function scheduleMonth(team, date) {
   const parsed = ScheduleParams({ team, month: date, date: void 0 });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.clubSchedule.month
+        endpoint: teamPaths.clubSchedule.month
       })
     };
   }
-  return client_default.get(route(_teamPaths.clubSchedule.month, parsed));
+  const path = resolvePath(teamPaths.clubSchedule.month, parsed);
+  return nhlClient.get(path);
 }
 async function scheduleSeason(team, season) {
   const parsed = TeamAndSeasonParams({ team, season });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.clubSchedule.season
+        endpoint: teamPaths.clubSchedule.season
       })
     };
   }
-  return client_default.get(route(_teamPaths.clubSchedule.season, parsed));
+  const path = resolvePath(teamPaths.clubSchedule.season, parsed);
+  return nhlClient.get(path);
 }
 var schedule2 = {
   season: scheduleSeason,
@@ -1872,6 +2585,7 @@ var schedule2 = {
 
 exports.EDGE = EDGE;
 exports.NHL = nhl_exports;
+exports.adv = edge_adv_exports2;
 exports.envConfig = envConfig;
 exports.gc = gamecenter_exports;
 exports.logEnvConfig = logEnvConfig;