nhle-api 0.5.3 → 0.6.0

package/lib/index.cjs

@@ -8,105 +8,72 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/api/gamecenter/index.ts
-var gamecenter_exports = {};
-__export(gamecenter_exports, {
-  draft: () => draft_exports,
-  game: () => game_exports,
-  misc: () => misc_exports,
-  player: () => player_exports,
-  score: () => score,
-  scoreboard: () => scoreboard,
-  team: () => team_exports
+// src/api/edge-adv/index.ts
+var edge_adv_exports2 = {};
+__export(edge_adv_exports2, {
+  byTheNumbers: () => byTheNumbers,
+  goalies: () => goalies_exports,
+  skaters: () => skaters_exports,
+  teams: () => teams_exports
 });
 
-// src/api/gamecenter/draft.ts
-var draft_exports = {};
-__export(draft_exports, {
-  picks: () => picks,
-  rankings: () => rankings,
-  tracker: () => tracker
+// src/api/edge-adv/goalies.ts
+var goalies_exports = {};
+__export(goalies_exports, {
+  compare: () => compare,
+  leaders: () => leaders,
+  player: () => player,
+  saveLocation: () => saveLocation,
+  savePercentage: () => savePercentage,
+  savePercentage5v5: () => savePercentage5v5,
+  top10: () => top10
 });
 
-// src/config/env.ts
-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";
+// src/config/index.ts
+var config = {
+  timeout: 5e3,
+  language: "en",
+  logLevel: "warn"
+};
+function logConfig() {
+  console.debug("NHL API Configuration:", config);
 }
-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/logging/index.ts
+var levelRank = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4
 };
-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 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 = {
@@ -126,6 +93,7 @@ var ErrorCategory = {
   VALIDATION: "VALIDATION"
 };
 var LogLevel = {
+  NONE: 0,
   ERROR: 1,
   WARN: 2,
   INFO: 3,
@@ -192,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
     };
   }
   /**
@@ -211,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
@@ -310,44 +294,84 @@ 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/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 BASE_URLS = {
+  gamecenter: "https://api-web.nhle.com/v1",
+  edgeStats: "https://api.nhle.com/stats/rest"
+};
+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 && baseURL in API_BASE_URLS) {
-      this.config.baseUrl = API_BASE_URLS[baseURL];
-    } else 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
@@ -372,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
       });
@@ -393,14 +415,14 @@ var NHLClient = class {
           endpoint: url
         });
         this.errorHandler.log(error);
-        return { status: "error", error };
+        return { success: false, error };
       }
-      return { data: await response.json(), status: "success" };
+      return { data: await response.json(), success: true };
     } catch (error) {
       clearTimeout(timeoutId);
       if (error instanceof NHLError) {
         this.errorHandler.log(error);
-        return { status: "error", error };
+        return { success: false, error };
       }
       let nhlError;
       if (error instanceof Error && error.name === "AbortError") {
@@ -418,59 +440,22 @@ var NHLClient = class {
         });
       }
       this.errorHandler.log(nhlError);
-      return { status: "error", error: nhlError };
+      return { success: false, error: nhlError };
     }
   }
   /**
    * 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("default");
-createNHLClient("edge-stats");
-var client_default = nhlClient;
-
-// src/utils/date.ts
-var NHL_TIMEZONE = "America/New_York";
-var getDate = (date) => new Intl.DateTimeFormat("en-CA", {
-  timeZone: NHL_TIMEZONE,
-  year: "numeric",
-  month: "2-digit",
-  day: "2-digit"
-}).format(date);
-var getCurrentDate = () => getDate(/* @__PURE__ */ new Date());
-var getYear = (date) => new Intl.DateTimeFormat("en-CA", {
-  timeZone: NHL_TIMEZONE,
-  year: "numeric"
-}).format(date);
-var getCurrentYear = () => getYear(/* @__PURE__ */ new Date());
-var getSeason = (date) => {
-  const format = new Intl.DateTimeFormat("en-CA", {
-    timeZone: NHL_TIMEZONE,
-    year: "numeric",
-    month: "numeric"
-  }).formatToParts(date instanceof Date ? date : new Date(date));
-  const month = format.find((part) => part.type === "month")?.value;
-  const year = format.find((part) => part.type === "year")?.value;
-  if (!year) {
-    throw new Error("Invalid date provided, could not extract year");
-  }
-  if (month && parseInt(month, 10) < 7) {
-    console.log(month, parseInt(month, 10) < 7);
-    return `${parseInt(year, 10) - 1}${year}`;
-  }
-  return `${year}${parseInt(year, 10) + 1}`;
-};
-var getCurrentSeason = () => getSeason(/* @__PURE__ */ new Date());
-/* @__PURE__ */ new Date(
-  `${getCurrentSeason().slice(4, 8)}-06-30`
-);
+var nhlClient = createNHLClient(BASE_URLS.gamecenter);
+var edgeStatsClient = createNHLClient(BASE_URLS.edgeStats);
 
 // src/constants/edge-adv.ts
 var edge_adv_exports = {};
@@ -592,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, {
@@ -619,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,
@@ -953,19 +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 };
+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;
@@ -978,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"
 );
@@ -1032,35 +1065,37 @@ 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) => {
     return v >= nhl_exports.PLAYER_ID_RANGE.MIN && v <= nhl_exports.PLAYER_ID_RANGE.MAX;
   })
 ).pipe((v) => v.toString()).describe("a valid NHL player ID");
-arktype.type.enumerated(
+var SaveLocationCategory = arktype.type.enumerated(
   ...Object.keys(
     EDGE.SaveLocationCategoryEnum
   )
 ).pipe((v) => EDGE.SaveLocationCategoryEnum[v]);
-arktype.type.enumerated(
+var ShotLocationSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.ShotLocationSortEnum
   )
 ).pipe((v) => EDGE.ShotLocationSortEnum[v]);
