nhle-api 0.5.3 → 0.6.0

package/lib/index.d.cts

@@ -2,7 +2,10 @@ import * as arktype_internal_variants_number_ts from 'arktype/internal/variants/
 import * as arktype_internal_variants_string_ts from 'arktype/internal/variants/string.ts';
 import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
 import * as arktype from 'arktype';
+import { Out } from 'arktype';
 import * as arktype_internal_attributes_ts from 'arktype/internal/attributes.ts';
+import { C as CayenneQueryBuilder } from './nhl-B7Hg7iMB.cjs';
+export { a as CayenneCondition, c as CayenneExpression, d as CayenneGroup, n as NHL, b as buildCayenneExp, e as createCayenneQuery } from './nhl-B7Hg7iMB.cjs';
 
 /**
  * Error handling module for NHL Sports Data API wrapper
@@ -25,6 +28,14 @@ declare const ErrorCategory: {
     readonly VALIDATION: "VALIDATION";
 };
 type ErrorCategory = (typeof ErrorCategory)[keyof typeof ErrorCategory];
+declare const LogLevel$1: {
+    NONE: number;
+    ERROR: number;
+    WARN: number;
+    INFO: number;
+    DEBUG: number;
+};
+type LogLevel$1 = (typeof LogLevel$1)[keyof typeof LogLevel$1];
 interface ErrorContext {
     /** HTTP status code if applicable */
     statusCode?: number;
@@ -43,6 +54,14 @@ interface ErrorContext {
     /** Additional metadata */
     metadata?: Record<string, unknown>;
 }
+interface ErrorConfig {
+    /** Logging level for error output */
+    logLevel?: LogLevel$1;
+    /** Custom logger function */
+    logger?: (level: LogLevel$1, message: string, context?: ErrorContext) => void;
+    /** Whether to include stack traces */
+    includeStack?: boolean;
+}
 /**
  * Base error class for all NHL API errors
  */
@@ -61,318 +80,3000 @@ declare class NHLError extends Error {
         context: ErrorContext;
     };
 }
+/**
+ * Network-level errors (timeouts, connection failures)
+ */
+declare class NetworkError extends NHLError {
+    constructor(message: string, context?: ErrorContext);
+}
+/**
+ * HTTP 4xx client errors
+ */
+declare class ClientError extends NHLError {
+    constructor(message: string, context?: ErrorContext);
+}
+/**
+ * HTTP 404 resource not found
+ */
+declare class NotFoundError extends ClientError {
+    constructor(message?: string, context?: ErrorContext);
+}
+/**
+ * HTTP 5xx server errors
+ */
+declare class ServerError extends NHLError {
+    constructor(message: string, context?: ErrorContext);
+}
+/**
+ * HTTP 429 rate limit errors
+ */
+declare class RateLimitError extends NHLError {
+    readonly retryAfter?: number;
+    constructor(message?: string, context?: ErrorContext, retryAfter?: number);
+}
+/**
+ * API returned 200 but with error message in JSON payload
+ */
+declare class APIError extends NHLError {
+    constructor(message: string, context?: ErrorContext);
+}
+/**
+ * Response parsing or validation failures
+ */
+declare class ParseError extends NHLError {
+    constructor(message: string, context?: ErrorContext);
+}
+/**
+ * Invalid user input or configuration
+ */
+declare class ValidationError extends NHLError {
+    constructor(message: string, context?: ErrorContext);
+}
+/**
+ * Error handler utility class
+ */
+declare class ErrorHandler {
+    private overrides;
+    /**
+     * @param config - Overrides; an unset `logLevel` follows the shared
+     * `config.logLevel` at log time.
+     */
+    constructor(config?: ErrorConfig);
+    private get config();
+    /**
+     * Default console-based logger
+     */
+    private defaultLogger;
+    /**
+     * Log an error based on configuration
+     */
+    log(error: NHLError): void;
+    /**
+     * Determine log level based on error category
+     */
+    private getLogLevel;
+    /**
+     * Create error from HTTP response
+     */
+    fromResponse(response: Response, context?: Omit<ErrorContext, 'statusCode'>): Promise<NHLError>;
+    /**
+     * Create error from caught exception
+     */
+    fromError(error: unknown, context?: ErrorContext): NHLError;
+    /**
+     * Update configuration
+     */
+    configure(config: Partial<ErrorConfig>): void;
+}
 
 /**
  * NHL API Client Type Definitions
  */
 
