nhle-api 0.5.1 → 0.5.2

package/lib/index.js

@@ -466,6 +466,9 @@ var getSeason = (date) => {
   return `${year}${parseInt(year, 10) + 1}`;
 };
 var getCurrentSeason = () => getSeason(/* @__PURE__ */ new Date());
+/* @__PURE__ */ new Date(
+  `${getCurrentSeason().slice(4, 8)}-06-30`
+);
 
 // src/constants/edge-adv.ts
 var edge_adv_exports = {};
@@ -966,6 +969,21 @@ var Year = type(`${nhl_exports.START_YEAR} <= number <= ${nhl_exports.END_YEAR}`
     return v >= nhl_exports.START_YEAR && v <= nhl_exports.END_YEAR;
   })
 ).describe(`a valid year from ${nhl_exports.START_YEAR} to ${nhl_exports.END_YEAR}`);
+var NHLMonth = type("Date | string").narrow((v) => {
+  if (typeof v === "string") {
+    return /^\d{4}-\d{2}$/.test(v);
+  } else if (v instanceof Date) {
+    return true;
+  }
+  return false;
+}).pipe((v) => typeof v === "string" ? v : v.toISOString().slice(0, 7)).describe(
+  "a valid month, either as a string (formatted as YYYY-MM) or a Date object"
+);
+var NHLDate = type("Date | string.date.iso").pipe(
+  (v) => typeof v === "string" ? new Date(v).toISOString().slice(0, 10) : v.toISOString().slice(0, 10)
+).describe(
+  "a valid date, either as a string (ISO date string) or a Date object"
+);
 var Season = type("number.integer | string.numeric.parse").narrow((v) => {
   const yr = Math.trunc(v / 1e4);
   return typeof Year(yr) === "number" && yr + 1 === v % 1e4;
@@ -976,12 +994,15 @@ var TeamAbbrev = type.enumerated(
     nhl_exports.InactiveTeamsEnum
   )
 ).describe("a valid NHL team abbreviation");
-var TeamId = type.enumerated(...Object.values(nhl_exports.TeamsEnum)).describe("a valid NHL team ID");
+var TeamId = type.enumerated(
+  ...Object.values(nhl_exports.TeamsEnum),
+  ...Object.values(nhl_exports.InactiveTeamsEnum)
+).describe("a valid NHL team ID");
 var GameType = type.enumerated(
   ...Object.keys(
     nhl_exports.GameTypeEnum
   )
-).pipe((v) => nhl_exports.GameTypeEnum[v]).or(type('1|2|3|4|19|"1"|"2"|"3"|"4"|"19"')).describe("a valid NHL game type (e.g., REG, PRE, POST)");
+).pipe((v) => nhl_exports.GameTypeEnum[v]).or(type("1|2|3|4|19")).describe("a valid NHL game type (e.g., REG, PRE, POST)");
 var GameNumber = type("number").atLeast(1).atMost(82 * 32 / 2).or(
   type("string.numeric.parse").narrow((v) => {
     return v >= 1 && v <= 82 * 32 / 2;
@@ -990,21 +1011,6 @@ var GameNumber = type("number").atLeast(1).atMost(82 * 32 / 2).or(
 var DraftRound = type("1 <= number <= 7").or(type(/^(1|2|3|4|5|6|7)$/)).pipe((v) => typeof v === "number" ? v.toString() : v).describe("a valid NHL draft round (1-7)");
 type("1 <= number <= 4").or(type(/^(1|2|3|4)$/)).pipe((v) => typeof v === "number" ? v.toString() : v).describe("a valid NHL playoff round (1-4)");
 var EventId = type("number.integer | string.numeric.parse").narrow((v) => Number.isInteger(v) && v > 0).describe("a positive integer representing an NHL event ID");
-var NHLDate = type("Date | string.date.iso").pipe(
-  (v) => typeof v === "string" ? new Date(v).toISOString().slice(0, 10) : v.toISOString().slice(0, 10)
-).describe(
-  "a valid date, either as a string (ISO date string) or a Date object"
-);
-type("Date | string").narrow((v) => {
-  if (typeof v === "string") {
-    return /^\d{4}-\d{2}$/.test(v);
-  } else if (v instanceof Date) {
-    return true;
-  }
-  return false;
-}).pipe((v) => typeof v === "string" ? v : v.toISOString().slice(0, 7)).describe(
-  "a valid month, either as a string (formatted as YYYY-MM) or a Date object"
-);
 type("1|2|3|4|19").describe(
   "a valid NHL game type code (1=PRE, 2=REG, 3=POST, 4=ASG, 19=INTL)"
 );
@@ -1024,7 +1030,7 @@ var GameId = type("number.integer | string.numeric.parse").narrow((v) => {
 var SeriesLetter = type.enumerated(...Object.values(nhl_exports.SeriesLetterEnum)).describe("a valid NHL playoff series letter (A-O)");
 type.enumerated(...Object.values(nhl_exports.GameStateEnum)).describe("a valid NHL game state");
 var CountryCode = type(/^[a-zA-Z]{2}$/).pipe((v) => v.toLowerCase()).describe("a valid ISO 3166-1 alpha-2 country code, e.g. US, CA, RU");
-var PostalCode = type(/^[a-zA-Z]\d[a-zA-Z] \d[a-zA-Z]\d$/).or(type(/^\d{5}$/)).describe(
+var PostalCode = type(/^[a-zA-Z]\d[a-zA-Z][ -]?\d[a-zA-Z]\d$/).or(type(/^\d{5}$/)).describe(
   "a valid postal code, either US ZIP code (5 digit) or Canadian postal code (A1A 1A1 format; space required)"
 );
 var PlayerId = type("number").atLeast(nhl_exports.PLAYER_ID_RANGE.MIN).atMost(nhl_exports.PLAYER_ID_RANGE.MAX).or(
@@ -1098,10 +1104,6 @@ var BaseParams = type({
     (v) => v ?? nhl_exports.GameTypeEnum.REG
   )
 });
-type({
-  season: Season.or("undefined").optional(),
-  gameType: GameType.or("undefined").optional()
-});
 BaseParams.merge({
   playerId: PlayerId,
   season: Season
@@ -1136,7 +1138,9 @@ var SeriesParams = type({
 var ScheduleParams = type({
   team: TeamAbbrev,
   date: NHLDate.or("undefined").pipe((v) => v ?? getCurrentDate()),
-  period: type('"week" | "month" | undefined').pipe((v) => v ?? "week")
+  month: NHLMonth.or("undefined").pipe(
+    (v) => v ?? getCurrentDate().slice(0, 7)
+  )
 });
 
 // src/utils/utils.ts
@@ -1149,8 +1153,71 @@ function route(template, params) {
   return route2;
 }
 
-// src/api/gamecenter/draft.ts
-var _paths = {
+// src/api/gamecenter/_paths.ts
+var _teamPaths = {
+  rosterSeasons: "roster-season/{team}",
+  roster: "roster/{team}/{season}",
+  prospects: "prospects/{team}",
+  clubStats: "club-stats/{team}/{season}/{gameType}",
+  clubStatsSeason: "club-stats-season/{team}",
+  standings: "standings/{date}",
+  standingsSeason: "standings-season",
+  clubSchedule: {
+    season: "club-schedule-season/{team}/{season}",
+    month: "club-schedule/{team}/month/{month}",
+    week: "club-schedule/{team}/week/{date}"
+  }
+};
+var _scorePaths = {
+  score: "score/{date}",
+  scoreboard: {
+    now: "scoreboard/now",
+    byTeam: "scoreboard/{team}/now",
+    byDate: "scoreboard/{date}"
+  }
+};
+var _playerPaths = {
+  landing: "player/{playerId}/landing",
+  gameLog: "player/{playerId}/game-log/{season}/{gameType}",
+  spotlight: "player-spotlight",
+  statsLeaders: {
+    skaters: "skater-stats-leaders/{season}/{gameType}",
+    goalies: "goalie-stats-leaders/{season}/{gameType}"
+  },
+  playerSearch: "https://search.d3.nhle.com/api/v1/search/player"
+};
+var _miscPaths = {
+  season: "season",
+  metaPlayoffSeries: "meta/playoff-series/{year}/{seriesLetter}",
+  metaGame: "meta/game/{gameId}",
+  postalLookup: "postal-lookup/{postalCode}",
+  location: "location",
+  partnerGame: "partner-game/{countryCode}/now"
+};
+var _gamePaths = {
+  schedule: "schedule/{date}",
+  scheduleCalendar: "schedule-calendar/{date}",
+  playoffBracket: "playoff-bracket/{year}",
+  playoffSeries: "playoff-series/{season}",
+  playoffSeriesSchedule: "schedule/playoff-series/{season}/{seriesLetter}",
+  gamecenter: {
+    playByPlay: "gamecenter/{gameId}/play-by-play",
+    reports: "gamecenter/{gameId}/right-rail",
+    landing: "gamecenter/{gameId}/landing",
+    boxscore: "gamecenter/{gameId}/boxscore"
+  },
+  wsc: {
+    gameStory: "wsc/game-story/{gameId}",
+    playByPlay: "wsc/play-by-play/{gameId}"
+  },
+  pptReplay: {
+    goal: "ppt-replay/goal/{gameId}/{eventId}",
+    event: "ppt-replay/{gameId}/{eventId}"
+  },
+  whereToWatch: "where-to-watch",
+  networkTVSchedule: "network/tv-schedule/{date}"
+};
+var _draftPaths = {
   draftPicks: {
     byYearAndRound: "draft/picks/{year}/{round}",
     byYear: "draft/picks/{year}/all"
@@ -1158,58 +1225,103 @@ var _paths = {
   draftRankings: "draft/rankings/{year}/{type}",
   draftTracker: "draft-tracker/picks/now"
 };
-var DraftRankingsEnum = {
-  skatersNA: "1",
-  skatersIntl: "2",
-  goaliesNA: "3",
-  goaliesIntl: "4"
-};
-var picks = (year, round) => {
+
+// src/api/gamecenter/draft.ts
+async function picks(year, round) {
   const parsed = DraftParams({ year, round });
   if (isParseError(parsed)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsed.summary, {
-        endpoint: _paths.draftPicks.byYearAndRound
+        endpoint: _draftPaths.draftPicks.byYearAndRound
       })
-    });
+    };
   }
   if (parsed.year && !parsed.round)
-    return client_default.get(route(_paths.draftPicks.byYear, parsed));
-  return client_default.get(route(_paths.draftPicks.byYearAndRound, parsed));
-};
-var tracker = () => client_default.get(_paths.draftTracker);
-var rankings = (year) => {
-  const getRankings = (type2) => {
+    return client_default.get(route(_draftPaths.draftPicks.byYear, parsed));
+  return client_default.get(route(_draftPaths.draftPicks.byYearAndRound, parsed));
+}
+async function tracker() {
+  return client_default.get(_draftPaths.draftTracker);
+}
+function rankings(year) {
+  const DraftRankingsEnum = {
+    skatersNA: "1",
+    skatersIntl: "2",
+    goaliesNA: "3",
+    goaliesIntl: "4"
+  };
+  const getRankings = async (type2) => {
     const parsedYear = Year(year ?? getCurrentYear());
     if (isParseError(parsedYear)) {
-      return Promise.resolve({
+      return {
         status: "error",
         error: new ValidationError(parsedYear.summary, {
-          endpoint: _paths.draftRankings
+          endpoint: _draftPaths.draftRankings
         })
-      });
+      };
     }
     return client_default.get(
-      route(_paths.draftRankings, {
+      route(_draftPaths.draftRankings, {
         year: parsedYear,
         type: type2
       })
     );
   };
   return {
-    skatersNA: () => getRankings(DraftRankingsEnum.skatersNA),
-    skatersIntl: () => getRankings(DraftRankingsEnum.skatersIntl),
-    goaliesNA: () => getRankings(DraftRankingsEnum.goaliesNA),
-    goaliesIntl: () => getRankings(DraftRankingsEnum.goaliesIntl),
-    all: () => Promise.all([
-      getRankings(DraftRankingsEnum.skatersNA),
-      getRankings(DraftRankingsEnum.skatersIntl),
-      getRankings(DraftRankingsEnum.goaliesNA),
-      getRankings(DraftRankingsEnum.goaliesIntl)
-    ])
+    /**
+     * Get North American skater draft rankings
+     * @returns Promise resolving to NA skater rankings
+     */
+    skatersNA: async () => getRankings(DraftRankingsEnum.skatersNA),
+    /**
+     * Get International skater draft rankings
+     * @returns Promise resolving to International skater rankings
+     */
+    skatersIntl: async () => getRankings(DraftRankingsEnum.skatersIntl),
+    /**
+     * Get North American goalie draft rankings
+     * @returns Promise resolving to NA goalie rankings
+     */
+    goaliesNA: async () => getRankings(DraftRankingsEnum.goaliesNA),
+    /**
+     * Get International goalie draft rankings
+     * @returns Promise resolving to International goalie rankings
+     */
+    goaliesIntl: async () => getRankings(DraftRankingsEnum.goaliesIntl),
+    /**
+     * Get all draft rankings (NA/Intl skaters and goalies)
+     * @returns Promise resolving to array of all rankings
+     */
+    all: async () => {
+      const unwrapAPIResponse = (apiResponse) => {
+        if (apiResponse.status === "success") {
+          return apiResponse.data;
+        }
+        throw apiResponse.error;
+      };
+      const response = await Promise.all([
+        getRankings(DraftRankingsEnum.skatersNA),
+        getRankings(DraftRankingsEnum.skatersIntl),
+        getRankings(DraftRankingsEnum.goaliesNA),
+        getRankings(DraftRankingsEnum.goaliesIntl)
+      ]);
+      try {
+        const dataOnly = response.map((r) => unwrapAPIResponse(r));
+        const newResponse = {
+          status: "success",
+          data: dataOnly
+        };
+        return newResponse;
+      } catch (error) {
+        return {
+          status: "error",
+          error
+        };
+      }
+    }
   };
-};
+}
 
 // src/api/gamecenter/game.ts
 var game_exports = {};
@@ -1228,248 +1340,206 @@ __export(game_exports, {
   whereToWatch: () => whereToWatch,
   wsc: () => wsc
 });
-var _paths2 = {
-  schedule: "schedule/{date}",
-  scheduleCalendar: "schedule-calendar/{date}",
-  playoffBracket: "playoff-bracket/{year}",
-  playoffSeries: "playoff-series/{season}",
-  playoffSeriesSchedule: "schedule/playoff-series/{season}/{seriesLetter}",
-  gamecenter: {
-    playByPlay: "gamecenter/{gameId}/play-by-play",
-    reports: "gamecenter/{gameId}/right-rail",
-    landing: "gamecenter/{gameId}/landing",
-    boxscore: "gamecenter/{gameId}/boxscore"
-  },
-  wsc: {
-    gameStory: "wsc/game-story/{gameId}",
-    playByPlay: "wsc/play-by-play/{gameId}"
-  },
-  pptReplay: {
-    goal: "ppt-replay/{gameId}/goal/{eventId}",
-    event: "ppt-replay/{date}"
-  },
-  whereToWatch: "where-to-watch",
-  networkTVSchedule: "network/tv-schedule/{date}"
-};
-var playByPlay = (gameId) => {
+async function playByPlay(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _paths2.gamecenter.playByPlay
+        endpoint: _gamePaths.gamecenter.playByPlay
       })
-    });
+    };
   }
   return client_default.get(
-    route(_paths2.gamecenter.playByPlay, { gameId: parsedGameId })
+    route(_gamePaths.gamecenter.playByPlay, { gameId: parsedGameId })
   );
-};
-var reports = (gameId) => {
+}
+async function reports(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _paths2.gamecenter.reports
+        endpoint: _gamePaths.gamecenter.reports
       })
-    });
+    };
   }
   return client_default.get(
-    route(_paths2.gamecenter.reports, { gameId: parsedGameId })
+    route(_gamePaths.gamecenter.reports, { gameId: parsedGameId })
   );
-};
-var landing = (gameId) => {
+}
+async function landing(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _paths2.gamecenter.landing
+        endpoint: _gamePaths.gamecenter.landing
       })
-    });
+    };
   }
   return client_default.get(
-    route(_paths2.gamecenter.landing, { gameId: parsedGameId })
+    route(_gamePaths.gamecenter.landing, { gameId: parsedGameId })
   );