-arktype.type.enumerated(
+var SaveLocationSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.SaveLocationSortEnum
   )
 ).pipe((v) => EDGE.SaveLocationSortEnum[v]);
-arktype.type.enumerated(
+var SavePercentage5v5Sort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.SavePercentage5v5SortEnum
   )
 ).pipe((v) => EDGE.SavePercentage5v5SortEnum[v]);
-arktype.type.enumerated(
+var SavePercentageSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.SavePercentageSortEnum
   )
@@ -1075,47 +1110,52 @@ var SkatersStrength = arktype.type.enumerated(
     EDGE.SkatersStrengthEnum
   )
 ).pipe((v) => EDGE.SkatersStrengthEnum[v]);
-arktype.type.enumerated(
+var ShotSpeedSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.ShotSpeedSortEnum
   )
 ).pipe((v) => EDGE.ShotSpeedSortEnum[v]);
-arktype.type.enumerated(
+var SkatingSpeedSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.SkatingSpeedSortEnum
   )
 ).pipe((v) => EDGE.SkatingSpeedSortEnum[v]);
-arktype.type.enumerated(
+var SkatingDistanceSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.SkatingDistanceSortEnum
   )
-);
-arktype.type.enumerated(
+).pipe((v) => EDGE.SkatingDistanceSortEnum[v]);
+var ShotLocationCategory = arktype.type.enumerated(
   ...Object.keys(
     EDGE.ShotLocationCategoryEnum
   )
 ).pipe((v) => EDGE.ShotLocationCategoryEnum[v]);
-arktype.type.enumerated(
+var ZoneTimeSort = arktype.type.enumerated(
   ...Object.keys(
     EDGE.ZoneTimeSortEnum
   )
 ).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(
     (v) => v ?? nhl_exports.GameTypeEnum.REG
   )
 });
