nhle-api 0.5.1

package/lib/index.cjs

@@ -0,0 +1,1905 @@
+'use strict';
+
+var arktype = require('arktype');
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in 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/gamecenter/draft.ts
+var draft_exports = {};
+__export(draft_exports, {
+  picks: () => picks,
+  rankings: () => rankings,
+  tracker: () => tracker
+});
+
+// src/config/env.ts
+function parseTimeout() {
+  const timeout = process.env.NHLE_API_TIMEOUT;
+  if (!timeout) return 5e3;
+  const parsed = parseInt(timeout, 10);
+  if (Number.isNaN(parsed) || parsed <= 0) {
+    console.warn(
+      `Invalid NHLE_API_TIMEOUT: "${timeout}". Using default 5000ms`
+    );
+    return 5e3;
+  }
+  return parsed;
+}
+function parseLanguage() {
+  const language = process.env.NHLE_API_LANGUAGE?.toLowerCase();
+  if (language === "fr") return "fr";
+  if (language && language !== "en") {
+    console.warn(
+      `Invalid NHLE_API_LANGUAGE: "${language}". Using default 'en'`
+    );
+  }
+  return "en";
+}
+function parseLogLevel() {
+  const logLevel = process.env.NHLE_API_LOGLEVEL?.toLowerCase();
+  const validLevels = [
+    "silent",
+    "error",
+    "warn",
+    "info",
+    "debug"
+  ];
+  if (!logLevel) return "warn";
+  if (validLevels.includes(logLevel)) {
+    return logLevel;
+  }
+  console.warn(
+    `Invalid NHLE_API_LOGLEVEL: "${logLevel}". Valid options: ${validLevels.join(", ")}. Using default 'warn'`
+  );
+  return "warn";
+}
+var envConfig = {
+  /**
+   * Request timeout in milliseconds
+   * Set via NHLE_API_TIMEOUT environment variable
+   * @default 5000
+   */
+  timeout: parseTimeout(),
+  /**
+   * Language code for API responses
+   * Set via NHLE_API_LANGUAGE environment variable
+   * @default 'en'
+   */
+  language: parseLanguage(),
+  /**
+   * Logging level for the client
+   * Set via NHLE_API_LOGLEVEL environment variable
+   * @default 'warn'
+   */
+  logLevel: parseLogLevel()
+};
+function logEnvConfig() {
+  const vars = {
+    timeout: process.env.NHLE_API_TIMEOUT,
+    language: process.env.NHLE_API_LANGUAGE,
+    logLevel: process.env.NHLE_API_LOGLEVEL
+  };
+  const configured = Object.entries(vars).filter(
+    ([, v]) => v !== void 0
+  );
+  if (configured.length > 0) {
+    console.debug("NHL API Environment Configuration:", {
+      ...Object.fromEntries(configured),
+      resolvedTimeout: envConfig.timeout,
+      resolvedLanguage: envConfig.language,
+      resolvedLogLevel: envConfig.logLevel
+    });
+  }
+}
+
+// src/errors/index.ts
+var ErrorCategory = {
+  /** Network-level errors (connection refused, timeout, etc.) */
+  NETWORK: "NETWORK",
+  /** HTTP 4xx client errors (invalid params, not found, etc.) */
+  CLIENT: "CLIENT",
+  /** HTTP 5xx server errors */
+  SERVER: "SERVER",
+  /** Rate limiting (HTTP 429) */
+  RATE_LIMIT: "RATE_LIMIT",
+  /** Valid HTTP response but with error payload */
+  API_ERROR: "API_ERROR",
+  /** Response parsing/validation failures */
+  PARSE: "PARSE",
+  /** Invalid user input or configuration */
+  VALIDATION: "VALIDATION"
+};
+var LogLevel = {
+  ERROR: 1,
+  WARN: 2,
+  INFO: 3,
+  DEBUG: 4
+};
+var NHLError = class extends Error {
+  category;
+  context;
+  constructor(message, category, context = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.category = category;
+    this.context = {
+      ...context,
+      timestamp: context.timestamp || /* @__PURE__ */ new Date()
+    };
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  /**
+   * Serialize error to JSON
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      category: this.category,
+      context: this.context,
+      ...this.stack && { stack: this.stack }
+    };
+  }
+};
+var NetworkError = class extends NHLError {
+  constructor(message, context = {}) {
+    super(message, ErrorCategory.NETWORK, context);
+  }
+};
+var ClientError = class extends NHLError {
+  constructor(message, context = {}) {
+    super(message, ErrorCategory.CLIENT, context);
+  }
+};
+var NotFoundError = class extends ClientError {
+  constructor(message = "Resource not found", context = {}) {
+    super(message, { ...context, statusCode: context.statusCode || 404 });
+  }
+};
+var ServerError = class extends NHLError {
+  constructor(message, context = {}) {
+    super(message, ErrorCategory.SERVER, context);
+  }
+};
+var RateLimitError = class extends NHLError {
+  retryAfter;
+  constructor(message = "Rate limit exceeded", context = {}, retryAfter) {
+    super(message, ErrorCategory.RATE_LIMIT, {
+      ...context,
+      statusCode: context.statusCode || 429
+    });
+    this.retryAfter = retryAfter || 0;
+  }
+};
+var APIError = class extends NHLError {
+  constructor(message, context = {}) {
+    super(message, ErrorCategory.API_ERROR, context);
+  }
+};
+var ValidationError = class extends NHLError {
+  constructor(message, context = {}) {
+    super(message, ErrorCategory.VALIDATION, context);
+  }
+};
+var ErrorHandler = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      logLevel: config.logLevel ?? LogLevel.ERROR,
+      logger: config.logger ?? this.defaultLogger.bind(this),
+      includeStack: config.includeStack ?? true
+    };
+  }
+  /**
+   * Default console-based logger
+   */
+  defaultLogger(level, message, context) {
+    if (level > this.config.logLevel) return;
+    const logFn = level === LogLevel.ERROR ? console.error : level === LogLevel.WARN ? console.warn : console.log;
+    logFn(`[NHL API] ${message}`, context);
+  }
+  /**
+   * Log an error based on configuration
+   */
+  log(error) {
+    const level = this.getLogLevel(error.category);
+    const context = this.config.includeStack ? { ...error.context, stack: error.stack } : error.context;
+    this.config.logger(level, error.message, context);
+  }
+  /**
+   * Determine log level based on error category
+   */
+  getLogLevel(category) {
+    switch (category) {
+      case ErrorCategory.NETWORK:
+      case ErrorCategory.SERVER:
+        return LogLevel.ERROR;
+      case ErrorCategory.RATE_LIMIT:
+        return LogLevel.WARN;
+      case ErrorCategory.CLIENT:
+      case ErrorCategory.API_ERROR:
+        return LogLevel.INFO;
+      case ErrorCategory.PARSE:
+      case ErrorCategory.VALIDATION:
+        return LogLevel.DEBUG;
+      default:
+        return LogLevel.ERROR;
+    }
+  }
+  /**
+   * Create error from HTTP response
+   */
+  async fromResponse(response, context = {}) {
+    const statusCode = response.status;
+    const baseContext = {
+      ...context,
+      statusCode,
+      endpoint: context.endpoint || response.url
+    };
+    let responseBody;
+    try {
+      const text = await response.text();
+      responseBody = text ? JSON.parse(text) : null;
+      baseContext.responseBody = responseBody;
+    } catch {
+    }
+    const errorMessage = responseBody && typeof responseBody === "object" && "message" in responseBody ? String(responseBody.message) : `HTTP ${statusCode}: ${response.statusText}`;
+    if (statusCode === 429) {
+      const retryAfter = response.headers.get("Retry-After");
+      return new RateLimitError(
+        errorMessage,
+        baseContext,
+        retryAfter ? parseInt(retryAfter, 10) : void 0
+      );
+    }
+    if (statusCode === 404) {
+      return new NotFoundError(errorMessage, baseContext);
+    }
+    if (statusCode >= 500) {
+      return new ServerError(errorMessage, baseContext);
+    }
+    if (statusCode >= 400) {
+      return new ClientError(errorMessage, baseContext);
+    }
+    if (responseBody && typeof responseBody === "object" && "message" in responseBody) {
+      return new APIError(errorMessage, baseContext);
+    }
+    return new NHLError(errorMessage, ErrorCategory.CLIENT, baseContext);
+  }
+  /**
+   * Create error from caught exception
+   */
+  fromError(error, context = {}) {
+    if (error instanceof NHLError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      if (error.name === "TypeError" || error.name === "NetworkError") {
+        return new NetworkError(error.message, {
+          ...context,
+          cause: error
+        });
+      }
+      return new NHLError(error.message, ErrorCategory.NETWORK, {
+        ...context,
+        cause: error
+      });
+    }
+    return new NHLError(
+      "An unknown error occurred",
+      ErrorCategory.NETWORK,
+      { ...context, cause: error }
+    );
+  }
+  /**
+   * Update configuration
+   */
+  configure(config) {
+    this.config = { ...this.config, ...config };
+  }
+};
+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 DEFAULT_CONFIG = {
+  baseUrl: "https://api-web.nhle.com/v1",
+  timeout: envConfig.timeout,
+  headers: {
+    Accept: "application/json"
+  },
+  language: envConfig.language
+};
+var NHLClient = class {
+  config;
+  errorHandler;
+  /**
+   * Creates a new NHL API client instance
+   * @param baseURL - Optional custom base URL or predefined API endpoint key
+   * @param errorConfig - Optional error handling configuration
+   */
+  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;
+    }
+    this.errorHandler = new ErrorHandler(errorConfig);
+  }
+  /**
+   * Helper to build URL with query parameters
+   * @private
+   */
+  buildUrl(endpoint, params) {
+    const cleanEndpoint = endpoint.startsWith("/") ? endpoint.slice(1) : endpoint;
+    const url = new URL(cleanEndpoint, `${this.config.baseUrl}/`);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+    return url.toString();
+  }
+  /**
+   * Send a GET request to the NHL API
+   * @param endpoint - API endpoint path
+   * @param params - Optional query parameters
+   * @returns Promise resolving to an APIResponse containing either data or error
+   */
+  async get(endpoint, params) {
+    const url = this.buildUrl(endpoint, params);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      this.config.timeout
+    );
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          ...this.config.headers,
+          "Accept-Language": this.config.language
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const error = await this.errorHandler.fromResponse(response, {
+          endpoint: url
+        });
+        this.errorHandler.log(error);
+        return { status: "error", error };
+      }
+      return { data: await response.json(), status: "success" };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof NHLError) {
+        this.errorHandler.log(error);
+        return { status: "error", error };
+      }
+      let nhlError;
+      if (error instanceof Error && error.name === "AbortError") {
+        nhlError = new NHLError(
+          "Request timeout",
+          ErrorCategory.CLIENT,
+          {
+            endpoint
+          }
+        );
+      } else {
+        nhlError = this.errorHandler.fromError(error, {
+          endpoint,
+          method: "GET"
+        });
+      }
+      this.errorHandler.log(nhlError);
+      return { status: "error", error: nhlError };
+    }
+  }
+  /**
+   * Configure error handling behavior
+   * @param config - Error configuration options
+   */
+  configureErrorHandling(config) {
+    this.errorHandler.configure(config);
+  }
+};
+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());
+
+// src/constants/edge-adv.ts
+var edge_adv_exports = {};
+__export(edge_adv_exports, {
+  PositionFilterEnum: () => PositionFilterEnum,
+  SaveLocationCategoryEnum: () => SaveLocationCategoryEnum,
+  SaveLocationSortEnum: () => SaveLocationSortEnum,
+  SavePercentage5v5SortEnum: () => SavePercentage5v5SortEnum,
+  SavePercentageSortEnum: () => SavePercentageSortEnum,
+  ShotLocationCategoryEnum: () => ShotLocationCategoryEnum,
+  ShotLocationSortEnum: () => ShotLocationSortEnum,
+  ShotSpeedSortEnum: () => ShotSpeedSortEnum,
+  SkatersStrengthEnum: () => SkatersStrengthEnum,
+  SkatingDistanceSortEnum: () => SkatingDistanceSortEnum,
+  SkatingSpeedSortEnum: () => SkatingSpeedSortEnum,
+  ZoneTimeSortEnum: () => ZoneTimeSortEnum
+});
+var SaveLocationCategoryEnum = {
+  /** Save Percentage */
+  "SV%": "save-pctg",
+  /** Saves */
+  SV: "saves",
+  /** Shots Against */
+  SA: "shots-against",
+  /** Goals Against */
+  GA: "goals-against"
+};
+var ShotLocationSortEnum = {
+  /** All shot locations */
+  ALL: "all",
+  /** High-danger (i.e. close-range) shot locations */
+  HIGH: "high",
+  /** Mid-range shot locations */
+  MID: "mid",
+  /** Long-range shot locations */
+  LONG: "long"
+};
+var SaveLocationSortEnum = ShotLocationSortEnum;
+var SavePercentage5v5SortEnum = {
+  /**5v5 Save %: The percentage of shots a goalie stops at even strength (5-on-5). */
+  "5v5-SV%": "save-pctg",
+  /**5v5 Save % in Close Situations: A “close situation” is the time during which a game is tied in the first or second period, or within one goal in the third period. This stats helps how goalies perform in high-pressure situations.*/
+  "5v5-SV%-Close": "save-pctg-close",
+  /**5v5 Shots Against: The total number of shots a goalie faces at even strength (5-on-5).*/
+  "5v5-SA": "shots",
+  /**5v5 Shots Against per 60 Minutes: The total number of shots a goalie faces at even strength (5-on-5) normalized to a 60-minute game. */
+  "5v5-SA/60": "shots-per-60"
+};
+var SavePercentageSortEnum = {
+  /** Starts above .900 */
+  GAMES: "games",
+  /** Percentage of starts above .900 */
+  PCTG: "pctg"
+};
+var PositionFilterEnum = {
+  /** Center */
+  ALL: "all",
+  /** Left Wing */
+  FWD: "forwards",
+  /** Right Wing */
+  DEF: "defense"
+};
+var SkatersStrengthEnum = {
+  /** All strengths */
+  ALL: "all",
+  /** Even strength */
+  ES: "es",
+  /** Power play */
+  PP: "pp",
+  /** Short-handed */
+  PK: "pk"
+};
+var ShotSpeedSortEnum = {
+  /** Hardest shot recorded by player */
+  MAX: "max",
+  /** Shots over 100 mph */
+  "OVER-100": "over-100",
+  /** Shots between 90 and 99 mph */
+  "90-99": "90-99",
+  /** Shots between 80 and 89 mph */
+  "80-89": "80-89",
+  /** Shots between 70 and 79 mph */
+  "70-79": "70-79"
+};
+var SkatingSpeedSortEnum = {
+  /** Fastest skating speed recorded by player */
+  TOP: "max",
+  /** Speed bursts recorded over 22 mph */
+  "OVER-22": "over-22",
+  /** Speed bursts recorded between 20 and 22 mph */
+  "20-22": "20-22",
+  /** Speed bursts recorded between 18 and 20 mph */
+  "18-20": "18-20"
+};
+var SkatingDistanceSortEnum = {
+  /** Total distance skated */
+  TOTAL: "total",
+  /** Average distance skated per 60 minutes */
+  "PER-60": "per-60",
+  /** Maximum distance skated in a single period */
+  "MAX-PERIOD": "max-period",
+  /** Maximum distance skated in a single game */
+  "MAX-GAME": "max-game"
+};
+var ShotLocationCategoryEnum = {
+  /** Total shots on goal */
+  SOG: "sog",
+  /** Total goals */
+  G: "goals",
+  /** Shooting percentage */
+  "SH%": "shooting-pctg"
+};
+var ZoneTimeSortEnum = {
+  /** Percentage of time spent in the offensive zone */
+  OZ: "offensive",
+  /** Percentage of time spent in the defensive zone */
+  DZ: "defensive",
+  /** Percentage of time spent in the neutral zone */
+  NZ: "neutral"
+};
+
+// src/constants/edge-stats.ts
+var edge_stats_exports = {};
+
+// src/constants/nhl.ts
+var nhl_exports = {};
+__export(nhl_exports, {
+  CURRENT: () => CURRENT,
+  END_SEASON: () => END_SEASON,
+  END_YEAR: () => END_YEAR,
+  GameStateEnum: () => GameStateEnum,
+  GameTypeEnum: () => GameTypeEnum,
+  InactiveTeamsEnum: () => InactiveTeamsEnum,
+  InactiveTeamsReverseEnum: () => InactiveTeamsReverseEnum,
+  PLAYER_ID_RANGE: () => PLAYER_ID_RANGE,
+  PeriodTypeEnum: () => PeriodTypeEnum,
+  PlayoffSeriesEnum: () => PlayoffSeriesEnum,
+  SEASON_RANGE: () => SEASON_RANGE,
+  START_SEASON: () => START_SEASON,
+  START_YEAR: () => START_YEAR,
+  SeasonsArray: () => SeasonsArray,
+  SeriesLetterByRound: () => SeriesLetterByRound,
+  SeriesLetterEnum: () => SeriesLetterEnum,
+  TEAM_ID_RANGE: () => TEAM_ID_RANGE,
+  TeamsEnum: () => TeamsEnum,
+  TeamsReverseEnum: () => TeamsReverseEnum,
+  YEAR_RANGE: () => YEAR_RANGE
+});
+var TeamsEnum = {
+  /** Anaheim Ducks */
+  ANA: 24,
+  /** Boston Bruins */
+  BOS: 6,
+  /** Buffalo Sabres */
+  BUF: 7,
+  /** Calgary Flames */
+  CGY: 20,
+  /** Carolina Hurricanes */
+  CAR: 12,
+  /** Chicago Blackhawks */
+  CHI: 16,
+  /** Colorado Avalanche */
+  COL: 21,
+  /** Columbus Blue Jackets */
+  CBJ: 29,
+  /** Dallas Stars */
+  DAL: 25,
+  /** Detroit Red Wings */
+  DET: 17,
+  /** Edmonton Oilers */
+  EDM: 22,
+  /** Florida Panthers */
+  FLA: 13,
+  /** Los Angeles Kings */
+  LAK: 26,
+  /** Minnesota Wild*/
+  MIN: 30,
+  /** Montreal Canadiens */
+  MTL: 8,
+  /** New Jersey Devils */
+  NJD: 1,
+  /** Nashville Predators */
+  NSH: 18,
+  /** New York Islanders */
+  NYI: 2,
+  /** New York Rangers */
+  NYR: 3,
+  /** Ottawa Senators */
+  OTT: 9,
+  /** Philadelphia Flyers */
+  PHI: 4,
+  /** Pittsburgh Penguins */
+  PIT: 5,
+  /** San Jose Sharks */
+  SJS: 28,
+  /** Seattle Kraken */
+  SEA: 55,
+  /** St. Louis Blues */
+  STL: 19,
+  /** Tampa Bay Lightning */
+  TBL: 14,
+  /** Toronto Maple Leafs */
+  TOR: 10,
+  /** Utah Hockey Club */
+  UTA: 59,
+  /** Vancouver Canucks */
+  VAN: 23,
+  /** Vegas Golden Knights */
+  VGK: 54,
+  /** Winnipeg Jets */
+  WPG: 52,
+  /** Washington Capitals */
+  WSH: 15
+};
+var TeamsReverseEnum = Object.fromEntries(
+  Object.entries(TeamsEnum).map(([key, value]) => [value, key])
+);
+var InactiveTeamsEnum = {
+  /** Atlanta Flames (not active) */
+  AFM: 47,
+  /** Arizona Coyotes (not active) */
+  ARI: 53,
+  /** Atlanta Thrashers (not active) */
+  ATL: 11,
+  /**  Brooklyn Americans - (not active) */
+  BRK: 51,
+  /** California Golden Seals (aka Bay Area Seals) - (not active) */
+  CGS: 56,
+  /** Cleveland Barons - (not active) */
+  CLE: 49,
+  /** Colorado Rockies - (not active) */
+  CLR: 35,
+  /** Detroit Cougars - (not active) */
+  DCG: 40,
+  /** Detroit Falcons - (not active) */
+  DFL: 50,
+  /** Hamilton Tigers - (not active) */
+  HAM: 37,
+  /** Hartford Whalers - (not active) */
+  HFD: 34,
+  /** Kansas City Scouts - (not active) */
+  KCS: 48,
+  /** Montreal Maroons - (not active) */
+  MMR: 43,
+  /** Minnesota North Stars - (not active) */
+  MNS: 31,
+  /** Montreal Wanderers - (not active) */
+  MWN: 41,
+  /** New York Americans - (not active) */
+  NYA: 44,
+  /** California Seals (aka Oakland Seals) - (not active) */
+  OAK: 46,
+  /** Phoenix Coyotes - (not active) */
+  PHX: 27,
+  /** Pittsburgh Pirates - (not active) */
+  PIR: 38,
+  /** Quebec Bulldogs - (not active) */
+  QBD: 42,
+  /** Philadelphia Quakers - (not active) */
+  QUA: 39,
+  /** Quebec Nordiques - (not active) */
+  QUE: 32,
+  /** Ottawa Senators (original franchise) - (not active) */
+  SEN: 36,
+  /** St. Louis Eagles - (not active) */
+  SLE: 45,
+  /** Toronto Hockey Club (aka Toronto Arenas) - (not active) */
+  TAN: 57,
+  /** Toronto St. Patricks - (not active) */
+  TSP: 58,
+  /** Winnipeg Jets (original franchise) - (not active) */
+  WIN: 33
+};
+var InactiveTeamsReverseEnum = Object.fromEntries(
+  Object.entries(InactiveTeamsEnum).map(([key, value]) => [value, key])
+);
+var SeasonsArray = [
+  19171918,
+  19181919,
+  19191920,
+  19201921,
+  19211922,
+  19221923,
+  19231924,
+  19241925,
+  19251926,
+  19261927,
+  19271928,
+  19281929,
+  19291930,
+  19301931,
+  19311932,
+  19321933,
+  19331934,
+  19341935,
+  19351936,
+  19361937,
+  19371938,
+  19381939,
+  19391940,
+  19401941,
+  19411942,
+  19421943,
+  19431944,
+  19441945,
+  19451946,
+  19461947,
+  19471948,
+  19481949,
+  19491950,
+  19501951,
+  19511952,
+  19521953,
+  19531954,
+  19541955,
+  19551956,
+  19561957,
+  19571958,
+  19581959,
+  19591960,
+  19601961,
+  19611962,
+  19621963,
+  19631964,
+  19641965,
+  19651966,
+  19661967,
+  19671968,
+  19681969,
+  19691970,
+  19701971,
+  19711972,
+  19721973,
+  19731974,
+  19741975,
+  19751976,
+  19761977,
+  19771978,
+  19781979,
+  19791980,
+  19801981,
+  19811982,
+  19821983,
+  19831984,
+  19841985,
+  19851986,
+  19861987,
+  19871988,
+  19881989,
+  19891990,
+  19901991,
+  19911992,
+  19921993,
+  19931994,
+  19941995,
+  19951996,
+  19961997,
+  19971998,
+  19981999,
+  19992e3,
+  20002001,
+  20012002,
+  20022003,
+  20032004,
+  20052006,
+  20062007,
+  20072008,
+  20082009,
+  20092010,
+  20102011,
+  20112012,
+  20122013,
+  20132014,
+  20142015,
+  20152016,
+  20162017,
+  20172018,
+  20182019,
+  20192020,
+  20202021,
+  20212022,
+  20222023,
+  20232024,
+  20242025,
+  20252026
+];
+var SeriesLetterEnum = {
+  /** Atlantic Division Round 1: D1 vs WC# */
+  A: "A",
+  /** Atlantic Division Round 1: D2 vs D3 */
+  B: "B",
+  /** Metropolitan Division Round 1: D1 vs WC# */
+  C: "C",
+  /** Metropolitan Division Round 1: D2 vs D3 */
+  D: "D",
+  /** Central Division Round 1: D1 vs WC# */
+  E: "E",
+  /** Central Division Round 1: D2 vs D3 */
+  F: "F",
+  /** Pacific Division Round 1: D1 vs WC# */
+  G: "G",
+  /** Pacific Division Round 1: D2 vs D3 */
+  H: "H",
+  /** Atlantic Division Round 2: Aw vs Bw */
+  I: "I",
+  /** Metropolitan Division Round 2: Cw vs Dw */
+  J: "J",
+  /** Central Division Round 2: Ew vs Fw */
+  K: "K",
+  /** Pacific Division Round 2: Gw vs Hw */
+  L: "L",
+  /** Eastern Conference Finals */
+  M: "M",
+  /** Western Conference Finals*/
+  N: "N",
+  /** Stanley Cup Finals */
+  O: "O"
+};
+var SeriesLetterByRound = {
+  R1: ["A", "B", "C", "D", "E", "F", "G", "H"],
+  R2: ["I", "J", "K", "L"],
+  CF: ["M", "N"],
+  SCF: ["O"]
+};
+var PlayoffSeriesEnum = {
+  Atlantic_R1_D1_vs_WC: "A",
+  Atlantic_R1_D2_vs_D3: "B",
+  Metropolitan_R1_D1_vs_WC: "C",
+  Metropolitan_R1_D2_vs_D3: "D",
+  Central_R1_D1_vs_WC: "E",
+  Central_R1_D2_vs_D3: "F",
+  Pacific_R1_D1_vs_WC: "G",
+  Pacific_R1_D2_vs_D3: "H",
+  Atlantic_R2_Aw_vs_Bw: "I",
+  Metropolitan_R2_Cw_vs_Dw: "J",
+  Central_R2_Ew_vs_Fw: "K",
+  Pacific_R2_Gw_vs_Hw: "L",
+  Eastern_Conference_Finals: "M",
+  Western_Conference_Finals: "N",
+  Stanley_Cup_Finals: "O"
+};
+var GameStateEnum = {
+  /** Future */
+  FUT: "FUT",
+  /** Live */
+  LIV: "LIV",
+  /** Finished */
+  FIN: "FIN"
+};
+var PeriodTypeEnum = {
+  /** Regulation */
+  REG: "REG",
+  /** Overtime */
+  OT: "OT",
+  /** Shootout */
+  SO: "SO"
+};
+var GameTypeEnum = {
+  /** Pre-season */
+  PRE: 1,
+  /** Regular season */
+  REG: 2,
+  /** Post-season (aka playoffs) */
+  POST: 3,
+  /** All-Star Game (unconfirmed) */
+  ASG: 4,
+  /** International (unconfirmed) */
+  INTL: 19
+};
+var SEASON_RANGE = {
+  START: SeasonsArray[0],
+  END: SeasonsArray.at(-1)
+};
+var START_SEASON = SEASON_RANGE.START;
+var END_SEASON = SEASON_RANGE.END;
+var YEAR_RANGE = {
+  START: parseInt(SEASON_RANGE.START.toString().slice(0, 4), 10),
+  END: parseInt(SEASON_RANGE.END.toString().slice(4, 8), 10)
+};
+var START_YEAR = YEAR_RANGE.START;
+var END_YEAR = YEAR_RANGE.END;
+var CURRENT = {
+  SEASON: SEASON_RANGE.END,
+  YEAR: YEAR_RANGE.END
+};
+var PLAYER_ID_RANGE = { MIN: 8444e3, MAX: 8489999 };
+var TEAM_ID_RANGE = { MIN: 1, MAX: 59 };
+
+// src/constants/index.ts
+var EDGE = { ...edge_adv_exports, ...edge_stats_exports };
+
+// src/utils/schemas.ts
+function isParseError(value) {
+  return value instanceof arktype.type.errors;
+}
+var Year = arktype.type(`${nhl_exports.START_YEAR} <= number <= ${nhl_exports.END_YEAR}`).or(
+  arktype.type("string.numeric.parse").narrow((v) => {
+    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 Season = arktype.type("number.integer | string.numeric.parse").narrow((v) => {
+  const yr = Math.trunc(v / 1e4);
+  return typeof Year(yr) === "number" && yr + 1 === v % 1e4;
+}).pipe((v) => v.toString()).describe(`a valid NHL season, e.g. ${nhl_exports.CURRENT.SEASON}`);
+var TeamAbbrev = arktype.type.enumerated(
+  ...Object.keys(nhl_exports.TeamsEnum),
+  ...Object.keys(
+    nhl_exports.InactiveTeamsEnum
+  )
+).describe("a valid NHL team abbreviation");
+var TeamId = arktype.type.enumerated(...Object.values(nhl_exports.TeamsEnum)).describe("a valid NHL team ID");
+var GameType = arktype.type.enumerated(
+  ...Object.keys(
+    nhl_exports.GameTypeEnum
+  )
+).pipe((v) => nhl_exports.GameTypeEnum[v]).or(arktype.type('1|2|3|4|19|"1"|"2"|"3"|"4"|"19"')).describe("a valid NHL game type (e.g., REG, PRE, POST)");
+var GameNumber = arktype.type("number").atLeast(1).atMost(82 * 32 / 2).or(
+  arktype.type("string.numeric.parse").narrow((v) => {
+    return v >= 1 && v <= 82 * 32 / 2;
+  })
+).pipe((v) => v.toString()).describe("a valid NHL game number between 1 and 1312");
+var DraftRound = arktype.type("1 <= number <= 7").or(arktype.type(/^(1|2|3|4|5|6|7)$/)).pipe((v) => typeof v === "number" ? v.toString() : v).describe("a valid NHL draft round (1-7)");
+arktype.type("1 <= number <= 4").or(arktype.type(/^(1|2|3|4)$/)).pipe((v) => typeof v === "number" ? v.toString() : v).describe("a valid NHL playoff round (1-4)");
+var EventId = arktype.type("number.integer | string.numeric.parse").narrow((v) => Number.isInteger(v) && v > 0).describe("a positive integer representing an NHL event ID");
+var NHLDate = arktype.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"
+);
+arktype.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"
+);
+arktype.type("1|2|3|4|19").describe(
+  "a valid NHL game type code (1=PRE, 2=REG, 3=POST, 4=ASG, 19=INTL)"
+);
+var parseGameIdParts = arktype.type({
+  year: Year,
+  gameType: GameType,
+  gameNumber: GameNumber
+});
+var GameId = arktype.type("number.integer | string.numeric.parse").narrow((v) => {
+  if (Number.isInteger(v) && v < 0) return false;
+  const year = Math.trunc(v / 1e6);
+  const gameType = Math.trunc(v / 1e4) % 100;
+  const gameNumber = v % 1e4;
+  const valid = !(parseGameIdParts({ year, gameType, gameNumber }) instanceof arktype.type.errors);
+  return valid;
+}).describe("a positive integer representing an NHL game ID");
+var SeriesLetter = arktype.type.enumerated(...Object.values(nhl_exports.SeriesLetterEnum)).describe("a valid NHL playoff series letter (A-O)");
+arktype.type.enumerated(...Object.values(nhl_exports.GameStateEnum)).describe("a valid NHL game state");
+var CountryCode = arktype.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 = arktype.type(/^[a-zA-Z]\d[a-zA-Z] \d[a-zA-Z]\d$/).or(arktype.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 = arktype.type("number").atLeast(nhl_exports.PLAYER_ID_RANGE.MIN).atMost(nhl_exports.PLAYER_ID_RANGE.MAX).or(
+  arktype.type("string.numeric.parse").narrow((v) => {
+    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(
+  ...Object.keys(
+    EDGE.SaveLocationCategoryEnum
+  )
+).pipe((v) => EDGE.SaveLocationCategoryEnum[v]);
+arktype.type.enumerated(
+  ...Object.keys(
+    EDGE.ShotLocationSortEnum
+  )
+).pipe((v) => EDGE.ShotLocationSortEnum[v]);
+arktype.type.enumerated(
+  ...Object.keys(
+    EDGE.SaveLocationSortEnum
+  )
+).pipe((v) => EDGE.SaveLocationSortEnum[v]);
+arktype.type.enumerated(
+  ...Object.keys(
+    EDGE.SavePercentage5v5SortEnum
+  )
+).pipe((v) => EDGE.SavePercentage5v5SortEnum[v]);
+arktype.type.enumerated(
+  ...Object.keys(
+    EDGE.SavePercentageSortEnum
+  )
+).pipe((v) => EDGE.SavePercentageSortEnum[v]);
+var PositionFilter = arktype.type.enumerated(
+  ...Object.keys(
+    EDGE.PositionFilterEnum
+  )
+).pipe((v) => EDGE.PositionFilterEnum[v]);
+var SkatersStrength = arktype.type.enumerated(
+  ...Object.keys(
+    EDGE.SkatersStrengthEnum
+  )
+).pipe((v) => EDGE.SkatersStrengthEnum[v]);
+arktype.type.enumerated(
+  ...Object.keys(
+    EDGE.ShotSpeedSortEnum
+  )
+).pipe((v) => EDGE.ShotSpeedSortEnum[v]);
+arktype.type.enumerated(
+  ...Object.keys(
+    EDGE.SkatingSpeedSortEnum
+  )
+).pipe((v) => EDGE.SkatingSpeedSortEnum[v]);
+arktype.type.enumerated(
+  ...Object.keys(
+    EDGE.SkatingDistanceSortEnum
+  )
+);
+arktype.type.enumerated(
+  ...Object.keys(
+    EDGE.ShotLocationCategoryEnum
+  )
+).pipe((v) => EDGE.ShotLocationCategoryEnum[v]);
+arktype.type.enumerated(
+  ...Object.keys(
+    EDGE.ZoneTimeSortEnum
+  )
+).pipe((v) => EDGE.ZoneTimeSortEnum[v]);
+var BaseParams = arktype.type({
+  season: Season.or("undefined").pipe((v) => v ?? nhl_exports.CURRENT.SEASON),
+  gameType: GameType.or("undefined").pipe(
+    (v) => v ?? nhl_exports.GameTypeEnum.REG
+  )
+});
+arktype.type({
+  season: Season.or("undefined").optional(),
+  gameType: GameType.or("undefined").optional()
+});
+BaseParams.merge({
+  playerId: PlayerId,
+  season: Season
+});
+BaseParams.merge({
+  teamId: TeamId
+});
+BaseParams.merge({
+  position: PositionFilter.default("ALL"),
+  strength: SkatersStrength.default("ALL")
+});
+var DraftParams = arktype.type({
+  year: Year.or("undefined").pipe((v) => v ?? nhl_exports.CURRENT.YEAR),
+  round: DraftRound.or("undefined").optional()
+});
+var GameIdAndEventId = arktype.type({
+  gameId: GameId,
+  eventId: EventId
+});
+var TeamAndSeasonParams = arktype.type({
+  team: TeamAbbrev,
+  season: Season.or("undefined").pipe((v) => v ?? nhl_exports.CURRENT.SEASON)
+});
+var SeriesAndSeasonParams = arktype.type({
+  seriesLetter: SeriesLetter,
+  season: Season.or("undefined").pipe((v) => v ?? nhl_exports.CURRENT.SEASON)
+});
+var SeriesParams = arktype.type({
+  seriesLetter: SeriesLetter,
+  year: Year.or("undefined").pipe((v) => v ?? nhl_exports.CURRENT.YEAR)
+});
+var ScheduleParams = arktype.type({
+  team: TeamAbbrev,
+  date: NHLDate.or("undefined").pipe((v) => v ?? getCurrentDate()),
+  period: arktype.type('"week" | "month" | undefined').pipe((v) => v ?? "week")
+});
+
+// src/utils/utils.ts
+function route(template, params) {
+  let route2 = template;
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    route2 = route2.replace(`{${key}}`, String(value));
+  }
+  return route2;
+}
+
+// src/api/gamecenter/draft.ts
+var _paths = {
+  draftPicks: {
+    byYearAndRound: "draft/picks/{year}/{round}",
+    byYear: "draft/picks/{year}/all"
+  },
+  draftRankings: "draft/rankings/{year}/{type}",
+  draftTracker: "draft-tracker/picks/now"
+};
+var DraftRankingsEnum = {
+  skatersNA: "1",
+  skatersIntl: "2",
+  goaliesNA: "3",
+  goaliesIntl: "4"
+};
+var picks = (year, round) => {
+  const parsed = DraftParams({ year, round });
+  if (isParseError(parsed)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: _paths.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) => {
+    const parsedYear = Year(year ?? getCurrentYear());
+    if (isParseError(parsedYear)) {
+      return Promise.resolve({
+        status: "error",
+        error: new ValidationError(parsedYear.summary, {
+          endpoint: _paths.draftRankings
+        })
+      });
+    }
+    return client_default.get(
+      route(_paths.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)
+    ])
+  };
+};
+
+// src/api/gamecenter/game.ts
+var game_exports = {};
+__export(game_exports, {
+  boxscore: () => boxscore,
+  landing: () => landing,
+  networkTVSchedule: () => networkTVSchedule,
+  playByPlay: () => playByPlay,
+  playoffBracket: () => playoffBracket,
+  playoffSeries: () => playoffSeries,
+  playoffSeriesSchedule: () => playoffSeriesSchedule,
+  pptReplay: () => pptReplay,
+  reports: () => reports,
+  schedule: () => schedule,
+  scheduleCalendar: () => scheduleCalendar,
+  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) => {
+  const parsedGameId = GameId(gameId);
+  if (isParseError(parsedGameId)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsedGameId.summary, {
+        endpoint: _paths2.gamecenter.playByPlay
+      })
+    });
+  }
+  return client_default.get(
+    route(_paths2.gamecenter.playByPlay, { gameId: parsedGameId })
+  );
+};
+var reports = (gameId) => {
+  const parsedGameId = GameId(gameId);
+  if (isParseError(parsedGameId)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsedGameId.summary, {
+        endpoint: _paths2.gamecenter.reports
+      })
+    });
+  }
+  return client_default.get(
+    route(_paths2.gamecenter.reports, { gameId: parsedGameId })
+  );
+};
+var landing = (gameId) => {
+  const parsedGameId = GameId(gameId);
+  if (isParseError(parsedGameId)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsedGameId.summary, {
+        endpoint: _paths2.gamecenter.landing
+      })
+    });
+  }
+  return client_default.get(
+    route(_paths2.gamecenter.landing, { gameId: parsedGameId })
+  );
+};
+var boxscore = (gameId) => {
+  const parsedGameId = GameId(gameId);
+  if (isParseError(parsedGameId)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsedGameId.summary, {
+        endpoint: _paths2.gamecenter.boxscore
+      })
+    });
+  }
+  return client_default.get(
+    route(_paths2.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 })
+    );
+  }
+};
+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 })
+    );
+  }
+};
+var schedule = (date) => {
+  const parsedDate = NHLDate(date ?? getCurrentDate());
+  if (isParseError(parsedDate)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsedDate.summary, {
+        endpoint: _paths2.schedule
+      })
+    });
+  }
+  return client_default.get(route(_paths2.schedule, { date: parsedDate }));
+};
+var scheduleCalendar = (date) => {
+  const parsedDate = NHLDate(date);
+  if (isParseError(parsedDate)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsedDate.summary, {
+        endpoint: _paths2.scheduleCalendar
+      })
+    });
+  }
+  return client_default.get(
+    route(_paths2.scheduleCalendar, { date: parsedDate })
+  );
+};
+var playoffBracket = (year) => {
+  const parsedYear = Year(year ?? getCurrentYear());
+  if (isParseError(parsedYear)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsedYear.summary, {
+        endpoint: _paths2.playoffBracket
+      })
+    });
+  }
+  return client_default.get(route(_paths2.playoffBracket, { year: parsedYear }));
+};
+var playoffSeries = (season) => {
+  const parsedSeason = Season(season ?? getCurrentSeason());
+  if (isParseError(parsedSeason)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsedSeason.summary, {
+        endpoint: _paths2.playoffSeries
+      })
+    });
+  }
+  return client_default.get(
+    route(_paths2.playoffSeries, { season: parsedSeason })
+  );
+};
+var playoffSeriesSchedule = (seriesLetter, season) => {
+  const parsed = SeriesAndSeasonParams({
+    seriesLetter,
+    season: season ?? getCurrentSeason()
+  });
+  if (isParseError(parsed)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: _paths2.playoffSeriesSchedule
+      })
+    });
+  }
+  return client_default.get(route(_paths2.playoffSeriesSchedule, parsed));
+};
+var whereToWatch = () => client_default.get(_paths2.whereToWatch);
+var networkTVSchedule = (date) => {
+  const parsedDate = NHLDate(date ?? getCurrentDate());
+  if (isParseError(parsedDate)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsedDate.summary, {
+        endpoint: _paths2.networkTVSchedule
+      })
+    });
+  }
+  return client_default.get(
+    route(_paths2.networkTVSchedule, { date: parsedDate })
+  );
+};
+
+// src/api/gamecenter/misc.ts
+var misc_exports = {};
+__export(misc_exports, {
+  location: () => location,
+  meta: () => meta,
+  partnerGame: () => partnerGame,
+  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);
+};
+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 })
+    );
+  }
+};
+var postalLookup = (postalCode) => {
+  const parsedPostalCode = PostalCode(postalCode);
+  if (isParseError(parsedPostalCode)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsedPostalCode.summary, {
+        endpoint: _paths3.postalLookup
+      })
+    });
+  }
+  return client_default.get(
+    route(_paths3.postalLookup, { postalCode: parsedPostalCode })
+  );
+};
+var location = () => {
+  return client_default.get(_paths3.location);
+};
+var partnerGame = (countryCode) => {
+  const parsedCountryCode = CountryCode(countryCode);
+  if (isParseError(parsedCountryCode)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsedCountryCode.summary, {
+        endpoint: _paths3.partnerGame
+      })
+    });
+  }
+  return client_default.get(
+    route(_paths3.partnerGame, { countryCode: parsedCountryCode })
+  );
+};
+
+// src/api/gamecenter/player.ts
+var player_exports = {};
+__export(player_exports, {
+  gameLog: () => gameLog,
+  landing: () => landing2,
+  search: () => search,
+  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 searchUrlParams = { culture: "en", q: "" };
+var landing2 = (playerId) => {
+  const parsedPlayerId = PlayerId(playerId);
+  if (isParseError(parsedPlayerId)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsedPlayerId.summary, {
+        endpoint: _paths4.landing
+      })
+    });
+  }
+  return client_default.get(
+    route(_paths4.landing, { playerId: parsedPlayerId })
+  );
+};
+var gameLog = (playerId, season, gameType) => {
+  const Parser = BaseParams.merge({
+    playerId: PlayerId
+  });
+  const parsed = Parser({ playerId, season, gameType });
+  if (isParseError(parsed)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: _paths4.gameLog
+      })
+    });
+  }
+  return client_default.get(route(_paths4.gameLog, parsed));
+};
+var spotlight = () => {
+  return client_default.get(_paths4.spotlight);
+};
+var 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));
+  }
+};
+
+// src/api/gamecenter/score.ts
+var _paths5 = {
+  score: "score/{date}",
+  scoreboard: {
+    now: "scoreboard/now",
+    byTeam: "scoreboard/{team}/now",
+    byDate: "scoreboard/{date}"
+  }
+};
+var score = (date) => {
+  const parsed = NHLDate(date ?? getCurrentDate());
+  if (isParseError(parsed)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: _paths5.score
+      })
+    });
+  }
+  return client_default.get(route(_paths5.score, { date: parsed }));
+};
+var scoreboard = () => client_default.get(_paths5.scoreboard.now);
+scoreboard.team = async (team) => {
+  const parsed = TeamAbbrev(team);
+  if (isParseError(parsed)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: _paths5.scoreboard.byTeam
+      })
+    });
+  }
+  return client_default.get(
+    route(_paths5.scoreboard.byTeam, { team: parsed })
+  );
+};
+scoreboard.date = async (date) => {
+  const parsed = NHLDate(date);
+  if (isParseError(parsed)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: _paths5.scoreboard.byDate
+      })
+    });
+  }
+  return client_default.get(
+    route(_paths5.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
+});
+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) => {
+  const parsed = TeamAbbrev(team);
+  if (isParseError(parsed)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: paths.rosterSeasons
+      })
+    });
+  }
+  return client_default.get(route(paths.rosterSeasons, { team: parsed }));
+};
+var roster = (team, season) => {
+  const parsed = TeamAndSeasonParams({ team, season });
+  if (isParseError(parsed)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: paths.roster
+      })
+    });
+  }
+  return client_default.get(route(paths.roster, parsed));
+};
+var prospects = (team) => {
+  const parsed = TeamAbbrev(team);
+  if (isParseError(parsed)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: paths.prospects
+      })
+    });
+  }
+  return client_default.get(route(paths.prospects, { team: parsed }));
+};
+var clubStats = (team, season, gameType) => {
+  const Parser = BaseParams.merge({
+    team: TeamAbbrev
+  });
+  const parsed = Parser({ team, season, gameType });
+  if (isParseError(parsed)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: paths.clubStats
+      })
+    });
+  }
+  return client_default.get(route(paths.clubStats, parsed));
+};
+var clubStatsSeason = (team) => {
+  const parsed = TeamAbbrev(team);
+  if (isParseError(parsed)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: paths.clubStatsSeason
+      })
+    });
+  }
+  return client_default.get(route(paths.clubStatsSeason, { team: parsed }));
+};
+var standings = (date) => {
+  const parsed = NHLDate(date ?? getCurrentDate());
+  if (isParseError(parsed)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: paths.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 });
+  if (isParseError(parsed)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: paths.clubSchedule
+      })
+    });
+  }
+  if (period === "month") {
+    parsed.date = parsed.date?.slice(0, 7);
+  }
+  return client_default.get(route(paths.clubSchedule, parsed));
+};
+var clubScheduleSeason = (team, season) => {
+  const parsed = TeamAndSeasonParams({ team, season });
+  if (isParseError(parsed)) {
+    return Promise.resolve({
+      status: "error",
+      error: new ValidationError(parsed.summary, {
+        endpoint: paths.clubScheduleSeason
+      })
+    });
+  }
+  return client_default.get(route(paths.clubScheduleSeason, 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")
+};
+
+exports.EDGE = EDGE;
+exports.NHL = nhl_exports;
+exports.envConfig = envConfig;
+exports.gc = gamecenter_exports;
+exports.logEnvConfig = logEnvConfig;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map