-};
-var boxscore = (gameId) => {
+}
+async function boxscore(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _paths2.gamecenter.boxscore
+        endpoint: _gamePaths.gamecenter.boxscore
       })
-    });
+    };
   }
   return client_default.get(
-    route(_paths2.gamecenter.boxscore, { gameId: parsedGameId })
+    route(_gamePaths.gamecenter.boxscore, { gameId: parsedGameId })
   );
-};
+}
 var wsc = {
-  /**
-   * Get game story data for a specific game
-   * @param gameId - The unique identifier for the game
-   * @returns Promise resolving to game story data
-   */
-  gameStory: (gameId) => {
-    const parsedGameId = GameId(gameId);
-    if (isParseError(parsedGameId)) {
-      return Promise.resolve({
-        status: "error",
-        error: new ValidationError(parsedGameId.summary, {
-          endpoint: _paths2.wsc.gameStory
-        })
-      });
-    }
-    return client_default.get(
-      route(_paths2.wsc.gameStory, { gameId: parsedGameId })
-    );
-  },
-  /**
-   * Get play-by-play data for a specific game
-   * @param gameId - The unique identifier for the game
-   * @returns Promise resolving to play-by-play data
-   */
-  playByPlay: (gameId) => {
-    const parsedGameId = GameId(gameId);
-    if (isParseError(parsedGameId)) {
-      return Promise.resolve({
-        status: "error",
-        error: new ValidationError(parsedGameId.summary, {
-          endpoint: _paths2.wsc.playByPlay
-        })
-      });
-    }
-    return client_default.get(
-      route(_paths2.wsc.playByPlay, { gameId: parsedGameId })
-    );
-  }
+  gameStory: wscGameStory,
+  playByPlay: wscPlayByPlay
 };