-BaseParams.merge({
+var PlayerParams = BaseParams.merge({
   playerId: PlayerId,
   season: Season
 });
-BaseParams.merge({
+var TeamParams = BaseParams.merge({
   teamId: TeamId
 });
-BaseParams.merge({
-  position: PositionFilter.default("ALL"),
-  strength: SkatersStrength.default("ALL")
+var top10Params = BaseParams.merge({
+  position: withDefault(PositionFilter, "ALL"),
+  strength: withDefault(SkatersStrength, "ALL")
 });
 var DraftParams = arktype.type({
   year: Year.or("undefined").pipe((v) => v ?? nhl_exports.CURRENT.YEAR),
@@ -1139,92 +1179,1189 @@ 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)
   )
 });
 
 // src/utils/utils.ts
-function route(template, params) {
-  let route2 = template;
+function resolvePath(template, params) {
+  let resolvedPath = template;
   for (const [key, value] of Object.entries(params)) {
     if (value === void 0) continue;
-    route2 = route2.replace(`{${key}}`, String(value));
+    resolvedPath = resolvedPath.replace(`{${key}}`, String(value));
   }
-  return route2;
+  return resolvedPath;
 }
 
-// src/api/gamecenter/_paths.ts
-var _teamPaths = {
+// src/api/edge-adv/paths.ts
+var goaliesPaths = {
+  /** Goalie detail page. */
+  player: "edge/goalie-detail/{playerId}/{season}/{gameType}",
+  /** Goalie comparison data. */
+  compare: "edge/goalie-comparison/{playerId}/{season}/{gameType}",
+  /** Goalie leaders landing page. */
+  leaders: "edge/goalie-landing/{season}/{gameType}",
+  /** Goalie 5v5 save percentage statistics. */
+  savePercentage5v5: "edge/goalie-5v5-detail/{playerId}/{season}/{gameType}",
+  /** Goalie save percentage statistics. */
+  savePercentage: "edge/goalie-save-percentage-detail/{playerId}/{season}/{gameType}",
+  /** Goalie shot location analysis. */
+  saveLocation: "edge/goalie-shot-location-detail/{playerId}/{season}/{gameType}",
+  /** Goalie top 10 leaders. */
+  top10: {
+    /** Top 10 goalies by save percentage. */
+    savePercentage: "edge/goalie-edge-save-pctg-top-10/{sortBy}/{season}/{gameType}",
+    /** Top 10 goalies by 5v5 save percentage. */
+    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}"
+  }
+};
+var skatersPaths = {
+  /** Skater detail page. */
+  player: "edge/skater-detail/{playerId}/{season}/{gameType}",
+  /** Skater comparison data. */
+  compare: "edge/skater-comparison/{playerId}/{season}/{gameType}",
+  /** Skater leaders landing page. */
+  leaders: "edge/skater-landing/{season}/{gameType}",
+  /** Skater shot location analysis. */
+  shotLocation: "edge/skater-shot-location-detail/{playerId}/{season}/{gameType}",
+  /** Skater shot speed analysis. */
+  shotSpeed: "edge/skater-shot-speed-detail/{playerId}/{season}/{gameType}",
+  /** Skater skating distance analysis. */
+  skatingDistance: "edge/skater-skating-distance-detail/{playerId}/{season}/{gameType}",
+  /** Skater skating speed analysis. */
+  skatingSpeed: "edge/skater-skating-speed-detail/{playerId}/{season}/{gameType}",
+  /** Skater zone time analysis. */
+  zoneTime: "edge/skater-zone-time/{playerId}/{season}/{gameType}",
+  /** Skater top 10 leaders. */
+  top10: {
+    /** Top 10 skaters by shot location. */
+    shotLocation: "edge/skater-shot-location-top-10/{position}/{category}/{sortBy}/{season}/{gameType}",
+    /** Top 10 skaters by shot speed. */
+    shotSpeed: "edge/skater-shot-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
+    /** Top 10 skaters by skating distance. */
+    skatingDistance: "edge/skater-distance-top-10/{position}/{strength}/{sortBy}/{season}/{gameType}",
+    /** Top 10 skaters by skating speed. */
+    skatingSpeed: "edge/skater-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
+    /** Top 10 skaters by zone time. */
+    zoneTime: "edge/skater-zone-time-top-10/{position}/{strength}/{sortBy}/{season}/{gameType}"
+  }
+};
+var teamsPaths = {
+  /** Team statistics detail page. */
+  stats: "edge/team-detail/{teamId}/{season}/{gameType}",
+  /** Team comparison data. */
+  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-speed-detail/{teamId}/{season}/{gameType}",
+  /** Team skating distance analysis. */
+  skatingDistance: "edge/team-skating-distance-detail/{teamId}/{season}/{gameType}",
+  /** Team skating speed analysis. */
+  skatingSpeed: "edge/team-skating-speed-detail/{teamId}/{season}/{gameType}",
+  /** Team zone time analysis. */
+  zoneTime: "edge/team-zone-time-details/{teamId}/{season}/{gameType}",
+  /** Team top 10 leaders. */
+  top10: {
+    /** Top 10 teams by shot location. */
+    shotLocation: "edge/team-shot-location-top-10/{position}/{category}/{sortBy}/{season}/{gameType}",
+    /** Top 10 teams by shot speed. */
+    shotSpeed: "edge/team-shot-speed-top-10/{position}/{sortBy}/{season}/{gameType}",
+    /** Top 10 teams by skating distance. */
+    skatingDistance: "edge/team-skating-distance-top-10/{position}/{strength}/{sortBy}/{season}/{gameType}",
+    /** Top 10 teams by skating speed. */
+    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}"
+  }
+};
+var summaryPaths = {
+  /** By the numbers summary. */
+  byTheNumbers: "edge/by-the-numbers/now"
+};
+
+// src/api/edge-adv/goalies.ts
+async function player(playerId, season, gameType) {
+  const parsed = PlayerParams({ playerId, season, gameType });
+  if (isParseError(parsed)) return 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 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 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 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 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 invalidParams(parsed, goaliesPaths.saveLocation);
+  const path = resolvePath(goaliesPaths.saveLocation, parsed);
+  return nhlClient.get(path);
+}
+var top10 = {
+  savePercentage: top10SavePercentage,
+  savePercentage5v5: top10SavePercentage5v5,
+  saveLocation: top10SaveLocation
+};
+async function top10SavePercentage(season, gameType, sortBy) {
+  const Parser = BaseParams.merge({
+    sortBy: withDefault(SavePercentageSort, "GAMES")
+  });
+  const parsed = Parser({ season, gameType, sortBy });
+  if (isParseError(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: withDefault(SavePercentage5v5Sort, "5v5-SV%")
+  });
+  const parsed = Parser({ season, gameType, sortBy });
+  if (isParseError(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: withDefault(SaveLocationCategory, "SV%"),
+    sortBy: withDefault(SaveLocationSort, "ALL")
+  });
+  const parsed = Parser({
+    season,
+    gameType,
+    category,
+    sortBy
+  });
+  if (isParseError(parsed))
+    return invalidParams(parsed, goaliesPaths.top10.saveLocation);
+  const path = resolvePath(goaliesPaths.top10.saveLocation, parsed);
+  return nhlClient.get(path);
+}
+
+// src/api/edge-adv/skaters.ts
+var skaters_exports = {};
+__export(skaters_exports, {
+  comparison: () => comparison,
+  detail: () => detail,
+  leaders: () => leaders2,
+  shotLocation: () => shotLocation,
+  shotSpeed: () => shotSpeed,
+  skatingDistance: () => skatingDistance,
+  skatingSpeed: () => skatingSpeed,
+  top10: () => top102,
+  zoneTime: () => zoneTime
+});
+async function detail(playerId, season, gameType) {
+  const parsed = PlayerParams({ playerId, season, gameType });
+  if (isParseError(parsed)) return 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 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 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 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 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 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 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 invalidParams(parsed, skatersPaths.leaders);
+  const path = resolvePath(skatersPaths.leaders, parsed);
+  return nhlClient.get(path);
+}
+var top102 = {
+  distance: top10Distance,
+  shotLocation: top10ShotLocation,
+  shotSpeed: top10ShotSpeed,
+  speed: top10Speed,
+  zoneTime: top10ZoneTime
+};
+async function top10Distance(season, gameType, position, strength, sortBy) {
+  const parsed = top10Params.merge({
+    sortBy: withDefault(SkatingDistanceSort, "TOTAL")
+  })({
+    season,
+    gameType,
+    position,
+    strength,
+    sortBy
+  });
+  if (isParseError(parsed))
+    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: withDefault(ShotLocationCategory, "G"),
+    sortBy: withDefault(ShotLocationSort, "ALL")
+  })({
+    season,
+    gameType,
+    position,
+    category,
+    sortBy
+  });
+  if (isParseError(parsed))
+    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: withDefault(ShotSpeedSort, "MAX")
+  })({
+    season,
+    gameType,
+    position,
+    sortBy
+  });
+  if (isParseError(parsed))
+    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: withDefault(SkatingSpeedSort, "TOP")
+  })({
+    season,
+    gameType,
+    position,
+    sortBy
+  });
+  if (isParseError(parsed))
+    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: withDefault(ZoneTimeSort, "OZ")
+  })({
+    season,
+    gameType,
+    position,
+    strength,
+    sortBy
+  });
+  if (isParseError(parsed)) return invalidParams(parsed, skatersPaths.top10.zoneTime);
+  const path = resolvePath(skatersPaths.top10.zoneTime, parsed);
+  return nhlClient.get(path);
+}
+
+// src/api/edge-adv/summary.ts
+async function byTheNumbers() {
+  return nhlClient.get(summaryPaths.byTheNumbers);
+}
+
+// src/api/edge-adv/teams.ts
+var teams_exports = {};
+__export(teams_exports, {
+  compare: () => compare2,
+  leaders: () => leaders3,
+  shotLocation: () => shotLocation2,
+  shotSpeed: () => shotSpeed2,
+  skatingDistance: () => skatingDistance2,
+  skatingSpeed: () => skatingSpeed2,
+  stats: () => stats,
+  top10: () => top103,
+  zoneTime: () => zoneTime2
+});
+async function stats(teamId, season, gameType) {
+  const parsed = TeamParams({ teamId, season, gameType });
+  if (isParseError(parsed)) return 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 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 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 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 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 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 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 invalidParams(parsed, teamsPaths.zoneTime);
+  const path = resolvePath(teamsPaths.zoneTime, parsed);
+  return nhlClient.get(path);
+}
+var top103 = {
+  shotLocation: top10ShotLocation2,
+  shotSpeed: top10ShotSpeed2,
+  skatingDistance: top10SkatingDistance,
+  skatingSpeed: top10SkatingSpeed,
+  zoneTime: top10ZoneTime2
+};
+async function top10ShotLocation2(season, gameType, position, category, sortBy) {
+  const Parser = BaseParams.merge({
+    position: withDefault(PositionFilter, "ALL"),
+    category: withDefault(ShotLocationCategory, "G"),
+    sortBy: withDefault(ShotLocationSort, "ALL")
+  });
+  const parsed = Parser({
+    season,
+    gameType,
+    position,
+    category,
+    sortBy
+  });
+  if (isParseError(parsed))
+    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: withDefault(PositionFilter, "ALL"),
+    sortBy: withDefault(ShotSpeedSort, "MAX")
+  });
+  const parsed = Parser({
+    season,
+    gameType,
+    position,
+    sortBy
+  });
+  if (isParseError(parsed))
+    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: withDefault(PositionFilter, "ALL"),
+    strength: withDefault(SkatersStrength, "ALL"),
+    sortBy: withDefault(SkatingDistanceSort, "TOTAL")
+  });
+  const parsed = Parser({
+    season,
+    gameType,
+    position,
+    strength,
+    sortBy
+  });
+  if (isParseError(parsed))
+    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: withDefault(PositionFilter, "ALL"),
+    sortBy: withDefault(SkatingSpeedSort, "TOP")
+  });
+  const parsed = Parser({
+    season,
+    gameType,
+    position,
+    sortBy
+  });
+  if (isParseError(parsed))
+    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: withDefault(SkatersStrength, "ALL"),
+    sortBy: withDefault(ZoneTimeSort, "OZ")
+  });
+  const parsed = Parser({
+    season,
+    gameType,
+    strength,
+    sortBy
+  });
+  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_exports2,
+  player: () => player_exports,
+  score: () => score,
+  scoreboard: () => scoreboard,
+  team: () => team_exports
+});
+
+// src/api/gamecenter/draft.ts
+var draft_exports = {};
+__export(draft_exports, {
+  picks: () => picks,
+  rankings: () => rankings,
+  tracker: () => tracker
+});
+
+// src/api/gamecenter/paths.ts
+var teamPaths = {
+  /** Team roster seasons. */
   rosterSeasons: "roster-season/{team}",
+  /** Team roster for a specific season. */
   roster: "roster/{team}/{season}",
+  /** Team prospects. */
   prospects: "prospects/{team}",
+  /** Team club statistics for a specific season and game type. */
   clubStats: "club-stats/{team}/{season}/{gameType}",
+  /** Team club statistics summary for a season. */
   clubStatsSeason: "club-stats-season/{team}",
+  /** League standings for a specific date. */
   standings: "standings/{date}",
+  /** League standings summary for a season. */
   standingsSeason: "standings-season",
+  /** Team schedule data. */
   clubSchedule: {
+    /** Team schedule for a season. */
     season: "club-schedule-season/{team}/{season}",
+    /** Team schedule for a specific month. */
     month: "club-schedule/{team}/month/{month}",
+    /** Team schedule for a specific week. */
     week: "club-schedule/{team}/week/{date}"
   }
 };