-type APIResponse<T> = {
-    status: 'success';
+/**
+ * Configuration options for the NHL API client
+ */
+interface NHLClientConfig {
+    /**
+     * Base URL for the NHL API
+     * @default 'https://api-web.nhle.com/v1'
+     */
+    baseUrl?: string;
+    /**
+     * Request timeout in milliseconds
+     * @default 5000 (5 seconds)
+     */
+    timeout?: number;
+    /**
+     * Additional headers to include with every request
+     */
+    headers?: Record<string, string>;
+    /**
+     * Language code for localized responses
+     * @default 'en' (English)
+     */
+    language?: 'en' | 'fr';
+}
+type APIResult<T> = {
+    success: true;
     data: T;
 } | {
-    status: 'error';
+    success: false;
     error: NHLError;
 };
 
-/** Categories for save location top-10 list */
-declare const SaveLocationCategoryEnum: {
-    /** Save Percentage */
-    readonly 'SV%': "save-pctg";
-    /** Saves */
-    readonly SV: "saves";
-    /** Shots Against */
-    readonly SA: "shots-against";
-    /** Goals Against */
-    readonly GA: "goals-against";
-};
-/** Sort options for shot location top-10 list */
-declare const ShotLocationSortEnum: {
-    /** All shot locations */
-    readonly ALL: "all";
-    /** High-danger (i.e. close-range) shot locations */
-    readonly HIGH: "high";
-    /** Mid-range shot locations */
-    readonly MID: "mid";
-    /** Long-range shot locations */
-    readonly LONG: "long";
-};
-/** Alias for ShotLocationSortEnum */
-declare const SaveLocationSortEnum: {
-    /** All shot locations */
-    readonly ALL: "all";
-    /** High-danger (i.e. close-range) shot locations */
-    readonly HIGH: "high";
-    /** Mid-range shot locations */
-    readonly MID: "mid";
-    /** Long-range shot locations */
-    readonly LONG: "long";
-};
-/** Sort options for 5v5 save percentage top-10 list */
-declare const SavePercentage5v5SortEnum: {
-    /**5v5 Save %: The percentage of shots a goalie stops at even strength (5-on-5). */
-    readonly '5v5-SV%': "save-pctg";
-    /**5v5 Save % in Close Situations: A “close situation” is the time during which a game is tied in the first or second period, or within one goal in the third period. This stats helps how goalies perform in high-pressure situations.*/
-    readonly '5v5-SV%-Close': "save-pctg-close";
-    /**5v5 Shots Against: The total number of shots a goalie faces at even strength (5-on-5).*/
-    readonly '5v5-SA': "shots";
-    /**5v5 Shots Against per 60 Minutes: The total number of shots a goalie faces at even strength (5-on-5) normalized to a 60-minute game. */
-    readonly '5v5-SA/60': "shots-per-60";
-};
-/** Sort options for save percentage top-10 list */
-declare const SavePercentageSortEnum: {
-    /** Starts above .900 */
-    readonly GAMES: "games";
-    /** Percentage of starts above .900 */
-    readonly PCTG: "pctg";
-};
-/** Filter options for player positions */
-declare const PositionFilterEnum: {
-    /** Center */
-    readonly ALL: "all";
-    /** Left Wing */
-    readonly FWD: "forwards";
-    /** Right Wing */
-    readonly DEF: "defense";
-};
-/** Categories for skater strength */
-declare const SkatersStrengthEnum: {
-    /** All strengths */
-    readonly ALL: "all";
-    /** Even strength */
-    readonly ES: "es";
-    /** Power play */
-    readonly PP: "pp";
-    /** Short-handed */
-    readonly PK: "pk";
-};
-/** Sorting options for shot speed top-10 list */
-declare const ShotSpeedSortEnum: {
-    /** Hardest shot recorded by player */
-    readonly MAX: "max";
-    /** Shots over 100 mph */
-    readonly 'OVER-100': "over-100";
-    /** Shots between 90 and 99 mph */
-    readonly '90-99': "90-99";
-    /** Shots between 80 and 89 mph */
-    readonly '80-89': "80-89";
-    /** Shots between 70 and 79 mph */
-    readonly '70-79': "70-79";
-};
-/** Sorting options for skating speed top-10 list */
-declare const SkatingSpeedSortEnum: {
-    /** Fastest skating speed recorded by player */
-    readonly TOP: "max";
-    /** Speed bursts recorded over 22 mph */
-    readonly 'OVER-22': "over-22";
-    /** Speed bursts recorded between 20 and 22 mph */
-    readonly '20-22': "20-22";
-    /** Speed bursts recorded between 18 and 20 mph */
-    readonly '18-20': "18-20";
-};
-/** Sorting options for skating distance top-10 list */
-declare const SkatingDistanceSortEnum: {
-    /** Total distance skated */
-    TOTAL: string;
-    /** Average distance skated per 60 minutes */
-    'PER-60': string;
-    /** Maximum distance skated in a single period */
-    'MAX-PERIOD': string;
-    /** Maximum distance skated in a single game */
-    'MAX-GAME': string;
-};
-/** Categories for shot location top-10 list */
-declare const ShotLocationCategoryEnum: {
-    /** Total shots on goal */
-    readonly SOG: "sog";
-    /** Total goals */
-    readonly G: "goals";
-    /** Shooting percentage */
-    readonly 'SH%': "shooting-pctg";
-};
-/** Sorting options for zone time top-10 lists. */
-declare const ZoneTimeSortEnum: {
-    /** Percentage of time spent in the offensive zone */
-    readonly OZ: "offensive";
-    /** Percentage of time spent in the defensive zone */
-    readonly DZ: "defensive";
-    /** Percentage of time spent in the neutral zone */
-    readonly NZ: "neutral";
-};
+/**
+ * Common types used in Gamecenter API responses
+ */
+/** The current state of the game. */
+type GameState$2 = 'OFF' | 'FUT' | 'LIVE' | 'PRE' | 'CRIT' | 'FINAL';
+/** The current state of the game. */
+type GameScheduleState = 'OK' | 'TBD' | 'CNCL' | (string & {});
+/** The type of period in the game. */
+type PeriodType = 'REG' | 'OT' | 'SO';
+/** Abbreviated day of the week. (MON = Monday, TUE = Tuesday ...) */
+type DayAbbrev = 'MON' | 'TUE' | 'WED' | 'THU' | 'FRI' | 'SAT' | 'SUN';
+/** The type of penalty. (MIN = Minor, BEN = Bench, MAJ = Major ...) */
+type PenaltyTypeCode = 'MIN' | 'BEN' | 'MAJ' | (string & {});
+/** The market for this broadcast. (H = Home, A = Away, N = National, S = Satellite Radio) */
+type Market = 'H' | 'A' | 'N' | 'S';
+/** The country code for this broadcast. (CA = Canada, US = United States) */
+type CountryCode$2 = 'CA' | 'US';
+/** The position code for a player. (C = Center, L[W] = Left Wing, R[W] = Right Wing, D = Defenseman, G = Goalie) */
+type PositionCode = 'C' | 'LW' | 'L' | 'RW' | 'R' | 'D' | 'G';
+/** Player's shooting/catching handedness. (L = Left, R = Right) */
+type ShootsCatches = 'L' | 'R';
+type HexColorCode = `#${string}`;
+type UTCOffset = `+${number}:${number}` | `-${number}:${number}`;
+type GoalModifier = 'none' | 'empty-net' | 'awarded-empty-net';
+type DefendingSide = 'left' | 'right';
+type Strength = 'ev' | 'pp' | 'sh';
+type ZoneCode = 'N' | 'D' | 'O';
+type ShotType = 'backhand' | 'bat' | 'between-legs' | 'deflected' | 'poke' | 'slap' | 'snap' | 'tip-in' | 'wrap-around' | 'wrist' | (string & {});
+type PenaltyDescKey = 'tripping' | 'hooking' | 'interference' | 'high-sticking' | 'roughing' | 'unsportsmanlike-conduct' | 'slashing' | 'delaying-game-puck-over-glass' | 'holding' | 'holding-the-stick' | 'too-many-men-on-the-ice' | 'fighting' | 'minor' | 'cross-checking' | (string & {});
+type Reason = 'blocked' | 'failed-bank-attempt' | 'wide-right' | 'goalie-stopped-after-sog' | 'offside' | 'teammate-blocked' | 'icing' | 'puck-in-netting' | 'wide-left' | 'high-and-wide-left' | 'puck-frozen' | 'above-crossbar' | 'tv-timeout' | 'hand-pass' | 'skater-puck-frozen' | 'high-stick' | 'high-and-wide-right' | 'hit-crossbar' | 'puck-in-benches' | 'hit-right-post' | 'short' | 'referee-or-linesman' | 'puck-in-crowd' | 'hit-left-post' | 'player-equipment' | 'net-dislodged-defensive-skater' | 'home-timeout' | 'chlg-hm-goal-interference' | 'video-review' | 'chlg-league-missed-stoppage' | 'visitor-timeout' | 'official-injury' | (string & {});
+type EventTypeDescKey = 'period-start' | 'faceoff' | 'blocked-shot' | 'goal' | 'hit' | 'giveaway' | 'missed-shot' | 'shot-on-goal' | 'stoppage' | 'takeaway' | 'penalty' | 'period-end' | 'delayed-penalty' | 'game-end' | (string & {});
+/** An object containing a default string an optional localized strings. */
+interface LocalizedText {
+    /** Default */
+    default: string;
+    /** French */
+    fr?: string;
+    /** Czech */
+    cs?: string;
+    /** German */
+    de?: string;
+    /** Spanish */
+    es?: string;
+    /** Finnish */
+    fi?: string;
+    /** Slovak */
+    sk?: string;
+    /** Swedish */
+    sv?: string;
+}
+interface TvBroadcast {
+    id: number;
+    market: Market;
+    countryCode: CountryCode$2;
+    network: string;
+    sequenceNumber: number;
+}
+
+/**
+ * Response types for the NHL Edge advanced stats endpoints
+ * (api-web.nhle.com/v1/edge/*), exposed as the `adv` namespace.
+ *
+ * Generated from live responses for two seasons (regular season and
+ * playoffs) and kept in step by the API drift check.
+ */
+
+/** A measurement in both unit systems (mph/km/h, feet/metres or miles/km) */
+interface EdgeMeasurement {
+    imperial: number;
+    metric: number;
+}
+/** A season with Edge data and the game types it covers */
+interface EdgeSeason {
+    id: number;
+    gameTypes: number[];
+}
+/** The game a stat was recorded in, shown as an overlay on nhl.com/edge */
+interface EdgeOverlay {
+    player?: {
+        firstName: LocalizedText;
+        lastName: LocalizedText;
+    };
+    gameDate: string;
+    awayTeam: {
+        abbrev: string;
+        score: number;
+    };
+    homeTeam: {
+        abbrev: string;
+        score: number;
+    };
+    gameOutcome: {
+        lastPeriodType: string;
+        otPeriods?: number;
+    };
+    periodDescriptor: EdgePeriodDescriptor;
+    timeInPeriod?: string;
+    gameType: number;
+}
+/** Period of a game event */
+interface EdgePeriodDescriptor {
+    maxRegulationPeriods: number;
+    number: number;
+    periodType: string;
+}
+/** Team logo URLs for light and dark backgrounds */
+interface EdgeTeamLogos {
+    light: string;
+    dark: string;
+}
+/**
+ * A team as Edge responses nest it. Detail and landing endpoints add
+ * the optional fields; game rows carry only names, abbrev and logos.
+ */
+interface EdgeTeam {
+    commonName: LocalizedText;
+    placeNameWithPreposition: LocalizedText;
+    abbrev?: string;
+    teamLogo: EdgeTeamLogos;
+    id?: number;
+    slug?: string;
+    conference?: string;
+    division?: string;
+    wins?: number;
+    losses?: number;
+    otLosses?: number;
+    gamesPlayed?: number;
+    points?: number;
+}
+/**
+ * A player as Edge responses nest it. Detail endpoints add season totals
+ * (skater or goalie); top-10 rows carry only names, slug and team.
+ */
+interface EdgePlayer {
+    birthDate?: string;
+    id?: number;
+    firstName: LocalizedText;
+    lastName: LocalizedText;
+    sweaterNumber?: number;
+    position?: string;
+    slug: string;
+    headshot?: string;
+    shootsCatches?: string;
+    team?: EdgeTeam;
+    goals?: number;
+    assists?: number;
+    points?: number;
+    gamesPlayed?: number;
+    wins?: number;
+    losses?: number;
+    overtimeLosses?: number;
+    goalsAgainstAvg?: number;
+    savePctg?: number;
+}
+/** Response of `adv.byTheNumbers` */
+interface EdgeByTheNumbers {
+    games: number;
+    gameDate: string;
+    hardestShotSkater: {
+        player: EdgePlayer;
+        overlay: EdgeOverlay;
+        shotSpeed: EdgeMeasurement;
+    };
+    maxSkatingSpeedSkater: {
+        player: EdgePlayer;
+        overlay: EdgeOverlay;
+        skatingSpeed: EdgeMeasurement;
+    };
+    totalDistanceSkatedSkater: {
+        player: EdgePlayer;
+        distanceSkated: {
+            imperial: number;
+            metric: number;
+            overlay: EdgeOverlay;
+        };
+    };
+    totalDistanceSkatedTeam: {
+        team: EdgeTeam;
+        game: {
+            gameCenterLink: string;
+            gameDate: string;
+            isHomeTeam: boolean;
+            homeTeam: EdgeTeam;
+            awayTeam: EdgeTeam;
+            distanceSkated: EdgeMeasurement;
+        };
+        topFiveSkaters: {
+            gameCenterLink: string;
+            gameDate: string;
+            playerOnHomeTeam: boolean;
+            distanceSkated: EdgeMeasurement;
+            toi: number;
+            homeTeam: {
+                id: number;
+                commonName: LocalizedText;
+                placeNameWithPreposition: LocalizedText;
+                abbrev: string;
+                slug: string;
+                teamLogo: EdgeTeamLogos;
+                conference: string;
+                division: string;
+            };
+            awayTeam: {
+                id: number;
+                commonName: LocalizedText;
+                placeNameWithPreposition: LocalizedText;
+                abbrev: string;
+                slug: string;
+                teamLogo: EdgeTeamLogos;
+                conference: string;
+                division: string;
+            };
+            player: {
+                name: LocalizedText;
+            };
+        }[];
+    };
+    totalDistanceSkatedLeague: {
+        distanceSkated: EdgeMeasurement;
+        topFiveSkaters: {
+            gameCenterLink: string;
+            gameDate: string;
+            playerOnHomeTeam: boolean;
+            distanceSkated: EdgeMeasurement;
+            toi: number;
+            homeTeam: {
+                id: number;
+                commonName: LocalizedText;
+                placeNameWithPreposition: LocalizedText;
+                abbrev: string;
+                slug: string;
+                teamLogo: EdgeTeamLogos;
+                conference: string;
+                division: string;
+            };
+            awayTeam: {
+                id: number;
+                commonName: LocalizedText;
+                placeNameWithPreposition: LocalizedText;
+                abbrev: string;
+                slug: string;
+                teamLogo: EdgeTeamLogos;
+                conference: string;
+                division: string;
+            };
+            player: {
+                name: LocalizedText;
+            };
+        }[];
+    };
+    sogTeam: {
+        team: EdgeTeam;
+        shots: number;
+        sogDetails: {
+            area: string;
+            shots: number;
+        }[];
+    };
+}
+/** Response of `adv.skaters.detail` */
+interface EdgeSkaterDetail {
+    player: EdgePlayer;
+    seasonsWithEdgeStats: EdgeSeason[];
+    topShotSpeed: {
+        imperial: number;
+        metric: number;
+        percentile: number;
+        leagueAvg: EdgeMeasurement;
+        overlay: EdgeOverlay;
+    };
+    skatingSpeed: {
+        speedMax: {
+            imperial: number;
+            metric: number;
+            percentile: number;
+            leagueAvg: EdgeMeasurement;
+            overlay: EdgeOverlay;
+        };
+        burstsOver20: {
+            value: number;
+            percentile: number;
+            leagueAvg: {
+                value: number;
+            };
+        };
+    };
+    totalDistanceSkated: {
+        imperial: number;
+        metric: number;
+        percentile: number;
+        leagueAvg: EdgeMeasurement;
+    };
+    distanceMaxGame: {
+        imperial: number;
+        metric: number;
+        percentile: number;
+        leagueAvg: EdgeMeasurement;
+        overlay: EdgeOverlay;
+    };
+    sogSummary: {
+        locationCode: string;
+        shots: number;
+        shotsPercentile: number;
+        shotsLeagueAvg: number;
+        goals: number;
+        goalsPercentile: number;
+        goalsLeagueAvg: number;
+        shootingPctg: number;
+        shootingPctgPercentile: number;
+        shootingPctgLeagueAvg: number;
+    }[];
+    sogDetails: {
+        area: string;
+        shots: number;
+        shotsPercentile: number;
+    }[];
+    zoneTimeDetails: {
+        offensiveZonePctg: number;
+        offensiveZonePercentile: number;
+        offensiveZoneLeagueAvg: number;
+        offensiveZoneEvPctg: number;
+        offensiveZoneEvPercentile: number;
+        offensiveZoneEvLeagueAvg: number;
+        neutralZonePctg: number;
+        neutralZonePercentile: number;
+        neutralZoneLeagueAvg: number;
+        defensiveZonePctg: number;
+        defensiveZonePercentile: number;
+        defensiveZoneLeagueAvg: number;
+    };
+}
+/** Response of `adv.skaters.comparison` */
+interface EdgeSkaterComparison {
+    player: EdgePlayer;
+    seasonsWithEdgeStats: EdgeSeason[];
+    shotSpeedDetails: {
+        topShotSpeed: {
+            imperial: number;
+            metric: number;
+            overlay: EdgeOverlay;
+        };
+        avgShotSpeed: EdgeMeasurement;
+        shotAttemptsOver100: number;
+        shotAttempts90To100: number;
+        shotAttempts80To90: number;
+        shotAttempts70To80: number;
+    };
+    skatingSpeedDetails: {
+        maxSkatingSpeed: {
+            imperial: number;
+            metric: number;
+            overlay: EdgeOverlay;
+        };
+        burstsOver22: number;
+        bursts20To22: number;
+        bursts18To20: number;
+    };
+    skatingDistanceLast10: {
+        gameCenterLink: string;
+        gameDate: string;
+        playerOnHomeTeam: boolean;
+        distanceSkated: EdgeMeasurement;
+        toi: number;
+        homeTeam: EdgeTeam;
+        awayTeam: EdgeTeam;
+    }[];
+    skatingDistanceDetails: {
+        distanceTotal: EdgeMeasurement;
+        distancePer60: EdgeMeasurement;
+        distanceMaxGame: {
+            imperial: number;
+            metric: number;
+            overlay: EdgeOverlay;
+        };
+        distanceMaxPeriod: {
+            imperial: number;
+            metric: number;
+            overlay: EdgeOverlay;
+        };
+    };
+    shotLocationDetails: {
+        area: string;
+        sog: number;
+        goals: number;
+        shootingPctg: number;
+    }[];
+    shotLocationTotals: {
+        locationCode: string;
+        sog: number;
+        goals: number;
+        shootingPctg: number;
+    }[];
+    zoneTimeDetails: {
+        offensiveZonePctg: number;
+        offensiveZoneLeagueAvg: number;
+        neutralZonePctg: number;
+        neutralZoneLeagueAvg: number;
+        defensiveZonePctg: number;
+        defensiveZoneLeagueAvg: number;
+    };
+    zoneStarts: {
+        offensiveZoneStarts: number;
+        neutralZoneStarts: number;
+        defensiveZoneStarts: number;
+    };
+}
+/** Response of `adv.skaters.leaders` */
+interface EdgeSkaterLanding {
+    seasonsWithEdgeStats: EdgeSeason[];
+    leaders: {
+        hardestShot: {
+            player: EdgePlayer;
+            overlay: EdgeOverlay;
+            shotSpeed: EdgeMeasurement;
+        };
+        maxSkatingSpeed: {
+            player: EdgePlayer;
+            overlay: EdgeOverlay;
+            skatingSpeed: EdgeMeasurement;
+        };
+        totalDistanceSkated: {
+            player: EdgePlayer;
+            distanceSkated: EdgeMeasurement;
+        };
+        distanceMaxGame: {
+            player: EdgePlayer;
+            distanceSkated: EdgeMeasurement;
+            overlay: EdgeOverlay;
+        };
+        highDangerSOG: {
+            player: EdgePlayer;
+            sog: number;
+            shotLocationDetails: {
+                area: string;
+                sog: number;
+                sogPercentile: number;
+            }[];
+        };
+        offensiveZoneTime: {
+            player: EdgePlayer;
+            zoneTime: number;
+        };
+        defensiveZoneTime: {
+            player: EdgePlayer;
+            zoneTime: number;
+        };
+    };
+}
+/** Response of `adv.skaters.shotLocation` */
+interface EdgeSkaterShotLocation {
+    shotLocationDetails: {
+        area: string;
+        sog: number;
+        goals: number;
+        shootingPctg: number | null;
+        sogPercentile: number;
+        goalsPercentile: number;
+        shootingPctgPercentile: number | null;
+    }[];
+    shotLocationTotals: {
+        locationCode: string;
+        sog: number;
+        goals: number;
+        shootingPctg: number;
+        sogPercentile: number;
+        goalsPercentile: number;
+        shootingPctgPercentile: number;
+        sogLeagueAvg: number;
+        goalsLeagueAvg: number;
+        shootingPctgLeagueAvg: number;
+    }[];
+}
+/** Response of `adv.skaters.shotSpeed` */
+interface EdgeSkaterShotSpeed {
+    hardestShots: {
+        gameCenterLink: string;
+        gameDate: string;
+        gameType: number;
+        playerOnHomeTeam: boolean;
+        shotSpeed: EdgeMeasurement;
+        timeInPeriod: string;
+        periodDescriptor: EdgePeriodDescriptor;
+        homeTeam: EdgeTeam;
+        awayTeam: EdgeTeam;
+    }[];
+    shotSpeedDetails: {
+        topShotSpeed: {
+            imperial: number;
+            metric: number;
+            percentile: number;
+            leagueAvg: EdgeMeasurement;
+            overlay: EdgeOverlay;
+        };
+        avgShotSpeed: {
+            imperial: number;
+            metric: number;
+            percentile: number;
+            leagueAvg: EdgeMeasurement;
+        };
+        shotAttemptsOver100: {
+            value: number;
+            percentile: number;
+            leagueAvg: number;
+        };
+        shotAttempts90To100: {
+            value: number;
+            percentile: number;
+            leagueAvg: number;
+        };
+        shotAttempts80To90: {
+            value: number;
+            percentile: number;
+            leagueAvg: number;
+        };
+        shotAttempts70To80: {
+            value: number;
+            percentile: number;
+            leagueAvg: number;
+        };
+    };
+}
+/** Response of `adv.skaters.skatingDistance` */
+interface EdgeSkaterSkatingDistance {
+    skatingDistanceLast10: {
+        gameCenterLink: string;
+        gameDate: string;
+        playerOnHomeTeam: boolean;
+        distanceSkatedAll: EdgeMeasurement;
+        toiAll: number;
+        distanceSkatedEven: EdgeMeasurement;
+        toiEven: number;
+        distanceSkatedPP: EdgeMeasurement;
+        toiPP: number;
+        homeTeam: EdgeTeam;
+        awayTeam: EdgeTeam;
+        distanceSkatedPK?: EdgeMeasurement;
+        toiPK?: number;
+    }[];
+    skatingDistanceDetails: {
+        strengthCode: string;
+        distanceTotal: {
+            imperial: number;
+            metric: number;
+            percentile: number;
+            leagueAvg: EdgeMeasurement;
+        };
+        distancePer60: {
+            imperial: number;
+            metric: number;
+            percentile: number;
+            leagueAvg: EdgeMeasurement;
+        };
+        distanceMaxGame: {
+            imperial: number;
+            metric: number;
+            percentile: number;
+            leagueAvg: EdgeMeasurement;
+            overlay: EdgeOverlay;
+        };
+        distanceMaxPeriod: {
+            imperial: number;
+            metric: number;
+            percentile: number;
+            leagueAvg: EdgeMeasurement;
+            overlay: EdgeOverlay;
+        };
+    }[];
+}
+/** Response of `adv.skaters.skatingSpeed` */
+interface EdgeSkaterSkatingSpeed {
+    topSkatingSpeeds: {
+        gameCenterLink: string;
+        gameDate: string;
+        gameType: number;
+        playerOnHomeTeam: boolean;
+        skatingSpeed: EdgeMeasurement;
+        timeInPeriod: string;
+        periodDescriptor: EdgePeriodDescriptor;
+        homeTeam: EdgeTeam;
+        awayTeam: EdgeTeam;
+    }[];
+    skatingSpeedDetails: {
+        maxSkatingSpeed: {
+            imperial: number;
+            metric: number;
+            percentile: number;
+            leagueAvg: EdgeMeasurement;
+            overlay: EdgeOverlay;
+        };
+        burstsOver22: {
+            value: number;
+            percentile: number;
+            leagueAvg: number;
+        };
+        bursts20To22: {
+            value: number;
+            percentile: number;
+            leagueAvg: number;
+        };
+        bursts18To20: {
+            value: number;
+            percentile: number;
+            leagueAvg: number;
+        };
+    };
+}
+/** Response of `adv.skaters.zoneTime` */
+interface EdgeSkaterZoneTime {
+    zoneTimeDetails: {
+        strengthCode: string;
+        offensiveZonePctg: number;
+        offensiveZonePercentile: number;
+        offensiveZoneLeagueAvg: number;
+        neutralZonePctg: number;
+        neutralZonePercentile: number;
+        neutralZoneLeagueAvg: number;
+        defensiveZonePctg: number;
+        defensiveZonePercentile: number;
+        defensiveZoneLeagueAvg: number;
+    }[];
+    zoneStarts: {
+        offensiveZoneStartsPctg: number;
+        offensiveZoneStartsPctgPercentile: number;
+        neutralZoneStartsPctg: number;
+        neutralZoneStartsPctgPercentile: number;
+        defensiveZoneStartsPctg: number;
+        defensiveZoneStartsPctgPercentile: number;
+    };
+}
+/** One row of `adv.skaters.top10.distance` */
+interface EdgeSkaterDistanceTop10Entry {
+    player: EdgePlayer;
+    distanceTotal: EdgeMeasurement;
+    distancePer60: EdgeMeasurement;
+    distanceMaxPerGame: {
+        imperial: number;
+        metric: number;
+        overlay: EdgeOverlay;
+    };
+    distanceMaxPerPeriod: {
+        imperial: number;
+        metric: number;
+        overlay: EdgeOverlay;
+    };
+}
+/** Response of `adv.skaters.top10.distance` */
+type EdgeSkaterDistanceTop10 = EdgeSkaterDistanceTop10Entry[];
+/** One row of `adv.skaters.top10.shotLocation` */
+interface EdgeSkaterShotLocationTop10Entry {
+    player: EdgePlayer;
+    all: number;
+    highDanger: number;
+    midRange: number;
+    longRange: number;
+}
+/** Response of `adv.skaters.top10.shotLocation` */
+type EdgeSkaterShotLocationTop10 = EdgeSkaterShotLocationTop10Entry[];
+/** One row of `adv.skaters.top10.shotSpeed` */
+interface EdgeSkaterShotSpeedTop10Entry {
+    player: EdgePlayer;
+    hardestShot: {
+        imperial: number;
+        metric: number;
+        overlay: EdgeOverlay;
+    };
+    shotAttemptsOver100: number;
+    shotAttempts90To100: number;
+    shotAttempts80To90: number;
+    shotAttempts70To80: number;
+}
+/** Response of `adv.skaters.top10.shotSpeed` */
+type EdgeSkaterShotSpeedTop10 = EdgeSkaterShotSpeedTop10Entry[];
+/** One row of `adv.skaters.top10.speed` */
+interface EdgeSkaterSpeedTop10Entry {
+    player: EdgePlayer;
+    maxSpeed: {
+        imperial: number;
+        metric: number;
+        overlay: EdgeOverlay;
+    };
+    burstsOver22: number;
+    bursts20To22: number;
+    bursts18To20: number;
+}
+/** Response of `adv.skaters.top10.speed` */
+type EdgeSkaterSpeedTop10 = EdgeSkaterSpeedTop10Entry[];
+/** One row of `adv.skaters.top10.zoneTime` */
+interface EdgeSkaterZoneTimeTop10Entry {
+    player: EdgePlayer;
+    offensiveZoneTime: number;
+    neutralZoneTime: number;
+    defensiveZoneTime: number;
+}
+/** Response of `adv.skaters.top10.zoneTime` */
+type EdgeSkaterZoneTimeTop10 = EdgeSkaterZoneTimeTop10Entry[];
+/** Response of `adv.goalies.player` */
+interface EdgeGoalieDetail {
+    player: EdgePlayer;
+    seasonsWithEdgeStats: EdgeSeason[];
+    stats: {
+        goalsAgainstAvg: {
+            value: number;
+            percentile: number;
+            leagueAvg: number;
+        };
+        gamesAbove900: {
+            value: number;
+            percentile: number;
+            leagueAvg: number;
+        };
+        goalDifferentialPer60: {
+            value: number;
+            percentile: number;
+            leagueAvg: number;
+        };
+        goalSupportAvg: {
+            value: number;
+            percentile: number;
+            leagueAvg: number;
+        };
+        pointPctg: {
+            value: number;
+            percentile: number;
+            leagueAvg: number;
+        };
+    };
+    shotLocationSummary: {
+        locationCode: string;
+        goalsAgainst: number;
+        goalsAgainstPercentile: number;
+        goalsAgainstLeagueAvg: number;
+        saves: number;
+        savesPercentile: number;
+        savesLeagueAvg: number;
+        savePctg: number;
+        savePctgPercentile: number;
+        savePctgLeagueAvg: number;
+    }[];
+    shotLocationDetails: {
+        area: string;
+        saves: number;
+        savesPercentile: number;
+        savePctg: number;
+        savePctgPercentile: number;
+    }[];
+}
+/** Response of `adv.goalies.compare` */
+interface EdgeGoalieComparison {
+    player: EdgePlayer;
+    seasonsWithEdgeStats: EdgeSeason[];
+    shotLocationSummary: {
+        locationCode: string;
+        shotsAgainst: number;
+        goalsAgainst: number;
+        saves: number;
+        savePctg: number;
+    }[];
+    shotLocationDetails: {
+        area: string;
+        goalsAgainst: number;
+        shotsAgainst: number;
+        saves: number;
+        savePctg: number;
+    }[];
+    savePctg5v5Last10: unknown[];
+    savePctg5v5Details: {
+        savePctg: number;
+        savePctgClose: number;
+        shots: number;
+        shotsPer60: number;
+    };
+    savePctgLast10: unknown[];
+    savePctgDetails: {
+        gamesAbove900: number;
+        pctgGamesAbove900: number;
+        pointPctg: number;
+        goalsAgainstAvg: number;
+        savePctg: number;
+    };
+}
+/** Response of `adv.goalies.leaders` */
+interface EdgeGoalieLanding {
+    seasonsWithEdgeStats: EdgeSeason[];
+    minimumGamesPlayed?: number;
+    leaders: {
+        highDangerSavePctg: {
+            player: EdgePlayer;
+            savePctg: number;
+            shotLocationDetails: {
+                area: string;
+                savePctg: number;
+                savePctgPercentile: number;
+            }[];
+        };
+        highDangerSaves: {
+            player: EdgePlayer;
+            saves: number;
+            shotLocationDetails: {
+                area: string;
+                saves: number;
+                savesPercentile: number;
+            }[];
+        };
+        highDangerGoalsAgainst: {
+            player: EdgePlayer;
+            goalsAgainst: number;
+        };
+        savePctg5v5: {
+            player: EdgePlayer;
+            savePctg: number;
+        };
+        gamesAbove900: {
+            player: EdgePlayer;
+            games: number;
+        };
+    };
+    minimumMinutesPlayed?: number;
+}
+/** Response of `adv.goalies.savePercentage` */
+interface EdgeGoalieSavePercentage {
+    savePctgLast10: {
+        gameCenterLink: string;
+        savePctg: number;
+        gameDate: string;
+        decision: string;
+        playerOnHomeTeam: boolean;
+        homeTeam: EdgeTeam;
+        awayTeam: EdgeTeam;
+    }[];
+    savePctgDetails: {
+        gamesAbove900: {
+            value: number;
+            percentile: number;
+            leagueAvg: number;
+        };
+        pctgGamesAbove900: {
+            value: number;
+            percentile: number;
+            leagueAvg: number;
+        };
+    };
+}
+/** Response of `adv.goalies.savePercentage5v5` */
+interface EdgeGoalieSavePercentage5v5 {
+    savePctg5v5Last10: unknown[];
+    savePctg5v5Details: {
+        savePctg: {
+            value: number;
+            leagueAvg: number;
+            percentile: number;
+        };
+        savePctgClose: {
+            value: number;
+            leagueAvg: number;
+            percentile: number;
+        };
+        shots: {
+            value: number;
+            leagueAvg: number;
+            percentile: number;
+        };
+        shotsPer60: {
+            value: number;
+            leagueAvg: number;
+            percentile: number;
+        };
+    };
+}
+/** Response of `adv.goalies.saveLocation` */
+interface EdgeGoalieShotLocation {
+    shotLocationDetails: {
+        area: string;
+        shotsAgainst: number;
+        saves: number;
+        goalsAgainst: number;
+        savePctg: number;
+        shotsAgainstPercentile: number;
+        savesPercentile: number;
+        goalsAgainstPercentile: number;
+        savePctgPercentile: number;
+    }[];
+    shotLocationTotals: {
+        locationCode: string;
+        shotsAgainst: number;
+        goalsAgainst: number;
+        saves: number;
+        savePctg: number;
+        shotsAgainstPercentile: number;
+        goalsAgainstPercentile: number;
+        savesPercentile: number;
+        savePctgPercentile: number;
+        shotsAgainstLeagueAvg: number;
+        goalsAgainstLeagueAvg: number;
+        savesLeagueAvg: number;
+        savePctgLeagueAvg: number;
+    }[];
+}
+/** One row of `adv.goalies.top10.savePercentage` */
+interface EdgeGoalieSavePercentageTop10Entry {
+    player: EdgePlayer;
+    gamesOver900: number;
+    pctgGamesOver900: number;
+}
+/** Response of `adv.goalies.top10.savePercentage` */
+type EdgeGoalieSavePercentageTop10 = EdgeGoalieSavePercentageTop10Entry[];
+/** One row of `adv.goalies.top10.savePercentage5v5` */
+interface EdgeGoalieSavePercentage5v5Top10Entry {
+    player: EdgePlayer;
+    savePctg: number;
+    savePctgClose: number;
+    shots: number;
+    shotsPer60: number;
+}
+/** Response of `adv.goalies.top10.savePercentage5v5` */
+type EdgeGoalieSavePercentage5v5Top10 = EdgeGoalieSavePercentage5v5Top10Entry[];
+/** One row of `adv.goalies.top10.saveLocation` */
+interface EdgeGoalieShotLocationTop10Entry {
+    player: EdgePlayer;
+    all: number;
+    highDanger: number;
+    midRange: number;
+    longRange: number;
+}
+/** Response of `adv.goalies.top10.saveLocation` */
+type EdgeGoalieShotLocationTop10 = EdgeGoalieShotLocationTop10Entry[];
+/** Response of `adv.teams.stats` */
+interface EdgeTeamDetail {
+    team: EdgeTeam;
+    seasonsWithEdgeStats: EdgeSeason[];
+    shotSpeed: {
+        shotAttemptsOver90: {
+            value: number;
+            rank: number;
+        };
+        topShotSpeed: {
+            imperial: number;
+            metric: number;
+            rank: number;
+            leagueAvg: EdgeMeasurement;
+            overlay: EdgeOverlay;
+        };
+    };
+    skatingSpeed: {
+        burstsOver22: {
+            value: number;
+            rank: number;
+        };
+        burstsOver20: {
+            value: number;
+            rank: number;
+            leagueAvg: {
+                value: number;
+            };
+        };
+        speedMax: {
+            imperial: number;
+            metric: number;
+            rank: number;
+            leagueAvg: EdgeMeasurement;
+            overlay: EdgeOverlay;
+        };
+    };
+    distanceSkated: {
+        total: {
+            imperial: number;
+            metric: number;
+            rank: number;
+            leagueAvg: EdgeMeasurement;
+        };
+    };
+    sogSummary: {
+        locationCode: string;
+        shots: number;
+        shotsRank: number;
+        shotsLeagueAvg: number;
+        shootingPctg: number;
+        shootingPctgRank: number;
+        shootingPctgLeagueAvg: number;
+        goals: number;
+        goalsRank: number;
+        goalsLeagueAvg: number;
+    }[];
+    sogDetails: {
+        area: string;
+        shots: number;
+        shotsRank: number;
+    }[];
+    zoneTimeDetails: {
+        offensiveZonePctg: number;
+        offensiveZoneRank: number;
+        offensiveZoneLeagueAvg: number;
+        offensiveZoneEvPctg: number;
+        offensiveZoneEvRank: number;
+        offensiveZoneEvLeagueAvg: number;
+        neutralZonePctg: number;
+        neutralZoneRank: number;
+        neutralZoneLeagueAvg: number;
+        defensiveZonePctg: number;
+        defensiveZoneRank: number;
+        defensiveZoneLeagueAvg: number;
+    };
+}
+/** Response of `adv.teams.compare` */
+interface EdgeTeamComparison {
+    team: EdgeTeam;
+    seasonsWithEdgeStats: EdgeSeason[];
+    shotSpeedDetails: {
+        topShotSpeed: {
+            imperial: number;
+            metric: number;
+            overlay: EdgeOverlay;
+        };
+        avgShotSpeed: EdgeMeasurement;
+        shotAttemptsOver100: number;
+        shotAttempts90To100: number;
+        shotAttempts80To90: number;
+        shotAttempts70To80: number;
+    };
+    skatingSpeedDetails: {
+        maxSkatingSpeed: {
+            imperial: number;
+            metric: number;
+            overlay: EdgeOverlay;
+        };
+        burstsOver22: number;
+        bursts20To22: number;
+        bursts18To20: number;
+    };
+    skatingDistanceLast10: {
+        gameCenterLink: string;
+        gameDate: string;
+        isHomeTeam: boolean;
+        distanceSkated: EdgeMeasurement;
+        homeTeam: EdgeTeam;
+        awayTeam: EdgeTeam;
+    }[];
+    skatingDistanceDetails: {
+        distanceTotal: EdgeMeasurement;
+        distancePer60: EdgeMeasurement;
+        distanceMaxGame: {
+            imperial: number;
+            metric: number;
+            overlay: EdgeOverlay;
+        };
+        distanceMaxPeriod: {
+            imperial: number;
+            metric: number;
+            overlay: EdgeOverlay;
+        };
+    };
+    shotLocationDetails: {
+        area: string;
+        sog: number;
+        goals: number;
+        shootingPctg: number;
+    }[];
+    shotLocationTotals: {
+        locationCode: string;
+        sog: number;
+        goals: number;
+        shootingPctg: number;
+    }[];
+    zoneTimeDetails: {
+        offensiveZonePctg: number;
+        offensiveZoneLeagueAvg: number;
+        neutralZonePctg: number;
+        neutralZoneLeagueAvg: number;
+        defensiveZonePctg: number;
+        defensiveZoneLeagueAvg: number;
+    };
+    shotDifferential: {
+        shotAttemptDifferential: number;
+        sogDifferential: number;
+    };
+}
+/** Response of `adv.teams.leaders` */
+interface EdgeTeamLanding {
+    seasonsWithEdgeStats: EdgeSeason[];
+    leaders: {
+        shotAttemptsOver90: {
+            team: EdgeTeam;
+            attempts: number;
+        };
+        burstsOver22: {
+            team: EdgeTeam;
+            bursts: number;
+        };
+        distancePer60: {
+            team: EdgeTeam;
+            distanceSkated: EdgeMeasurement;
+        };
+        highDangerSOG: {
+            team: EdgeTeam;
+            sog: number;
+            shotLocationDetails: {
+                area: string;
+                sog: number;
+                rank: number;
+            }[];
+        };
+        offensiveZoneTime: {
+            team: EdgeTeam;
+            zoneTime: number;
+        };
+        neutralZoneTime: {
+            team: EdgeTeam;
+            zoneTime: number;
+        };
+        defensiveZoneTime: {
+            team: EdgeTeam;
+            zoneTime: number;
+        };
+    };
+}
+/** Response of `adv.teams.shotLocation` */
+interface EdgeTeamShotLocation {
+    shotLocationDetails: {
+        area: string;
+        sog: number;
+        sogRank: number;
+        goals: number;
+        goalsRank: number;
+        shootingPctg: number | null;
+        shootingPctgRank: number | null;
+    }[];
+    shotLocationTotals: {
+        locationCode: string;
+        position: string;
+        sog: number;
+        sogRank: number;
+        sogLeagueAvg: number;
+        goals: number;
+        goalsRank: number;
+        goalsLeagueAvg: number;
+        shootingPctg: number;
+        shootingPctgRank: number;
+        shootingPctgLeagueAvg: number;
+    }[];
+}
+/** Response of `adv.teams.shotSpeed` */
+interface EdgeTeamShotSpeed {
+    hardestShots: {
+        player: EdgePlayer;
+        gameCenterLink: string;
+        gameDate: string;
+        gameType: number;
+        isHomeTeam: boolean;
+        shotSpeed: EdgeMeasurement;
+        timeInPeriod: string;
+        periodDescriptor: EdgePeriodDescriptor;
+        homeTeam: EdgeTeam;
+        awayTeam: EdgeTeam;
+    }[];
+    shotSpeedDetails: {
+        position: string;
+        topShotSpeed: {
+            imperial: number;
+            metric: number;
+            rank: number;
+            leagueAvg: EdgeMeasurement;
+            overlay: EdgeOverlay;
+        };
+        avgShotSpeed: {
+            imperial: number;
+            metric: number;
+            rank: number;
+            leagueAvg: EdgeMeasurement;
+        };
+        shotAttemptsOver100: {
+            value: number;
+            rank: number;
+            leagueAvg: number;
+        };
+        shotAttempts90To100: {
+            value: number;
+            rank: number;
+            leagueAvg: number;
+        };
+        shotAttempts80To90: {
+            value: number;
+            leagueAvg: number;
+        };
+        shotAttempts70To80: {
+            value: number;
+            leagueAvg: number;
+        };
+    }[];
+}
+/** Response of `adv.teams.skatingDistance` */
+interface EdgeTeamSkatingDistance {
+    skatingDistanceLast10: {
+        gameCenterLink: string;
+        gameDate: string;
+        isHomeTeam: boolean;
+        toiAll: number;
+        distanceSkatedAll: EdgeMeasurement;
+        toiEven: number;
+        distanceSkatedEven: EdgeMeasurement;
+        toiPP?: number;
+        distanceSkatedPP?: EdgeMeasurement;
+        toiPK: number;
+        distanceSkatedPK: EdgeMeasurement;
+        homeTeam: EdgeTeam;
+        awayTeam: EdgeTeam;
+    }[];
+    skatingDistanceDetails: {
+        strengthCode: string;
+        positionCode: string;
+        distanceTotal: {
+            imperial: number;
+            metric: number;
+            rank: number;
+            leagueAvg: EdgeMeasurement;
+        };
+        distancePer60: {
+            imperial: number;
+            metric: number;
+            rank: number;
+            leagueAvg: EdgeMeasurement;
+        };
+        distanceMaxGame: {
+            imperial: number;
+            metric: number;
+            rank: number;
+            leagueAvg: EdgeMeasurement;
+            overlay: EdgeOverlay;
+        };
+        distanceMaxPeriod: {
+            imperial: number;
+            metric: number;
+            rank: number;
+            leagueAvg: EdgeMeasurement;
+            overlay: EdgeOverlay;
+        };
+    }[];
+}
+/** Response of `adv.teams.skatingSpeed` */
+interface EdgeTeamSkatingSpeed {
+    topSkatingSpeeds: {
+        player: EdgePlayer;
+        gameCenterLink: string;
+        gameDate: string;
+        gameType: number;
+        isHomeTeam: boolean;
+        skatingSpeed: EdgeMeasurement;
+        timeInPeriod: string;
+        periodDescriptor: EdgePeriodDescriptor;
+        homeTeam: EdgeTeam;
+        awayTeam: EdgeTeam;
+    }[];
+    skatingSpeedDetails: {
+        positionCode: string;
+        maxSkatingSpeed: {
+            imperial: number;
+            metric: number;
+            rank: number;
+            leagueAvg: EdgeMeasurement;
+            overlay: EdgeOverlay;
+        };
+        burstsOver22: {
+            value: number;
+            rank: number;
+            leagueAvg: number;
+        };
+        bursts20To22: {
+            value: number;
+            rank: number;
+            leagueAvg: number;
+        };
+        bursts18To20: {
+            value: number;
+            rank: number;
+            leagueAvg: number;
+        };
+    }[];
+}
+/** Response of `adv.teams.zoneTime` */
+interface EdgeTeamZoneTime {
+    zoneTimeDetails: {
+        strengthCode: string;
+        offensiveZonePctg: number;
+        offensiveZoneRank: number;
+        offensiveZoneLeagueAvg: number;
+        neutralZonePctg: number;
+        neutralZoneRank: number;
+        neutralZoneLeagueAvg: number;
+        defensiveZonePctg: number;
+        defensiveZoneRank: number;
+        defensiveZoneLeagueAvg: number;
+    }[];
+    shotDifferential: {
+        shotAttemptDifferential: number;
+        shotAttemptDifferentialRank: number;
+        sogDifferential: number;
+        sogDifferentialRank: number;
+    };
+}
+/** One row of `adv.teams.top10.shotLocation` */
+interface EdgeTeamShotLocationTop10Entry {
+    team: EdgeTeam;
+    all: number;
+    highDanger: number;
+    midRange: number;
+    longRange: number;
+}
+/** Response of `adv.teams.top10.shotLocation` */
+type EdgeTeamShotLocationTop10 = EdgeTeamShotLocationTop10Entry[];
+/** One row of `adv.teams.top10.shotSpeed` */
+interface EdgeTeamShotSpeedTop10Entry {
+    team: EdgeTeam;
+    hardestShot: {
+        imperial: number;
+        metric: number;
+        overlay: EdgeOverlay;
+    };
+    shotAttemptsOver100: number;
+    shotAttempts90To100: number;
+    shotAttempts80To90: number;
+    shotAttempts70To80: number;
+}
+/** Response of `adv.teams.top10.shotSpeed` */
+type EdgeTeamShotSpeedTop10 = EdgeTeamShotSpeedTop10Entry[];
+/** One row of `adv.teams.top10.skatingDistance` */
+interface EdgeTeamSkatingDistanceTop10Entry {
+    team: EdgeTeam;
+    distanceTotal: EdgeMeasurement;
+    distancePer60: EdgeMeasurement;
+    distanceMaxPerGame: {
+        imperial: number;
+        metric: number;
+        overlay: EdgeOverlay;
+    };
+    distanceMaxPerPeriod: {
+        imperial: number;
+        metric: number;
+        overlay: EdgeOverlay;
+    };
+}
+/** Response of `adv.teams.top10.skatingDistance` */
+type EdgeTeamSkatingDistanceTop10 = EdgeTeamSkatingDistanceTop10Entry[];
+/** One row of `adv.teams.top10.skatingSpeed` */
+interface EdgeTeamSkatingSpeedTop10Entry {
+    team: EdgeTeam;
+    maxSkatingSpeed: {
+        imperial: number;
+        metric: number;
+        overlay: EdgeOverlay;
+    };
+    burstsOver22: number;
+    bursts20To22: number;
+    bursts18To20: number;
+}
+/** Response of `adv.teams.top10.skatingSpeed` */
+type EdgeTeamSkatingSpeedTop10 = EdgeTeamSkatingSpeedTop10Entry[];
+/** One row of `adv.teams.top10.zoneTime` */
+interface EdgeTeamZoneTimeTop10Entry {
+    team: EdgeTeam;
+    offensiveZoneTime: number;
+    neutralZoneTime: number;
+    defensiveZoneTime: number;
+}
+/** Response of `adv.teams.top10.zoneTime` */
+type EdgeTeamZoneTimeTop10 = EdgeTeamZoneTimeTop10Entry[];
+
+/** Categories for save location top-10 list */
+declare const SaveLocationCategoryEnum: {
+    /** Save Percentage */
+    readonly 'SV%': "save-pctg";
+    /** Saves */
+    readonly SV: "saves";
+    /** Shots Against */
+    readonly SA: "shots-against";
+    /** Goals Against */
+    readonly GA: "goals-against";
+};
+/** Sort options for shot location top-10 list */
+declare const ShotLocationSortEnum: {
+    /** All shot locations */
+    readonly ALL: "all";
+    /** High-danger (i.e. close-range) shot locations */
+    readonly HIGH: "high";
+    /** Mid-range shot locations */
+    readonly MID: "mid";
+    /** Long-range shot locations */
+    readonly LONG: "long";
+};
+/** Alias for ShotLocationSortEnum */
+declare const SaveLocationSortEnum: {
+    /** All shot locations */
+    readonly ALL: "all";
+    /** High-danger (i.e. close-range) shot locations */
+    readonly HIGH: "high";
+    /** Mid-range shot locations */
+    readonly MID: "mid";
+    /** Long-range shot locations */
+    readonly LONG: "long";
+};
+/** Sort options for 5v5 save percentage top-10 list */
+declare const SavePercentage5v5SortEnum: {
+    /**5v5 Save %: The percentage of shots a goalie stops at even strength (5-on-5). */
+    readonly '5v5-SV%': "save-pctg";
+    /**5v5 Save % in Close Situations: A “close situation” is the time during which a game is tied in the first or second period, or within one goal in the third period. This stats helps how goalies perform in high-pressure situations.*/
+    readonly '5v5-SV%-Close': "save-pctg-close";
+    /**5v5 Shots Against: The total number of shots a goalie faces at even strength (5-on-5).*/
+    readonly '5v5-SA': "shots";
+    /**5v5 Shots Against per 60 Minutes: The total number of shots a goalie faces at even strength (5-on-5) normalized to a 60-minute game. */
+    readonly '5v5-SA/60': "shots-per-60";
+};
+/** Sort options for save percentage top-10 list */
+declare const SavePercentageSortEnum: {
+    /** Starts above .900 */
+    readonly GAMES: "games";
+    /** Percentage of starts above .900 */
+    readonly PCTG: "pctg";
+};
+/** Filter options for player positions */
+declare const PositionFilterEnum: {
+    /** Center */
+    readonly ALL: "all";
+    /** Left Wing */
+    readonly FWD: "forwards";
+    /** Right Wing */
+    readonly DEF: "defense";
+};
+/** Categories for skater strength */
+declare const SkatersStrengthEnum: {
+    /** All strengths */
+    readonly ALL: "all";
+    /** Even strength */
+    readonly ES: "es";
+    /** Power play */
+    readonly PP: "pp";
+    /** Short-handed */
+    readonly PK: "pk";
+};
+/** Sorting options for shot speed top-10 list */
+declare const ShotSpeedSortEnum: {
+    /** Hardest shot recorded by player */
+    readonly MAX: "max";
+    /** Shots over 100 mph */
+    readonly 'OVER-100': "over-100";
+    /** Shots between 90 and 99 mph */
+    readonly '90-99': "90-99";
+    /** Shots between 80 and 89 mph */
+    readonly '80-89': "80-89";
+    /** Shots between 70 and 79 mph */
+    readonly '70-79': "70-79";
+};
+/** Sorting options for skating speed top-10 list */
+declare const SkatingSpeedSortEnum: {
+    /** Fastest skating speed recorded by player */
+    readonly TOP: "max";
+    /** Speed bursts recorded over 22 mph */
+    readonly 'OVER-22': "over-22";
+    /** Speed bursts recorded between 20 and 22 mph */
+    readonly '20-22': "20-22";
+    /** Speed bursts recorded between 18 and 20 mph */
+    readonly '18-20': "18-20";
+};
+/** Sorting options for skating distance top-10 list */
+declare const SkatingDistanceSortEnum: {
+    /** Total distance skated */
+    TOTAL: string;
+    /** Average distance skated per 60 minutes */
+    'PER-60': string;
+    /** Maximum distance skated in a single period */
+    'MAX-PERIOD': string;
+    /** Maximum distance skated in a single game */
+    'MAX-GAME': string;
+};
+/** Categories for shot location top-10 list */
+declare const ShotLocationCategoryEnum: {
+    /** Total shots on goal */
+    readonly SOG: "sog";
+    /** Total goals */
+    readonly G: "goals";
+    /** Shooting percentage */
+    readonly 'SH%': "shooting-pctg";
+};
+/** Sorting options for zone time top-10 lists. */
+declare const ZoneTimeSortEnum: {
+    /** Percentage of time spent in the offensive zone */
+    readonly OZ: "offensive";
+    /** Percentage of time spent in the defensive zone */
+    readonly DZ: "defensive";
+    /** Percentage of time spent in the neutral zone */
+    readonly NZ: "neutral";
+};
+
+declare const Year$1: arktype.BaseType<number | ((In: string) => arktype_internal_attributes_ts.To<number>), {}>;
+declare const NHLMonth$1: arktype_internal_variants_object_ts.ObjectType<(In: string | Date) => Out<string>, {}>;
+declare const NHLDate$1: arktype_internal_variants_object_ts.ObjectType<(In: string | Date) => Out<string>, {}>;
+declare const Season$2: arktype_internal_variants_object_ts.ObjectType<(In: string | number) => Out<string>, {}>;
+declare const TeamAbbrev$1: arktype_internal_variants_string_ts.StringType<"MIN" | "ANA" | "BOS" | "BUF" | "CGY" | "CAR" | "CHI" | "COL" | "CBJ" | "DAL" | "DET" | "EDM" | "FLA" | "LAK" | "MTL" | "NJD" | "NSH" | "NYI" | "NYR" | "OTT" | "PHI" | "PIT" | "SJS" | "SEA" | "STL" | "TBL" | "TOR" | "UTA" | "VAN" | "VGK" | "WPG" | "WSH" | "AFM" | "ARI" | "ATL" | "BRK" | "CGS" | "CLE" | "CLR" | "DCG" | "DFL" | "HAM" | "HFD" | "KCS" | "MMR" | "MNS" | "MWN" | "NYA" | "OAK" | "PHX" | "PIR" | "QBD" | "QUA" | "QUE" | "SEN" | "SLE" | "TAN" | "TSP" | "WIN", {}>;
+declare const TeamId$1: arktype_internal_variants_number_ts.NumberType<1 | 2 | 3 | 4 | 10 | 8 | 7 | 24 | 6 | 20 | 12 | 16 | 21 | 29 | 25 | 17 | 22 | 13 | 26 | 30 | 18 | 9 | 5 | 28 | 55 | 19 | 14 | 59 | 23 | 54 | 52 | 15 | 47 | 53 | 11 | 51 | 56 | 49 | 35 | 40 | 50 | 37 | 34 | 48 | 43 | 31 | 41 | 44 | 46 | 27 | 38 | 42 | 39 | 32 | 36 | 45 | 57 | 58 | 33, {}>;
+declare const GameType$1: arktype.BaseType<1 | 2 | 3 | 4 | 19 | ((In: "PRE" | "REG" | "POST" | "ASG" | "INTL") => Out<1 | 2 | 3 | 4 | 19>), {}>;
+declare const GameNumber$1: arktype_internal_variants_object_ts.ObjectType<(In: string | number) => Out<string>, {}>;
+declare const DraftRound$1: arktype_internal_variants_object_ts.ObjectType<(In: string | number) => Out<string>, {}>;
+declare const EventId$1: arktype.BaseType<number | ((In: string) => arktype_internal_attributes_ts.To<number>), {}>;
+declare const GameId$1: arktype.BaseType<number | ((In: string) => arktype_internal_attributes_ts.To<number>), {}>;
+declare const SeriesLetter$2: arktype_internal_variants_string_ts.StringType<"H" | "A" | "N" | "C" | "L" | "D" | "G" | "O" | "B" | "E" | "F" | "I" | "J" | "K" | "M", {}>;
+declare const GameState$1: arktype_internal_variants_string_ts.StringType<"FUT" | "LIV" | "FIN", {}>;
+declare const CountryCode$1: arktype_internal_variants_object_ts.ObjectType<(In: string) => Out<string>, {}>;
+declare const PostalCode$1: arktype_internal_variants_object_ts.ObjectType<(In: string) => Out<string>, {}>;
+declare const PlayerId$1: arktype_internal_variants_object_ts.ObjectType<(In: string | number) => Out<string>, {}>;
+
+/**
+ * Represents a valid NHL year (e.g., 2023, 2024, ...)
+ */
+type Year = typeof Year$1.inferIn;
+/**
+ * Represents an NHL season in the format YYYYYYYY (e.g., 20232024)
+ */
+type Season$1 = typeof Season$2.inferIn;
+/**
+ * Represents a valid NHL game type (e.g. REG, PRE, POST)
+ */
+type GameType = typeof GameType$1.inferIn;
+/**
+ * Represents an NHL game ID with regex /\d{10}/
+ * Breakdown of the ID: (YYYYTTNNNN)
+ * - First 4 digits: Year of the game (YYYY)
+ * - Next 2 digits: Game type (TT)(01 for preseason, 02 for regular
+ * season, 03 for playoffs)
+ * - Next 4 digits: Game number of the season (NNNN)
+ */
+type GameId = typeof GameId$1.inferIn;
+/**
+ * Represents a valid NHL team abbreviation (e.g., NYR, MTL, ...)
+ */
+type TeamAbbrev = typeof TeamAbbrev$1.inferIn | (string & {});
+/**
+ * Represents a valid NHL team ID
+ */
+type TeamId = typeof TeamId$1.inferIn | (number & {});
+/**
+ * Represents a valid NHL game number
+ */
+type GameNumber = typeof GameNumber$1.inferIn;
+/**
+ * Represents a valid NHL game state
+ */
+type GameState = typeof GameState$1.inferIn;
+/**
+ * Represents a valid draft round (1-7)
+ */
+type DraftRound = typeof DraftRound$1.inferIn;
+/**
+ * Represents a valid NHL event ID
+ */
+type EventId = typeof EventId$1.inferIn;
+/**
+ * Represents a valid NHL date in the format YYYY-MM-DD
+ */
+type NHLDate = typeof NHLDate$1.inferIn;
+/**
+ * Represents a valid NHL month in the format YYYY-MM
+ */
+type NHLMonth = typeof NHLMonth$1.inferIn;
+/**
+ * Represents a valid NHL series letter (A-O)
+ */
+type SeriesLetter$1 = typeof SeriesLetter$2.inferIn;
+/**
+ * Represents the playoff rounds in an NHL season (1-4)
+ */
+type PlayoffRound = 1 | 2 | 3 | 4;
+/**
+ * Represents a valid country code (e.g., CAN, USA, SWE, ...)
+ */
+type CountryCode = typeof CountryCode$1.inferIn;
+/**
+ * Represents a valid country code (e.g., CAN, USA, SWE, ...)
+ */
+type PostalCode = typeof PostalCode$1.inferIn;
+/**
+ * Represents a valid NHL player ID
+ */
+type PlayerId = typeof PlayerId$1.inferIn;
+/**
+ * Type definitions for enums from constants.ts
+ */
+/** Categories for shot location top-10 list */
+type ShotLocationCategory = keyof typeof ShotLocationCategoryEnum;
+/** Sort options for shot location top-10 list */
+type ShotLocationSort = keyof typeof ShotLocationSortEnum;
+/** Sort options for 5v5 save percentage top-10 list */
+type SavePercentage5v5Sort = keyof typeof SavePercentage5v5SortEnum;
+/** Sort options for save percentage top-10 list */
+type SavePercentageSort = keyof typeof SavePercentageSortEnum;
+/** Categories for save location top-10 list */
+type SaveLocationCategory = keyof typeof SaveLocationCategoryEnum;
+/** Sort options for save location top-10 list */
+type SaveLocationSort = keyof typeof SaveLocationSortEnum;
+/** Positions filter for player stats */
+type PositionFilter = keyof typeof PositionFilterEnum;
+/** Strength situation for skater stats */
+type SkatersStrength = keyof typeof SkatersStrengthEnum;
+/** Sort options for shot speed top-10 list */
+type ShotSpeedSort = keyof typeof ShotSpeedSortEnum;
+/** Sort options for skating speed top-10 list */
+type SkatingSpeedSort = keyof typeof SkatingSpeedSortEnum;
+/** Sort options for skating distance top-10 list */
+type SkatingDistanceSort = keyof typeof SkatingDistanceSortEnum;
+/** Sort options for zone time top-10 lists. */
+type ZoneTimeSort = keyof typeof ZoneTimeSortEnum;
+
+/**
+ * ======================================================================
+ * API endpoints for goalie-related data.
+ * Base url: api-web.nhle.com/v1/edge
+ *
+ * Notes:
+ * - Convenience endpoints using 'now' for season have been
+ * excluded in favor of using calculated current season. You can optionally
+ * configure the switch over date for how current season is calculated.
+ * See README for details.
+ * - There is an extra endpoint that appears to duplicate
+ * the functionality of /skater-detail at `v1/cat/edge/skater-detail`
+ * As such, it has been excluded from this implementation.
+ * ======================================================================
+ */
+
+/**
+ * Goalie Edge Advanced Stats API helpers.
+ *
+ * Lightweight wrapper exposing functions that call the underlying nhlClient
+ * for goalie-related endpoints. Each function resolves to an APIResult; invalid
+ * parameters give a ValidationError result without a request.
+ */
+/**
+ * Get goalie detail for a player.
+ * @param playerId - The player's numeric id.
+ * @param season - Optional season (numeric season format or 'now' via argParse).
+ * @param gameType - Optional game type id.
+ * @returns Promise resolving to an APIResult with the response data.
+ */
+declare function player$1(playerId: PlayerId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeGoalieDetail>>;
+/**
+ * Get goalie comparison data for a player.
+ * @param playerId - The player's numeric id.
+ * @param season - Optional season (numeric season format or 'now' via argParse).
+ * @param gameType - Optional game type id.
+ * @returns Promise resolving to an APIResult with the response data.
+ */
+declare function compare$1(playerId: PlayerId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeGoalieComparison>>;
+/**
+ * Get goalie landing / leaders for a season.
+ * @param season - Optional season (numeric season format or 'now' via argParse).
+ * @param gameType - Optional game type id.
+ * @returns Promise resolving to an APIResult with the response data.
+ */
+declare function leaders$2(season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeGoalieLanding>>;
+/**
+ * Get 5v5 save percentage details for a goalie.
+ * @param playerId - The player's numeric id.
+ * @param season - Optional season (numeric season format or 'now' via argParse).
+ * @param gameType - Optional game type id.
+ * @returns Promise resolving to an APIResult with the response data.
+ */
+declare function savePercentage5v5(playerId: PlayerId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeGoalieSavePercentage5v5>>;
+/**
+ * Get save percentage details for a goalie.
+ * @param playerId - The player's numeric id.
+ * @param season - Optional season (numeric season format or 'now' via argParse).
+ * @param gameType - Optional game type id.
+ * @returns Promise resolving to an APIResult with the response data.
+ */
+declare function savePercentage(playerId: PlayerId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeGoalieSavePercentage>>;
+/**
+ * Get save location details for a goalie.
+ * @param playerId - The player's numeric id.
+ * @param season - Optional season (numeric season format or 'now' via argParse).
+ * @param gameType - Optional game type id.
+ * @returns Promise resolving to an APIResult with the response data.
+ */
+declare function saveLocation(playerId: PlayerId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeGoalieShotLocation>>;
+/**
+ * Accessor for top-10 leaderboards.
+ * @returns Object with methods to fetch various top-10 lists.
+ */
+declare const top10$2: {
+    savePercentage: typeof top10SavePercentage;
+    savePercentage5v5: typeof top10SavePercentage5v5;
+    saveLocation: typeof top10SaveLocation;
+};
+/**
+ * Top-10 edge save percentage lists.
+ * @param sortBy - Sorting key for the leaderboard.
+ * @param season - Optional season (numeric or 'now').
+ * @param gameType - Optional game type id.
+ * @returns Promise resolving to an APIResult with the response data.
+ */
+declare function top10SavePercentage(season?: Season$1, gameType?: GameType, sortBy?: SavePercentageSort): Promise<APIResult<EdgeGoalieSavePercentageTop10>>;
+/**
+ * Top-10 5v5 save percentage lists.
+ * @param sortBy - Sorting key for the leaderboard.
+ * @param season - Optional season (numeric or 'now').
+ * @param gameType - Optional game type id.
+ * @returns Promise resolving to an APIResult with the response data.
+ */
+declare function top10SavePercentage5v5(season?: Season$1, gameType?: GameType, sortBy?: SavePercentage5v5Sort): Promise<APIResult<EdgeGoalieSavePercentage5v5Top10>>;
+/**
+ * Top-10 save location lists.
+ * @param category - Category key (see SaveLocationCategoryEnum).
+ * @param sortBy - Sorting key for the leaderboard (see SaveLocationSortEnum).
+ * @param season - Optional season (e.g. 20242025).
+ * @param gameType - Optional game type.
+ * @returns Promise resolving to an APIResult with the response data.
+ */
+declare function top10SaveLocation(season?: Season$1, gameType?: GameType, category?: SaveLocationCategory, sortBy?: SaveLocationSort): Promise<APIResult<EdgeGoalieShotLocationTop10>>;
+
+declare const goalies$1_saveLocation: typeof saveLocation;
+declare const goalies$1_savePercentage: typeof savePercentage;
+declare const goalies$1_savePercentage5v5: typeof savePercentage5v5;
+declare namespace goalies$1 {
+  export { compare$1 as compare, leaders$2 as leaders, player$1 as player, goalies$1_saveLocation as saveLocation, goalies$1_savePercentage as savePercentage, goalies$1_savePercentage5v5 as savePercentage5v5, top10$2 as top10 };
+}
+
+/**
+ * ======================================================================
+ * API endpoints for skater-related data.
+ * Base url: api-web.nhle.com/v1/edge
+ *
+ * Notes:
+ * - Convenience endpoints using 'now' for season have been
+ * excluded in favor of using calculated current season. You can optionally
+ * configure the switch over date for how current season is calculated.
+ * See README for details.
+ * - There is an extra endpoint that appears to duplicate
+ * the functionality of /skater-detail at `v1/cat/edge/skater-detail`
+ * As such, it has been excluded from this implementation.
+ * =====================================================================
+ */
+
+/**
+ * Skater Edge Advanced Stats API helpers.
+ *
+ * Lightweight wrapper exposing functions that call the underlying nhlClient
+ * for skater-related endpoints. Each function resolves to an APIResult; invalid
+ * parameters give a ValidationError result without a request.
+ */
+/** Get skater detail for a player. */
+declare function detail(playerId: PlayerId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeSkaterDetail>>;
+/** Get skater shot location details for a player. */
+declare function shotLocation$1(playerId: PlayerId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeSkaterShotLocation>>;
+/** Get skater shot speed details for a player. */
+declare function shotSpeed$1(playerId: PlayerId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeSkaterShotSpeed>>;
+/** Get skater skating distance details for a player. */
+declare function skatingDistance$1(playerId: PlayerId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeSkaterSkatingDistance>>;
+/** Get skater skating speed details for a player. */
+declare function skatingSpeed$1(playerId: PlayerId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeSkaterSkatingSpeed>>;
+/** Get skater zone time for a player. */
+declare function zoneTime$1(playerId: PlayerId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeSkaterZoneTime>>;
+/** Get skater comparison data for a player. */
+declare function comparison(playerId: PlayerId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeSkaterComparison>>;
+/** Get skater landing / leaders for a season. */
+declare function leaders$1(season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeSkaterLanding>>;
+declare const top10$1: {
+    distance: typeof top10Distance;
+    shotLocation: typeof top10ShotLocation$1;
+    shotSpeed: typeof top10ShotSpeed$1;
+    speed: typeof top10Speed;
+    zoneTime: typeof top10ZoneTime$1;
+};
+/** Top-10 skating distance lists. */
+declare function top10Distance(season?: Season$1, gameType?: GameType, position?: PositionFilter, strength?: SkatersStrength, sortBy?: SkatingDistanceSort): Promise<APIResult<EdgeSkaterDistanceTop10>>;
+/** Top-10 shot location lists. */
+declare function top10ShotLocation$1(season?: Season$1, gameType?: GameType, position?: PositionFilter, category?: ShotLocationCategory, sortBy?: ShotLocationSort): Promise<APIResult<EdgeSkaterShotLocationTop10>>;
+/** Top-10 shot speed lists. */
+declare function top10ShotSpeed$1(season?: Season$1, gameType?: GameType, position?: PositionFilter, sortBy?: ShotSpeedSort): Promise<APIResult<EdgeSkaterShotSpeedTop10>>;
+/** Top-10 skating speed lists. */
+declare function top10Speed(season?: Season$1, gameType?: GameType, position?: PositionFilter, sortBy?: SkatingSpeedSort): Promise<APIResult<EdgeSkaterSpeedTop10>>;
+/** Top-10 zone time lists. */
+declare function top10ZoneTime$1(season?: Season$1, gameType?: GameType, position?: PositionFilter, strength?: SkatersStrength, sortBy?: ZoneTimeSort): Promise<APIResult<EdgeSkaterZoneTimeTop10>>;
+
+declare const skaters$1_comparison: typeof comparison;
+declare const skaters$1_detail: typeof detail;
+declare namespace skaters$1 {
+  export { skaters$1_comparison as comparison, skaters$1_detail as detail, leaders$1 as leaders, shotLocation$1 as shotLocation, shotSpeed$1 as shotSpeed, skatingDistance$1 as skatingDistance, skatingSpeed$1 as skatingSpeed, top10$1 as top10, zoneTime$1 as zoneTime };
+}
+
+/**
+ * Edge Advanced Stats API helpers.
+ *
+ * Lightweight wrapper exposing functions that call the underlying nhlClient
+ * for related endpoints. Each function resolves to an APIResult; invalid
+ * parameters give a ValidationError result without a request.
+ */
+/**
+ * Get the "by the numbers" data for the current day, updated daily with
+ * insights from the previous days games.
+ * @returns A promise that resolves to the "by the numbers" data.
+ */
+declare function byTheNumbers(): Promise<APIResult<EdgeByTheNumbers>>;
+
+/**
+ * ======================================================================
+ * API endpoints for team-related data.
+ * Base url: api-web.nhle.com/v1/edge
+ *
+ * note: the season and game-type params on any endpoint can
+ * be replaced with 'now' to get current season data.
+ * ex. `/team-detail/{team-id}/now`
+ * ======================================================================
+ */
+
+/**
+ * Team Edge Advanced Stats API helpers.
+ *
+ * Lightweight wrapper exposing functions that call the underlying nhlClient
+ * for team-related endpoints. Each function resolves to an APIResult; invalid
+ * parameters give a ValidationError result without a request.
+ */
+/**
+ * Get team detail stats for a team.
+ * @param teamId - Team numeric id.
+ * @param season - Optional season (numeric season format or 'now').
+ * @param gameType - Optional game type id (defaults to Regular Season).
+ */
+declare function stats$1(teamId: TeamId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeTeamDetail>>;
+/**
+ * Get team comparison data for a single team.
+ */
+declare function compare(teamId: TeamId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeTeamComparison>>;
+/**
+ * Get team landing/leaders for a season.
+ */
+declare function leaders(season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeTeamLanding>>;
+/**
+ * Get shot location details for a team.
+ */
+declare function shotLocation(teamId: TeamId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeTeamShotLocation>>;
+/**
+ * Get shot speed details for a team.
+ */
+declare function shotSpeed(teamId: TeamId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeTeamShotSpeed>>;
+/**
+ * Get skating distance details for a team.
+ */
+declare function skatingDistance(teamId: TeamId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeTeamSkatingDistance>>;
+/**
+ * Get skating speed details for a team.
+ */
+declare function skatingSpeed(teamId: TeamId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeTeamSkatingSpeed>>;
+/**
+ * Get zone time details for a team.
+ */
+declare function zoneTime(teamId: TeamId, season?: Season$1, gameType?: GameType): Promise<APIResult<EdgeTeamZoneTime>>;
+declare const top10: {
+    shotLocation: typeof top10ShotLocation;
+    shotSpeed: typeof top10ShotSpeed;
+    skatingDistance: typeof top10SkatingDistance;
+    skatingSpeed: typeof top10SkatingSpeed;
+    zoneTime: typeof top10ZoneTime;
+};
+/**
+ * Top-10 team shot location lists.
+ */
+declare function top10ShotLocation(season?: Season$1, gameType?: GameType, position?: PositionFilter, category?: ShotLocationCategory, sortBy?: ShotLocationSort): Promise<APIResult<EdgeTeamShotLocationTop10>>;
+/**
+ * Top-10 team shot speed lists.
+ */
+declare function top10ShotSpeed(season?: Season$1, gameType?: GameType, position?: PositionFilter, sortBy?: ShotSpeedSort): Promise<APIResult<EdgeTeamShotSpeedTop10>>;
+/**
+ * Top-10 team skating distance lists.
+ */
+declare function top10SkatingDistance(season?: Season$1, gameType?: GameType, position?: PositionFilter, strength?: SkatersStrength, sortBy?: SkatingDistanceSort): Promise<APIResult<EdgeTeamSkatingDistanceTop10>>;
+/**
+ * Top-10 team skating speed lists.
+ */
+declare function top10SkatingSpeed(season?: Season$1, gameType?: GameType, position?: PositionFilter, sortBy?: SkatingSpeedSort): Promise<APIResult<EdgeTeamSkatingSpeedTop10>>;
+/**
+ * Top-10 team zone time lists.
+ */
+declare function top10ZoneTime(season?: Season$1, gameType?: GameType, strength?: SkatersStrength, sortBy?: ZoneTimeSort): Promise<APIResult<EdgeTeamZoneTimeTop10>>;
+
+declare const teams$1_compare: typeof compare;
+declare const teams$1_leaders: typeof leaders;
+declare const teams$1_shotLocation: typeof shotLocation;
+declare const teams$1_shotSpeed: typeof shotSpeed;
+declare const teams$1_skatingDistance: typeof skatingDistance;
+declare const teams$1_skatingSpeed: typeof skatingSpeed;
+declare const teams$1_top10: typeof top10;
+declare const teams$1_zoneTime: typeof zoneTime;
+declare namespace teams$1 {
+  export { teams$1_compare as compare, teams$1_leaders as leaders, teams$1_shotLocation as shotLocation, teams$1_shotSpeed as shotSpeed, teams$1_skatingDistance as skatingDistance, teams$1_skatingSpeed as skatingSpeed, stats$1 as stats, teams$1_top10 as top10, teams$1_zoneTime as zoneTime };
+}
+
+/**
+ * ========================================================================
+ * NHL Edge Advanced Stats API Module Exports
+ * Base URL: https://api.nhle.com/stats/rest
+ * ========================================================================
+ * Complete NHL Edge Advanced Stats API implementation with modules for:
+ * - Players (skaters, goalies)
+ * - Teams and franchises
+ * - Advanced statistical numbers
+ * ========================================================================
+ */
+
+declare const index$2_byTheNumbers: typeof byTheNumbers;
+declare namespace index$2 {
+  export { index$2_byTheNumbers as byTheNumbers, goalies$1 as goalies, skaters$1 as skaters, teams$1 as teams };
+}
+
+/**
+ * ======================================================================
+ * NHL Edge Stats API - Endpoint Paths
+ * Base URL: https://api.nhle.com/stats/rest
+ * ======================================================================
+ * Defines the endpoint paths for all categories of data in the NHL Edge
+ * Stats API. These paths are used by the various API functions to
+ * construct the correct URLs for making requests to the API.
+ *
+ * Note: These endpoints generally return entire datasets (tabular data)
+ * as arrays of objects. The API expects query parameters to be used for
+ * filtering and column selection (namely through cayenneExp). Some
+ * endpoints will return empty arrays or 'not found' errors when queried
+ * without parameters.
+ */
+declare const dataPaths: {
+    /** Goalie-related statistics and reports. */
+    goalie: {
+        /** Goalie leader boards by stat category. */
+        leaders: {
+            /** Goals-against average leaders. */
+            gaa: string;
+            /** Save percentage leaders. */
+            savePctg: string;
+            /** Shutouts leaders. */
+            shutouts: string;
+        };
+        /** Goalie statistical reports. */
+        report: string;
+        /** Goalie career milestones. */
+        milestones: string;
+    };
+    /** Skater/player-related statistics and reports. */
+    skater: {
+        /** Player directory and information. */
+        players: string;
+        /** Skater leader boards by stat category. */
+        leaders: {
+            /** Assists leaders. */
+            assists: string;
+            /** Goals leaders. */
+            goals: string;
+            /** Points leaders. */
+            points: string;
+        };
+        /** Skater career milestones. */
+        milestones: string;
+        /** Skater statistical reports. */
+        report: string;
+    };
+    /** Team-related statistics and reports. */
+    team: {
+        /** All teams data. */
+        all: string;
+        /** Team data by team ID. */
+        byId: string;
+        /** Team statistical reports. */
+        report: string;
+    };
+    /** Season-related data. */
+    season: string;
+    /** Game-related data. */
+    game: string;
+    /** Draft-related data. */
+    draft: string;
+    /** Configuration data for skater, goalie, and team reports. */
+    config: string;
+    /** Country data. */
+    countries: string;
+    /** Shift chart data. */
+    shiftCharts: string;
+    /** Glossary data. */
+    glossary: string;
+    /** Franchise data. */
+    franchises: string;
+};
+
+/**
+ * Response and parameter types for the NHL Stats API
+ * (https://api.nhle.com/stats/rest)
+ *
+ * Every list endpoint answers `{ data: T[], total }`. Report rows (skater,
+ * goalie and team reports) vary with the report and with `isAggregate` /
+ * `isGame`, so their types list the `summary` fields and keep an index
+ * signature for the rest.
+ *
+ * With `isAggregate=true`, report rows drop per-instance fields (seasonId,
+ * teamId, gameId) and team reports add franchise fields; see
+ * TeamStatsWithFranchise.
+ */
+
+/** List response returned by every Stats API list endpoint */
+interface PaginatedData<T> {
+    data: T[];
+    /** Number of rows matching the query, before `limit` */
+    total: number;
+}
+type APIResultPaginated<T> = APIResult<PaginatedData<T>>;
+/**
+ * Skater report names listed by `/config` (`playerReportData`).
+ * Any other string is accepted for reports added later.
+ */
+type SkaterReport = 'bios' | 'faceoffpercentages' | 'faceoffwins' | 'goalsForAgainst' | 'penalties' | 'penaltyShots' | 'penaltykill' | 'percentages' | 'powerplay' | 'puckPossessions' | 'realtime' | 'scoringRates' | 'scoringpergame' | 'shootout' | 'shottype' | 'summary' | 'summaryshooting' | 'timeonice' | (string & {});
+/** Goalie report names listed by `/config` (`goalieReportData`) */
+type GoalieReport = 'advanced' | 'bios' | 'daysrest' | 'penaltyShots' | 'savesByStrength' | 'shootout' | 'startedVsRelieved' | 'summary' | (string & {});
+/** Team report names listed by `/config` (`teamReportData`) */
+type TeamReport = 'daysbetweengames' | 'faceoffpercentages' | 'faceoffwins' | 'goalgames' | 'goalsagainstbystrength' | 'goalsagainstbystrengthgoaliepull' | 'goalsbyperiod' | 'goalsforbystrength' | 'goalsforbystrengthgoaliepull' | 'leadingtrailing' | 'outshootoutshotby' | 'penalties' | 'penaltykill' | 'penaltykilltime' | 'percentages' | 'powerplay' | 'powerplaytime' | 'realtime' | 'savePercentage' | 'scoretrailfirst' | 'shootout' | 'shottype' | 'summary' | 'summaryshooting' | (string & {});
+/** A player as listed by `/players` and nested in leader rows */
+interface PlayerInfo {
+    id: number;
+    currentTeamId: number | null;
+    firstName: string;
+    fullName: string;
+    lastName: string;
+    positionCode: string;
+    sweaterNumber: number | null;
+}
+/** A team logo, included with `include=logos` */
+interface TeamLogo {
+    id: number;
+    background: string;
+    endSeason: number;
+    secureUrl: string;
+    startSeason: number;
+    teamId: number;
+    url: string;
+}
+/** A team as listed by `/team` and `/team/id/{id}` */
+interface Team$b {
+    id: number;
+    franchiseId: number | null;
+    fullName: string;
+    leagueId: number;
+    rawTricode: string;
+    triCode: string;
+    /** Present with `include=logos`, and on leader rows */
+    logos?: TeamLogo[];
+}
+/** Row of a skater report (fields of the `summary` report) */
+interface SkaterStats {
+    playerId: number;
+    skaterFullName?: string;
+    lastName?: string;
+    seasonId?: number;
+    teamAbbrevs?: string;
+    positionCode?: string;
+    shootsCatches?: string;
+    gamesPlayed?: number;
+    goals?: number;
+    assists?: number;
+    points?: number;
+    plusMinus?: number;
+    pointsPerGame?: number;
+    penaltyMinutes?: number;
+    evGoals?: number;
+    evPoints?: number;
+    ppGoals?: number;
+    ppPoints?: number;
+    shGoals?: number;
+    shPoints?: number;
+    otGoals?: number;
+    gameWinningGoals?: number;
+    shots?: number;
+    shootingPct?: number | null;
+    faceoffWinPct?: number | null;
+    timeOnIcePerGame?: number;
+    [key: string]: unknown;
+}
+/** Row of a goalie report (fields of the `summary` report) */
+interface GoalieStats {
+    playerId: number;
+    goalieFullName?: string;
+    lastName?: string;
+    seasonId?: number;
+    teamAbbrevs?: string;
+    shootsCatches?: string;
+    gamesPlayed?: number;
+    gamesStarted?: number;
+    wins?: number;
+    losses?: number;
+    otLosses?: number | null;
+    ties?: number | null;
+    shutouts?: number;
+    goalsAgainst?: number;
+    goalsAgainstAverage?: number;
+    saves?: number;
+    shotsAgainst?: number;
+    savePct?: number | null;
+    timeOnIce?: number;
+    goals?: number;
+    assists?: number;
+    points?: number;
+    penaltyMinutes?: number;
+    [key: string]: unknown;
+}
+/** Row of a team report (fields of the `summary` report) */
+interface TeamStats$1 {
+    teamId?: number;
+    teamFullName?: string;
+    seasonId?: number;
+    gamesPlayed?: number;
+    wins?: number;
+    losses?: number;
+    otLosses?: number | null;
+    ties?: number | null;
+    points?: number;
+    pointPct?: number;
+    regulationAndOtWins?: number;
+    winsInRegulation?: number;
+    winsInShootout?: number;
+    goalsFor?: number;
+    goalsAgainst?: number;
+    goalsForPerGame?: number;
+    goalsAgainstPerGame?: number;
+    shotsForPerGame?: number;
+    shotsAgainstPerGame?: number;
+    powerPlayPct?: number | null;
+    powerPlayNetPct?: number | null;
+    penaltyKillPct?: number | null;
+    penaltyKillNetPct?: number | null;
+    faceoffWinPct?: number | null;
+    teamShutouts?: number;
+    [key: string]: unknown;
+}
+/**
+ * Row of a team report requested with `isAggregate=true`: per-team and
+ * per-season fields are dropped and franchise fields added.
+ */
+interface TeamStatsWithFranchise extends TeamStats$1 {
+    franchiseId: number;
+    franchiseName: string;
+}
+/** Skater leader row; the stat field is named after the category */
+interface SkaterLeader$1 {
+    player: PlayerInfo;
+    team: Team$b;
+    goals?: number;
+    assists?: number;
+    points?: number;
+}
+/** Goalie leader row; the stat field is named after the category */
+interface GoalieLeader$1 {
+    player: PlayerInfo;
+    team: Team$b;
+    gaa?: number | null;
+    savePctg?: number | null;
+    shutouts?: number;
+}
+/** Shared fields of a milestone row */
+interface Milestone {
+    id: number;
+    playerId: number;
+    firstName: string;
+    lastName: string;
+    playerFullName: string;
+    currentTeamId: number;
+    teamAbbrev: string;
+    teamCommonName: string;
+    teamFullName: string;
+    teamPlaceName: string;
+    gameTypeId: number;
+    gamesPlayed: number;
+    /** The stat being approached, e.g. "Goals" or "Shutouts" */
+    milestone: string;
+    milestoneAmount: number;
+}
+/** A skater approaching a career milestone */
+interface SkaterMilestone extends Milestone {
+    goals: number;
+    assists: number;
+    points: number;
+}
+/** A goalie approaching a career milestone */
+interface GoalieMilestone extends Milestone {
+    wins: number;
+    so: number;
+    toiMinutes: number;
+}
+/** A franchise from `/franchise` */
+interface Franchise {
+    id: number;
+    fullName: string;
+    teamCommonName: string;
+    teamPlaceName: string;
+}
+/** A season from `/season` */
+interface Season {
+    /** Season id, e.g. 20242025 */
+    id: number;
+    formattedSeasonId: string;
+    seasonOrdinal: number;
+    startDate: string;
+    endDate: string;
+    preseasonStartdate: string | null;
+    regularSeasonEndDate: string;
+    numberOfGames: number;
+    totalRegularSeasonGames: number;
+    totalPlayoffGames: number;
+    allStarGameInUse: number;
+    conferencesInUse: number;
+    divisionsInUse: number;
+    entryDraftInUse: number;
+    nhlStanleyCupOwner: number;
+    olympicsParticipation: number;
+    pointForOTLossInUse: number;
+    rowInUse: number;
+    supplementalDraftInUse: number;
+    tiesInUse: number;
+    wildcardInUse: number;
+    minimumPlayoffMinutesForGoalieStatsLeaders: number;
+    minimumRegularGamesForGoalieStatsLeaders: number;
+}
+/** A game from `/game` */
+interface Game$6 {
+    /** Game id, e.g. 2024020001 */
+    id: number;
+    season: number;
+    /** 1 = preseason, 2 = regular season, 3 = playoffs */
+    gameType: number;
+    gameNumber: number;
+    gameDate: string;
+    easternStartTime: string;
+    gameScheduleStateId: number;
+    gameStateId: number;
+    period: number | null;
+    homeTeamId: number;
+    homeScore: number | null;
+    visitingTeamId: number;
+    visitingScore: number | null;
+}
+/** A draft year from `/draft` */
+interface Draft {
+    id: number;
+    draftYear: number;
+    rounds: number;
+}
+/**
+ * Report configuration from `/config`: the columns, filters and sort keys
+ * of every skater, goalie and team report.
+ */
+interface Config {
+    playerReportData: Record<string, unknown>;
+    goalieReportData: Record<string, unknown>;
+    teamReportData: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/** A country from `/country` */
+interface Country {
+    /** Three-letter code, same as country3Code */
+    id: string;
+    country3Code: string;
+    countryCode: string;
+    countryName: string;
+    nationalityName: string;
+    iocCode: string | null;
+    hasPlayerStats: number;
+    isActive: number;
+    imageUrl: string | null;
+    thumbnailUrl: string | null;
+    olympicUrl: string | null;
+}
+/** One shift (or goal event) from `/shiftcharts` */
+interface ShiftChart {
+    id: number;
+    gameId: number;
+    playerId: number;
+    firstName: string;
+    lastName: string;
+    teamId: number;
+    teamAbbrev: string;
+    teamName: string;
+    hexValue: string;
+    period: number;
+    shiftNumber: number;
+    startTime: string;
+    endTime: string;
+    duration: string | null;
+    /** 517 = shift, 505 = goal */
+    typeCode: number;
+    detailCode: number;
+    eventNumber: number | null;
+    eventDescription: string | null;
+    eventDetails: string | null;
+}
+/** A stat definition from `/glossary` */
+interface GlossaryEntry {
+    id: number;
+    abbreviation: string;
+    fullName: string;
+    definition: string;
+    firstSeasonForStat: number | null;
+    languageCode: string;
+    lastUpdated: string;
+}
+/**
+ * Query parameters for Stats API list endpoints
+ */
+interface StatsQueryParams extends Record<string, unknown> {
+    /**
+     * Cayenne expression for filtering. Skater and goalie reports fail
+     * (HTTP 500) without one, so the report functions send an empty
+     * expression when none is given.
+     */
+    cayenneExp?: string;
+    /** Sort field, or a JSON array of `{property, direction}` */
+    sort?: string;
+    /** Sort direction: 'asc' or 'desc' */
+    dir?: 'asc' | 'desc';
+    /** Number of results to return; -1 returns all results */
+    limit?: number;
+    /** Starting index for pagination */
+    start?: number;
+    /** Include related data, e.g. 'logos' on teams */
+    include?: string;
+    /** Exclude certain fields */
+    exclude?: string;
+    /** Cayenne expression applied to the underlying facts (e.g. gamesPlayed>=10) */
+    factCayenneExp?: string;
+    /** Aggregate rows across seasons and teams */
+    isAggregate?: boolean;
+    /** Return one row per game */
+    isGame?: boolean;
+}
+/** Convenience filters for the `getStatsWithFilters` functions */
+interface StatsFilters {
+    seasonId?: string | number;
+    gameTypeId?: number;
+    playerId?: number;
+    teamId?: number;
+    /** Any other field, matched with equality */
+    [key: string]: string | number | undefined;
+}
+/** Sorting for the `getStatsWithFilters` functions */
+interface StatsSorting {
+    sortBy?: string;
+    direction?: 'asc' | 'desc';
+}
+/** Pagination for the `getStatsWithFilters` functions */
+interface StatsPagination {
+    limit?: number;
+    start?: number;
+}
+
+/**
+ * ======================================================================
+ * NHL Stats API - Goalie Endpoints
+ * Base URL: https://api.nhle.com/stats/rest
+ * ======================================================================
+ * Provides functions for retrieving goalie statistics and information
+ * from the NHL Stats API.
+ */
+
+/**
+ * Get goalie leaders for a stat category
+ *
+ * Without a filter the leaders are all-time; filter by season with
+ * `{ cayenneExp: 'season=20242025 and gameType=2' }`.
+ *
+ * @param statCategory - 'gaa', 'savePctg' or 'shutouts'
+ * @param params - Query parameters (the endpoint ignores `limit`)
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to goalie leaders
+ *
+ * @example
+ * const leaders = await stats.goalies.getLeaders('gaa', {
+ *    cayenneExp: 'season=20242025 and gameType=2',
+ * });
+ */
+declare function getLeaders$1(statCategory: keyof typeof dataPaths.goalie.leaders, params?: StatsQueryParams, lang?: string): Promise<APIResultPaginated<GoalieLeader$1>>;
+/**
+ * Get a goalie report
+ *
+ * @param report - The report name (default: 'summary')
+ * @param params - Query parameters including cayenneExp for filtering
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to goalie statistics
+ *
+ * @example
+ * const result = await stats.goalies.getStats('summary', {
+ *    cayenneExp: 'seasonId=20242025 and gameTypeId=2',
+ *    sort: 'wins',
+ *    dir: 'desc',
+ *    limit: 10,
+ * });
+ */
+declare function getStats$2(report?: GoalieReport, params?: StatsQueryParams, lang?: string): Promise<APIResultPaginated<GoalieStats>>;
+/**
+ * Get goalie stats with low-level query parameters
+ * This is the most flexible approach - you build the query parameters yourself
+ *
+ * @param report - The report name (e.g., 'summary', 'advanced')
+ * @param params - Query parameters including cayenneExp for filtering
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to goalie statistics
+ *
+ * @example
+ * const result = await stats.goalies.getStatsWithParams('summary', {
+ *    cayenneExp: 'seasonId=20232024 and gameTypeId=2',
+ *    sort: 'wins',
+ *    limit: 10,
+ *    dir: 'desc',
+ * });
+ */
+declare function getStatsWithParams$2(report: GoalieReport, params: StatsQueryParams, lang?: string): Promise<APIResultPaginated<GoalieStats>>;
+/**
+ * Get goalie stats using a fluent query builder
+ *
+ * @param report - The report name (e.g., 'summary', 'advanced')
+ * @param buildQuery - Function that receives a CayenneQueryBuilder and returns params
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to goalie statistics
+ *
+ * @example
+ * const result = await stats.goalies.getStatsWithBuilder('summary', (q) => ({
+ *    cayenneExp: q.equals('seasonId', 20232024).equals('gameTypeId', 2).build(),
+ *    sort: 'wins',
+ *    limit: 10,
+ *    dir: 'desc' as const,
+ * }));
+ */
+declare function getStatsWithBuilder$2(report: GoalieReport, buildQuery: (builder: CayenneQueryBuilder) => StatsQueryParams, lang?: string): Promise<APIResultPaginated<GoalieStats>>;
+/**
+ * Get goalie stats with high-level convenience parameters
+ * Every filter is matched with equality.
+ *
+ * @param report - The report name (e.g., 'summary', 'advanced')
+ * @param filters - Field filters, e.g. `{ seasonId: 20232024, gameTypeId: 2 }`
+ * @param sorting - Sorting options
+ * @param pagination - Pagination options
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to goalie statistics
+ *
+ * @example
+ * const result = await stats.goalies.getStatsWithFilters(
+ *    'summary',
+ *    { seasonId: '20232024', gameTypeId: 2 },
+ *    { sortBy: 'wins', direction: 'desc' },
+ *    { limit: 10, start: 0 },
+ * );
+ */
+declare function getStatsWithFilters$2(report: GoalieReport, filters?: StatsFilters, sorting?: StatsSorting, pagination?: StatsPagination, lang?: string): Promise<APIResultPaginated<GoalieStats>>;
+/**
+ * Get active goalies approaching a career milestone
+ *
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to goalie milestones
+ *
+ * @example
+ * const milestones = await stats.goalies.getMilestones();
+ */
+declare function getMilestones$1(lang?: string): Promise<APIResultPaginated<GoalieMilestone>>;
+
+declare namespace goalies {
+  export { getLeaders$1 as getLeaders, getMilestones$1 as getMilestones, getStats$2 as getStats, getStatsWithBuilder$2 as getStatsWithBuilder, getStatsWithFilters$2 as getStatsWithFilters, getStatsWithParams$2 as getStatsWithParams };
+}
+
+/**
+ * ======================================================================
+ * NHL Stats API - Miscellaneous Endpoints
+ * Base URL: https://api.nhle.com/stats/rest
+ * ======================================================================
+ * Provides functions for miscellaneous operations including configuration,
+ * country information, shift charts, glossary, and content modules.
+ */
+
+/**
+ * Get configuration information
+ *
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to configuration data
+ *
+ * @example
+ * const config = await getConfig('en');
+ */
+declare function getConfig(lang?: string): Promise<APIResult<Config>>;
+/**
+ * Get country information
+ * Returns list of all countries with a hockey presence
+ *
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to country data
+ *
+ * @example
+ * const countries = await getCountries('en');
+ */
+declare function getCountries(lang?: string): Promise<APIResultPaginated<Country>>;
+/**
+ * Get the glossary for a specific language
+ *
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to glossary data
+ *
+ * @example
+ * const glossary = await glossary.get('en');
+ */
+declare function getGlossary(lang?: string): Promise<APIResultPaginated<GlossaryEntry>>;
+/**
+ * Get franchise information
+ *
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to franchise data
+ *
+ * @example
+ * const allFranchises = await getFranchises('en');
+ */
+declare function getFranchises(lang?: string): Promise<APIResultPaginated<Franchise>>;
 
-declare const Year$1: arktype.BaseType<number | ((In: string) => arktype_internal_attributes_ts.To<number>), {}>;
-declare const NHLMonth$1: arktype_internal_variants_object_ts.ObjectType<(In: string | Date) => arktype.Out<string>, {}>;
-declare const NHLDate$1: arktype_internal_variants_object_ts.ObjectType<(In: string | Date) => arktype.Out<string>, {}>;
-declare const Season$1: arktype_internal_variants_object_ts.ObjectType<(In: string | number) => arktype.Out<string>, {}>;
-declare const TeamAbbrev$1: arktype_internal_variants_string_ts.StringType<"ANA" | "BOS" | "BUF" | "CGY" | "CAR" | "CHI" | "COL" | "CBJ" | "DAL" | "DET" | "EDM" | "FLA" | "LAK" | "MIN" | "MTL" | "NJD" | "NSH" | "NYI" | "NYR" | "OTT" | "PHI" | "PIT" | "SJS" | "SEA" | "STL" | "TBL" | "TOR" | "UTA" | "VAN" | "VGK" | "WPG" | "WSH" | "AFM" | "ARI" | "ATL" | "BRK" | "CGS" | "CLE" | "CLR" | "DCG" | "DFL" | "HAM" | "HFD" | "KCS" | "MMR" | "MNS" | "MWN" | "NYA" | "OAK" | "PHX" | "PIR" | "QBD" | "QUA" | "QUE" | "SEN" | "SLE" | "TAN" | "TSP" | "WIN", {}>;
-declare const TeamId$1: arktype_internal_variants_number_ts.NumberType<1 | 10 | 2 | 3 | 4 | 24 | 6 | 7 | 20 | 12 | 16 | 21 | 29 | 25 | 17 | 22 | 13 | 26 | 30 | 8 | 18 | 9 | 5 | 28 | 55 | 19 | 14 | 59 | 23 | 54 | 52 | 15 | 47 | 53 | 11 | 51 | 56 | 49 | 35 | 40 | 50 | 37 | 34 | 48 | 43 | 31 | 41 | 44 | 46 | 27 | 38 | 42 | 39 | 32 | 36 | 45 | 57 | 58 | 33, {}>;
-declare const GameType$1: arktype.BaseType<1 | 2 | 3 | 4 | 19 | ((In: "REG" | "PRE" | "POST" | "ASG" | "INTL") => arktype.Out<1 | 2 | 3 | 4 | 19>), {}>;
-declare const GameNumber$1: arktype_internal_variants_object_ts.ObjectType<(In: string | number) => arktype.Out<string>, {}>;
-declare const DraftRound$1: arktype_internal_variants_object_ts.ObjectType<(In: string | number) => arktype.Out<string>, {}>;
-declare const EventId$1: arktype.BaseType<number | ((In: string) => arktype_internal_attributes_ts.To<number>), {}>;
-declare const GameId$1: arktype.BaseType<number | ((In: string) => arktype_internal_attributes_ts.To<number>), {}>;
-declare const SeriesLetter$2: arktype_internal_variants_string_ts.StringType<"A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O", {}>;
-declare const GameState$2: arktype_internal_variants_string_ts.StringType<"FUT" | "LIV" | "FIN", {}>;
-declare const CountryCode$2: arktype_internal_variants_object_ts.ObjectType<(In: string) => arktype.Out<string>, {}>;
-declare const PostalCode$1: arktype_internal_variants_string_ts.StringType<string, {}>;
-declare const PlayerId$1: arktype_internal_variants_object_ts.ObjectType<(In: string | number) => arktype.Out<string>, {}>;
+declare const misc$1_getConfig: typeof getConfig;
+declare const misc$1_getCountries: typeof getCountries;
+declare const misc$1_getFranchises: typeof getFranchises;
+declare const misc$1_getGlossary: typeof getGlossary;
+declare namespace misc$1 {
+  export { misc$1_getConfig as getConfig, misc$1_getCountries as getCountries, misc$1_getFranchises as getFranchises, misc$1_getGlossary as getGlossary };
+}
 
 /**
- * Represents a valid NHL year (e.g., 2023, 2024, ...)
+ * ======================================================================
+ * NHL Stats API - Season and Game Endpoints
+ * Base URL: https://api.nhle.com/stats/rest
+ * ======================================================================
+ * Provides functions for retrieving season and game information
+ * from the NHL Stats API.
  */
-type Year = typeof Year$1.inferIn;
+
 /**
- * Represents an NHL season in the format YYYYYYYY (e.g., 20232024)
+ * Get every season's settings (dates, game counts, rules in use)
+ *
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to season data
+ *
+ * @example
+ * const seasons = await stats.season.getSeasons();
  */
-type Season = typeof Season$1.inferIn;
+declare function getSeasons(lang?: string): Promise<APIResultPaginated<Season>>;
 /**
- * Represents a valid NHL game type (e.g. REG, PRE, POST)
+ * Get games
+ *
+ * Without a filter this downloads every game since 1917 (about 19 MB),
+ * so filter by season or date.
+ *
+ * @param params - Query parameters, e.g. `{ cayenneExp: 'season=20242025 and gameType=2' }`
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to game data
+ *
+ * @example
+ * const games = await stats.season.getGames({
+ *    cayenneExp: 'gameDate="2025-01-15"',
+ * });
  */
-type GameType = typeof GameType$1.inferIn;
+declare function getGames(params?: StatsQueryParams, lang?: string): Promise<APIResultPaginated<Game$6>>;
 /**
- * Represents an NHL game ID with regex /\d{10}/
- * Breakdown of the ID: (YYYYTTNNNN)
- * - First 4 digits: Year of the game (YYYY)
- * - Next 2 digits: Game type (TT)(01 for preseason, 02 for regular
- * season, 03 for playoffs)
- * - Next 4 digits: Game number of the season (NNNN)
+ * Get every shift (and goal event) of a game
+ *
+ * @param gameId - The game ID
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to shift chart data
+ *
+ * @example
+ * const shifts = await stats.season.getShiftChart(2024020500);
  */
-type GameId = typeof GameId$1.inferIn;
+declare function getShiftChart(gameId: string | number, lang?: string): Promise<APIResultPaginated<ShiftChart>>;
 /**
- * Represents a valid NHL team abbreviation (e.g., NYR, MTL, ...)
+ * Get the draft years and their number of rounds
+ *
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to draft data
+ *
+ * @example
+ * const drafts = await stats.season.getDraft();
  */
-type TeamAbbrev = typeof TeamAbbrev$1.inferIn | (string & {});
+declare function getDraft(lang?: string): Promise<APIResultPaginated<Draft>>;
+
+declare const seasonGame_getDraft: typeof getDraft;
+declare const seasonGame_getGames: typeof getGames;
+declare const seasonGame_getSeasons: typeof getSeasons;
+declare const seasonGame_getShiftChart: typeof getShiftChart;
+declare namespace seasonGame {
+  export { seasonGame_getDraft as getDraft, seasonGame_getGames as getGames, seasonGame_getSeasons as getSeasons, seasonGame_getShiftChart as getShiftChart };
+}
+
 /**
- * Represents a valid NHL team ID
+ * ======================================================================
+ * NHL Stats API - Skater Endpoints
+ * Base URL: https://api.nhle.com/stats/rest
+ * ======================================================================
+ * Provides functions for retrieving skater (player) statistics and information
+ * from the NHL Stats API.
  */
-type TeamId = typeof TeamId$1.inferIn | (number & {});
+
 /**
- * Represents a valid NHL game number
+ * Look up players (skaters and goalies)
+ *
+ * The endpoint returns nothing without a filter, so pass a `cayenneExp`.
+ *
+ * @param params - Query parameters, e.g. `{ cayenneExp: 'id=8478402' }`
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to matching players
+ *
+ * @example
+ * const players = await stats.skaters.getPlayerInfo({
+ *    cayenneExp: 'lastName="McDavid"',
+ * });
  */
-type GameNumber = typeof GameNumber$1.inferIn;
+declare function getPlayerInfo(params?: StatsQueryParams, lang?: string): Promise<APIResultPaginated<PlayerInfo>>;
 /**
- * Represents a valid NHL game state
+ * Get skater leaders for a stat category
+ *
+ * Without a filter the leaders are all-time; filter by season with
+ * `{ cayenneExp: 'season=20242025 and gameType=2' }`.
+ *
+ * @param statCategory - 'points', 'goals' or 'assists'
+ * @param params - Query parameters (the endpoint ignores `limit`)
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to skater leaders
+ *
+ * @example
+ * const leaders = await stats.skaters.getLeaders('points', {
+ *    cayenneExp: 'season=20242025 and gameType=2',
+ * });
  */
-type GameState$1 = typeof GameState$2.inferIn;
+declare function getLeaders(statCategory: keyof typeof dataPaths.skater.leaders, params?: StatsQueryParams, lang?: string): Promise<APIResultPaginated<SkaterLeader$1>>;
 /**
- * Represents a valid draft round (1-7)
+ * Get active skaters approaching a career milestone
+ *
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to skater milestones
+ *
+ * @example
+ * const milestones = await stats.skaters.getMilestones();
  */
-type DraftRound = typeof DraftRound$1.inferIn;
+declare function getMilestones(lang?: string): Promise<APIResultPaginated<SkaterMilestone>>;
 /**
- * Represents a valid NHL event ID
+ * Get a skater report
+ *
+ * @param report - The report name (default: 'summary')
+ * @param params - Query parameters including cayenneExp for filtering
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to skater statistics
+ *
+ * @example
+ * const result = await stats.skaters.getStats('summary', {
+ *    cayenneExp: 'seasonId=20242025 and gameTypeId=2',
+ *    sort: 'points',
+ *    dir: 'desc',
+ *    limit: 10,
+ * });
  */
-type EventId = typeof EventId$1.inferIn;
+declare function getStats$1(report?: SkaterReport, params?: StatsQueryParams, lang?: string): Promise<APIResultPaginated<SkaterStats>>;
 /**
- * Represents a valid NHL date in the format YYYY-MM-DD
+ * Get skater stats with low-level query parameters
+ * This is the most flexible approach - you build the query parameters yourself
+ *
+ * @param report - The report name (e.g., 'summary', 'realtime')
+ * @param params - Query parameters including cayenneExp for filtering
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to skater statistics
+ *
+ * @example
+ * const result = await stats.skaters.getStatsWithParams('summary', {
+ *    cayenneExp: 'seasonId=20232024 and gameTypeId=2',
+ *    sort: 'points',
+ *    limit: 10,
+ *    dir: 'desc',
+ * });
  */
-type NHLDate = typeof NHLDate$1.inferIn;
+declare function getStatsWithParams$1(report: SkaterReport, params: StatsQueryParams, lang?: string): Promise<APIResultPaginated<SkaterStats>>;
 /**
- * Represents a valid NHL month in the format YYYY-MM
+ * Get skater stats using a fluent query builder
+ *
+ * @param report - The report name (e.g., 'summary', 'realtime')
+ * @param buildQuery - Function that receives a CayenneQueryBuilder and returns params
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to skater statistics
+ *
+ * @example
+ * const result = await stats.skaters.getStatsWithBuilder('summary', (q) => ({
+ *    cayenneExp: q.equals('seasonId', 20232024).equals('gameTypeId', 2).build(),
+ *    sort: 'points',
+ *    limit: 10,
+ *    dir: 'desc' as const,
+ * }));
  */
-type NHLMonth = typeof NHLMonth$1.inferIn;
+declare function getStatsWithBuilder$1(report: SkaterReport, buildQuery: (builder: CayenneQueryBuilder) => StatsQueryParams, lang?: string): Promise<APIResultPaginated<SkaterStats>>;
 /**
- * Represents a valid NHL series letter (A-O)
+ * Get skater stats with high-level convenience parameters
+ * Every filter is matched with equality.
+ *
+ * @param report - The report name (e.g., 'summary', 'realtime')
+ * @param filters - Field filters, e.g. `{ seasonId: 20232024, gameTypeId: 2 }`
+ * @param sorting - Sorting options
+ * @param pagination - Pagination options
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to skater statistics
+ *
+ * @example
+ * const result = await stats.skaters.getStatsWithFilters(
+ *    'summary',
+ *    { seasonId: '20232024', gameTypeId: 2 },
+ *    { sortBy: 'points', direction: 'desc' },
+ *    { limit: 10, start: 0 },
+ * );
  */
-type SeriesLetter$1 = typeof SeriesLetter$2.inferIn;
+declare function getStatsWithFilters$1(report: SkaterReport, filters?: StatsFilters, sorting?: StatsSorting, pagination?: StatsPagination, lang?: string): Promise<APIResultPaginated<SkaterStats>>;
+
+declare const skaters_getLeaders: typeof getLeaders;
+declare const skaters_getMilestones: typeof getMilestones;
+declare const skaters_getPlayerInfo: typeof getPlayerInfo;
+declare namespace skaters {
+  export { skaters_getLeaders as getLeaders, skaters_getMilestones as getMilestones, skaters_getPlayerInfo as getPlayerInfo, getStats$1 as getStats, getStatsWithBuilder$1 as getStatsWithBuilder, getStatsWithFilters$1 as getStatsWithFilters, getStatsWithParams$1 as getStatsWithParams };
+}
+
 /**
- * Represents the playoff rounds in an NHL season (1-4)
+ * ======================================================================
+ * NHL Stats API - Team Endpoints
+ * Base URL: https://api.nhle.com/stats/rest
+ * ======================================================================
+ * Provides functions for retrieving team statistics and information
+ * from the NHL Stats API.
  */
-type PlayoffRound = 1 | 2 | 3 | 4;
+
 /**
- * Represents a valid country code (e.g., CAN, USA, SWE, ...)
+ * Get every team, past and present
+ *
+ * @param params - Query parameters, e.g. `{ include: 'logos' }`
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to the team list
+ *
+ * @example
+ * const allTeams = await stats.teams.getAll();
  */
-type CountryCode$1 = typeof CountryCode$2.inferIn;
+declare function getAll(params?: StatsQueryParams, lang?: string): Promise<APIResultPaginated<Team$b>>;
 /**
- * Represents a valid country code (e.g., CAN, USA, SWE, ...)
+ * Get a team by ID
+ *
+ * The API answers with a one-row list.
+ *
+ * @param teamId - The team ID
+ * @param params - Query parameters, e.g. `{ include: 'logos' }`
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to a list holding the team
+ *
+ * @example
+ * const result = await stats.teams.getById(10);
+ * if (result.success) console.log(result.data.data[0]?.fullName);
  */
-type PostalCode = typeof PostalCode$1.inferIn;
+declare function getById(teamId: number, params?: StatsQueryParams, lang?: string): Promise<APIResultPaginated<Team$b>>;
 /**
- * Represents a valid NHL player ID
+ * Get a team report
+ *
+ * @param report - The report name (default: 'summary')
+ * @param params - Query parameters including cayenneExp for filtering
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to team statistics
+ *
+ * @example
+ * const result = await stats.teams.getStats('summary', {
+ *    cayenneExp: 'seasonId=20242025 and gameTypeId=2',
+ *    sort: 'points',
+ *    dir: 'desc',
+ * });
  */
-type PlayerId = typeof PlayerId$1.inferIn;
+declare function getStats(report?: TeamReport, params?: StatsQueryParams, lang?: string): Promise<APIResultPaginated<TeamStats$1>>;
 /**
- * Type definitions for enums from constants.ts
+ * Get team stats with low-level query parameters
+ * This is the most flexible approach - you build the query parameters yourself
+ *
+ * @param report - The report name (e.g., 'summary', 'powerplay')
+ * @param params - Query parameters including cayenneExp for filtering
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to team statistics
+ *
+ * @example
+ * const result = await stats.teams.getStatsWithParams('summary', {
+ *    cayenneExp: 'seasonId=20232024 and gameTypeId=2',
+ *    sort: 'shotsForPerGame',
+ * });
  */
-/** Categories for shot location top-10 list */
-type ShotLocationCategory = keyof typeof ShotLocationCategoryEnum;
-/** Sort options for shot location top-10 list */
-type ShotLocationSort = keyof typeof ShotLocationSortEnum;
-/** Sort options for 5v5 save percentage top-10 list */
-type SavePercentage5v5Sort = keyof typeof SavePercentage5v5SortEnum;
-/** Sort options for save percentage top-10 list */
-type SavePercentageSort = keyof typeof SavePercentageSortEnum;
-/** Categories for save location top-10 list */
-type SaveLocationCategory = keyof typeof SaveLocationCategoryEnum;
-/** Sort options for save location top-10 list */
-type SaveLocationSort = keyof typeof SaveLocationSortEnum;
-/** Positions filter for player stats */
-type PositionFilter = keyof typeof PositionFilterEnum;
-/** Strength situation for skater stats */
-type SkatersStrength = keyof typeof SkatersStrengthEnum;
-/** Sort options for shot speed top-10 list */
-type ShotSpeedSort = keyof typeof ShotSpeedSortEnum;
-/** Sort options for skating speed top-10 list */
-type SkatingSpeedSort = keyof typeof SkatingSpeedSortEnum;
-/** Sort options for skating distance top-10 list */
-type SkatingDistanceSort = keyof typeof SkatingDistanceSortEnum;
-/** Sort options for zone time top-10 lists. */
-type ZoneTimeSort = keyof typeof ZoneTimeSortEnum;
-
+declare function getStatsWithParams(report: TeamReport, params: StatsQueryParams, lang?: string): Promise<APIResultPaginated<TeamStats$1>>;
 /**
- * Common types used in Gamecenter API responses
+ * Get team stats using a fluent query builder
+ *
+ * @param report - The report name (e.g., 'summary', 'powerplay')
+ * @param buildQuery - Function that receives a CayenneQueryBuilder and returns params
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to team statistics
+ *
+ * @example
+ * const result = await stats.teams.getStatsWithBuilder('summary', (q) => ({
+ *    cayenneExp: q.equals('seasonId', 20232024).equals('gameTypeId', 2).build(),
+ *    sort: 'shotsForPerGame',
+ *    limit: 10,
+ *    dir: 'desc' as const,
+ * }));
  */
-/** The current state of the game. */
-type GameState = 'OFF' | 'FUT' | 'LIVE' | 'PRE' | 'CRIT' | 'FINAL';
-/** The current state of the game. */
-type GameScheduleState = 'OK' | 'TBD' | 'CNCL' | (string & {});
-/** The type of period in the game. */
-type PeriodType = 'REG' | 'OT' | 'SO';
-/** Abbreviated day of the week. (MON = Monday, TUE = Tuesday ...) */
-type DayAbbrev = 'MON' | 'TUE' | 'WED' | 'THU' | 'FRI' | 'SAT' | 'SUN';
-/** The type of penalty. (MIN = Minor, BEN = Bench, MAJ = Major ...) */
-type PenaltyTypeCode = 'MIN' | 'BEN' | 'MAJ' | (string & {});
-/** The market for this broadcast. (H = Home, A = Away, N = National, S = Satellite Radio) */
-type Market = 'H' | 'A' | 'N' | 'S';
-/** The country code for this broadcast. (CA = Canada, US = United States) */
-type CountryCode = 'CA' | 'US';
-/** The position code for a player. (C = Center, L[W] = Left Wing, R[W] = Right Wing, D = Defenseman, G = Goalie) */
-type PositionCode = 'C' | 'LW' | 'L' | 'RW' | 'R' | 'D' | 'G';
-/** Player's shooting/catching handedness. (L = Left, R = Right) */
-type ShootsCatches = 'L' | 'R';
-type HexColorCode = `#${string}`;
-type UTCOffset = `+${number}:${number}` | `-${number}:${number}`;
-type GoalModifier = 'none' | 'empty-net' | 'awarded-empty-net';
-type DefendingSide = 'left' | 'right';
-type Strength = 'ev' | 'pp' | 'sh';
-type ZoneCode = 'N' | 'D' | 'O';
-type ShotType = 'backhand' | 'bat' | 'between-legs' | 'deflected' | 'poke' | 'slap' | 'snap' | 'tip-in' | 'wrap-around' | 'wrist' | (string & {});
-type PenaltyDescKey = 'tripping' | 'hooking' | 'interference' | 'high-sticking' | 'roughing' | 'unsportsmanlike-conduct' | 'slashing' | 'delaying-game-puck-over-glass' | 'holding' | 'holding-the-stick' | 'too-many-men-on-the-ice' | 'fighting' | 'minor' | 'cross-checking' | (string & {});
-type Reason = 'blocked' | 'failed-bank-attempt' | 'wide-right' | 'goalie-stopped-after-sog' | 'offside' | 'teammate-blocked' | 'icing' | 'puck-in-netting' | 'wide-left' | 'high-and-wide-left' | 'puck-frozen' | 'above-crossbar' | 'tv-timeout' | 'hand-pass' | 'skater-puck-frozen' | 'high-stick' | 'high-and-wide-right' | 'hit-crossbar' | 'puck-in-benches' | 'hit-right-post' | 'short' | 'referee-or-linesman' | 'puck-in-crowd' | 'hit-left-post' | 'player-equipment' | 'net-dislodged-defensive-skater' | 'home-timeout' | 'chlg-hm-goal-interference' | 'video-review' | 'chlg-league-missed-stoppage' | 'visitor-timeout' | 'official-injury' | (string & {});
-type EventTypeDescKey = 'period-start' | 'faceoff' | 'blocked-shot' | 'goal' | 'hit' | 'giveaway' | 'missed-shot' | 'shot-on-goal' | 'stoppage' | 'takeaway' | 'penalty' | 'period-end' | 'delayed-penalty' | 'game-end' | (string & {});
-/** An object containing a default string an optional localized strings. */
-interface LocalizedText {
-    /** Default */
-    default: string;
-    /** French */
-    fr?: string;
-    /** Czech */
-    cs?: string;
-    /** German */
-    de?: string;
-    /** Spanish */
-    es?: string;
-    /** Finnish */
-    fi?: string;
-    /** Slovak */
-    sk?: string;
-    /** Swedish */
-    sv?: string;
+declare function getStatsWithBuilder(report: TeamReport, buildQuery: (builder: CayenneQueryBuilder) => StatsQueryParams, lang?: string): Promise<APIResultPaginated<TeamStats$1>>;
+/**
+ * Get team stats with high-level convenience parameters
+ * Every filter is matched with equality.
+ *
+ * @param report - The report name (e.g., 'summary', 'powerplay')
+ * @param filters - Field filters, e.g. `{ seasonId: 20232024, gameTypeId: 2 }`
+ * @param sorting - Sorting options
+ * @param pagination - Pagination options
+ * @param lang - Language code (default: configured language)
+ * @returns Promise resolving to team statistics
+ *
+ * @example
+ * const result = await stats.teams.getStatsWithFilters(
+ *    'summary',
+ *    { seasonId: '20232024', gameTypeId: 2 },
+ *    { sortBy: 'shotsForPerGame', direction: 'desc' },
+ *    { limit: 10, start: 0 },
+ * );
+ */
+declare function getStatsWithFilters(report: TeamReport, filters?: StatsFilters, sorting?: StatsSorting, pagination?: StatsPagination, lang?: string): Promise<APIResultPaginated<TeamStats$1>>;
+
+declare const teams_getAll: typeof getAll;
+declare const teams_getById: typeof getById;
+declare const teams_getStats: typeof getStats;
+declare const teams_getStatsWithBuilder: typeof getStatsWithBuilder;
+declare const teams_getStatsWithFilters: typeof getStatsWithFilters;
+declare const teams_getStatsWithParams: typeof getStatsWithParams;
+declare namespace teams {
+  export { teams_getAll as getAll, teams_getById as getById, teams_getStats as getStats, teams_getStatsWithBuilder as getStatsWithBuilder, teams_getStatsWithFilters as getStatsWithFilters, teams_getStatsWithParams as getStatsWithParams };
 }
-interface TvBroadcast {
-    id: number;
-    market: Market;
-    countryCode: CountryCode;
-    network: string;
-    sequenceNumber: number;
+
+/**
+ * ======================================================================
+ * NHL Stats API Module Exports
+ * Base URL: https://api.nhle.com/stats/rest
+ * ======================================================================
+ * Complete NHL Stats API implementation with modules for:
+ * - Players (skaters, goalies, draft info)
+ * - Teams and franchises
+ * - Seasons and games
+ * - Miscellaneous (config, shifts, glossary, etc.)
+ */
+
+type index$1_APIResultPaginated<T> = APIResultPaginated<T>;
+type index$1_Config = Config;
+type index$1_Country = Country;
+type index$1_Draft = Draft;
+type index$1_Franchise = Franchise;
+type index$1_GlossaryEntry = GlossaryEntry;
+type index$1_GoalieMilestone = GoalieMilestone;
+type index$1_GoalieReport = GoalieReport;
+type index$1_GoalieStats = GoalieStats;
+type index$1_PaginatedData<T> = PaginatedData<T>;
+type index$1_PlayerInfo = PlayerInfo;
+type index$1_Season = Season;
+type index$1_ShiftChart = ShiftChart;
+type index$1_SkaterMilestone = SkaterMilestone;
+type index$1_SkaterReport = SkaterReport;
+type index$1_SkaterStats = SkaterStats;
+type index$1_StatsFilters = StatsFilters;
+type index$1_StatsPagination = StatsPagination;
+type index$1_StatsQueryParams = StatsQueryParams;
+type index$1_StatsSorting = StatsSorting;
+type index$1_TeamLogo = TeamLogo;
+type index$1_TeamReport = TeamReport;
+type index$1_TeamStatsWithFranchise = TeamStatsWithFranchise;
+declare const index$1_goalies: typeof goalies;
+declare const index$1_skaters: typeof skaters;
+declare const index$1_teams: typeof teams;
+declare namespace index$1 {
+  export { type index$1_APIResultPaginated as APIResultPaginated, type index$1_Config as Config, type index$1_Country as Country, type index$1_Draft as Draft, type index$1_Franchise as Franchise, type Game$6 as Game, type index$1_GlossaryEntry as GlossaryEntry, type GoalieLeader$1 as GoalieLeader, type index$1_GoalieMilestone as GoalieMilestone, type index$1_GoalieReport as GoalieReport, type index$1_GoalieStats as GoalieStats, type index$1_PaginatedData as PaginatedData, type index$1_PlayerInfo as PlayerInfo, type index$1_Season as Season, type index$1_ShiftChart as ShiftChart, type SkaterLeader$1 as SkaterLeader, type index$1_SkaterMilestone as SkaterMilestone, type index$1_SkaterReport as SkaterReport, type index$1_SkaterStats as SkaterStats, type index$1_StatsFilters as StatsFilters, type index$1_StatsPagination as StatsPagination, type index$1_StatsQueryParams as StatsQueryParams, type index$1_StatsSorting as StatsSorting, type Team$b as Team, type index$1_TeamLogo as TeamLogo, type index$1_TeamReport as TeamReport, type TeamStats$1 as TeamStats, type index$1_TeamStatsWithFranchise as TeamStatsWithFranchise, index$1_goalies as goalies, misc$1 as misc, seasonGame as season, index$1_skaters as skaters, index$1_teams as teams };
 }
 
 interface GamecenterBoxscore {
@@ -387,7 +3088,7 @@ interface GamecenterBoxscore {
     easternUTCOffset: UTCOffset;
     venueUTCOffset: UTCOffset;
     tvBroadcasts: TvBroadcast[];
-    gameState: GameState;
+    gameState: GameState$2;
     gameScheduleState: GameScheduleState;
     periodDescriptor?: PeriodDescriptor$9;
     regPeriods: number;
@@ -601,7 +3302,7 @@ interface GamecenterLanding {
     venueTimezone: string;
     periodDescriptor?: PeriodDescriptor$8;
     tvBroadcasts: TvBroadcast[];
-    gameState: GameState;
+    gameState: GameState$2;
     gameScheduleState: GameScheduleState;
     awayTeam: LandingTeam;
     homeTeam: LandingTeam;
@@ -871,7 +3572,7 @@ interface ThreeStar$1 {
     savePctg?: number;
 }
 
-type NHLSeasons = Array<Season>;
+type NHLSeasons = Array<Season$1>;
 interface PlayoffSeriesMeta {
     seriesTitle: string;
     teams: Teams;
@@ -970,7 +3671,7 @@ interface GamecenterPlayByPlay {
     easternUTCOffset: UTCOffset;
     venueUTCOffset: UTCOffset;
     tvBroadcasts: TvBroadcast[];
-    gameState: GameState;
+    gameState: GameState$2;
     gameScheduleState: GameScheduleState;
     periodDescriptor?: PeriodDescriptor$7;
     awayTeam: Team$7;
@@ -1060,7 +3761,7 @@ interface RosterSpot {
     firstName: LocalizedText;
     lastName: LocalizedText;
     sweaterNumber: number;
-    positionCode: Position;
+    positionCode: PositionCode;
     headshot: string;
 }
 interface Situation {
@@ -1104,7 +3805,7 @@ interface PenaltyBoxElement {
     playerId: number;
     name: LocalizedText;
     sweaterNumber: number;
-    positionCode: Position;
+    positionCode: PositionCode;
     headshot: string;
     totalSOI?: number;
     secondsRemaining?: number;
@@ -1113,7 +3814,7 @@ interface GoalieElement {
     playerId: number;
     name: LocalizedText;
     sweaterNumber: number;
-    positionCode: Position;
+    positionCode: PositionCode;
     headshot: string;
     totalSOI?: number;
 }
@@ -1135,7 +3836,7 @@ interface PurpleForward {
     playerId: number;
     name: LocalizedText;
     sweaterNumber: number;
-    positionCode: Position;
+    positionCode: PositionCode;
     headshot: string;
     totalSOI?: number;
 }
@@ -1144,7 +3845,7 @@ interface PlayerSpotlight {
     playerId: number;
     name: LocalizedText;
     playerSlug: string;
-    position: Position;
+    position: PositionCode;
     sweaterNumber: number;
     teamId: number;
     headshot: string;
@@ -1159,7 +3860,7 @@ interface PlayerLanding {
     lastName: LocalizedText;
     badges: Badge[];
     sweaterNumber: number;
-    position: Position;
+    position: PositionCode;
     headshot: string;
     heroImage: string;
     heightInInches: number;
@@ -1170,7 +3871,7 @@ interface PlayerLanding {
     birthCity: LocalizedText;
     birthStateProvince?: LocalizedText;
     birthCountry: string;
-    shootsCatches: Position;
+    shootsCatches: ShootsCatches;
     draftDetails?: DraftDetails;
     playerSlug: string;
     inTop100AllTime: number;
@@ -1562,7 +4263,7 @@ interface BasePPTReplay {
     gameDate: string;
     awayTeam: Team$5;
     homeTeam: Team$5;
-    gameState: GameState;
+    gameState: GameState$2;
     gameType: number;
 }
 interface Team$5 {
@@ -1719,7 +4420,7 @@ interface SeasonSeriesGame {
     startTimeUTC: string;
     easternUTCOffset: UTCOffset;
     venueUTCOffset: UTCOffset;
-    gameState: GameState;
+    gameState: GameState$2;
     gameScheduleState: GameScheduleState;
     awayTeam: TeamDetail;
     homeTeam: TeamDetail;
@@ -1797,7 +4498,7 @@ interface Game$3 {
     easternUTCOffset: UTCOffset;
     venueUTCOffset: UTCOffset;
     venueTimezone: string;
-    gameState: GameState;
+    gameState: GameState$2;
     gameScheduleState: GameScheduleState;
     tvBroadcasts: TvBroadcast[];
     awayTeam: Team$4;
@@ -1902,7 +4603,7 @@ interface Game$2 {
     easternUTCOffset: UTCOffset;
     venueUTCOffset: UTCOffset;
     tvBroadcasts: TvBroadcast[];
-    gameState: GameState;
+    gameState: GameState$2;
     gameScheduleState: GameScheduleState;
     awayTeam: Team$3;
     homeTeam: Team$3;
@@ -1968,7 +4669,7 @@ interface Game$1 {
     easternUTCOffset: UTCOffset;
     venueUTCOffset: UTCOffset;
     tvBroadcasts: TvBroadcast[];
-    gameState: GameState;
+    gameState: GameState$2;
     gameScheduleState: GameScheduleState;
     awayTeam: Team$2;
     homeTeam: Team$2;
@@ -2140,7 +4841,7 @@ interface Goalie$3 extends BaseProspect {
     positionCode: 'G';
 }
 
-type TeamRosterSeasons = Array<Season>;
+type TeamRosterSeasons = Array<Season$1>;
 interface TeamRoster {
     forwards: Forward[];
     defensemen: Defenseman[];
@@ -2208,7 +4909,7 @@ interface Game {
     easternUTCOffset: string;
     venueUTCOffset: string;
     venueTimezone: string;
-    gameState: GameState;
+    gameState: GameState$2;
     gameScheduleState: GameScheduleState;
     tvBroadcasts: TvBroadcast[];
     awayTeam: Team$1;
@@ -2278,7 +4979,7 @@ interface WinningGoal {
     lastName: LocalizedText;
 }
 interface AlternateBroadcast {
-    country: CountryCode;
+    country: CountryCode$2;
     descriptions: LocalizedText[];
 }
 
@@ -2367,7 +5068,7 @@ interface WSCGameStory {
     venueUTCOffset: UTCOffset;
     venueTimezone: string;
     tvBroadcasts: TvBroadcast[];
-    gameState: GameState;
+    gameState: GameState$2;
     gameScheduleState: 'OK';
     awayTeam: Team;
     homeTeam: Team;
@@ -2613,7 +5314,7 @@ type PlayerSearchResult = Record<string, unknown>;
  * picks(2023, 1).then((data) => console.log(data));
  * ```
  */
-declare function picks(year?: Year, round?: DraftRound): Promise<APIResponse<DraftPicks>>;
+declare function picks(year?: Year, round?: DraftRound): Promise<APIResult<DraftPicks>>;
 /**
  * Get current draft tracker information for live draft coverage
  * @returns Promise resolving to current draft tracker data, including live pick information
@@ -2622,7 +5323,7 @@ declare function picks(year?: Year, round?: DraftRound): Promise<APIResponse<Dra
  * tracker().then((data) => console.log(data));
  * ```
  */
-declare function tracker(): Promise<APIResponse<DraftTracker>>;
+declare function tracker(): Promise<APIResult<DraftTracker>>;
 /**
  * Access draft rankings by category (skaters/goalies, NA/International)
  * @param year - The draft year (defaults to current year if not provided)
@@ -2637,11 +5338,11 @@ declare function tracker(): Promise<APIResponse<DraftTracker>>;
  * ```
  */
 declare function rankings(year?: Year): {
-    skatersNA: () => Promise<APIResponse<DraftRankings>>;
-    skatersIntl: () => Promise<APIResponse<DraftRankings>>;
-    goaliesNA: () => Promise<APIResponse<DraftRankings>>;
-    goaliesIntl: () => Promise<APIResponse<DraftRankings>>;
-    all: () => Promise<APIResponse<DraftRankings[]>>;
+    skatersNA: () => Promise<APIResult<DraftRankings>>;
+    skatersIntl: () => Promise<APIResult<DraftRankings>>;
+    goaliesNA: () => Promise<APIResult<DraftRankings>>;
+    goaliesIntl: () => Promise<APIResult<DraftRankings>>;
+    all: () => Promise<APIResult<DraftRankings[]>>;
 };
 
 declare const draft_picks: typeof picks;
@@ -2660,7 +5361,7 @@ declare namespace draft {
  * playByPlay(2023020001).then((data) => console.log(data));
  * ```
  */
-declare function playByPlay(gameId: GameId): Promise<APIResponse<GamecenterPlayByPlay>>;
+declare function playByPlay(gameId: GameId): Promise<APIResult<GamecenterPlayByPlay>>;
 /**
  * Get comprehensive game data including stats, reports, and game information
  *
@@ -2691,7 +5392,7 @@ declare function playByPlay(gameId: GameId): Promise<APIResponse<GamecenterPlayB
  * reports(2023020001).then((data) => console.log(data));
  * ```
  */
-declare function reports(gameId: GameId): Promise<APIResponse<GamecenterReports>>;
+declare function reports(gameId: GameId): Promise<APIResult<GamecenterReports>>;
 /**
  * Get landing page data for a specific game
  * @param gameId - The unique identifier for the game (10-digit format)
@@ -2701,7 +5402,7 @@ declare function reports(gameId: GameId): Promise<APIResponse<GamecenterReports>
  * landing(2023020001).then((data) => console.log(data));
  * ```
  */
-declare function landing$1(gameId: GameId): Promise<APIResponse<GamecenterLanding>>;
+declare function landing$1(gameId: GameId): Promise<APIResult<GamecenterLanding>>;
 /**
  * Get boxscore data for a specific game
  * @param gameId - The unique identifier for the game (10-digit format)
@@ -2711,7 +5412,7 @@ declare function landing$1(gameId: GameId): Promise<APIResponse<GamecenterLandin
  * boxscore(2023020001).then((data) => console.log(data));
  * ```
  */
-declare function boxscore(gameId: GameId): Promise<APIResponse<GamecenterBoxscore>>;
+declare function boxscore(gameId: GameId): Promise<APIResult<GamecenterBoxscore>>;
 /**
  * Access WSC Sports related game content endpoints
  * @description Alternative data source for game information
@@ -2729,7 +5430,7 @@ declare const wsc: {
  * wsc.gameStory(2023020001).then((data) => console.log(data));
  * ```
  */
-declare function wscGameStory(gameId: GameId): Promise<APIResponse<WSCGameStory>>;
+declare function wscGameStory(gameId: GameId): Promise<APIResult<WSCGameStory>>;
 /**
  * Get WSC play-by-play data for a specific game
  * @param gameId - The unique identifier for the game (10-digit format)
@@ -2739,7 +5440,7 @@ declare function wscGameStory(gameId: GameId): Promise<APIResponse<WSCGameStory>
  * wsc.playByPlay(2023020001).then((data) => console.log(data));
  * ```
  */
-declare function wscPlayByPlay(gameId: GameId): Promise<APIResponse<WSCPlayByPlay>>;
+declare function wscPlayByPlay(gameId: GameId): Promise<APIResult<WSCPlayByPlay>>;
 /**
  * Access PPT (Player and Puck Tracking) visualization data endpoints
  * @description Endpoints for accessing player and puck tracking data used for replay visualizations
@@ -2758,7 +5459,7 @@ declare const pptReplay: {
  * pptReplay.goal(2023020001, 42).then((data) => console.log(data));
  * ```
  */
-declare function pptReplayGoal(gameId: GameId, eventId: number | string): Promise<APIResponse<PPTReplayGoal>>;
+declare function pptReplayGoal(gameId: GameId, eventId: number | string): Promise<APIResult<PPTReplayGoal>>;
 /**
  * Get player and puck tracking visualization data for a specific event
  * @param gameId - The unique identifier for the game (10-digit format)
@@ -2769,7 +5470,7 @@ declare function pptReplayGoal(gameId: GameId, eventId: number | string): Promis
  * pptReplay.event(2023020001, 42).then((data) => console.log(data));
  * ```
  */
-declare function pptReplayEvent(gameId: GameId, eventId: number | string): Promise<APIResponse<PPTReplayEvent>>;
+declare function pptReplayEvent(gameId: GameId, eventId: number | string): Promise<APIResult<PPTReplayEvent>>;
 /**
  * Get the league schedule for a specific date
  * @param date - Date to get schedule for (Date object or ISO date string 'YYYY-MM-DD'). Defaults to current date
@@ -2783,7 +5484,7 @@ declare function pptReplayEvent(gameId: GameId, eventId: number | string): Promi
  * schedule('2023-11-15').then((data) => console.log(data));
  * ```
  */
-declare function schedule$1(date?: Date | string): Promise<APIResponse<LeagueSchedule>>;
+declare function schedule$1(date?: Date | string): Promise<APIResult<LeagueSchedule>>;
 /**
  * Get schedule calendar data for a specific date
  * @param date - Date to get calendar data for (Date object or ISO date string 'YYYY-MM-DD'). Defaults to current date
@@ -2793,7 +5494,7 @@ declare function schedule$1(date?: Date | string): Promise<APIResponse<LeagueSch
  * scheduleCalendar('2023-11-15').then((data) => console.log(data));
  * ```
  */
-declare function scheduleCalendar(date?: Date | string): Promise<APIResponse<ScheduleCalendar>>;
+declare function scheduleCalendar(date?: Date | string): Promise<APIResult<ScheduleCalendar>>;
 /**
  * Get playoff bracket data for a specific year
  * @param year - The playoff year (YYYY format). Defaults to current year
@@ -2803,7 +5504,7 @@ declare function scheduleCalendar(date?: Date | string): Promise<APIResponse<Sch
  * playoffBracket(2023).then((data) => console.log(data));
  * ```
  */
-declare function playoffBracket(year?: Year): Promise<APIResponse<PlayoffBracket>>;
+declare function playoffBracket(year?: Year): Promise<APIResult<PlayoffBracket>>;
 /**
  * Get playoff series information for a season
  * @param season - The season identifier (8-digit format: YYYYYYYY, e.g., 20232024). Defaults to current season
@@ -2813,7 +5514,7 @@ declare function playoffBracket(year?: Year): Promise<APIResponse<PlayoffBracket
  * playoffSeries(20232024).then((data) => console.log(data));
  * ```
  */
-declare function playoffSeries(season?: Season): Promise<APIResponse<PlayoffSeries>>;
+declare function playoffSeries(season?: Season$1): Promise<APIResult<PlayoffSeries>>;
 /**
  * Get schedule for a specific playoff series
  * @param seriesLetter - Single letter identifier for the playoff series (A-O)
@@ -2824,16 +5525,19 @@ declare function playoffSeries(season?: Season): Promise<APIResponse<PlayoffSeri
  * playoffSeriesSchedule('A', 20232024).then((data) => console.log(data));
  * ```
  */
-declare function playoffSeriesSchedule(seriesLetter: SeriesLetter$1, season?: Season): Promise<APIResponse<PlayoffSeriesSchedule>>;
+declare function playoffSeriesSchedule(seriesLetter: SeriesLetter$1, season?: Season$1): Promise<APIResult<PlayoffSeriesSchedule>>;
+declare function playoffSeriesSchedule(seriesLetter: string, season?: Season$1): Promise<APIResult<PlayoffSeriesSchedule>>;
 /**
  * Get information about where games are available to watch
+ * @deprecated The NHL retired this endpoint, and it now returns 404
+ * (`NotFoundError`). It will be removed in a future major version.
  * @returns Promise resolving to streaming and broadcast availability information
  * @example
  * ```ts
  * whereToWatch().then((data) => console.log(data));
  * ```
  */
-declare function whereToWatch(): Promise<APIResponse<WhereToWatch>>;
+declare function whereToWatch(): Promise<APIResult<WhereToWatch>>;
 /**
  * Get TV network schedule for a specific date
  * @param date - Date to get TV schedule for (Date object or ISO date string 'YYYY-MM-DD'). Defaults to current date
@@ -2843,7 +5547,7 @@ declare function whereToWatch(): Promise<APIResponse<WhereToWatch>>;
  * networkTVSchedule('2023-11-15').then((data) => console.log(data));
  * ```
  */
-declare function networkTVSchedule(date?: Date | string): Promise<APIResponse<NetworkTVSchedule>>;
+declare function networkTVSchedule(date?: Date | string): Promise<APIResult<NetworkTVSchedule>>;
 
 declare const game_boxscore: typeof boxscore;
 declare const game_networkTVSchedule: typeof networkTVSchedule;
@@ -2873,7 +5577,7 @@ declare namespace game {
  * seasons().then((data) => console.log(data));
  * ```
  */
-declare function seasons(): Promise<APIResponse<NHLSeasons>>;
+declare function seasons(): Promise<APIResult<NHLSeasons>>;
 /**
  * Access meta information endpoints
  * @description Get metadata about playoff series and games
@@ -2892,7 +5596,7 @@ declare const meta: {
  * meta.game(2023020001).then((data) => console.log(data));
  * ```
  */
-declare function metaGame(gameId: GameId): Promise<APIResponse<GameMeta>>;
+declare function metaGame(gameId: GameId): Promise<APIResult<GameMeta>>;
 /**
  * Get meta information for a playoff series
  *
@@ -2904,7 +5608,8 @@ declare function metaGame(gameId: GameId): Promise<APIResponse<GameMeta>>;
  * meta.playoffSeries('A', 2023).then((data) => console.log(data));
  * ```
  */
-declare function metaPlayoffSeries(seriesLetter: SeriesLetter$1, year?: Year): Promise<APIResponse<PlayoffSeriesMeta>>;
+declare function metaPlayoffSeries(seriesLetter: SeriesLetter$1, year?: Year): Promise<APIResult<PlayoffSeriesMeta>>;
+declare function metaPlayoffSeries(seriesLetter: string, year?: Year): Promise<APIResult<PlayoffSeriesMeta>>;
 /**
  * Lookup information based on postal/zip code
  *
@@ -2916,7 +5621,7 @@ declare function metaPlayoffSeries(seriesLetter: SeriesLetter$1, year?: Year): P
  * postalLookup('M5H 2N2').then((data) => console.log(data)); // Canadian postal
  * ```
  */
-declare function postalLookup(postalCode: PostalCode): Promise<APIResponse<PostalCodeInfo>>;
+declare function postalLookup(postalCode: PostalCode): Promise<APIResult<PostalCodeInfo>>;
 /**
  * Get location information based on IP address
  *
@@ -2927,7 +5632,7 @@ declare function postalLookup(postalCode: PostalCode): Promise<APIResponse<Posta
  * location().then((data) => console.log(data));
  * ```
  */
-declare function location(): Promise<APIResponse<LocationInfo>>;
+declare function location(): Promise<APIResult<LocationInfo>>;
 /**
  * Get partner game information for a specific country
  *
@@ -2938,7 +5643,7 @@ declare function location(): Promise<APIResponse<LocationInfo>>;
  * partnerGame('USA').then((data) => console.log(data));
  * ```
  */
-declare function partnerGame(countryCode: CountryCode$1): Promise<APIResponse<PartnerGameInfo>>;
+declare function partnerGame(countryCode: CountryCode): Promise<APIResult<PartnerGameInfo>>;
 
 declare const misc_location: typeof location;
 declare const misc_meta: typeof meta;
@@ -2963,7 +5668,7 @@ declare namespace misc {
  * landing(8478402).then((data) => console.log(data)); // Connor McDavid
  * ```
  */
-declare function landing(playerId: number | string): Promise<APIResponse<PlayerLanding>>;
+declare function landing(playerId: number | string): Promise<APIResult<PlayerLanding>>;
 /**
  * Get player game log for a specific season
  * @param playerId - The unique player identifier (NHL player ID number)
@@ -2975,7 +5680,8 @@ declare function landing(playerId: number | string): Promise<APIResponse<PlayerL
  * gameLog(8478402, 20232024, 2).then((data) => console.log(data));
  * ```
  */
-declare function gameLog(playerId: number | string, season?: Season, gameType?: GameType): Promise<APIResponse<PlayerGameLog>>;
+declare function gameLog(playerId: number | string, season?: Season$1, gameType?: GameType): Promise<APIResult<PlayerGameLog>>;
+declare function gameLog(playerId: number | string, season?: Season$1, gameType?: number | string): Promise<APIResult<PlayerGameLog>>;
 /**
  * Get player spotlight featuring highlighted players
  * @returns Promise resolving to featured/spotlight players
@@ -2984,17 +5690,18 @@ declare function gameLog(playerId: number | string, season?: Season, gameType?:
  * spotlight().then((data) => console.log(data));
  * ```
  */
-declare function spotlight(): Promise<APIResponse<PlayerSpotlight[]>>;
+declare function spotlight(): Promise<APIResult<PlayerSpotlight[]>>;
 /**
  * Search for players by name
  * @param query - The search query string (player name)
  * @returns Promise resolving to player search results
+ * @deprecated This endpoint is deprecated and may be removed in future versions. Use the NHL Stats API player endpoint instead.
  * @example
  * ```ts
  * search('McDavid').then((data) => console.log(data));
  * ```
  */
-declare function search(query: string): Promise<APIResponse<PlayerSearchResult>>;
+declare function search(query: string): Promise<APIResult<PlayerSearchResult[] | undefined>>;
 /**
  * Access stats leaders endpoints for skaters and goalies
  * @description Get statistical leaders across various categories
@@ -3013,7 +5720,7 @@ declare const statsLeaders: {
  * statsLeaders.skaters(20232024, 2).then((data) => console.log(data));
  * ```
  */
-declare function statsLeadersSkaters(season?: Season, gameType?: GameType): Promise<APIResponse<SkaterStatsLeaders>>;
+declare function statsLeadersSkaters(season?: Season$1, gameType?: GameType): Promise<APIResult<SkaterStatsLeaders>>;
 /**
  * Get goalie stats leaders
  * @param season - The season identifier (8-digit format: YYYYYYYY). Defaults to current season
@@ -3024,7 +5731,7 @@ declare function statsLeadersSkaters(season?: Season, gameType?: GameType): Prom
  * statsLeaders.goalies(20232024, 2).then((data) => console.log(data));
  * ```
  */
-declare function statsLeadersGoalies(season?: Season, gameType?: GameType): Promise<APIResponse<GoalieStatsLeaders>>;
+declare function statsLeadersGoalies(season?: Season$1, gameType?: GameType): Promise<APIResult<GoalieStatsLeaders>>;
 
 declare const player_gameLog: typeof gameLog;
 declare const player_landing: typeof landing;
@@ -3048,7 +5755,7 @@ declare namespace player {
  * score('2023-11-15').then((data) => console.log(data));
  * ```
  */
-declare function score(date?: Date | string): Promise<APIResponse<Score>>;
+declare function score(date?: Date | string): Promise<APIResult<Score>>;
 /**
  * Get current scoreboard information
  * @returns Promise resolving to current scoreboard with live and recent game data
@@ -3057,10 +5764,10 @@ declare function score(date?: Date | string): Promise<APIResponse<Score>>;
  * scoreboard().then((data) => console.log(data));
  * ```
  */
-declare function scoreboard(): Promise<APIResponse<Scoreboard>>;
+declare function scoreboard(): Promise<APIResult<Scoreboard>>;
 declare namespace scoreboard {
-    var team: (team: TeamAbbrev) => Promise<APIResponse<Scoreboard>>;
-    var date: (date: Date | string) => Promise<APIResponse<Scoreboard>>;
+    var team: (team: TeamAbbrev) => Promise<APIResult<Scoreboard>>;
+    var date: (date: Date | string) => Promise<APIResult<Scoreboard>>;
 }
 
 /**
@@ -3072,7 +5779,7 @@ declare namespace scoreboard {
  * rosterSeasons('TOR').then((data) => console.log(data));
  * ```
  */
-declare function rosterSeasons(team: TeamAbbrev): Promise<APIResponse<TeamRosterSeasons>>;
+declare function rosterSeasons(team: TeamAbbrev): Promise<APIResult<TeamRosterSeasons>>;
 /**
  * Get team roster for a specific season
  * @param team - The team abbreviation (e.g., 'TOR', 'MTL', 'NYR')
@@ -3083,7 +5790,7 @@ declare function rosterSeasons(team: TeamAbbrev): Promise<APIResponse<TeamRoster
  * roster('TOR', 20232024).then((data) => console.log(data));
  * ```
  */
-declare function roster(team: string, season?: string | number): Promise<APIResponse<TeamRoster>>;
+declare function roster(team: string, season?: string | number): Promise<APIResult<TeamRoster>>;
 /**
  * Get team prospects information
  * @param team - The team abbreviation (e.g., 'TOR', 'MTL', 'NYR')
@@ -3093,7 +5800,7 @@ declare function roster(team: string, season?: string | number): Promise<APIResp
  * prospects('TOR').then((data) => console.log(data));
  * ```
  */
-declare function prospects(team: TeamAbbrev): Promise<APIResponse<TeamProspects>>;
+declare function prospects(team: TeamAbbrev): Promise<APIResult<TeamProspects>>;
 /**
  * Get team statistics for a specific season
  * @param team - The team abbreviation (e.g., 'TOR', 'MTL', 'NYR')
@@ -3105,7 +5812,7 @@ declare function prospects(team: TeamAbbrev): Promise<APIResponse<TeamProspects>
  * stats('TOR', 20232024, 'REG').then((data) => console.log(data));
  * ```
  */
-declare function stats(team: TeamAbbrev, season?: Season, gameType?: GameType): Promise<APIResponse<TeamStats>>;
+declare function stats(team: TeamAbbrev, season?: Season$1, gameType?: GameType): Promise<APIResult<TeamStats>>;
 /**
  * Get valid season and game type options for a team's statistics
  * @param team - The team abbreviation (e.g., 'TOR', 'MTL', 'NYR')
@@ -3117,7 +5824,7 @@ declare function stats(team: TeamAbbrev, season?: Season, gameType?: GameType):
  * statsSeason('TOR').then((data) => console.log(data));
  * ```
  */
-declare function statsSeason(team: TeamAbbrev): Promise<APIResponse<TeamStatsSeason>>;
+declare function statsSeason(team: TeamAbbrev): Promise<APIResult<TeamStatsSeason>>;
 /**
  * Get league standings for a specific date
  * @param date - Date to get standings for (Date object or ISO date string 'YYYY-MM-DD'). Defaults to current date
@@ -3127,7 +5834,7 @@ declare function statsSeason(team: TeamAbbrev): Promise<APIResponse<TeamStatsSea
  * standings('2023-11-15').then((data) => console.log(data));
  * ```
  */
-declare function standings(date?: Date | string): Promise<APIResponse<NHLStandings>>;
+declare function standings(date?: Date | string): Promise<APIResult<NHLStandings>>;
 /**
  * Get current season standings information
  * @returns Promise resolving to current season standings with detailed team records
@@ -3136,7 +5843,7 @@ declare function standings(date?: Date | string): Promise<APIResponse<NHLStandin
  * standingsSeason().then((data) => console.log(data));
  * ```
  */
-declare function standingsSeason(): Promise<APIResponse<NHLStandingsSeason>>;
+declare function standingsSeason(): Promise<APIResult<NHLStandingsSeason>>;
 /**
  * Get the team schedule for any seven-day period
  * @param team - The team abbreviation (e.g., 'TOR', 'MTL', 'NYR')
@@ -3153,8 +5860,8 @@ declare function standingsSeason(): Promise<APIResponse<NHLStandingsSeason>>;
  * });
  * ```
  */
-declare function scheduleWeek(team: TeamAbbrev, date?: Date | string): Promise<APIResponse<TeamScheduleWeek>>;
-declare function scheduleWeek(team: string, date?: Date | string): Promise<APIResponse<TeamScheduleWeek>>;
+declare function scheduleWeek(team: TeamAbbrev, date?: Date | string): Promise<APIResult<TeamScheduleWeek>>;
+declare function scheduleWeek(team: string, date?: Date | string): Promise<APIResult<TeamScheduleWeek>>;
 /**
  * Get the team schedule for any month
  * @param team - The team abbreviation (e.g., 'TOR', 'MTL', 'NYR')
@@ -3170,8 +5877,8 @@ declare function scheduleWeek(team: string, date?: Date | string): Promise<APIRe
  * });
  * ```
  */
-declare function scheduleMonth(team: TeamAbbrev, date?: Date | string): Promise<APIResponse<TeamScheduleMonth>>;
-declare function scheduleMonth(team: string, date?: Date | string): Promise<APIResponse<TeamScheduleMonth>>;
+declare function scheduleMonth(team: TeamAbbrev, date?: Date | string): Promise<APIResult<TeamScheduleMonth>>;
+declare function scheduleMonth(team: string, date?: Date | string): Promise<APIResult<TeamScheduleMonth>>;
 /**
  * Returns the full season schedule for the provided team and season
  * @param team - The team abbreviation for the desired team (e.g., 'TOR', 'MTL', 'NYR')
@@ -3185,8 +5892,8 @@ declare function scheduleMonth(team: string, date?: Date | string): Promise<APIR
  * });
  * ```
  */
-declare function scheduleSeason(team: TeamAbbrev, season?: Season): Promise<APIResponse<TeamScheduleSeason>>;
-declare function scheduleSeason(team: string, season?: Season): Promise<APIResponse<TeamScheduleSeason>>;
+declare function scheduleSeason(team: TeamAbbrev, season?: Season$1): Promise<APIResult<TeamScheduleSeason>>;
+declare function scheduleSeason(team: string, season?: Season$1): Promise<APIResult<TeamScheduleSeason>>;
 /**
  * Access team schedule endpoints for different time periods
  * @description Get team schedules by season, week, or month
@@ -3226,297 +5933,154 @@ declare namespace index {
 }
 
 /**
- * All valid NHL team abbreviations and their corresponding team IDs.
- */
-declare const TeamsEnum: {
-    /** Anaheim Ducks */
-    readonly ANA: 24;
-    /** Boston Bruins */
-    readonly BOS: 6;
-    /** Buffalo Sabres */
-    readonly BUF: 7;
-    /** Calgary Flames */
-    readonly CGY: 20;
-    /** Carolina Hurricanes */
-    readonly CAR: 12;
-    /** Chicago Blackhawks */
-    readonly CHI: 16;
-    /** Colorado Avalanche */
-    readonly COL: 21;
-    /** Columbus Blue Jackets */
-    readonly CBJ: 29;
-    /** Dallas Stars */
-    readonly DAL: 25;
-    /** Detroit Red Wings */
-    readonly DET: 17;
-    /** Edmonton Oilers */
-    readonly EDM: 22;
-    /** Florida Panthers */
-    readonly FLA: 13;
-    /** Los Angeles Kings */
-    readonly LAK: 26;
-    /** Minnesota Wild*/
-    readonly MIN: 30;
-    /** Montreal Canadiens */
-    readonly MTL: 8;
-    /** New Jersey Devils */
-    readonly NJD: 1;
-    /** Nashville Predators */
-    readonly NSH: 18;
-    /** New York Islanders */
-    readonly NYI: 2;
-    /** New York Rangers */
-    readonly NYR: 3;
-    /** Ottawa Senators */
-    readonly OTT: 9;
-    /** Philadelphia Flyers */
-    readonly PHI: 4;
-    /** Pittsburgh Penguins */
-    readonly PIT: 5;
-    /** San Jose Sharks */
-    readonly SJS: 28;
-    /** Seattle Kraken */
-    readonly SEA: 55;
-    /** St. Louis Blues */
-    readonly STL: 19;
-    /** Tampa Bay Lightning */
-    readonly TBL: 14;
-    /** Toronto Maple Leafs */
-    readonly TOR: 10;
-    /** Utah Hockey Club */
-    readonly UTA: 59;
-    /** Vancouver Canucks */
-    readonly VAN: 23;
-    /** Vegas Golden Knights */
-    readonly VGK: 54;
-    /** Winnipeg Jets */
-    readonly WPG: 52;
-    /** Washington Capitals */
-    readonly WSH: 15;
-};
-declare const TeamsReverseEnum: Record<(typeof TeamsEnum)[keyof typeof TeamsEnum], keyof typeof TeamsEnum>;
-/**
- * All inactive NHL teams and their corresponding team IDs.
- */
-declare const InactiveTeamsEnum: {
-    /** Atlanta Flames (not active) */
-    readonly AFM: 47;
-    /** Arizona Coyotes (not active) */
-    readonly ARI: 53;
-    /** Atlanta Thrashers (not active) */
-    readonly ATL: 11;
-    /**  Brooklyn Americans - (not active) */
-    readonly BRK: 51;
-    /** California Golden Seals (aka Bay Area Seals) - (not active) */
-    readonly CGS: 56;
-    /** Cleveland Barons - (not active) */
-    readonly CLE: 49;
-    /** Colorado Rockies - (not active) */
-    readonly CLR: 35;
-    /** Detroit Cougars - (not active) */
-    readonly DCG: 40;
-    /** Detroit Falcons - (not active) */
-    readonly DFL: 50;
-    /** Hamilton Tigers - (not active) */
-    readonly HAM: 37;
-    /** Hartford Whalers - (not active) */
-    readonly HFD: 34;
-    /** Kansas City Scouts - (not active) */
-    readonly KCS: 48;
-    /** Montreal Maroons - (not active) */
-    readonly MMR: 43;
-    /** Minnesota North Stars - (not active) */
-    readonly MNS: 31;
-    /** Montreal Wanderers - (not active) */
-    readonly MWN: 41;
-    /** New York Americans - (not active) */
-    readonly NYA: 44;
-    /** California Seals (aka Oakland Seals) - (not active) */
-    readonly OAK: 46;
-    /** Phoenix Coyotes - (not active) */
-    readonly PHX: 27;
-    /** Pittsburgh Pirates - (not active) */
-    readonly PIR: 38;
-    /** Quebec Bulldogs - (not active) */
-    readonly QBD: 42;
-    /** Philadelphia Quakers - (not active) */
-    readonly QUA: 39;
-    /** Quebec Nordiques - (not active) */
-    readonly QUE: 32;
-    /** Ottawa Senators (original franchise) - (not active) */
-    readonly SEN: 36;
-    /** St. Louis Eagles - (not active) */
-    readonly SLE: 45;
-    /** Toronto Hockey Club (aka Toronto Arenas) - (not active) */
-    readonly TAN: 57;
-    /** Toronto St. Patricks - (not active) */
-    readonly TSP: 58;
-    /** Winnipeg Jets (original franchise) - (not active) */
-    readonly WIN: 33;
-};
-declare const InactiveTeamsReverseEnum: Record<(typeof InactiveTeamsEnum)[keyof typeof InactiveTeamsEnum], keyof typeof InactiveTeamsEnum>;
-/**
- * All valid NHL seasons in yyyyYYYY format.
- */
-declare const SeasonsArray: readonly [19171918, 19181919, 19191920, 19201921, 19211922, 19221923, 19231924, 19241925, 19251926, 19261927, 19271928, 19281929, 19291930, 19301931, 19311932, 19321933, 19331934, 19341935, 19351936, 19361937, 19371938, 19381939, 19391940, 19401941, 19411942, 19421943, 19431944, 19441945, 19451946, 19461947, 19471948, 19481949, 19491950, 19501951, 19511952, 19521953, 19531954, 19541955, 19551956, 19561957, 19571958, 19581959, 19591960, 19601961, 19611962, 19621963, 19631964, 19641965, 19651966, 19661967, 19671968, 19681969, 19691970, 19701971, 19711972, 19721973, 19731974, 19741975, 19751976, 19761977, 19771978, 19781979, 19791980, 19801981, 19811982, 19821983, 19831984, 19841985, 19851986, 19861987, 19871988, 19881989, 19891990, 19901991, 19911992, 19921993, 19931994, 19941995, 19951996, 19961997, 19971998, 19981999, 19992000, 20002001, 20012002, 20022003, 20032004, 20052006, 20062007, 20072008, 20082009, 20092010, 20102011, 20112012, 20122013, 20132014, 20142015, 20152016, 20162017, 20172018, 20182019, 20192020, 20202021, 20212022, 20222023, 20232024, 20242025, 20252026];
-/**
- * All valid NHL playoff series letters.
- */
-declare const SeriesLetterEnum: {
-    /** Atlantic Division Round 1: D1 vs WC# */
-    readonly A: "A";
-    /** Atlantic Division Round 1: D2 vs D3 */
-    readonly B: "B";
-    /** Metropolitan Division Round 1: D1 vs WC# */
-    readonly C: "C";
-    /** Metropolitan Division Round 1: D2 vs D3 */
-    readonly D: "D";
-    /** Central Division Round 1: D1 vs WC# */
-    readonly E: "E";
-    /** Central Division Round 1: D2 vs D3 */
-    readonly F: "F";
-    /** Pacific Division Round 1: D1 vs WC# */
-    readonly G: "G";
-    /** Pacific Division Round 1: D2 vs D3 */
-    readonly H: "H";
-    /** Atlantic Division Round 2: Aw vs Bw */
-    readonly I: "I";
-    /** Metropolitan Division Round 2: Cw vs Dw */
-    readonly J: "J";
-    /** Central Division Round 2: Ew vs Fw */
-    readonly K: "K";
-    /** Pacific Division Round 2: Gw vs Hw */
-    readonly L: "L";
-    /** Eastern Conference Finals */
-    readonly M: "M";
-    /** Western Conference Finals*/
-    readonly N: "N";
-    /** Stanley Cup Finals */
-    readonly O: "O";
-};
+ * ======================================================================
+ * NHL video metadata from Brightcove, the NHL's video host.
+ * Base URL: https://edge.api.brightcove.com/playback/v1
+ * ======================================================================
+ * Video ids come from `highlightClip` / `discreteClip` fields in Game
+ * Center responses (e.g. `gc.game.landing` goals). The policy key is the
+ * public one nhl.com's player sends.
+ */
+
+/** One rendition of a video */
+interface VideoSource {
+    src: string;
+    /** MIME type of a streaming manifest, e.g. application/x-mpegURL */
+    type?: string;
+    /** Container of a progressive download, e.g. MP4 */
+    container?: string;
+    codec?: string;
+    width?: number;
+    height?: number;
+}
+/** Metadata and playable sources for a video */
+interface VideoMetadata {
+    id: string;
+    title: string;
+    description: string | null;
+    longDescription: string | null;
+    /** Length in milliseconds */
+    duration: number;
+    publishedAt: string;
+    poster: string | null;
+    thumbnail: string | null;
+    /** The widest HTTPS MP4 rendition, or null when there is none */
+    url: string | null;
+    sources: VideoSource[];
+    tags: string[];
+}
 /**
- * All valid NHL playoff series letters grouped by round.
+ * Get a video's title, descriptions and playable sources
+ *
+ * @param videoId - Brightcove video id, e.g. a goal's `highlightClip`
+ * @returns Promise resolving to the video metadata; an unknown id gives a
+ * NotFoundError result
+ *
+ * @example
+ * const result = await video.metadata(6366156642112);
+ * if (result.success) console.log(result.data.title, result.data.url);
  */
-declare const SeriesLetterByRound: {
-    R1: string[];
-    R2: string[];
-    CF: string[];
-    SCF: string[];
-};
+declare function metadata(videoId: string | number): Promise<APIResult<VideoMetadata>>;
+
+type video_VideoMetadata = VideoMetadata;
+type video_VideoSource = VideoSource;
+declare const video_metadata: typeof metadata;
+declare namespace video {
+  export { type video_VideoMetadata as VideoMetadata, type video_VideoSource as VideoSource, video_metadata as metadata };
+}
+
 /**
- * All valid NHL playoff series letters mapped to human-readable names.
- */
-declare const PlayoffSeriesEnum: {
-    Atlantic_R1_D1_vs_WC: string;
-    Atlantic_R1_D2_vs_D3: string;
-    Metropolitan_R1_D1_vs_WC: string;
-    Metropolitan_R1_D2_vs_D3: string;
-    Central_R1_D1_vs_WC: string;
-    Central_R1_D2_vs_D3: string;
-    Pacific_R1_D1_vs_WC: string;
-    Pacific_R1_D2_vs_D3: string;
-    Atlantic_R2_Aw_vs_Bw: string;
-    Metropolitan_R2_Cw_vs_Dw: string;
-    Central_R2_Ew_vs_Fw: string;
-    Pacific_R2_Gw_vs_Hw: string;
-    Eastern_Conference_Finals: string;
-    Western_Conference_Finals: string;
-    Stanley_Cup_Finals: string;
-};
+ * NHL API Client implementation
+ * Internal client for making API requests to the NHL API
+ */
+
 /**
- * All valid NHL game states.
+ * Extended configuration for the NHL API client including error handling
  */
-declare const GameStateEnum: {
-    /** Future */
-    readonly FUT: "FUT";
-    /** Live */
-    readonly LIV: "LIV";
-    /** Finished */
-    readonly FIN: "FIN";
+interface NHLClientWithErrorConfig extends NHLClientConfig {
+    /**
+     * Error handling configuration
+     */
+    errorConfig?: ErrorConfig;
+}
+/** Base URLs of the NHL APIs the library calls. */
+declare const BASE_URLS: {
+    readonly gamecenter: "https://api-web.nhle.com/v1";
+    readonly edgeStats: "https://api.nhle.com/stats/rest";
 };
 /**
- * All valid NHL period types.
+ * NHL API Client class for making API requests to the NHL API
+ * Provides methods for sending GET requests to the NHL API with automatic
+ * URL construction, query parameter handling, timeout management, and
+ * comprehensive error handling using the ErrorHandler utility.
  */
-declare const PeriodTypeEnum: {
-    /** Regulation */
-    readonly REG: "REG";
-    /** Overtime */
-    readonly OT: "OT";
-    /** Shootout */
-    readonly SO: "SO";
-};
+declare class NHLClient {
+    private options;
+    private errorHandler;
+    /**
+     * Creates a new NHL API client instance
+     *
+     * 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(baseURLOrOptions?: string | NHLClientWithErrorConfig, errorConfig?: ErrorConfig);
+    /** Base URL, timeout, headers and language in effect for the next request. */
+    private get config();
+    /**
+     * Helper to build URL with query parameters
+     * @private
+     */
+    private buildUrl;
+    /**
+     * Send a GET request to the NHL API
+     * @param endpoint - API endpoint path
+     * @param params - Optional query parameters
+     * @returns Promise resolving to an APIResponse containing either data or error
+     */
+    get<T = unknown>(endpoint: string, params?: Record<string, unknown>): Promise<APIResult<T>>;
+    /**
+     * Configure error handling behavior
+     * @param config - Error configuration options
+     */
+    configureErrorHandling(config: Partial<ErrorConfig>): void;
+}
 /**
- * All valid NHL game types.
- */
-declare const GameTypeEnum: {
-    /** Pre-season */
-    readonly PRE: 1;
-    /** Regular season */
-    readonly REG: 2;
-    /** Post-season (aka playoffs) */
-    readonly POST: 3;
-    /** All-Star Game (unconfirmed) */
-    readonly ASG: 4;
-    /** International (unconfirmed) */
-    readonly INTL: 19;
-};
-/**  */
-declare const SEASON_RANGE: {
-    START: number;
-    END: number;
-};
-/**  */
-declare const START_SEASON: number;
-/**  */
-declare const END_SEASON: number;
-/**  */
-declare const YEAR_RANGE: {
-    START: number;
-    END: number;
-};
-/**  */
-declare const START_YEAR: number;
-/**  */
-declare const END_YEAR: number;
-/**  */
-declare const CURRENT: {
-    SEASON: number;
-    YEAR: number;
-};
-/**  */
-declare const PLAYER_ID_RANGE: {
-    readonly MIN: 8444000;
-    readonly MAX: 8489999;
-};
-/**  */
-declare const TEAM_ID_RANGE: {
-    readonly MIN: 1;
-    readonly MAX: 59;
-};
+ * Factory function for backward compatibility
+ * Creates a new NHL API client instance
+ *
+ * @param baseURL - Optional custom base URL or predefined API endpoint key
+ * @param errorConfig - Optional error handling configuration
+ * @returns A new NHL API client instance
+ */
+declare function createNHLClient(baseURLOrOptions?: string | NHLClientWithErrorConfig, errorConfig?: ErrorConfig): NHLClient;
 
-declare const nhl_CURRENT: typeof CURRENT;
-declare const nhl_END_SEASON: typeof END_SEASON;
-declare const nhl_END_YEAR: typeof END_YEAR;
-declare const nhl_GameStateEnum: typeof GameStateEnum;
-declare const nhl_GameTypeEnum: typeof GameTypeEnum;
-declare const nhl_InactiveTeamsEnum: typeof InactiveTeamsEnum;
-declare const nhl_InactiveTeamsReverseEnum: typeof InactiveTeamsReverseEnum;
-declare const nhl_PLAYER_ID_RANGE: typeof PLAYER_ID_RANGE;
-declare const nhl_PeriodTypeEnum: typeof PeriodTypeEnum;
-declare const nhl_PlayoffSeriesEnum: typeof PlayoffSeriesEnum;
-declare const nhl_SEASON_RANGE: typeof SEASON_RANGE;
-declare const nhl_START_SEASON: typeof START_SEASON;
-declare const nhl_START_YEAR: typeof START_YEAR;
-declare const nhl_SeasonsArray: typeof SeasonsArray;
-declare const nhl_SeriesLetterByRound: typeof SeriesLetterByRound;
-declare const nhl_SeriesLetterEnum: typeof SeriesLetterEnum;
-declare const nhl_TEAM_ID_RANGE: typeof TEAM_ID_RANGE;
-declare const nhl_TeamsEnum: typeof TeamsEnum;
-declare const nhl_TeamsReverseEnum: typeof TeamsReverseEnum;
-declare const nhl_YEAR_RANGE: typeof YEAR_RANGE;
-declare namespace nhl {
-  export { nhl_CURRENT as CURRENT, nhl_END_SEASON as END_SEASON, nhl_END_YEAR as END_YEAR, nhl_GameStateEnum as GameStateEnum, nhl_GameTypeEnum as GameTypeEnum, nhl_InactiveTeamsEnum as InactiveTeamsEnum, nhl_InactiveTeamsReverseEnum as InactiveTeamsReverseEnum, nhl_PLAYER_ID_RANGE as PLAYER_ID_RANGE, nhl_PeriodTypeEnum as PeriodTypeEnum, nhl_PlayoffSeriesEnum as PlayoffSeriesEnum, nhl_SEASON_RANGE as SEASON_RANGE, nhl_START_SEASON as START_SEASON, nhl_START_YEAR as START_YEAR, nhl_SeasonsArray as SeasonsArray, nhl_SeriesLetterByRound as SeriesLetterByRound, nhl_SeriesLetterEnum as SeriesLetterEnum, nhl_TEAM_ID_RANGE as TEAM_ID_RANGE, nhl_TeamsEnum as TeamsEnum, nhl_TeamsReverseEnum as TeamsReverseEnum, nhl_YEAR_RANGE as YEAR_RANGE };
-}
+/**
+ * Code-defined configuration for the NHL API client.
+ *
+ * Change these values in source when the application needs different
+ * defaults.
+ */
+type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug';
+interface NHLConfig {
+    /** Request timeout in milliseconds. */
+    timeout: number;
+    /** Language code for localized API responses. */
+    language: 'en' | 'fr';
+    /** Logging level for the client. */
+    logLevel: LogLevel;
+}
+/** Default configuration used by the shared NHL API clients. */
+declare const config: NHLConfig;
+/** Log the active code-defined configuration. */
+declare function logConfig(): void;
 
 declare const EDGE: {
     SaveLocationCategoryEnum: {
@@ -3589,4 +6153,15 @@ declare const EDGE: {
     };
 };
 
-export { type CountryCode$1 as CountryCode, type DraftPicks, type DraftRankings, type DraftRound, type DraftTracker, EDGE, type EventId, type GameId, type GameMeta, type GameNumber, type GameState$1 as GameState, type GameType, type GamecenterBoxscore, type GamecenterLanding, type GamecenterPlayByPlay, type GamecenterReports, type GoalieStatsLeaders, type LeagueSchedule, type LocationInfo, nhl as NHL, type NHLDate, type NHLMonth, type NHLSeasons, type NHLStandings, type NHLStandingsSeason, type NetworkTVSchedule, type PPTReplayEvent, type PPTReplayGoal, type PartnerGameInfo, type PlayerGameLog, type PlayerId, type PlayerLanding, type PlayerSearchResult, type PlayerSpotlight, type PlayoffBracket, type PlayoffRound, type PlayoffSeries, type PlayoffSeriesMeta, type PlayoffSeriesSchedule, type PositionFilter, type PostalCode, type PostalCodeInfo, type SaveLocationCategory, type SaveLocationSort, type SavePercentage5v5Sort, type SavePercentageSort, type ScheduleCalendar, type Score, type Scoreboard, type Season, type SeriesLetter$1 as SeriesLetter, type ShotLocationCategory, type ShotLocationSort, type ShotSpeedSort, type SkaterStatsLeaders, type SkatersStrength, type SkatingDistanceSort, type SkatingSpeedSort, type TeamAbbrev, type TeamId, type TeamProspects, type TeamRoster, type TeamRosterSeasons, type TeamScheduleMonth, type TeamScheduleSeason, type TeamScheduleWeek, type TeamStats, type TeamStatsSeason, type WSCGameStory, type WSCPlayByPlay, type WSCPlayByPlayEvent, type WhereToWatch, type Year, type ZoneTimeSort, index as gc };
+type LogContext = unknown;
+/** Write a message when its level is enabled by the configured threshold. */
+declare function writeLog(level: Exclude<LogLevel, 'silent'>, message: string, context?: LogContext, threshold?: LogLevel): void;
+/** Simple level-aware logging wrappers for library messages. */
+declare const logger: {
+    error: (message: string, context?: LogContext) => void;
+    warn: (message: string, context?: LogContext) => void;
+    info: (message: string, context?: LogContext) => void;
+    debug: (message: string, context?: LogContext) => void;
+};
+
+export { APIError, type APIResult, BASE_URLS, CayenneQueryBuilder, ClientError, type CountryCode, type DraftPicks, type DraftRankings, type DraftRound, type DraftTracker, EDGE, type EdgeByTheNumbers, type EdgeGoalieComparison, type EdgeGoalieDetail, type EdgeGoalieLanding, type EdgeGoalieSavePercentage, type EdgeGoalieSavePercentage5v5, type EdgeGoalieSavePercentage5v5Top10, type EdgeGoalieSavePercentage5v5Top10Entry, type EdgeGoalieSavePercentageTop10, type EdgeGoalieSavePercentageTop10Entry, type EdgeGoalieShotLocation, type EdgeGoalieShotLocationTop10, type EdgeGoalieShotLocationTop10Entry, type EdgeMeasurement, type EdgeOverlay, type EdgePeriodDescriptor, type EdgePlayer, type EdgeSeason, type EdgeSkaterComparison, type EdgeSkaterDetail, type EdgeSkaterDistanceTop10, type EdgeSkaterDistanceTop10Entry, type EdgeSkaterLanding, type EdgeSkaterShotLocation, type EdgeSkaterShotLocationTop10, type EdgeSkaterShotLocationTop10Entry, type EdgeSkaterShotSpeed, type EdgeSkaterShotSpeedTop10, type EdgeSkaterShotSpeedTop10Entry, type EdgeSkaterSkatingDistance, type EdgeSkaterSkatingSpeed, type EdgeSkaterSpeedTop10, type EdgeSkaterSpeedTop10Entry, type EdgeSkaterZoneTime, type EdgeSkaterZoneTimeTop10, type EdgeSkaterZoneTimeTop10Entry, type EdgeTeam, type EdgeTeamComparison, type EdgeTeamDetail, type EdgeTeamLanding, type EdgeTeamLogos, type EdgeTeamShotLocation, type EdgeTeamShotLocationTop10, type EdgeTeamShotLocationTop10Entry, type EdgeTeamShotSpeed, type EdgeTeamShotSpeedTop10, type EdgeTeamShotSpeedTop10Entry, type EdgeTeamSkatingDistance, type EdgeTeamSkatingDistanceTop10, type EdgeTeamSkatingDistanceTop10Entry, type EdgeTeamSkatingSpeed, type EdgeTeamSkatingSpeedTop10, type EdgeTeamSkatingSpeedTop10Entry, type EdgeTeamZoneTime, type EdgeTeamZoneTimeTop10, type EdgeTeamZoneTimeTop10Entry, ErrorCategory, type ErrorConfig, type ErrorContext, ErrorHandler, LogLevel$1 as ErrorLogLevel, type EventId, type GameId, type GameMeta, type GameNumber, type GameState, type GameType, type GamecenterBoxscore, type GamecenterLanding, type GamecenterPlayByPlay, type GamecenterReports, type GoalieStatsLeaders, type LeagueSchedule, type LocalizedText, type LocationInfo, type LogContext, type LogLevel, NHLClient, type NHLClientConfig, type NHLClientWithErrorConfig, type NHLConfig, type NHLDate, NHLError, type NHLMonth, type NHLSeasons, type NHLStandings, type NHLStandingsSeason, NetworkError, type NetworkTVSchedule, NotFoundError, type PPTReplayEvent, type PPTReplayGoal, ParseError, type PartnerGameInfo, type PlayerGameLog, type PlayerId, type PlayerLanding, type PlayerSearchResult, type PlayerSpotlight, type PlayoffBracket, type PlayoffRound, type PlayoffSeries, type PlayoffSeriesMeta, type PlayoffSeriesSchedule, type PositionFilter, type PostalCode, type PostalCodeInfo, RateLimitError, type SaveLocationCategory, type SaveLocationSort, type SavePercentage5v5Sort, type SavePercentageSort, type ScheduleCalendar, type Score, type Scoreboard, type Season$1 as Season, type SeriesLetter$1 as SeriesLetter, ServerError, type ShotLocationCategory, type ShotLocationSort, type ShotSpeedSort, type SkaterStatsLeaders, type SkatersStrength, type SkatingDistanceSort, type SkatingSpeedSort, type TeamAbbrev, type TeamId, type TeamProspects, type TeamRoster, type TeamRosterSeasons, type TeamScheduleMonth, type TeamScheduleSeason, type TeamScheduleWeek, type TeamStats, type TeamStatsSeason, ValidationError, type WSCGameStory, type WSCPlayByPlay, type WSCPlayByPlayEvent, type WhereToWatch, type Year, type ZoneTimeSort, index$2 as adv, config, createNHLClient, index as gc, logConfig, logger, index$1 as stats, video, writeLog };