-var pptReplay = {
-  /**
-   * Get goal replay data for a specific game and event
-   * @param gameId - The unique identifier for the game
-   * @param eventId - The unique identifier for the event
-   * @returns Promise resolving to goal replay data
-   */
-  goal: (gameId, eventId) => {
-    const parsed = GameIdAndEventId({ gameId, eventId });
-    if (isParseError(parsed)) {
-      return Promise.resolve({
-        status: "error",
-        error: new ValidationError(parsed.summary, {
-          endpoint: _paths2.pptReplay.goal
-        })
-      });
-    }
-    return client_default.get(
-      route(_paths2.pptReplay.goal, { gameId, eventId })
-    );
-  },
-  /**
-   * Get event replay data for a specific date
-   * @param date - Date to get event replay data for (Date object or ISO date string)
-   * @returns Promise resolving to event replay data
-   */
-  event: async (date) => {
-    const parsedDate = NHLDate(date);
-    if (isParseError(parsedDate)) {
-      return Promise.resolve({
-        status: "error",
-        error: new ValidationError(parsedDate.summary, {
-          endpoint: _paths2.pptReplay.event
-        })
-      });
-    }
-    return client_default.get(
-      route(_paths2.pptReplay.event, { date: parsedDate })
-    );
+async function wscGameStory(gameId) {
+  const parsedGameId = GameId(gameId);
+  if (isParseError(parsedGameId)) {
+    return {
+      status: "error",
+      error: new ValidationError(parsedGameId.summary, {
+        endpoint: _gamePaths.wsc.gameStory
+      })
+    };
+  }
+  return client_default.get(
+    route(_gamePaths.wsc.gameStory, { gameId: parsedGameId })
+  );
+}
+async function wscPlayByPlay(gameId) {
+  const parsedGameId = GameId(gameId);
+  if (isParseError(parsedGameId)) {
+    return {
+      status: "error",
+      error: new ValidationError(parsedGameId.summary, {
+        endpoint: _gamePaths.wsc.playByPlay
+      })
+    };
   }
+  return client_default.get(
+    route(_gamePaths.wsc.playByPlay, { gameId: parsedGameId })
+  );
+}
+var pptReplay = {
+  goal: pptReplayGoal,
+  event: pptReplayEvent
 };
-var schedule = (date) => {
+async function pptReplayGoal(gameId, eventId) {
+  const parsed = GameIdAndEventId({ gameId, eventId });
+  if (isParseError(parsed)) {
+    return {
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: _gamePaths.pptReplay.goal
+      })
+    };
+  }
+  return client_default.get(route(_gamePaths.pptReplay.goal, { gameId, eventId }));
+}
+async function pptReplayEvent(gameId, eventId) {
+  const parsed = GameIdAndEventId({ gameId, eventId });
+  if (isParseError(parsed)) {
+    return {
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: _gamePaths.pptReplay.event
+      })
+    };
+  }
+  return client_default.get(route(_gamePaths.pptReplay.event, { gameId, eventId }));
+}
+async function schedule(date) {
   const parsedDate = NHLDate(date ?? getCurrentDate());
   if (isParseError(parsedDate)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsedDate.summary, {
-        endpoint: _paths2.schedule
+        endpoint: _gamePaths.schedule
       })
-    });
+    };
   }