-var _scorePaths = {
+var scorePaths = {
+  /** Game scores for a specific date. */
   score: "score/{date}",
+  /** Scoreboard data. */
   scoreboard: {
+    /** Current scoreboard. */
     now: "scoreboard/now",
+    /** Scoreboard for a specific team. */
     byTeam: "scoreboard/{team}/now",
+    /** Scoreboard for a specific date. */
     byDate: "scoreboard/{date}"
   }
 };
-var _playerPaths = {
+var playerPaths = {
+  /** Player landing page data. */
   landing: "player/{playerId}/landing",
+  /** Player game log for a season and game type. */
   gameLog: "player/{playerId}/game-log/{season}/{gameType}",
+  /** Current player spotlight. */
   spotlight: "player-spotlight",
+  /** Player statistics leaders. */
   statsLeaders: {
+    /** Skater statistics leaders. */
     skaters: "skater-stats-leaders/{season}/{gameType}",
+    /** Goalie statistics leaders. */
     goalies: "goalie-stats-leaders/{season}/{gameType}"
   },
+  /** Player search functionality. */
   playerSearch: "https://search.d3.nhle.com/api/v1/search/player"
 };
-var _miscPaths = {
+var miscPaths = {
+  /** Current season information. */
   season: "season",
+  /** Playoff series metadata for a specific year and series. */
   metaPlayoffSeries: "meta/playoff-series/{year}/{seriesLetter}",
+  /** Game metadata. */
   metaGame: "meta/game/{gameId}",
+  /** Location lookup by postal code. */
   postalLookup: "postal-lookup/{postalCode}",
+  /** Location information. */
   location: "location",
+  /** Partner game for a specific country. */
   partnerGame: "partner-game/{countryCode}/now"
 };
-var _gamePaths = {
+var gamePaths = {
+  /** Game schedule for a specific date. */
   schedule: "schedule/{date}",
+  /** Game schedule calendar for a specific date. */
   scheduleCalendar: "schedule-calendar/{date}",
+  /** Playoff bracket for a specific year. */
   playoffBracket: "playoff-bracket/{year}",
+  /** Playoff series carousel for a season. */
   playoffSeries: "playoff-series/carousel/{season}",
+  /** Playoff series schedule. */
   playoffSeriesSchedule: "schedule/playoff-series/{season}/{seriesLetter}",
+  /** Game center data with multiple views. */
   gamecenter: {
+    /** Play-by-play data for a game. */
     playByPlay: "gamecenter/{gameId}/play-by-play",
+    /** Right rail reports for a game. */
     reports: "gamecenter/{gameId}/right-rail",
+    /** Game landing page. */
     landing: "gamecenter/{gameId}/landing",
+    /** Game box score. */
     boxscore: "gamecenter/{gameId}/boxscore"
   },
+  /** Web Stat Center (WSC) data. */
   wsc: {
+    /** Game story from WSC. */
     gameStory: "wsc/game-story/{gameId}",
+    /** Play-by-play from WSC. */
     playByPlay: "wsc/play-by-play/{gameId}"
   },
+  /** PPT replay data. */
   pptReplay: {
+    /** Goal replay. */
     goal: "ppt-replay/goal/{gameId}/{eventId}",
+    /** Event replay. */
     event: "ppt-replay/{gameId}/{eventId}"
   },
+  /** Where to watch information. */
   whereToWatch: "where-to-watch",
+  /** Network TV schedule for a specific date. */
   networkTVSchedule: "network/tv-schedule/{date}"
 };
-var _draftPaths = {
+var draftPaths = {
+  /** Draft picks data. */
   draftPicks: {
+    /** Draft picks by year and round. */
     byYearAndRound: "draft/picks/{year}/{round}",
+    /** All draft picks for a year. */
     byYear: "draft/picks/{year}/all"
   },
+  /** Draft rankings for a year and type. */
   draftRankings: "draft/rankings/{year}/{type}",
+  /** Current draft tracker. */
   draftTracker: "draft-tracker/picks/now"
 };
 
@@ -1233,18 +2370,22 @@ async function picks(year, round) {
   const parsed = DraftParams({ year, round });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _draftPaths.draftPicks.byYearAndRound
+        endpoint: draftPaths.draftPicks.byYearAndRound
       })
     };
   }
-  if (parsed.year && !parsed.round)
-    return client_default.get(route(_draftPaths.draftPicks.byYear, parsed));
-  return client_default.get(route(_draftPaths.draftPicks.byYearAndRound, parsed));
+  let path = "";
+  if (parsed.year && !parsed.round) {
+    path = resolvePath(draftPaths.draftPicks.byYear, parsed);
+  } else {
+    path = resolvePath(draftPaths.draftPicks.byYearAndRound, parsed);
+  }
+  return nhlClient.get(path);
 }
 async function tracker() {
-  return client_default.get(_draftPaths.draftTracker);
+  return nhlClient.get(draftPaths.draftTracker);
 }
 function rankings(year) {
   const DraftRankingsEnum = {
@@ -1254,21 +2395,17 @@ function rankings(year) {
     goaliesIntl: "4"
   };
   const getRankings = async (type2) => {
-    const parsedYear = Year(year ?? getCurrentYear());
+    const parsedYear = Year(year ?? getCurrentNHLYear());
     if (isParseError(parsedYear)) {
       return {
-        status: "error",
+        success: false,
         error: new ValidationError(parsedYear.summary, {
-          endpoint: _draftPaths.draftRankings
+          endpoint: draftPaths.draftRankings
         })
       };
     }
-    return client_default.get(
-      route(_draftPaths.draftRankings, {
-        year: parsedYear,
-        type: type2
-      })
-    );
+    const path = resolvePath(draftPaths.draftRankings, { year: parsedYear, type: type2 });
+    return nhlClient.get(path);
   };
   return {
     /**
@@ -1297,7 +2434,7 @@ function rankings(year) {
      */
     all: async () => {
       const unwrapAPIResponse = (apiResponse) => {
-        if (apiResponse.status === "success") {
+        if (apiResponse.success) {
           return apiResponse.data;
         }
         throw apiResponse.error;
@@ -1311,13 +2448,13 @@ function rankings(year) {
       try {
         const dataOnly = response.map((r) => unwrapAPIResponse(r));
         const newResponse = {
-          status: "success",
+          success: true,
           data: dataOnly
         };
         return newResponse;
       } catch (error) {
         return {
-          status: "error",
+          success: false,
           error
         };
       }
@@ -1346,57 +2483,57 @@ async function playByPlay(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _gamePaths.gamecenter.playByPlay
+        endpoint: gamePaths.gamecenter.playByPlay
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.gamecenter.playByPlay, { gameId: parsedGameId })
-  );
+  const path = resolvePath(gamePaths.gamecenter.playByPlay, {
+    gameId: parsedGameId
+  });
+  return nhlClient.get(path);
 }
 async function reports(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _gamePaths.gamecenter.reports
+        endpoint: gamePaths.gamecenter.reports
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.gamecenter.reports, { gameId: parsedGameId })
-  );
+  const path = resolvePath(gamePaths.gamecenter.reports, { gameId: parsedGameId });
+  return nhlClient.get(path);
 }
 async function landing(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _gamePaths.gamecenter.landing
+        endpoint: gamePaths.gamecenter.landing
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.gamecenter.landing, { gameId: parsedGameId })
-  );
+  const path = resolvePath(gamePaths.gamecenter.landing, { gameId: parsedGameId });
+  return nhlClient.get(path);
 }
 async function boxscore(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _gamePaths.gamecenter.boxscore
+        endpoint: gamePaths.gamecenter.boxscore
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.gamecenter.boxscore, { gameId: parsedGameId })
-  );
+  const path = resolvePath(gamePaths.gamecenter.boxscore, {
+    gameId: parsedGameId
+  });
+  return nhlClient.get(path);
 }
 var wsc = {
   gameStory: wscGameStory,
@@ -1406,29 +2543,27 @@ async function wscGameStory(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _gamePaths.wsc.gameStory
+        endpoint: gamePaths.wsc.gameStory
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.wsc.gameStory, { gameId: parsedGameId })
-  );
+  const path = resolvePath(gamePaths.wsc.gameStory, { gameId: parsedGameId });
+  return nhlClient.get(path);
 }
 async function wscPlayByPlay(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _gamePaths.wsc.playByPlay
+        endpoint: gamePaths.wsc.playByPlay
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.wsc.playByPlay, { gameId: parsedGameId })
-  );
+  const path = resolvePath(gamePaths.wsc.playByPlay, { gameId: parsedGameId });
+  return nhlClient.get(path);
 }
 var pptReplay = {
   goal: pptReplayGoal,
@@ -1438,77 +2573,79 @@ async function pptReplayGoal(gameId, eventId) {
   const parsed = GameIdAndEventId({ gameId, eventId });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _gamePaths.pptReplay.goal
+        endpoint: gamePaths.pptReplay.goal
       })
     };
   }
