nhle-api 0.5.4 → 0.6.0

package/lib/index.cjs

@@ -29,86 +29,52 @@ __export(goalies_exports, {
   top10: () => top10
 });
 
-// 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()
+// src/config/index.ts
+var config = {
+  timeout: 5e3,
+  language: "en",
+  logLevel: "warn"
 };
-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
-    });
-  }
+function logConfig() {
+  console.debug("NHL API Configuration:", config);
 }
 
+// src/logging/index.ts
+var levelRank = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4
+};
+function isEnabled(level, threshold) {
+  return levelRank[level] > 0 && levelRank[level] <= levelRank[threshold];
+}
+function writeLog(level, message, context, threshold = config.logLevel) {
+  if (!isEnabled(level, threshold)) return;
+  const args = context === void 0 ? [message] : [message, context];
+  switch (level) {
+    case "error":
+      console.error(...args);
+      break;
+    case "warn":
+      console.warn(...args);
+      break;
+    case "info":
+      console.info(...args);
+      break;
+    case "debug":
+      console.debug(...args);
+      break;
+  }
+}
+var logger = {
+  error: (message, context) => writeLog("error", message, context),
+  warn: (message, context) => writeLog("warn", message, context),
+  info: (message, context) => writeLog("info", message, context),
+  debug: (message, context) => writeLog("debug", message, context)
+};
+
 // src/errors/index.ts
 var ErrorCategory = {
   /** Network-level errors (connection refused, timeout, etc.) */
@@ -127,6 +93,7 @@ var ErrorCategory = {
   VALIDATION: "VALIDATION"
 };
 var LogLevel = {
+  NONE: 0,
   ERROR: 1,
   WARN: 2,
   INFO: 3,
@@ -193,18 +160,30 @@ var APIError = class extends NHLError {
     super(message, ErrorCategory.API_ERROR, context);
   }
 };
+var ParseError = class extends NHLError {
+  constructor(message, context = {}) {
+    super(message, ErrorCategory.PARSE, 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
+  overrides;
+  /**
+   * @param config - Overrides; an unset `logLevel` follows the shared
+   * `config.logLevel` at log time.
+   */
+  constructor(config2 = {}) {
+    this.overrides = { ...config2 };
+  }
+  get config() {
+    return {
+      logLevel: this.overrides.logLevel ?? toErrorLogLevel(config.logLevel),
+      logger: this.overrides.logger ?? this.defaultLogger.bind(this),
+      includeStack: this.overrides.includeStack ?? true
     };
   }
   /**
@@ -212,8 +191,12 @@ var ErrorHandler = class {
    */
   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);
+    writeLog(
+      toClientLogLevel(level),
+      `[NHL API] ${message}`,
+      context,
+      toClientThreshold(this.config.logLevel)
+    );
   }
   /**
    * Log an error based on configuration
@@ -311,10 +294,41 @@ var ErrorHandler = class {
   /**
    * Update configuration
    */
-  configure(config) {
-    this.config = { ...this.config, ...config };
+  configure(config2) {
+    this.overrides = { ...this.overrides, ...config2 };
   }
 };
+function toErrorLogLevel(level) {
+  switch (level) {
+    case "silent":
+      return LogLevel.NONE;
+    case "error":
+      return LogLevel.ERROR;
+    case "warn":
+      return LogLevel.WARN;
+    case "info":
+      return LogLevel.INFO;
+    case "debug":
+      return LogLevel.DEBUG;
+  }
+}
+function toClientLogLevel(level) {
+  switch (level) {
+    case LogLevel.ERROR:
+      return "error";
+    case LogLevel.WARN:
+      return "warn";
+    case LogLevel.INFO:
+      return "info";
+    case LogLevel.DEBUG:
+      return "debug";
+    default:
+      return "debug";
+  }
+}
+function toClientThreshold(level) {
+  return level === LogLevel.NONE ? "silent" : toClientLogLevel(level);
+}
 new ErrorHandler();
 
 // src/client/index.ts
@@ -322,26 +336,42 @@ var BASE_URLS = {
   gamecenter: "https://api-web.nhle.com/v1",
   edgeStats: "https://api.nhle.com/stats/rest"
 };
-var DEFAULT_CONFIG = {
-  baseUrl: BASE_URLS.gamecenter,
-  timeout: envConfig.timeout,
-  headers: {
-    Accept: "application/json"
-  },
-  language: envConfig.language
+var DEFAULT_HEADERS = {
+  Accept: "application/json"
 };
 var NHLClient = class {
-  config;
+  options;
   errorHandler;
   /**
    * Creates a new NHL API client instance
-   * @param baseURL - Optional custom base URL or predefined API endpoint key
+   *
+   * Options left unset (timeout, language) follow the shared `config`
+   * object at request time, so changing `config` after import still
+   * applies to this client.
+   *
+   * @param baseURLOrOptions - Base URL, or client options
    * @param errorConfig - Optional error handling configuration
+   *
+   * @example
+   * const client = new NHLClient('https://api-web.nhle.com/v1');
+   * const slow = new NHLClient({ timeout: 15000, language: 'fr' });
    */
-  constructor(baseURL, errorConfig) {
-    this.config = { ...DEFAULT_CONFIG };
-    if (baseURL) this.config.baseUrl = baseURL;
-    this.errorHandler = new ErrorHandler(errorConfig);
+  constructor(baseURLOrOptions, errorConfig) {
+    const options = typeof baseURLOrOptions === "string" ? { baseUrl: baseURLOrOptions } : baseURLOrOptions ?? {};
+    const { errorConfig: optionsErrorConfig, ...clientOptions } = options;
+    this.options = clientOptions;
+    this.errorHandler = new ErrorHandler(
+      errorConfig ?? optionsErrorConfig
+    );
+  }
+  /** Base URL, timeout, headers and language in effect for the next request. */
+  get config() {
+    return {
+      baseUrl: this.options.baseUrl ?? BASE_URLS.gamecenter,
+      timeout: this.options.timeout ?? config.timeout,
+      headers: { ...DEFAULT_HEADERS, ...this.options.headers },
+      language: this.options.language ?? config.language
+    };
   }
   /**
    * Helper to build URL with query parameters
@@ -366,18 +396,16 @@ var NHLClient = class {
    * @returns Promise resolving to an APIResponse containing either data or error
    */
   async get(endpoint, params) {
+    const { timeout, headers, language } = this.config;
     const url = this.buildUrl(endpoint, params);
     const controller = new AbortController();
-    const timeoutId = setTimeout(
-      () => controller.abort(),
-      this.config.timeout
-    );
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
     try {
       const response = await fetch(url, {
         method: "GET",
         headers: {
-          ...this.config.headers,
-          "Accept-Language": this.config.language
+          ...headers,
+          "Accept-Language": language
         },
         signal: controller.signal
       });
@@ -419,15 +447,15 @@ var NHLClient = class {
    * Configure error handling behavior
    * @param config - Error configuration options
    */
-  configureErrorHandling(config) {
-    this.errorHandler.configure(config);
+  configureErrorHandling(config2) {
+    this.errorHandler.configure(config2);
   }
 };
-function createNHLClient(baseURL, errorConfig) {
-  return new NHLClient(baseURL, errorConfig);
+function createNHLClient(baseURLOrOptions, errorConfig) {
+  return new NHLClient(baseURLOrOptions, errorConfig);
 }
 var nhlClient = createNHLClient(BASE_URLS.gamecenter);
-createNHLClient(BASE_URLS.edgeStats);
+var edgeStatsClient = createNHLClient(BASE_URLS.edgeStats);
 
 // src/constants/edge-adv.ts
 var edge_adv_exports = {};
@@ -549,9 +577,6 @@ var ZoneTimeSortEnum = {
   NZ: "neutral"
 };
 
-// src/constants/edge-stats.ts
-var edge_stats_exports = {};
-
 // src/constants/nhl.ts
 var nhl_exports = {};
 __export(nhl_exports, {
@@ -576,6 +601,50 @@ __export(nhl_exports, {
   TeamsReverseEnum: () => TeamsReverseEnum,
   YEAR_RANGE: () => YEAR_RANGE
 });
+
+// src/utils/date.ts
+var NHL_TIMEZONE = "America/New_York";
+var getNHLDate = (date) => new Intl.DateTimeFormat("en-CA", {
+  timeZone: NHL_TIMEZONE,
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit"
+}).format(date);
+var getCurrentNHLDate = () => getNHLDate(/* @__PURE__ */ new Date());
+var getNHLMonth = (date) => {
+  return new Intl.DateTimeFormat("en-CA", {
+    timeZone: NHL_TIMEZONE,
+    year: "numeric",
+    month: "2-digit"
+  }).format(date);
+};
+var getYear = (date) => new Intl.DateTimeFormat("en-CA", {
+  timeZone: NHL_TIMEZONE,
+  year: "numeric"
+}).format(date);
+var getCurrentNHLYear = () => getYear(/* @__PURE__ */ new Date());
+var getSeason = (date) => {
+  const format = new Intl.DateTimeFormat("en-CA", {
+    timeZone: NHL_TIMEZONE,
+    year: "numeric",
+    month: "numeric"
+  }).formatToParts(date instanceof Date ? date : new Date(date));
+  const month = format.find((part) => part.type === "month")?.value;
+  const year = format.find((part) => part.type === "year")?.value;
+  if (!year) {
+    throw new Error("Invalid date provided, could not extract year");
+  }
+  if (month && parseInt(month, 10) < 7) {
+    return `${parseInt(year, 10) - 1}${year}`;
+  }
+  return `${year}${parseInt(year, 10) + 1}`;
+};
+var getCurrentSeason = () => getSeason(/* @__PURE__ */ new Date());
+/* @__PURE__ */ new Date(
+  `${getCurrentSeason().slice(4, 8)}-06-30`
+);
+
+// src/constants/nhl.ts
 var TeamsEnum = {
   /** Anaheim Ducks */
   ANA: 24,
@@ -910,54 +979,26 @@ var YEAR_RANGE = {
 var START_YEAR = YEAR_RANGE.START;
 var END_YEAR = YEAR_RANGE.END;
 var CURRENT = {
-  SEASON: SEASON_RANGE.END,
+  /** The season for today's date, so the default never goes stale. */
+  SEASON: Number(getCurrentSeason()),
   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/date.ts
-var NHL_TIMEZONE = "America/New_York";
-var getDate = (date) => new Intl.DateTimeFormat("en-CA", {
-  timeZone: NHL_TIMEZONE,
-  year: "numeric",
-  month: "2-digit",
-  day: "2-digit"
-}).format(date);
-var getCurrentDate = () => getDate(/* @__PURE__ */ new Date());
-var getYear = (date) => new Intl.DateTimeFormat("en-CA", {
-  timeZone: NHL_TIMEZONE,
-  year: "numeric"
-}).format(date);
-var getCurrentYear = () => getYear(/* @__PURE__ */ new Date());
-var getSeason = (date) => {
-  const format = new Intl.DateTimeFormat("en-CA", {
-    timeZone: NHL_TIMEZONE,
-    year: "numeric",
-    month: "numeric"
-  }).formatToParts(date instanceof Date ? date : new Date(date));
-  const month = format.find((part) => part.type === "month")?.value;
-  const year = format.find((part) => part.type === "year")?.value;
-  if (!year) {
-    throw new Error("Invalid date provided, could not extract year");
-  }
-  if (month && parseInt(month, 10) < 7) {
-    return `${parseInt(year, 10) - 1}${year}`;
-  }
-  return `${year}${parseInt(year, 10) + 1}`;
-};
-var getCurrentSeason = () => getSeason(/* @__PURE__ */ new Date());
-/* @__PURE__ */ new Date(
-  `${getCurrentSeason().slice(4, 8)}-06-30`
-);
+var EDGE = { ...edge_adv_exports };
 
 // src/utils/schemas.ts
 function isParseError(value) {
   return value instanceof arktype.type.errors;
 }
+function invalidParams(errors, endpoint) {
+  return {
+    success: false,
+    error: new ValidationError(errors.summary, { endpoint })
+  };
+}
 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;
@@ -970,11 +1011,11 @@ var NHLMonth = arktype.type("Date | string").narrow((v) => {
     return true;
   }
   return false;
-}).pipe((v) => typeof v === "string" ? v : v.toISOString().slice(0, 7)).describe(
+}).pipe((v) => typeof v === "string" ? v : getNHLMonth(v)).describe(
   "a valid month, either as a string (formatted as YYYY-MM) or a Date object"
 );
 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)
+  (v) => typeof v === "string" ? new Date(v).toISOString().slice(0, 10) : getNHLDate(v)
 ).describe(
   "a valid date, either as a string (ISO date string) or a Date object"
 );
@@ -1024,8 +1065,10 @@ var GameId = arktype.type("number.integer | string.numeric.parse").narrow((v) =>
 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 PostalCode = arktype.type(/^[a-zA-Z]\d[a-zA-Z][ -]?\d[a-zA-Z]\d$/).or(arktype.type(/^\d{5}$/)).pipe(
+  (v) => v.length === 5 ? v : `${v.slice(0, 3)} ${v.slice(-3)}`.toUpperCase()
+).describe(
+  "a valid postal code, either US ZIP code (5 digit) or Canadian postal code (A1A 1A1, A1A1A1 or A1A-1A1)"
 );
 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) => {
@@ -1081,7 +1124,7 @@ var SkatingDistanceSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.SkatingDistanceSortEnum
   )
-);
+).pipe((v) => EDGE.SkatingDistanceSortEnum[v]);
 var ShotLocationCategory = arktype.type.enumerated(
   ...Object.keys(
     EDGE.ShotLocationCategoryEnum
@@ -1092,6 +1135,11 @@ var ZoneTimeSort = arktype.type.enumerated(
     EDGE.ZoneTimeSortEnum
   )
 ).pipe((v) => EDGE.ZoneTimeSortEnum[v]);
+function withDefault(schema, fallback) {
+  const resolved = schema.assert(fallback);
+  const optional = schema.or("undefined").pipe((v) => v ?? resolved);
+  return [optional, "=", fallback];
+}
 var BaseParams = arktype.type({
   season: Season.or("undefined").pipe((v) => v ?? nhl_exports.CURRENT.SEASON),
   gameType: GameType.or("undefined").pipe(
@@ -1106,8 +1154,8 @@ var TeamParams = BaseParams.merge({
   teamId: TeamId
 });
 var top10Params = BaseParams.merge({
-  position: PositionFilter.default("ALL"),
-  strength: SkatersStrength.default("ALL")
+  position: withDefault(PositionFilter, "ALL"),
+  strength: withDefault(SkatersStrength, "ALL")
 });
 var DraftParams = arktype.type({
   year: Year.or("undefined").pipe((v) => v ?? nhl_exports.CURRENT.YEAR),
@@ -1131,9 +1179,9 @@ var SeriesParams = arktype.type({
 });
 var ScheduleParams = arktype.type({
   team: TeamAbbrev,
-  date: NHLDate.or("undefined").pipe((v) => v ?? getCurrentDate()),
+  date: NHLDate.or("undefined").pipe((v) => v ?? getCurrentNHLDate()),
   month: NHLMonth.or("undefined").pipe(
-    (v) => v ?? getCurrentDate().slice(0, 7)
+    (v) => v ?? getCurrentNHLDate().slice(0, 7)
   )
 });
 
@@ -1164,71 +1212,71 @@ var goaliesPaths = {
   /** Goalie top 10 leaders. */
   top10: {
     /** Top 10 goalies by save percentage. */
-    SavePercentage: "edge/goalie-5v5-top-10/{sortBy}/{season}/{gameType}",
+    savePercentage: "edge/goalie-edge-save-pctg-top-10/{sortBy}/{season}/{gameType}",
     /** Top 10 goalies by 5v5 save percentage. */
-    SavePercentage5v5: "edge/goalie-edge-save-pctg-top-10/{sortBy}/{season}/{gameType}",
+    savePercentage5v5: "edge/goalie-5v5-top-10/{sortBy}/{season}/{gameType}",
     /** Top 10 goalies by shot location. */
-    SaveLocation: "edge/goalie-shot-location-top-10/{category}/{sortBy}/{season}/{gameType}"
+    saveLocation: "edge/goalie-shot-location-top-10/{category}/{sortBy}/{season}/{gameType}"
   }
 };
 var skatersPaths = {
   /** Skater detail page. */
-  player: "skater-detail/{playerId}/{season}/{gameType}",
+  player: "edge/skater-detail/{playerId}/{season}/{gameType}",
   /** Skater comparison data. */
-  compare: "skater-comparison/{playerId}/{season}/{gameType}",
+  compare: "edge/skater-comparison/{playerId}/{season}/{gameType}",
   /** Skater leaders landing page. */
-  leaders: "skater-landing/{season}/{gameType}",
+  leaders: "edge/skater-landing/{season}/{gameType}",
   /** Skater shot location analysis. */
-  shotLocation: "skater-shot-location-detail/{playerId}/{season}/{gameType}",
+  shotLocation: "edge/skater-shot-location-detail/{playerId}/{season}/{gameType}",
   /** Skater shot speed analysis. */
-  shotSpeed: "skater-shot-speed-detail/{playerId}/{season}/{gameType}",
+  shotSpeed: "edge/skater-shot-speed-detail/{playerId}/{season}/{gameType}",
   /** Skater skating distance analysis. */
-  skatingDistance: "skater-skating-distance-detail/{playerId}/{season}/{gameType}",
+  skatingDistance: "edge/skater-skating-distance-detail/{playerId}/{season}/{gameType}",
   /** Skater skating speed analysis. */
-  skatingSpeed: "skater-skating-speed-detail/{playerId}/{season}/{gameType}",
+  skatingSpeed: "edge/skater-skating-speed-detail/{playerId}/{season}/{gameType}",
   /** Skater zone time analysis. */
-  zoneTime: "skater-zone-time/{playerId}/{season}/{gameType}",
+  zoneTime: "edge/skater-zone-time/{playerId}/{season}/{gameType}",
   /** Skater top 10 leaders. */
   top10: {
     /** Top 10 skaters by shot location. */
-    shotLocation: "skater-shot-location-top-10/{position}/{category}/{sortBy}/{season}/{gameType}",
+    shotLocation: "edge/skater-shot-location-top-10/{position}/{category}/{sortBy}/{season}/{gameType}",
     /** Top 10 skaters by shot speed. */
-    shotSpeed: "skater-shot-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
+    shotSpeed: "edge/skater-shot-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
     /** Top 10 skaters by skating distance. */
-    skatingDistance: "skater-distance-top-10/{position}/{strength}/{sortBy}/{season}/{gameType}",
+    skatingDistance: "edge/skater-distance-top-10/{position}/{strength}/{sortBy}/{season}/{gameType}",
     /** Top 10 skaters by skating speed. */
-    skatingSpeed: "skater-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
+    skatingSpeed: "edge/skater-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
     /** Top 10 skaters by zone time. */
-    zoneTime: "skater-zone-time-top-10/{position}/{strength}/{sortBy}/{season}/{gameType}"
+    zoneTime: "edge/skater-zone-time-top-10/{position}/{strength}/{sortBy}/{season}/{gameType}"
   }
 };
 var teamsPaths = {
   /** Team statistics detail page. */
-  stats: "edge/team-comparison/{teamId}/{season}/{gameType}",
+  stats: "edge/team-detail/{teamId}/{season}/{gameType}",
   /** Team comparison data. */
-  compare: "edge/team-detail/{teamId}/{season}/{gameType}",
+  compare: "edge/team-comparison/{teamId}/{season}/{gameType}",
   /** Team leaders landing page. */
   leaders: "edge/team-landing/{season}/{gameType}",
   /** Team shot location analysis. */
   shotLocation: "edge/team-shot-location-detail/{teamId}/{season}/{gameType}",
   /** Team shot speed analysis. */
-  shotSpeed: "edge/team-shot-location-top-10/{position}/{category}/{sortBy}/{season}/{gameType}",
+  shotSpeed: "edge/team-shot-speed-detail/{teamId}/{season}/{gameType}",
   /** Team skating distance analysis. */
-  skatingDistance: "edge/team-shot-speed-detail/{teamId}/{season}/{gameType}",
+  skatingDistance: "edge/team-skating-distance-detail/{teamId}/{season}/{gameType}",
   /** Team skating speed analysis. */
-  skatingSpeed: "edge/team-shot-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
+  skatingSpeed: "edge/team-skating-speed-detail/{teamId}/{season}/{gameType}",
   /** Team zone time analysis. */
-  zoneTime: "edge/team-skating-distance-detail/{teamId}/{season}/{gameType}",
+  zoneTime: "edge/team-zone-time-details/{teamId}/{season}/{gameType}",
   /** Team top 10 leaders. */
   top10: {
     /** Top 10 teams by shot location. */
-    shotLocation: "edge/team-skating-distance-top-10/{position}/{strength}/{sortBy}/{season}/{gameType}",
+    shotLocation: "edge/team-shot-location-top-10/{position}/{category}/{sortBy}/{season}/{gameType}",
     /** Top 10 teams by shot speed. */
-    shotSpeed: "edge/team-skating-speed-detail/{teamId}/{season}/{gameType}",
+    shotSpeed: "edge/team-shot-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
     /** Top 10 teams by skating distance. */
-    skatingDistance: "edge/team-skating-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
+    skatingDistance: "edge/team-skating-distance-top-10/{position}/{strength}/{sortBy}/{season}/{gameType}",
     /** Top 10 teams by skating speed. */
-    skatingSpeed: "edge/team-zone-time-details/{teamId}/{season}/{gameType}",
+    skatingSpeed: "edge/team-skating-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
     /** Top 10 teams by zone time. */
     zoneTime: "edge/team-zone-time-top-10/{strength}/{sortBy}/{season}/{gameType}"
   }
@@ -1241,67 +1289,38 @@ var summaryPaths = {
 // src/api/edge-adv/goalies.ts
 async function player(playerId, season, gameType) {
   const parsed = PlayerParams({ playerId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: goaliesPaths.player
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, goaliesPaths.player);
   const path = resolvePath(goaliesPaths.player, parsed);
   return nhlClient.get(path);
 }
 async function compare(playerId, season, gameType) {
   const parsed = PlayerParams({ playerId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: goaliesPaths.compare
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, goaliesPaths.compare);
   const path = resolvePath(goaliesPaths.compare, parsed);
   return nhlClient.get(path);
 }
 async function leaders(season, gameType) {
   const parsed = BaseParams({ season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: goaliesPaths.leaders
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, goaliesPaths.leaders);
   const path = resolvePath(goaliesPaths.leaders, parsed);
   return nhlClient.get(path);
 }
 async function savePercentage5v5(playerId, season, gameType) {
   const parsed = PlayerParams({ playerId, season, gameType });
   if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: goaliesPaths.savePercentage5v5
-      })
-    );
+    return invalidParams(parsed, goaliesPaths.savePercentage5v5);
   const path = resolvePath(goaliesPaths.savePercentage5v5, parsed);
   return nhlClient.get(path);
 }
 async function savePercentage(playerId, season, gameType) {
   const parsed = PlayerParams({ playerId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: goaliesPaths.savePercentage
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, goaliesPaths.savePercentage);
   const path = resolvePath(goaliesPaths.savePercentage, parsed);
   return nhlClient.get(path);
 }
 async function saveLocation(playerId, season, gameType) {
   const parsed = PlayerParams({ playerId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: goaliesPaths.saveLocation
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, goaliesPaths.saveLocation);
   const path = resolvePath(goaliesPaths.saveLocation, parsed);
   return nhlClient.get(path);
 }
@@ -1312,36 +1331,28 @@ var top10 = {
 };
 async function top10SavePercentage(season, gameType, sortBy) {
   const Parser = BaseParams.merge({
-    sortBy: SavePercentageSort.default("GAMES")
+    sortBy: withDefault(SavePercentageSort, "GAMES")
   });
   const parsed = Parser({ season, gameType, sortBy });
   if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: goaliesPaths.top10.SavePercentage
-      })
-    );
-  const path = resolvePath(goaliesPaths.top10.SavePercentage, parsed);
+    return invalidParams(parsed, goaliesPaths.top10.savePercentage);
+  const path = resolvePath(goaliesPaths.top10.savePercentage, parsed);
   return nhlClient.get(path);
 }
 async function top10SavePercentage5v5(season, gameType, sortBy) {
   const Parser = BaseParams.merge({
-    sortBy: SavePercentage5v5Sort.default("5v5-SV%")
+    sortBy: withDefault(SavePercentage5v5Sort, "5v5-SV%")
   });
   const parsed = Parser({ season, gameType, sortBy });
   if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: goaliesPaths.top10.SavePercentage5v5
-      })
-    );
-  const path = resolvePath(goaliesPaths.top10.SavePercentage5v5, parsed);
+    return invalidParams(parsed, goaliesPaths.top10.savePercentage5v5);
+  const path = resolvePath(goaliesPaths.top10.savePercentage5v5, parsed);
   return nhlClient.get(path);
 }
 async function top10SaveLocation(season, gameType, category, sortBy) {
   const Parser = BaseParams.merge({
-    category: SaveLocationCategory.default("SV%"),
-    sortBy: SaveLocationSort.default("ALL")
+    category: withDefault(SaveLocationCategory, "SV%"),
+    sortBy: withDefault(SaveLocationSort, "ALL")
   });
   const parsed = Parser({
     season,
@@ -1350,12 +1361,8 @@ async function top10SaveLocation(season, gameType, category, sortBy) {
     sortBy
   });
   if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: goaliesPaths.top10.SaveLocation
-      })
-    );
-  const path = resolvePath(goaliesPaths.top10.SaveLocation, parsed);
+    return invalidParams(parsed, goaliesPaths.top10.saveLocation);
+  const path = resolvePath(goaliesPaths.top10.saveLocation, parsed);
   return nhlClient.get(path);
 }
 
@@ -1374,89 +1381,50 @@ __export(skaters_exports, {
 });
 async function detail(playerId, season, gameType) {
   const parsed = PlayerParams({ playerId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: skatersPaths.player
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, skatersPaths.player);
   const path = resolvePath(skatersPaths.player, parsed);
   return nhlClient.get(path);
 }
 async function shotLocation(playerId, season, gameType) {
   const parsed = PlayerParams({ playerId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: skatersPaths.shotLocation
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, skatersPaths.shotLocation);
   const path = resolvePath(skatersPaths.shotLocation, parsed);
   return nhlClient.get(path);
 }
 async function shotSpeed(playerId, season, gameType) {
   const parsed = PlayerParams({ playerId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: skatersPaths.shotSpeed
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, skatersPaths.shotSpeed);
   const path = resolvePath(skatersPaths.shotSpeed, parsed);
   return nhlClient.get(path);
 }
 async function skatingDistance(playerId, season, gameType) {
   const parsed = PlayerParams({ playerId, season, gameType });
   if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: skatersPaths.skatingDistance
-      })
-    );
+    return invalidParams(parsed, skatersPaths.skatingDistance);
   const path = resolvePath(skatersPaths.skatingDistance, parsed);
   return nhlClient.get(path);
 }
 async function skatingSpeed(playerId, season, gameType) {
   const parsed = PlayerParams({ playerId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: skatersPaths.skatingSpeed
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, skatersPaths.skatingSpeed);
   const path = resolvePath(skatersPaths.skatingSpeed, parsed);
   return nhlClient.get(path);
 }
 async function zoneTime(playerId, season, gameType) {
   const parsed = PlayerParams({ playerId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: skatersPaths.zoneTime
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, skatersPaths.zoneTime);
   const path = resolvePath(skatersPaths.zoneTime, parsed);
   return nhlClient.get(path);
 }
 async function comparison(playerId, season, gameType) {
   const parsed = PlayerParams({ playerId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: skatersPaths.compare
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, skatersPaths.compare);
   const path = resolvePath(skatersPaths.compare, parsed);
   return nhlClient.get(path);
 }
 async function leaders2(season, gameType) {
   const parsed = BaseParams({ season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: skatersPaths.leaders
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, skatersPaths.leaders);
   const path = resolvePath(skatersPaths.leaders, parsed);
   return nhlClient.get(path);
 }
@@ -1469,7 +1437,7 @@ var top102 = {
 };
 async function top10Distance(season, gameType, position, strength, sortBy) {
   const parsed = top10Params.merge({
-    sortBy: SkatingDistanceSort.default("TOTAL")
+    sortBy: withDefault(SkatingDistanceSort, "TOTAL")
   })({
     season,
     gameType,
@@ -1478,18 +1446,14 @@ async function top10Distance(season, gameType, position, strength, sortBy) {
     sortBy
   });
   if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: skatersPaths.top10.skatingDistance
-      })
-    );
+    return invalidParams(parsed, skatersPaths.top10.skatingDistance);
   const path = resolvePath(skatersPaths.top10.skatingDistance, parsed);
   return nhlClient.get(path);
 }
 async function top10ShotLocation(season, gameType, position, category, sortBy) {
   const parsed = top10Params.merge({
-    category: ShotLocationCategory.default("G"),
-    sortBy: ShotLocationSort.default("ALL")
+    category: withDefault(ShotLocationCategory, "G"),
+    sortBy: withDefault(ShotLocationSort, "ALL")
   })({
     season,
     gameType,
@@ -1498,17 +1462,13 @@ async function top10ShotLocation(season, gameType, position, category, sortBy) {
     sortBy
   });
   if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: skatersPaths.top10.shotLocation
-      })
-    );
+    return invalidParams(parsed, skatersPaths.top10.shotLocation);
   const path = resolvePath(skatersPaths.top10.shotLocation, parsed);
   return nhlClient.get(path);
 }
 async function top10ShotSpeed(season, gameType, position, sortBy) {
   const parsed = top10Params.merge({
-    sortBy: ShotSpeedSort.default("MAX")
+    sortBy: withDefault(ShotSpeedSort, "MAX")
   })({
     season,
     gameType,
@@ -1516,17 +1476,13 @@ async function top10ShotSpeed(season, gameType, position, sortBy) {
     sortBy
   });
   if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: skatersPaths.top10.shotSpeed
-      })
-    );
+    return invalidParams(parsed, skatersPaths.top10.shotSpeed);
   const path = resolvePath(skatersPaths.top10.shotSpeed, parsed);
   return nhlClient.get(path);
 }
 async function top10Speed(season, gameType, position, sortBy) {
   const parsed = top10Params.merge({
-    sortBy: SkatingSpeedSort.default("TOP")
+    sortBy: withDefault(SkatingSpeedSort, "TOP")
   })({
     season,
     gameType,
@@ -1534,17 +1490,13 @@ async function top10Speed(season, gameType, position, sortBy) {
     sortBy
   });
   if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: skatersPaths.top10.skatingSpeed
-      })
-    );
+    return invalidParams(parsed, skatersPaths.top10.skatingSpeed);
   const path = resolvePath(skatersPaths.top10.skatingSpeed, parsed);
   return nhlClient.get(path);
 }
 async function top10ZoneTime(season, gameType, position, strength, sortBy) {
   const parsed = top10Params.merge({
-    sortBy: ZoneTimeSort.default("OZ")
+    sortBy: withDefault(ZoneTimeSort, "OZ")
   })({
     season,
     gameType,
@@ -1552,12 +1504,7 @@ async function top10ZoneTime(season, gameType, position, strength, sortBy) {
     strength,
     sortBy
   });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: skatersPaths.top10.zoneTime
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, skatersPaths.top10.zoneTime);
   const path = resolvePath(skatersPaths.top10.zoneTime, parsed);
   return nhlClient.get(path);
 }
@@ -1582,90 +1529,51 @@ __export(teams_exports, {
 });
 async function stats(teamId, season, gameType) {
   const parsed = TeamParams({ teamId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: teamsPaths.stats
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, teamsPaths.stats);
   const path = resolvePath(teamsPaths.stats, parsed);
   return nhlClient.get(path);
 }
 async function compare2(teamId, season, gameType) {
   gameType ??= "REG";
   const parsed = TeamParams({ teamId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: teamsPaths.compare
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, teamsPaths.compare);
   const path = resolvePath(teamsPaths.compare, parsed);
   return nhlClient.get(path);
 }
 async function leaders3(season, gameType) {
   const parsed = BaseParams({ season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: teamsPaths.leaders
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, teamsPaths.leaders);
   const path = resolvePath(teamsPaths.leaders, parsed);
   return nhlClient.get(path);
 }
 async function shotLocation2(teamId, season, gameType) {
   const parsed = TeamParams({ teamId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: teamsPaths.shotLocation
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, teamsPaths.shotLocation);
   const path = resolvePath(teamsPaths.shotLocation, parsed);
   return nhlClient.get(path);
 }
 async function shotSpeed2(teamId, season, gameType) {
   const parsed = TeamParams({ teamId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: teamsPaths.shotSpeed
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, teamsPaths.shotSpeed);
   const path = resolvePath(teamsPaths.shotSpeed, parsed);
   return nhlClient.get(path);
 }
 async function skatingDistance2(teamId, season, gameType) {
   const parsed = TeamParams({ teamId, season, gameType });
   if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: teamsPaths.skatingDistance
-      })
-    );
+    return invalidParams(parsed, teamsPaths.skatingDistance);
   const path = resolvePath(teamsPaths.skatingDistance, parsed);
   return nhlClient.get(path);
 }
 async function skatingSpeed2(teamId, season, gameType) {
   const parsed = TeamParams({ teamId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: teamsPaths.skatingSpeed
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, teamsPaths.skatingSpeed);
   const path = resolvePath(teamsPaths.skatingSpeed, parsed);
   return nhlClient.get(path);
 }
 async function zoneTime2(teamId, season, gameType) {
   const parsed = TeamParams({ teamId, season, gameType });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: teamsPaths.zoneTime
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, teamsPaths.zoneTime);
   const path = resolvePath(teamsPaths.zoneTime, parsed);
   return nhlClient.get(path);
 }
@@ -1678,9 +1586,9 @@ var top103 = {
 };
 async function top10ShotLocation2(season, gameType, position, category, sortBy) {
   const Parser = BaseParams.merge({
-    position: PositionFilter.default("ALL"),
-    category: ShotLocationCategory.default("G"),
-    sortBy: ShotLocationSort.default("ALL")
+    position: withDefault(PositionFilter, "ALL"),
+    category: withDefault(ShotLocationCategory, "G"),
+    sortBy: withDefault(ShotLocationSort, "ALL")
   });
   const parsed = Parser({
     season,
@@ -1690,18 +1598,14 @@ async function top10ShotLocation2(season, gameType, position, category, sortBy)
     sortBy
   });
   if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: teamsPaths.shotLocation
-      })
-    );
+    return invalidParams(parsed, teamsPaths.top10.shotLocation);
   const path = resolvePath(teamsPaths.top10.shotLocation, parsed);
   return nhlClient.get(path);
 }
 async function top10ShotSpeed2(season, gameType, position, sortBy) {
   const Parser = BaseParams.merge({
-    position: PositionFilter.default("ALL"),
-    sortBy: ShotSpeedSort.default("MAX")
+    position: withDefault(PositionFilter, "ALL"),
+    sortBy: withDefault(ShotSpeedSort, "MAX")
   });
   const parsed = Parser({
     season,
@@ -1710,19 +1614,15 @@ async function top10ShotSpeed2(season, gameType, position, sortBy) {
     sortBy
   });
   if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: teamsPaths.shotSpeed
-      })
-    );
+    return invalidParams(parsed, teamsPaths.top10.shotSpeed);
   const path = resolvePath(teamsPaths.top10.shotSpeed, parsed);
   return nhlClient.get(path);
 }
 async function top10SkatingDistance(season, gameType, position, strength, sortBy) {
   const Parser = BaseParams.merge({
-    position: PositionFilter.default("ALL"),
-    strength: SkatersStrength.default("ALL"),
-    sortBy: SkatingDistanceSort.default("TOTAL")
+    position: withDefault(PositionFilter, "ALL"),
+    strength: withDefault(SkatersStrength, "ALL"),
+    sortBy: withDefault(SkatingDistanceSort, "TOTAL")
   });
   const parsed = Parser({
     season,
@@ -1732,18 +1632,14 @@ async function top10SkatingDistance(season, gameType, position, strength, sortBy
     sortBy
   });
   if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: teamsPaths.skatingDistance
-      })
-    );
+    return invalidParams(parsed, teamsPaths.top10.skatingDistance);
   const path = resolvePath(teamsPaths.top10.skatingDistance, parsed);
   return nhlClient.get(path);
 }
 async function top10SkatingSpeed(season, gameType, position, sortBy) {
   const Parser = BaseParams.merge({
-    position: PositionFilter.default("ALL"),
-    sortBy: SkatingSpeedSort.default("TOP")
+    position: withDefault(PositionFilter, "ALL"),
+    sortBy: withDefault(SkatingSpeedSort, "TOP")
   });
   const parsed = Parser({
     season,
@@ -1752,18 +1648,14 @@ async function top10SkatingSpeed(season, gameType, position, sortBy) {
     sortBy
   });
   if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: teamsPaths.skatingSpeed
-      })
-    );
+    return invalidParams(parsed, teamsPaths.top10.skatingSpeed);
   const path = resolvePath(teamsPaths.top10.skatingSpeed, parsed);
   return nhlClient.get(path);
 }
 async function top10ZoneTime2(season, gameType, strength, sortBy) {
   const Parser = BaseParams.merge({
-    strength: SkatersStrength.default("ALL"),
-    sortBy: ZoneTimeSort.default("OZ")
+    strength: withDefault(SkatersStrength, "ALL"),
+    sortBy: withDefault(ZoneTimeSort, "OZ")
   });
   const parsed = Parser({
     season,
@@ -1771,22 +1663,569 @@ async function top10ZoneTime2(season, gameType, strength, sortBy) {
     strength,
     sortBy
   });
-  if (isParseError(parsed))
-    return Promise.reject(
-      new NHLError(parsed.summary, "VALIDATION", {
-        endpoint: teamsPaths.zoneTime
-      })
-    );
+  if (isParseError(parsed)) return invalidParams(parsed, teamsPaths.top10.zoneTime);
   const path = resolvePath(teamsPaths.top10.zoneTime, parsed);
   return nhlClient.get(path);
 }
 
+// src/api/edge-stats/index.ts
+var edge_stats_exports = {};
+__export(edge_stats_exports, {
+  goalies: () => goalies_exports2,
+  misc: () => misc_exports,
+  season: () => season_game_exports,
+  skaters: () => skaters_exports2,
+  teams: () => teams_exports2
+});
+
+// src/api/edge-stats/goalies.ts
+var goalies_exports2 = {};
+__export(goalies_exports2, {
+  getLeaders: () => getLeaders,
+  getMilestones: () => getMilestones,
+  getStats: () => getStats,
+  getStatsWithBuilder: () => getStatsWithBuilder,
+  getStatsWithFilters: () => getStatsWithFilters,
+  getStatsWithParams: () => getStatsWithParams
+});
+
+// src/utils/cayenne-query-builder.ts
+var CayenneQueryBuilder = class {
+  conditions = [];
+  currentLogicalOp = "and";
+  groupStack = [];
+  /**
+   * Start a new logical group
+   * All subsequent conditions will be added to this group until endGroup() is called
+   * @returns This builder instance for chaining
+   * @example
+   * builder
+   *   .equals('field1', 'value1')
+   *   .group()
+   *   .equals('field2', 'value2')
+   *   .or()
+   *   .equals('field3', 'value3')
+   *   .endGroup()
+   *   // Generates: "field1=value1 and (field2=value2 or field3=value3)"
+   */
+  group() {
+    this.groupStack.push({
+      conditions: this.conditions,
+      logicalOp: this.currentLogicalOp
+    });
+    this.conditions = [];
+    this.currentLogicalOp = "and";
+    return this;
+  }
+  /**
+   * End the current logical group
+   * @returns This builder instance for chaining
+   * @throws Error if there's no open group
+   */
+  endGroup() {
+    if (this.groupStack.length === 0) {
+      throw new Error("Cannot end group: no open group found");
+    }
+    const groupConditions = this.conditions;
+    const parent = this.groupStack.pop();
+    if (!parent) {
+      throw new Error("Failed to restore parent context");
+    }
+    this.conditions = parent.conditions;
+    const groupLogicalOp = parent.logicalOp;
+    this.currentLogicalOp = parent.logicalOp;
+    const group = {
+      type: "group",
+      conditions: groupConditions,
+      logicalOp: groupLogicalOp
+    };
+    this.conditions.push(group);
+    return this;
+  }
+  /**
+   * Set the logical operator to AND for subsequent conditions
+   * @returns This builder instance for chaining
+   */
+  and() {
+    this.currentLogicalOp = "and";
+    return this;
+  }
+  /**
+   * Set the logical operator to OR for subsequent conditions
+   * @returns This builder instance for chaining
+   */
+  or() {
+    this.currentLogicalOp = "or";
+    return this;
+  }
+  /**
+   * Add an equality condition
+   * @param field - The field name to filter on
+   * @param value - The value to match
+   * @returns This builder instance for chaining
+   */
+  equals(field, value) {
+    this.conditions.push({
+      field,
+      operator: "=",
+      value,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add a not-equal condition
+   * @param field - The field name to filter on
+   * @param value - The value to exclude
+   * @returns This builder instance for chaining
+   */
+  notEquals(field, value) {
+    this.conditions.push({
+      field,
+      operator: "!=",
+      value,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add a less-than condition
+   * @param field - The field name to filter on
+   * @param value - The upper bound (exclusive)
+   * @returns This builder instance for chaining
+   */
+  lessThan(field, value) {
+    this.conditions.push({
+      field,
+      operator: "<",
+      value,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add a greater-than condition
+   * @param field - The field name to filter on
+   * @param value - The lower bound (exclusive)
+   * @returns This builder instance for chaining
+   */
+  greaterThan(field, value) {
+    this.conditions.push({
+      field,
+      operator: ">",
+      value,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add a less-than-or-equal condition
+   * @param field - The field name to filter on
+   * @param value - The upper bound (inclusive)
+   * @returns This builder instance for chaining
+   */
+  lessThanOrEqual(field, value) {
+    this.conditions.push({
+      field,
+      operator: "<=",
+      value,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add a greater-than-or-equal condition
+   * @param field - The field name to filter on
+   * @param value - The lower bound (inclusive)
+   * @returns This builder instance for chaining
+   */
+  greaterThanOrEqual(field, value) {
+    this.conditions.push({
+      field,
+      operator: ">=",
+      value,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add an IN condition to match multiple values
+   * @param field - The field name to filter on
+   * @param values - Array of values to match against
+   * @returns This builder instance for chaining
+   * @example
+   * builder.in('playerId', [8476791, 8477933, 8478402])
+   * // Generates: "playerId in (8476791, 8477933, 8478402)"
+   */
+  in(field, values) {
+    if (values.length === 0) {
+      throw new Error("IN condition requires at least one value");
+    }
+    this.conditions.push({
+      field,
+      operator: "in",
+      value: values,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add a LIKE condition for pattern matching
+   * @param field - The field name to filter on
+   * @param pattern - The pattern to match (supports % for wildcards)
+   * @returns This builder instance for chaining
+   * @example
+   * builder.like('playerName', '%McDavid%')
+   * // Generates: "playerName like '%McDavid%'"
+   */
+  like(field, pattern) {
+    this.conditions.push({
+      field,
+      operator: "like",
+      value: pattern,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Add a raw condition string
+   * Useful for complex expressions or unsupported operators
+   * @param condition - The raw condition string (e.g., "playerId=8476791")
+   * @returns This builder instance for chaining
+   */
+  raw(condition) {
+    this.conditions.push({
+      field: "__raw__",
+      operator: "=",
+      value: condition,
+      logicalOp: this.currentLogicalOp
+    });
+    return this;
+  }
+  /**
+   * Build the cayenneExp string
+   * @returns The formatted cayenneExp string ready for API consumption
+   */
+  build() {
+    if (this.groupStack.length > 0) {
+      throw new Error(
+        `Cannot build: ${this.groupStack.length} group(s) still open. Call endGroup() to close them.`
+      );
+    }
+    const buildExpression = (items, depth = 0) => {
+      return items.map((item, index) => {
+        let expr = "";
+        if ("type" in item && item.type === "group") {
+          const groupExpr = buildExpression(
+            item.conditions,
+            depth + 1
+          );
+          expr = `(${groupExpr})`;
+        } else if ("field" in item) {
+          const condition = item;
+          if (condition.field === "__raw__") {
+            expr = String(condition.value);
+          } else if (condition.operator === "in") {
+            const values = Array.isArray(condition.value) ? condition.value.join(", ") : condition.value;
+            expr = `${condition.field} in (${values})`;
+          } else if (condition.operator === "like") {
+            expr = `${condition.field} like '${condition.value}'`;
+          } else {
+            expr = `${condition.field}${condition.operator}${condition.value}`;
+          }
+        }
+        if (index < items.length - 1) {
+          const nextItem = items[index + 1];
+          if (nextItem) {
+            const nextLogicalOp = ("logicalOp" in nextItem ? nextItem.logicalOp : void 0) || "and";
+            expr += ` ${nextLogicalOp}`;
+          }
+        }
+        return expr;
+      }).join(" ");
+    };
+    return buildExpression(this.conditions);
+  }
+  /**
+   * Clear all conditions
+   * @returns This builder instance for chaining
+   */
+  clear() {
+    this.conditions = [];
+    return this;
+  }
+  /**
+   * Get the number of conditions currently in the builder
+   */
+  count() {
+    return this.conditions.length;
+  }
+};
+function createCayenneQuery() {
+  return new CayenneQueryBuilder();
+}
+function buildCayenneExp(filters) {
+  const builder = new CayenneQueryBuilder();
+  Object.entries(filters).forEach(([field, value]) => {
+    builder.equals(field, value);
+  });
+  return builder.build();
+}
+
+// src/api/edge-stats/paths.ts
+var dataPaths = {
+  /** Goalie-related statistics and reports. */
+  goalie: {
+    /** Goalie leader boards by stat category. */
+    leaders: {
+      /** Goals-against average leaders. */
+      gaa: "{lang}/leaders/goalies/gaa",
+      /** Save percentage leaders. */
+      savePctg: "{lang}/leaders/goalies/savePctg",
+      /** Shutouts leaders. */
+      shutouts: "{lang}/leaders/goalies/shutouts"
+    },
+    /** Goalie statistical reports. */
+    report: "{lang}/goalie/{report}",
+    /** Goalie career milestones. */
+    milestones: "{lang}/milestones/goalies"
+  },
+  /** Skater/player-related statistics and reports. */
+  skater: {
+    /** Player directory and information. */
+    players: "{lang}/players",
+    /** Skater leader boards by stat category. */
+    leaders: {
+      /** Assists leaders. */
+      assists: "{lang}/leaders/skaters/assists",
+      /** Goals leaders. */
+      goals: "{lang}/leaders/skaters/goals",
+      /** Points leaders. */
+      points: "{lang}/leaders/skaters/points"
+    },
+    /** Skater career milestones. */
+    milestones: "{lang}/milestones/skaters",
+    /** Skater statistical reports. */
+    report: "{lang}/skater/{report}"
+  },
+  /** Team-related statistics and reports. */
+  team: {
+    /** All teams data. */
+    all: "{lang}/team",
+    /** Team data by team ID. */
+    byId: "{lang}/team/id/{teamId}",
+    /** Team statistical reports. */
+    report: "{lang}/team/{report}"
+  },
+  /** Season-related data. */
+  season: "{lang}/season",
+  /** Game-related data. */
+  game: "{lang}/game",
+  /** Draft-related data. */
+  draft: "{lang}/draft",
+  /** Configuration data for skater, goalie, and team reports. */
+  config: "{lang}/config",
+  /** Country data. */
+  countries: "{lang}/country",
+  /** Shift chart data. */
+  shiftCharts: "{lang}/shiftcharts",
+  /** Glossary data. */
+  glossary: "{lang}/glossary",
+  /** Franchise data. */
+  franchises: "{lang}/franchise"
+};
+
+// src/api/edge-stats/query.ts
+function reportParams(params = {}) {
+  return { ...params, cayenneExp: params.cayenneExp ?? "" };
+}
+function filterParams(filters = {}, sorting = {}, pagination = {}) {
+  const conditions = {};
+  for (const [field, value] of Object.entries(filters)) {
+    if (value !== void 0 && value !== "") conditions[field] = value;
+  }
+  const params = {
+    cayenneExp: buildCayenneExp(conditions)
+  };
+  if (sorting.sortBy) params.sort = sorting.sortBy;
+  if (sorting.direction) params.dir = sorting.direction;
+  if (pagination.limit !== void 0) params.limit = pagination.limit;
+  if (pagination.start !== void 0) params.start = pagination.start;
+  return params;
+}
+
+// src/api/edge-stats/goalies.ts
+async function getLeaders(statCategory, params = {}, lang = config.language) {
+  const path = resolvePath(dataPaths.goalie.leaders[statCategory], { lang });
+  return edgeStatsClient.get(path, params);
+}
+async function getStats(report = "summary", params = {}, lang = config.language) {
+  const path = resolvePath(dataPaths.goalie.report, { lang, report });
+  return edgeStatsClient.get(
+    path,
+    reportParams(params)
+  );
+}
+async function getStatsWithParams(report, params, lang = config.language) {
+  return getStats(report, params, lang);
+}
+async function getStatsWithBuilder(report, buildQuery, lang = config.language) {
+  return getStats(report, buildQuery(new CayenneQueryBuilder()), lang);
+}
+async function getStatsWithFilters(report, filters, sorting, pagination, lang = config.language) {
+  return getStats(
+    report,
+    filterParams(filters, sorting, pagination),
+    lang
+  );
+}
+async function getMilestones(lang = config.language) {
+  const path = resolvePath(dataPaths.goalie.milestones, { lang });
+  return edgeStatsClient.get(path);
+}
+
+// src/api/edge-stats/misc.ts
+var misc_exports = {};
+__export(misc_exports, {
+  getConfig: () => getConfig,
+  getCountries: () => getCountries,
+  getFranchises: () => getFranchises,
+  getGlossary: () => getGlossary
+});
+async function getConfig(lang = config.language) {
+  const path = resolvePath(dataPaths.config, { lang });
+  return edgeStatsClient.get(path);
+}
+async function getCountries(lang = config.language) {
+  const path = resolvePath(dataPaths.countries, { lang });
+  return edgeStatsClient.get(path);
+}
+async function getGlossary(lang = config.language) {
+  const path = resolvePath(dataPaths.glossary, { lang });
+  return edgeStatsClient.get(path);
+}
+async function getFranchises(lang = config.language) {
+  const path = resolvePath(dataPaths.franchises, { lang });
+  return edgeStatsClient.get(path);
+}
+
+// src/api/edge-stats/season-game.ts
+var season_game_exports = {};
+__export(season_game_exports, {
+  getDraft: () => getDraft,
+  getGames: () => getGames,
+  getSeasons: () => getSeasons,
+  getShiftChart: () => getShiftChart
+});
+async function getSeasons(lang = config.language) {
+  const path = resolvePath(dataPaths.season, { lang });
+  return edgeStatsClient.get(path);
+}
+async function getGames(params = {}, lang = config.language) {
+  const path = resolvePath(dataPaths.game, { lang });
+  return edgeStatsClient.get(path, params);
+}
+async function getShiftChart(gameId, lang = config.language) {
+  const path = resolvePath(dataPaths.shiftCharts, { lang });
+  const cayenneExp = `gameId=${gameId}`;
+  return edgeStatsClient.get(path, {
+    cayenneExp
+  });
+}
+async function getDraft(lang = config.language) {
+  const path = resolvePath(dataPaths.draft, { lang });
+  return edgeStatsClient.get(path);
+}
+
+// src/api/edge-stats/skaters.ts
+var skaters_exports2 = {};
+__export(skaters_exports2, {
+  getLeaders: () => getLeaders2,
+  getMilestones: () => getMilestones2,
+  getPlayerInfo: () => getPlayerInfo,
+  getStats: () => getStats2,
+  getStatsWithBuilder: () => getStatsWithBuilder2,
+  getStatsWithFilters: () => getStatsWithFilters2,
+  getStatsWithParams: () => getStatsWithParams2
+});
+async function getPlayerInfo(params = {}, lang = config.language) {
+  const path = resolvePath(dataPaths.skater.players, { lang });
+  return edgeStatsClient.get(path, params);
+}
+async function getLeaders2(statCategory, params = {}, lang = config.language) {
+  const path = resolvePath(dataPaths.skater.leaders[statCategory], { lang });
+  return edgeStatsClient.get(path, params);
+}
+async function getMilestones2(lang = config.language) {
+  const path = resolvePath(dataPaths.skater.milestones, { lang });
+  return edgeStatsClient.get(path);
+}
+async function getStats2(report = "summary", params = {}, lang = config.language) {
+  const path = resolvePath(dataPaths.skater.report, { lang, report });
+  return edgeStatsClient.get(
+    path,
+    reportParams(params)
+  );
+}
+async function getStatsWithParams2(report, params, lang = config.language) {
+  return getStats2(report, params, lang);
+}
+async function getStatsWithBuilder2(report, buildQuery, lang = config.language) {
+  return getStats2(report, buildQuery(new CayenneQueryBuilder()), lang);
+}
+async function getStatsWithFilters2(report, filters, sorting, pagination, lang = config.language) {
+  return getStats2(
+    report,
+    filterParams(filters, sorting, pagination),
+    lang
+  );
+}
+
+// src/api/edge-stats/teams.ts
+var teams_exports2 = {};
+__export(teams_exports2, {
+  getAll: () => getAll,
+  getById: () => getById,
+  getStats: () => getStats3,
+  getStatsWithBuilder: () => getStatsWithBuilder3,
+  getStatsWithFilters: () => getStatsWithFilters3,
+  getStatsWithParams: () => getStatsWithParams3
+});
+async function getAll(params = {}, lang = config.language) {
+  const path = resolvePath(dataPaths.team.all, { lang });
+  return edgeStatsClient.get(path, params);
+}
+async function getById(teamId, params = {}, lang = config.language) {
+  const path = resolvePath(dataPaths.team.byId, { lang, teamId });
+  return edgeStatsClient.get(path, params);
+}
+async function getStats3(report = "summary", params = {}, lang = config.language) {
+  const path = resolvePath(dataPaths.team.report, { lang, report });
+  return edgeStatsClient.get(
+    path,
+    reportParams(params)
+  );
+}
+async function getStatsWithParams3(report, params, lang = config.language) {
+  return getStats3(report, params, lang);
+}
+async function getStatsWithBuilder3(report, buildQuery, lang = config.language) {
+  return getStats3(report, buildQuery(new CayenneQueryBuilder()), lang);
+}
+async function getStatsWithFilters3(report, filters, sorting, pagination, lang = config.language) {
+  return getStats3(
+    report,
+    filterParams(filters, sorting, pagination),
+    lang
+  );
+}
+
 // src/api/gamecenter/index.ts
 var gamecenter_exports = {};
 __export(gamecenter_exports, {
   draft: () => draft_exports,
   game: () => game_exports,
-  misc: () => misc_exports,
+  misc: () => misc_exports2,
   player: () => player_exports,
   score: () => score,
   scoreboard: () => scoreboard,
@@ -1956,7 +2395,7 @@ function rankings(year) {
     goaliesIntl: "4"
   };
   const getRankings = async (type2) => {
-    const parsedYear = Year(year ?? getCurrentYear());
+    const parsedYear = Year(year ?? getCurrentNHLYear());
     if (isParseError(parsedYear)) {
       return {
         success: false,
@@ -2157,7 +2596,7 @@ async function pptReplayEvent(gameId, eventId) {
   return nhlClient.get(path);
 }
 async function schedule(date) {
-  const parsedDate = NHLDate(date ?? getCurrentDate());
+  const parsedDate = NHLDate(date ?? getCurrentNHLDate());
   if (isParseError(parsedDate)) {
     return {
       success: false,
@@ -2183,7 +2622,7 @@ async function scheduleCalendar(date) {
   return nhlClient.get(path);
 }
 async function playoffBracket(year) {
-  const parsedYear = Year(year ?? getCurrentYear());
+  const parsedYear = Year(year ?? getCurrentNHLYear());
   if (isParseError(parsedYear)) {
     return {
       success: false,
@@ -2229,7 +2668,7 @@ async function whereToWatch() {
   return nhlClient.get(path);
 }
 async function networkTVSchedule(date) {
-  const parsedDate = NHLDate(date ?? getCurrentDate());
+  const parsedDate = NHLDate(date ?? getCurrentNHLDate());
   if (isParseError(parsedDate)) {
     return {
       success: false,
@@ -2243,8 +2682,8 @@ async function networkTVSchedule(date) {
 }
 
 // src/api/gamecenter/misc.ts
-var misc_exports = {};
-__export(misc_exports, {
+var misc_exports2 = {};
+__export(misc_exports2, {
   location: () => location,
   meta: () => meta,
   partnerGame: () => partnerGame,
@@ -2400,7 +2839,7 @@ async function statsLeadersGoalies(season, gameType) {
 
 // src/api/gamecenter/score.ts
 async function score(date) {
-  const parsed = NHLDate(date ?? getCurrentDate());
+  const parsed = NHLDate(date ?? getCurrentNHLDate());
   if (isParseError(parsed)) {
     return {
       success: false,
@@ -2523,7 +2962,7 @@ async function statsSeason(team) {
   return nhlClient.get(path);
 }
 async function standings(date) {
-  const parsed = NHLDate(date ?? getCurrentDate());
+  const parsed = NHLDate(date ?? getCurrentNHLDate());
   if (isParseError(parsed)) {
     return {
       success: false,
@@ -2583,11 +3022,76 @@ var schedule2 = {
   month: scheduleMonth
 };
 
+// src/api/video.ts
+var video_exports = {};
+__export(video_exports, {
+  metadata: () => metadata
+});
+var ACCOUNT_ID = "6415718365001";
+var POLICY_KEY = "BCpkADawqM3l37Vq8trLJ95vVwxubXYZXYglAopEZXQTHTWX3YdalyF9xmkuknxjBgiMYwt8VZ_OZ1jAjYxz_yzuNh_cjC3uOaMspVTD-hZfNUHtNnBnhVD0Gmsih8TBF8QlQFXiCQM3W_u4ydJ1qK2Rx8ZutCUg3PHb7Q";
+var brightcoveClient = createNHLClient({
+  baseUrl: `https://edge.api.brightcove.com/playback/v1/accounts/${ACCOUNT_ID}`,
+  headers: { Accept: `application/json;pk=${POLICY_KEY}` }
+});
+async function metadata(videoId) {
+  const result = await brightcoveClient.get(
+    `videos/${encodeURIComponent(String(videoId))}`
+  );
+  if (!result.success) return result;
+  const video = result.data;
+  const mp4 = video.sources.filter((s) => s.container === "MP4" && s.src?.startsWith("https:")).sort((a, b) => (b.width ?? 0) - (a.width ?? 0));
+  return {
+    success: true,
+    data: {
+      id: video.id,
+      title: video.name,
+      description: video.description,
+      longDescription: video.long_description,
+      duration: video.duration,
+      publishedAt: video.published_at,
+      poster: video.poster,
+      thumbnail: video.thumbnail,
+      url: mp4[0]?.src ?? null,
+      sources: video.sources.map((s) => ({
+        src: s.src,
+        ...s.type && { type: s.type },
+        ...s.container && { container: s.container },
+        ...s.codec && { codec: s.codec },
+        ...s.width && { width: s.width },
+        ...s.height && { height: s.height }
+      })),
+      tags: video.tags
+    }
+  };
+}
+
+exports.APIError = APIError;
+exports.BASE_URLS = BASE_URLS;
+exports.CayenneQueryBuilder = CayenneQueryBuilder;
+exports.ClientError = ClientError;
 exports.EDGE = EDGE;
+exports.ErrorCategory = ErrorCategory;
+exports.ErrorHandler = ErrorHandler;
+exports.ErrorLogLevel = LogLevel;
 exports.NHL = nhl_exports;
+exports.NHLClient = NHLClient;
+exports.NHLError = NHLError;
+exports.NetworkError = NetworkError;
+exports.NotFoundError = NotFoundError;
+exports.ParseError = ParseError;
+exports.RateLimitError = RateLimitError;
+exports.ServerError = ServerError;
+exports.ValidationError = ValidationError;
 exports.adv = edge_adv_exports2;
-exports.envConfig = envConfig;
+exports.buildCayenneExp = buildCayenneExp;
+exports.config = config;
+exports.createCayenneQuery = createCayenneQuery;
+exports.createNHLClient = createNHLClient;
 exports.gc = gamecenter_exports;
-exports.logEnvConfig = logEnvConfig;
+exports.logConfig = logConfig;
+exports.logger = logger;
+exports.stats = edge_stats_exports;
+exports.video = video_exports;
+exports.writeLog = writeLog;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map