-  return client_default.get(route(_paths2.schedule, { date: parsedDate }));
-};
-var scheduleCalendar = (date) => {
+  return client_default.get(route(_gamePaths.schedule, { date: parsedDate }));
+}
+async function scheduleCalendar(date) {
   const parsedDate = NHLDate(date);
   if (isParseError(parsedDate)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsedDate.summary, {
-        endpoint: _paths2.scheduleCalendar
+        endpoint: _gamePaths.scheduleCalendar
       })
-    });
+    };
   }
   return client_default.get(
-    route(_paths2.scheduleCalendar, { date: parsedDate })
+    route(_gamePaths.scheduleCalendar, { date: parsedDate })
   );
-};
-var playoffBracket = (year) => {
+}
+async function playoffBracket(year) {
   const parsedYear = Year(year ?? getCurrentYear());
   if (isParseError(parsedYear)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsedYear.summary, {
-        endpoint: _paths2.playoffBracket
+        endpoint: _gamePaths.playoffBracket
       })
-    });
+    };
   }
-  return client_default.get(route(_paths2.playoffBracket, { year: parsedYear }));
-};
-var playoffSeries = (season) => {
+  return client_default.get(route(_gamePaths.playoffBracket, { year: parsedYear }));
+}
+async function playoffSeries(season) {
   const parsedSeason = Season(season ?? getCurrentSeason());
   if (isParseError(parsedSeason)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsedSeason.summary, {
-        endpoint: _paths2.playoffSeries
+        endpoint: _gamePaths.playoffSeries
       })
-    });
+    };
   }
   return client_default.get(
-    route(_paths2.playoffSeries, { season: parsedSeason })
+    route(_gamePaths.playoffSeries, { season: parsedSeason })
   );