-  return client_default.get(route(_gamePaths.pptReplay.goal, { gameId, eventId }));
+  const path = resolvePath(gamePaths.pptReplay.goal, { gameId, eventId });
+  return nhlClient.get(path);
 }
 async function pptReplayEvent(gameId, eventId) {
   const parsed = GameIdAndEventId({ gameId, eventId });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _gamePaths.pptReplay.event
+        endpoint: gamePaths.pptReplay.event
       })
     };
   }
-  return client_default.get(route(_gamePaths.pptReplay.event, { gameId, eventId }));
+  const path = resolvePath(gamePaths.pptReplay.event, { gameId, eventId });
+  return nhlClient.get(path);
 }
 async function schedule(date) {
-  const parsedDate = NHLDate(date ?? getCurrentDate());
+  const parsedDate = NHLDate(date ?? getCurrentNHLDate());
   if (isParseError(parsedDate)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedDate.summary, {
-        endpoint: _gamePaths.schedule
+        endpoint: gamePaths.schedule
       })
     };
   }
-  return client_default.get(route(_gamePaths.schedule, { date: parsedDate }));
+  const path = resolvePath(gamePaths.schedule, { date: parsedDate });
+  return nhlClient.get(path);
 }
 async function scheduleCalendar(date) {
   const parsedDate = NHLDate(date);
   if (isParseError(parsedDate)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedDate.summary, {
-        endpoint: _gamePaths.scheduleCalendar
+        endpoint: gamePaths.scheduleCalendar
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.scheduleCalendar, { date: parsedDate })
-  );
+  const path = resolvePath(gamePaths.scheduleCalendar, { date: parsedDate });
+  return nhlClient.get(path);
 }
 async function playoffBracket(year) {
-  const parsedYear = Year(year ?? getCurrentYear());
+  const parsedYear = Year(year ?? getCurrentNHLYear());
   if (isParseError(parsedYear)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedYear.summary, {
-        endpoint: _gamePaths.playoffBracket
+        endpoint: gamePaths.playoffBracket
       })
     };
   }
-  return client_default.get(route(_gamePaths.playoffBracket, { year: parsedYear }));
+  const path = resolvePath(gamePaths.playoffBracket, { year: parsedYear });
+  return nhlClient.get(path);
 }
 async function playoffSeries(season) {
   const parsedSeason = Season(season ?? getCurrentSeason());
   if (isParseError(parsedSeason)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedSeason.summary, {
-        endpoint: _gamePaths.playoffSeries
+        endpoint: gamePaths.playoffSeries
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.playoffSeries, { season: parsedSeason })
-  );
+  const path = resolvePath(gamePaths.playoffSeries, { season: parsedSeason });
+  return nhlClient.get(path);
 }
 async function playoffSeriesSchedule(seriesLetter, season) {
   const parsed = SeriesAndSeasonParams({
@@ -1517,35 +2654,36 @@ async function playoffSeriesSchedule(seriesLetter, season) {
   });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _gamePaths.playoffSeriesSchedule
+        endpoint: gamePaths.playoffSeriesSchedule
       })
     };
   }
-  return client_default.get(route(_gamePaths.playoffSeriesSchedule, parsed));
+  const path = resolvePath(gamePaths.playoffSeriesSchedule, parsed);
+  return nhlClient.get(path);
 }
 async function whereToWatch() {
-  return client_default.get(_gamePaths.whereToWatch);
+  const path = resolvePath(gamePaths.whereToWatch, {});
+  return nhlClient.get(path);
 }
 async function networkTVSchedule(date) {
-  const parsedDate = NHLDate(date ?? getCurrentDate());
+  const parsedDate = NHLDate(date ?? getCurrentNHLDate());
   if (isParseError(parsedDate)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedDate.summary, {
-        endpoint: _gamePaths.networkTVSchedule
+        endpoint: gamePaths.networkTVSchedule
       })
     };
   }