-};
-var playoffSeriesSchedule = (seriesLetter, season) => {
+}
+async function playoffSeriesSchedule(seriesLetter, season) {
   const parsed = SeriesAndSeasonParams({
     seriesLetter,
     season: season ?? getCurrentSeason()
   });
   if (isParseError(parsed)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsed.summary, {
-        endpoint: _paths2.playoffSeriesSchedule
+        endpoint: _gamePaths.playoffSeriesSchedule
       })
-    });
+    };
   }
-  return client_default.get(route(_paths2.playoffSeriesSchedule, parsed));
-};
-var whereToWatch = () => client_default.get(_paths2.whereToWatch);
-var networkTVSchedule = (date) => {
+  return client_default.get(route(_gamePaths.playoffSeriesSchedule, parsed));
+}
+async function whereToWatch() {
+  return client_default.get(_gamePaths.whereToWatch);
+}
+async function networkTVSchedule(date) {
   const parsedDate = NHLDate(date ?? getCurrentDate());
   if (isParseError(parsedDate)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsedDate.summary, {
-        endpoint: _paths2.networkTVSchedule
+        endpoint: _gamePaths.networkTVSchedule
       })
-    });
+    };
   }
   return client_default.get(
-    route(_paths2.networkTVSchedule, { date: parsedDate })
+    route(_gamePaths.networkTVSchedule, { date: parsedDate })
   );
-};
+}
 
 // src/api/gamecenter/misc.ts
 var misc_exports = {};
@@ -1480,89 +1550,68 @@ __export(misc_exports, {
   postalLookup: () => postalLookup,
   seasons: () => seasons
 });
-var _paths3 = {
-  season: "season",
-  metaPlayoffSeries: "meta/playoff-series/{year}/{seriesLetter}",
-  metaGame: "meta/game/{gameId}",
-  postalLookup: "postal-lookup/{postalCode}",
-  location: "location",
-  partnerGame: "partner-game/{countryCode}/now"
-};
-var seasons = () => {
-  return client_default.get(_paths3.season);
-};
+async function seasons() {
+  return client_default.get(_miscPaths.season);
+}
 var meta = {
-  /**
-   * Get meta information for a playoff series
-   *
-   * @param year - The year in YYYY format
-   * @param seriesLetter - Single letter identifier for the playoff series
-   * @returns Promise resolving to playoff series meta information
-   */
-  playoffSeries: (seriesLetter, year) => {
-    const parsed = SeriesParams({ year, seriesLetter });
-    if (isParseError(parsed)) {
-      return Promise.resolve({
-        status: "error",
-        error: new ValidationError(parsed.summary, {
-          endpoint: _paths3.metaPlayoffSeries
-        })
-      });
-    }
-    return client_default.get(route(_paths3.metaPlayoffSeries, parsed));
-  },
-  /**
-   * Get meta information for a specific game
-   *
-   * @param gameId - The unique game identifier
-   * @returns Promise resolving to game meta information
-   */
-  game: (gameId) => {
-    const parsedGameId = GameId(gameId);
-    if (isParseError(parsedGameId)) {
-      return Promise.resolve({
-        status: "error",
-        error: new ValidationError(parsedGameId.summary, {
-          endpoint: _paths3.metaGame
-        })
-      });
-    }
-    return client_default.get(
-      route(_paths3.metaGame, { gameId: parsedGameId })
-    );
-  }
+  game: metaGame,
+  playoffSeries: metaPlayoffSeries
 };