-  return client_default.get(
-    route(_gamePaths.networkTVSchedule, { date: parsedDate })
-  );
+  const path = resolvePath(gamePaths.networkTVSchedule, { date: parsedDate });
+  return nhlClient.get(path);
 }
 
 // src/api/gamecenter/misc.ts
-var misc_exports = {};
-__export(misc_exports, {
+var misc_exports2 = {};
+__export(misc_exports2, {
   location: () => location,
   meta: () => meta,
   partnerGame: () => partnerGame,
@@ -1553,7 +2691,7 @@ __export(misc_exports, {
   seasons: () => seasons
 });
 async function seasons() {
-  return client_default.get(_miscPaths.season);
+  return nhlClient.get(miscPaths.season);
 }
 var meta = {
   game: metaGame,
@@ -1563,56 +2701,60 @@ async function metaGame(gameId) {
   const parsedGameId = GameId(gameId);
   if (isParseError(parsedGameId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedGameId.summary, {
-        endpoint: _miscPaths.metaGame
+        endpoint: miscPaths.metaGame
       })
     };
   }
-  return client_default.get(route(_miscPaths.metaGame, { gameId: parsedGameId }));
+  const path = resolvePath(miscPaths.metaGame, { gameId: parsedGameId });
+  return nhlClient.get(path);
 }
 async function metaPlayoffSeries(seriesLetter, year) {
   const parsed = SeriesParams({ year, seriesLetter });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _miscPaths.metaPlayoffSeries
+        endpoint: miscPaths.metaPlayoffSeries
       })
     };
   }
-  return client_default.get(route(_miscPaths.metaPlayoffSeries, parsed));
+  const path = resolvePath(miscPaths.metaPlayoffSeries, parsed);
+  return nhlClient.get(path);
 }
 async function postalLookup(postalCode) {
   const parsedPostalCode = PostalCode(postalCode);
   if (isParseError(parsedPostalCode)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedPostalCode.summary, {
-        endpoint: _miscPaths.postalLookup
+        endpoint: miscPaths.postalLookup
       })
     };
   }
-  return client_default.get(
-    route(_miscPaths.postalLookup, { postalCode: parsedPostalCode })
-  );
+  const path = resolvePath(miscPaths.postalLookup, {
+    postalCode: parsedPostalCode
+  });
+  return nhlClient.get(path);
 }
 async function location() {
-  return client_default.get(_miscPaths.location);
+  return nhlClient.get(miscPaths.location);
 }
 async function partnerGame(countryCode) {
   const parsedCountryCode = CountryCode(countryCode);
   if (isParseError(parsedCountryCode)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedCountryCode.summary, {
-        endpoint: _miscPaths.partnerGame
+        endpoint: miscPaths.partnerGame
       })
     };
   }
-  return client_default.get(
-    route(_miscPaths.partnerGame, { countryCode: parsedCountryCode })
-  );
+  const path = resolvePath(miscPaths.partnerGame, {
+    countryCode: parsedCountryCode
+  });
+  return nhlClient.get(path);
 }
 
 // src/api/gamecenter/player.ts
@@ -1624,21 +2766,20 @@ __export(player_exports, {
   spotlight: () => spotlight,
   statsLeaders: () => statsLeaders
 });
-var nhlPlayerSearch = createNHLClient(_playerPaths.playerSearch);
+var nhlPlayerSearch = createNHLClient(playerPaths.playerSearch);
 var searchUrlParams = { culture: "en", q: "" };
 async function landing2(playerId) {
   const parsedPlayerId = PlayerId(playerId);
   if (isParseError(parsedPlayerId)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsedPlayerId.summary, {
-        endpoint: _playerPaths.landing
+        endpoint: playerPaths.landing
       })
     };
   }
-  return client_default.get(
-    route(_playerPaths.landing, { playerId: parsedPlayerId })
-  );
+  const path = resolvePath(playerPaths.landing, { playerId: parsedPlayerId });
+  return nhlClient.get(path);
 }
 async function gameLog(playerId, season, gameType) {
   const Parser = BaseParams.merge({
@@ -1647,16 +2788,17 @@ async function gameLog(playerId, season, gameType) {
   const parsed = Parser({ playerId, season, gameType });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _playerPaths.gameLog
+        endpoint: playerPaths.gameLog
       })
     };
   }
-  return client_default.get(route(_playerPaths.gameLog, parsed));
+  const path = resolvePath(playerPaths.gameLog, parsed);
+  return nhlClient.get(path);
 }
 async function spotlight() {
-  return client_default.get(_playerPaths.spotlight);
+  return nhlClient.get(playerPaths.spotlight);
 }
 async function search(query) {
   return nhlPlayerSearch.get("", {
@@ -1672,70 +2814,71 @@ async function statsLeadersSkaters(season, gameType) {
   const parsed = BaseParams({ season, gameType });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _playerPaths.statsLeaders.skaters
+        endpoint: playerPaths.statsLeaders.skaters
       })
     };
   }
-  return client_default.get(route(_playerPaths.statsLeaders.skaters, parsed));
+  const path = resolvePath(playerPaths.statsLeaders.skaters, parsed);
+  return nhlClient.get(path);
 }
 async function statsLeadersGoalies(season, gameType) {
   const parsed = BaseParams({ season, gameType });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _playerPaths.statsLeaders.goalies
+        endpoint: playerPaths.statsLeaders.goalies
       })
     };
   }
-  return client_default.get(route(_playerPaths.statsLeaders.goalies, parsed));
+  const path = resolvePath(playerPaths.statsLeaders.goalies, parsed);
+  return nhlClient.get(path);
 }
 
 // src/api/gamecenter/score.ts
 async function score(date) {
-  const parsed = NHLDate(date ?? getCurrentDate());
+  const parsed = NHLDate(date ?? getCurrentNHLDate());
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _scorePaths.score
+        endpoint: scorePaths.score
       })
     };
   }