-var postalLookup = (postalCode) => {
+async function metaGame(gameId) {
+  const parsedGameId = GameId(gameId);
+  if (isParseError(parsedGameId)) {
+    return {
+      status: "error",
+      error: new ValidationError(parsedGameId.summary, {
+        endpoint: _miscPaths.metaGame
+      })
+    };
+  }
+  return client_default.get(route(_miscPaths.metaGame, { gameId: parsedGameId }));
+}
+async function metaPlayoffSeries(seriesLetter, year) {
+  const parsed = SeriesParams({ year, seriesLetter });
+  if (isParseError(parsed)) {
+    return {
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: _miscPaths.metaPlayoffSeries
+      })
+    };
+  }
+  return client_default.get(route(_miscPaths.metaPlayoffSeries, parsed));
+}
+async function postalLookup(postalCode) {
   const parsedPostalCode = PostalCode(postalCode);
   if (isParseError(parsedPostalCode)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsedPostalCode.summary, {
-        endpoint: _paths3.postalLookup
+        endpoint: _miscPaths.postalLookup
       })
-    });
+    };
   }
   return client_default.get(
-    route(_paths3.postalLookup, { postalCode: parsedPostalCode })
+    route(_miscPaths.postalLookup, { postalCode: parsedPostalCode })
   );
-};
-var location = () => {
-  return client_default.get(_paths3.location);
-};
-var partnerGame = (countryCode) => {
+}
+async function location() {
+  return client_default.get(_miscPaths.location);
+}
+async function partnerGame(countryCode) {
   const parsedCountryCode = CountryCode(countryCode);
   if (isParseError(parsedCountryCode)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsedCountryCode.summary, {
-        endpoint: _paths3.partnerGame
+        endpoint: _miscPaths.partnerGame
       })
-    });
+    };
   }
   return client_default.get(
-    route(_paths3.partnerGame, { countryCode: parsedCountryCode })
+    route(_miscPaths.partnerGame, { countryCode: parsedCountryCode })
   );
-};
+}
 
 // src/api/gamecenter/player.ts
 var player_exports = {};
@@ -1573,325 +1622,250 @@ __export(player_exports, {
   spotlight: () => spotlight,
   statsLeaders: () => statsLeaders
 });
-var _paths4 = {
-  landing: "player/{playerId}/landing",
-  gameLog: "player/{playerId}/game-log/{season}/{gameType}",
-  spotlight: "player-spotlight",
-  statsLeaders: {
-    skaters: "skater-stats-leaders/{season}/{gameType}",
-    goalies: "goalie-stats-leaders/{season}/{gameType}"
-  },
-  playerSearch: "https://search.d3.nhle.com/api/v1/search/player"
-};
-var nhlPlayerSearch = createNHLClient(_paths4.playerSearch);
+var nhlPlayerSearch = createNHLClient(_playerPaths.playerSearch);
 var searchUrlParams = { culture: "en", q: "" };
-var landing2 = (playerId) => {
+async function landing2(playerId) {
   const parsedPlayerId = PlayerId(playerId);
   if (isParseError(parsedPlayerId)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsedPlayerId.summary, {
-        endpoint: _paths4.landing
+        endpoint: _playerPaths.landing
       })
-    });
+    };
   }
   return client_default.get(
-    route(_paths4.landing, { playerId: parsedPlayerId })
+    route(_playerPaths.landing, { playerId: parsedPlayerId })
   );
-};
-var gameLog = (playerId, season, gameType) => {
+}
+async function gameLog(playerId, season, gameType) {
   const Parser = BaseParams.merge({
     playerId: PlayerId
   });
   const parsed = Parser({ playerId, season, gameType });
   if (isParseError(parsed)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsed.summary, {
-        endpoint: _paths4.gameLog
+        endpoint: _playerPaths.gameLog
       })
-    });
+    };
   }
-  return client_default.get(route(_paths4.gameLog, parsed));
-};
-var spotlight = () => {
-  return client_default.get(_paths4.spotlight);
-};
-var search = (query) => {
+  return client_default.get(route(_playerPaths.gameLog, parsed));
+}
+async function spotlight() {
+  return client_default.get(_playerPaths.spotlight);
+}
+async function search(query) {
   return nhlPlayerSearch.get("", {
     ...searchUrlParams,
     q: query
   });
-};
+}
 var statsLeaders = {
-  /**
-   * Get skater stats leaders
-   * @param season - The season identifier (optional)
-   * @param gameType - The game type identifier (optional)
-   * @returns Promise resolving to skater stats leaders
-   */
-  skaters: (season, gameType) => {
-    const parsed = BaseParams({ season, gameType });
-    if (isParseError(parsed)) {
-      return Promise.resolve({
-        status: "error",
-        error: new ValidationError(parsed.summary, {
-          endpoint: _paths4.statsLeaders.skaters
-        })
-      });
-    }
-    return client_default.get(route(_paths4.statsLeaders.skaters, parsed));
-  },
-  /**
-   * Get goalie stats leaders
-   * @param season - The season identifier (optional)
-   * @param gameType - The game type identifier (optional)
-   * @returns Promise resolving to goalie stats leaders
-   */
-  goalies: (season, gameType) => {
-    const parsed = BaseParams({ season, gameType });
-    if (isParseError(parsed)) {
-      return Promise.resolve({
-        status: "error",
-        error: new ValidationError(parsed.summary, {
-          endpoint: _paths4.statsLeaders.goalies
-        })
-      });
-    }
-    return client_default.get(route(_paths4.statsLeaders.goalies, parsed));
-  }
+  skaters: statsLeadersSkaters,
+  goalies: statsLeadersGoalies
 };
+async function statsLeadersSkaters(season, gameType) {
+  const parsed = BaseParams({ season, gameType });
+  if (isParseError(parsed)) {
+    return {
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: _playerPaths.statsLeaders.skaters
+      })
+    };
+  }
+  return client_default.get(route(_playerPaths.statsLeaders.skaters, parsed));
+}
+async function statsLeadersGoalies(season, gameType) {
+  const parsed = BaseParams({ season, gameType });
+  if (isParseError(parsed)) {
+    return {
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: _playerPaths.statsLeaders.goalies
+      })
+    };
+  }
+  return client_default.get(route(_playerPaths.statsLeaders.goalies, parsed));
+}
 
 // src/api/gamecenter/score.ts
-var _paths5 = {
-  score: "score/{date}",
-  scoreboard: {
-    now: "scoreboard/now",
-    byTeam: "scoreboard/{team}/now",
-    byDate: "scoreboard/{date}"
-  }
-};
-var score = (date) => {
+async function score(date) {
   const parsed = NHLDate(date ?? getCurrentDate());
   if (isParseError(parsed)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsed.summary, {
-        endpoint: _paths5.score
+        endpoint: _scorePaths.score
       })
-    });
+    };
   }
-  return client_default.get(route(_paths5.score, { date: parsed }));
-};
-var scoreboard = () => client_default.get(_paths5.scoreboard.now);
+  return client_default.get(route(_scorePaths.score, { date: parsed }));
+}
+async function scoreboard() {
+  return client_default.get(_scorePaths.scoreboard.now);
+}
 scoreboard.team = async (team) => {
   const parsed = TeamAbbrev(team);
   if (isParseError(parsed)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsed.summary, {
-        endpoint: _paths5.scoreboard.byTeam
+        endpoint: _scorePaths.scoreboard.byTeam
       })
-    });
+    };
   }
   return client_default.get(
-    route(_paths5.scoreboard.byTeam, { team: parsed })
+    route(_scorePaths.scoreboard.byTeam, { team: parsed })
   );
 };
 scoreboard.date = async (date) => {
   const parsed = NHLDate(date);
   if (isParseError(parsed)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsed.summary, {
-        endpoint: _paths5.scoreboard.byDate
+        endpoint: _scorePaths.scoreboard.byDate
       })
-    });
+    };
   }
   return client_default.get(
-    route(_paths5.scoreboard.byDate, { date: parsed })
+    route(_scorePaths.scoreboard.byDate, { date: parsed })
   );
 };
 
 // src/api/gamecenter/team.ts
 var team_exports = {};
 __export(team_exports, {
-  clubStats: () => clubStats,
-  clubStatsSeason: () => clubStatsSeason,
   prospects: () => prospects,
   roster: () => roster,
   rosterSeasons: () => rosterSeasons,
   schedule: () => schedule2,
   standings: () => standings,
-  standingsSeason: () => standingsSeason
+  standingsSeason: () => standingsSeason,
+  stats: () => stats,
+  statsSeason: () => statsSeason
 });
-var paths = {
-  rosterSeasons: "roster-season/{team}",
-  roster: "roster/{team}/{season}",
-  prospects: "prospects/{team}",
-  clubStats: "club-stats/{team}/{season}/{gameType}",
-  clubStatsSeason: "club-stats-season/{team}",
-  standings: "standings/{date}",
-  standingsSeason: "standings-season",
-  clubSchedule: "club-schedule/{team}/{period}/{date}",
-  clubScheduleSeason: "club-schedule-season/{team}/{season}"
-};
-var rosterSeasons = (team) => {
+async function rosterSeasons(team) {
   const parsed = TeamAbbrev(team);
   if (isParseError(parsed)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsed.summary, {
-        endpoint: paths.rosterSeasons
+        endpoint: _teamPaths.rosterSeasons
       })
-    });
+    };
   }
-  return client_default.get(route(paths.rosterSeasons, { team: parsed }));
-};
-var roster = (team, season) => {
+  return client_default.get(route(_teamPaths.rosterSeasons, { team: parsed }));
+}
+async function roster(team, season) {
   const parsed = TeamAndSeasonParams({ team, season });
   if (isParseError(parsed)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsed.summary, {
-        endpoint: paths.roster
+        endpoint: _teamPaths.roster
       })
-    });
+    };
   }
-  return client_default.get(route(paths.roster, parsed));
-};
-var prospects = (team) => {
+  return client_default.get(route(_teamPaths.roster, parsed));
+}
+async function prospects(team) {
   const parsed = TeamAbbrev(team);
   if (isParseError(parsed)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsed.summary, {
-        endpoint: paths.prospects
+        endpoint: _teamPaths.prospects
       })
-    });
+    };
   }