-  return client_default.get(route(_scorePaths.score, { date: parsed }));
+  const path = resolvePath(scorePaths.score, { date: parsed });
+  return nhlClient.get(path);
 }
 async function scoreboard() {
-  return client_default.get(_scorePaths.scoreboard.now);
+  return nhlClient.get(scorePaths.scoreboard.now);
 }
 scoreboard.team = async (team) => {
   const parsed = TeamAbbrev(team);
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _scorePaths.scoreboard.byTeam
+        endpoint: scorePaths.scoreboard.byTeam
       })
     };
   }
-  return client_default.get(
-    route(_scorePaths.scoreboard.byTeam, { team: parsed })
-  );
+  const path = resolvePath(scorePaths.scoreboard.byTeam, { team: parsed });
+  return nhlClient.get(path);
 };
 scoreboard.date = async (date) => {
   const parsed = NHLDate(date);
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _scorePaths.scoreboard.byDate
+        endpoint: scorePaths.scoreboard.byDate
       })
     };
   }
-  return client_default.get(
-    route(_scorePaths.scoreboard.byDate, { date: parsed })
-  );
+  const path = resolvePath(scorePaths.scoreboard.byDate, { date: parsed });
+  return nhlClient.get(path);
 };
 
 // src/api/gamecenter/team.ts
@@ -1747,122 +2890,131 @@ __export(team_exports, {
   schedule: () => schedule2,
   standings: () => standings,
   standingsSeason: () => standingsSeason,
-  stats: () => stats,
+  stats: () => stats2,
   statsSeason: () => statsSeason
 });
 async function rosterSeasons(team) {
   const parsed = TeamAbbrev(team);
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.rosterSeasons
+        endpoint: teamPaths.rosterSeasons
       })
     };
   }
-  return client_default.get(route(_teamPaths.rosterSeasons, { team: parsed }));
+  const path = resolvePath(teamPaths.rosterSeasons, { team: parsed });
+  return nhlClient.get(path);
 }
 async function roster(team, season) {
   const parsed = TeamAndSeasonParams({ team, season });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.roster
+        endpoint: teamPaths.roster
       })
     };
   }
-  return client_default.get(route(_teamPaths.roster, parsed));
+  const path = resolvePath(teamPaths.roster, parsed);
+  return nhlClient.get(path);
 }
 async function prospects(team) {
   const parsed = TeamAbbrev(team);
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.prospects
+        endpoint: teamPaths.prospects
       })
     };
   }
-  return client_default.get(route(_teamPaths.prospects, { team: parsed }));
+  const path = resolvePath(teamPaths.prospects, { team: parsed });
+  return nhlClient.get(path);
 }
-async function stats(team, season, gameType) {
+async function stats2(team, season, gameType) {
   const Parser = BaseParams.merge({
     team: TeamAbbrev
   });
   const parsed = Parser({ team, season, gameType });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.clubStats
+        endpoint: teamPaths.clubStats
       })
     };
   }
-  return client_default.get(route(_teamPaths.clubStats, parsed));
+  const path = resolvePath(teamPaths.clubStats, parsed);
+  return nhlClient.get(path);
 }
 async function statsSeason(team) {
   const parsed = TeamAbbrev(team);
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.clubStatsSeason
+        endpoint: teamPaths.clubStatsSeason
       })
     };
   }
-  return client_default.get(route(_teamPaths.clubStatsSeason, { team: parsed }));
+  const path = resolvePath(teamPaths.clubStatsSeason, { team: parsed });
+  return nhlClient.get(path);
 }
 async function standings(date) {
-  const parsed = NHLDate(date ?? getCurrentDate());
+  const parsed = NHLDate(date ?? getCurrentNHLDate());
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.standings
+        endpoint: teamPaths.standings
       })
     };
   }
-  return client_default.get(route(_teamPaths.standings, { date: parsed }));
+  const path = resolvePath(teamPaths.standings, { date: parsed });
+  return nhlClient.get(path);
 }
 async function standingsSeason() {
-  return client_default.get(_teamPaths.standingsSeason);
+  return nhlClient.get(teamPaths.standingsSeason);
 }
 async function scheduleWeek(team, date) {
   const parsed = ScheduleParams({ team, date, month: void 0 });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.clubSchedule.week
+        endpoint: teamPaths.clubSchedule.week
       })
     };
   }
-  return client_default.get(route(_teamPaths.clubSchedule.week, parsed));
+  const path = resolvePath(teamPaths.clubSchedule.week, parsed);
+  return nhlClient.get(path);
 }
 async function scheduleMonth(team, date) {
   const parsed = ScheduleParams({ team, month: date, date: void 0 });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.clubSchedule.month
+        endpoint: teamPaths.clubSchedule.month
       })
     };
   }
-  return client_default.get(route(_teamPaths.clubSchedule.month, parsed));
+  const path = resolvePath(teamPaths.clubSchedule.month, parsed);
+  return nhlClient.get(path);
 }
 async function scheduleSeason(team, season) {
   const parsed = TeamAndSeasonParams({ team, season });
   if (isParseError(parsed)) {
     return {
-      status: "error",
+      success: false,
       error: new ValidationError(parsed.summary, {
-        endpoint: _teamPaths.clubSchedule.season
+        endpoint: teamPaths.clubSchedule.season
       })
     };
   }
-  return client_default.get(route(_teamPaths.clubSchedule.season, parsed));
+  const path = resolvePath(teamPaths.clubSchedule.season, parsed);
+  return nhlClient.get(path);
 }
 var schedule2 = {
   season: scheduleSeason,
@@ -1870,10 +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.envConfig = envConfig;
+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.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