-  return client_default.get(route(paths.prospects, { team: parsed }));
-};
-var clubStats = (team, season, gameType) => {
+  return client_default.get(route(_teamPaths.prospects, { team: parsed }));
+}
+async function stats(team, season, gameType) {
   const Parser = BaseParams.merge({
     team: TeamAbbrev
   });
   const parsed = Parser({ team, season, gameType });
   if (isParseError(parsed)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsed.summary, {
-        endpoint: paths.clubStats
+        endpoint: _teamPaths.clubStats
       })
-    });
+    };
   }
-  return client_default.get(route(paths.clubStats, parsed));
-};
-var clubStatsSeason = (team) => {
+  return client_default.get(route(_teamPaths.clubStats, parsed));
+}
+async function statsSeason(team) {
   const parsed = TeamAbbrev(team);
   if (isParseError(parsed)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsed.summary, {
-        endpoint: paths.clubStatsSeason
+        endpoint: _teamPaths.clubStatsSeason
       })
-    });
+    };
   }
-  return client_default.get(route(paths.clubStatsSeason, { team: parsed }));
-};
-var standings = (date) => {
+  return client_default.get(route(_teamPaths.clubStatsSeason, { team: parsed }));
+}
+async function standings(date) {
   const parsed = NHLDate(date ?? getCurrentDate());
   if (isParseError(parsed)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsed.summary, {
-        endpoint: paths.standings
+        endpoint: _teamPaths.standings
       })
-    });
+    };
   }
-  return client_default.get(route(paths.standings, { date: parsed }));
-};
-var standingsSeason = () => {
-  return client_default.get(paths.standingsSeason);
-};
-var clubSchedule = (team, date, period) => {
-  const parsed = ScheduleParams({ team, date, period });
+  return client_default.get(route(_teamPaths.standings, { date: parsed }));
+}
+async function standingsSeason() {
+  return client_default.get(_teamPaths.standingsSeason);
+}
+async function scheduleWeek(team, date) {
+  const parsed = ScheduleParams({ team, date, month: void 0 });
   if (isParseError(parsed)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsed.summary, {
-        endpoint: paths.clubSchedule
+        endpoint: _teamPaths.clubSchedule.week
       })
-    });
+    };
   }
-  if (period === "month") {
-    parsed.date = parsed.date?.slice(0, 7);
+  return client_default.get(route(_teamPaths.clubSchedule.week, parsed));
+}
+async function scheduleMonth(team, date) {
+  const parsed = ScheduleParams({ team, month: date, date: void 0 });
+  if (isParseError(parsed)) {
+    return {
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: _teamPaths.clubSchedule.month
+      })
+    };
   }
-  return client_default.get(route(paths.clubSchedule, parsed));
-};
-var clubScheduleSeason = (team, season) => {
+  return client_default.get(route(_teamPaths.clubSchedule.month, parsed));
+}
+async function scheduleSeason(team, season) {
   const parsed = TeamAndSeasonParams({ team, season });
   if (isParseError(parsed)) {
-    return Promise.resolve({
+    return {
       status: "error",
       error: new ValidationError(parsed.summary, {
-        endpoint: paths.clubScheduleSeason
+        endpoint: _teamPaths.clubSchedule.season
       })
-    });
+    };
   }
-  return client_default.get(route(paths.clubScheduleSeason, parsed));
-};
+  return client_default.get(route(_teamPaths.clubSchedule.season, parsed));
+}
 var schedule2 = {
-  /** Returns the full season schedule for the provided team and season
-   * @param team - The team abbreviation for the desired team
-   * @param season - The specific season (e.g. 20222023); if not provided, defaults to the current season.
-   * @returns A promise that resolves to the full season schedule for the specified team and season
-   * @example
-   * ```ts
-   * // Get the full season schedule for the Boston Bruins for the 2022-2023 season
-   * schedule.season('BOS', 20222023).then((data) => {
-   *    console.log(data);
-   * });
-   * ```
-   */
-  season: clubScheduleSeason,
-  /**
-   * Get the team schedule for any seven-day period
-   * @param team - The team abbreviation
-   * @param date - The date indicating the start of the seven-day period.
-   * If not provided, defaults to the current date. format: 'YYYY-MM'
-   * @returns A promise that resolves to the club schedule for the specified week
-   *
-   * @example
-   * ```ts
-   * import { schedule } from 'nhle-api';
-   *
-   * // Get the schedule for the Chicago Blackhawks for the week of November 4, 2023
-   * // This returns the schedule from November 4 to November 10, 2023
-   * schedule.week('CHI', '2023-11-04').then((data) => {
-   *    console.log(data);
-   * });
-   * ```
-   */
-  week: (team, date) => clubSchedule(team, date, "week"),
-  /**
-   * Get the team schedule for any month
-   * @param team - The team abbreviation
-   * @param date - The date indicating the month to get the schedule for.
-   * If not provided, defaults to the current month. format: 'YYYY-MM'
-   * @returns A promise that resolves to the club schedule for the specified month
-   *
-   * @example
-   * ```ts
-   * import { schedule } from 'nhle-api';
-   *
-   * // Get the schedule for the Toronto Maple Leafs for November 2023
-   * schedule.month('TOR', '2023-11').then((data) => {
-   *    console.log(data);
-   * });
-   * ```
-   */
-  month: (team, date) => clubSchedule(team, date, "month")
+  season: scheduleSeason,
+  week: scheduleWeek,
+  month: scheduleMonth
 };
 
 export { EDGE, nhl_exports as NHL, envConfig, gamecenter_exports as gc, logEnvConfig };