nhle-api 0.5.1

package/lib/index.d.ts

@@ -0,0 +1,1623 @@
+import * as arktype_internal_variants_number_ts from 'arktype/internal/variants/number.ts';
+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 * as arktype_internal_attributes_ts from 'arktype/internal/attributes.ts';
+
+/**
+ * Error handling module for NHL Sports Data API wrapper
+ * Provides structured error classification and logging for API interactions
+ */
+declare const ErrorCategory: {
+    /** Network-level errors (connection refused, timeout, etc.) */
+    readonly NETWORK: "NETWORK";
+    /** HTTP 4xx client errors (invalid params, not found, etc.) */
+    readonly CLIENT: "CLIENT";
+    /** HTTP 5xx server errors */
+    readonly SERVER: "SERVER";
+    /** Rate limiting (HTTP 429) */
+    readonly RATE_LIMIT: "RATE_LIMIT";
+    /** Valid HTTP response but with error payload */
+    readonly API_ERROR: "API_ERROR";
+    /** Response parsing/validation failures */
+    readonly PARSE: "PARSE";
+    /** Invalid user input or configuration */
+    readonly VALIDATION: "VALIDATION";
+};
+type ErrorCategory = (typeof ErrorCategory)[keyof typeof ErrorCategory];
+interface ErrorContext {
+    /** HTTP status code if applicable */
+    statusCode?: number;
+    /** Original error object */
+    cause?: unknown;
+    /** Request URL or endpoint */
+    endpoint?: string;
+    /** Request method */
+    method?: string;
+    /** Request parameters */
+    params?: Record<string, unknown>;
+    /** Response body if available */
+    responseBody?: unknown;
+    /** Timestamp of error */
+    timestamp?: Date;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Base error class for all NHL API errors
+ */
+declare class NHLError extends Error {
+    readonly category: ErrorCategory;
+    readonly context: ErrorContext;
+    constructor(message: string, category: ErrorCategory, context?: ErrorContext);
+    /**
+     * Serialize error to JSON
+     */
+    toJSON(): {
+        stack?: string;
+        name: string;
+        message: string;
+        category: ErrorCategory;
+        context: ErrorContext;
+    };
+}
+
+/**
+ * NHL API Client Type Definitions
+ */
+
+type APIResponse<T> = {
+    status: 'success';
+    data: T;
+} | {
+    status: 'error';
+    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";
+};
+
+declare const Year$1: arktype.BaseType<number | ((In: string) => arktype_internal_attributes_ts.To<number>), {}>;
+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, {}>;
+declare const GameType$1: arktype.BaseType<1 | "1" | "2" | "3" | "4" | 2 | 3 | 4 | 19 | ((In: "REG" | "PRE" | "POST" | "ASG" | "INTL") => arktype.Out<1 | 2 | 3 | 4 | 19>) | "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 NHLDate$1: arktype_internal_variants_object_ts.ObjectType<(In: string | Date) => arktype.Out<string>, {}>;
+declare const NHLMonth$1: arktype_internal_variants_object_ts.ObjectType<(In: string | Date) => arktype.Out<string>, {}>;
+declare const GameId$1: arktype.BaseType<number | ((In: string) => arktype_internal_attributes_ts.To<number>), {}>;
+declare const SeriesLetter$1: arktype_internal_variants_string_ts.StringType<"A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O", {}>;
+declare const GameState$3: arktype_internal_variants_string_ts.StringType<"FUT" | "LIV" | "FIN", {}>;
+declare const CountryCode$3: arktype_internal_variants_object_ts.ObjectType<(In: string) => arktype.Out<string>, {}>;
+declare const PlayerId$1: arktype_internal_variants_object_ts.ObjectType<(In: string | number) => arktype.Out<string>, {}>;
+
+/**
+ * Type definitions for common parameters
+ */
+/**
+ * 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 = typeof Season$1.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;
+/**
+ * Represents a valid NHL team ID
+ */
+type TeamId = typeof TeamId$1.inferIn;
+/**
+ * Represents a valid NHL game number
+ */
+type GameNumber = typeof GameNumber$1.inferIn;
+/**
+ * Represents a valid NHL game state
+ */
+type GameState$2 = typeof GameState$3.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 = typeof SeriesLetter$1.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$2 = typeof CountryCode$3.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;
+
+/**
+ * Common types used in Gamecenter API responses
+ */
+/** GameState - The current state of the game. */
+type GameState$1 = 'OFF' | 'FUT' | 'LIVE' | 'PRE' | 'CRIT' | 'FINAL';
+/** Market - The market for this broadcast. (H = Home, A = Away, N = National) */
+type Market = 'H' | 'A' | 'N';
+/** CountryCode - The country code for this broadcast. (CA = Canada, US = United States) */
+type CountryCode$1 = 'CA' | 'US' | string;
+/** CountryTLA - The three-letter country code. */
+type CountryTLA = 'CAN' | 'FIN' | 'USA' | 'LAT' | 'CZE' | 'SWE' | 'CHE' | 'GER' | 'RUS' | 'AUT' | 'GBR' | 'NOR' | 'DEU' | 'SVK' | 'LVA' | 'BLR' | 'KAZ' | 'DNK' | 'ITA' | 'SUI' | 'FRA' | string;
+/**
+ * PositionCode - The position code for a player. (D = Defenseman, C = Center, R[W] = Right Wing, L[W] = Left Wing, G = Goalie)
+ * Note: The NHL data likes to switch between including and excluding the [W] for wing positions
+ */
+type PositionCode = 'D' | 'C' | 'L' | 'LW' | 'R' | 'RW' | 'G';
+/** ShootsCatches - Player's shooting/catching handedness. (L = Left, R = Right) */
+type ShootsCatches = 'L' | 'R';
+/** Default - An object containing a default string value. */
+interface Default {
+    default: string;
+}
+/** DefaultWithTranslations - An object containing a default string value as well as any alternative spellings for other languages. */
+interface DefaultWithTranslations extends Default {
+    /** French */
+    fr?: string;
+    /** Czech */
+    cs?: string;
+    /** Finnish */
+    fi?: string;
+    /** Slovak */
+    sk?: string;
+    /** Swedish */
+    sv?: string;
+    /** German */
+    de?: string;
+    /** Spanish */
+    es?: string;
+    [key: string]: string | undefined;
+}
+
+interface DraftPicks {
+    broadcastStartTimeUTC: string;
+    draftYear: number;
+    draftYears: number[];
+    selectableRounds: number[];
+    state: 'over' | string;
+    picks: Pick$1[];
+}
+interface Pick$1 {
+    round: number;
+    pickInRound: number;
+    overallPick: number;
+    teamId: number;
+    teamAbbrev: TeamAbbrev;
+    teamName: TeamName$1;
+    teamCommonName: TeamName$1;
+    teamPlaceNameWithPreposition: TeamName$1;
+    displayAbbrev: DisplayAbbrev;
+    teamLogoLight: string;
+    teamLogoDark: string;
+    teamPickHistory: string;
+    firstName: DisplayAbbrev;
+    lastName: DisplayAbbrev;
+    positionCode: PositionCode;
+    countryCode: CountryCode;
+    height: number;
+    weight: number;
+    amateurLeague: AmateurLeague$1;
+    amateurClubName: string;
+}
+type AmateurLeague$1 = 'OHL' | 'SWEDEN-2' | 'QMJHL' | 'H-EAST' | 'WHL' | 'RUSSIA-JR.' | 'BIG10' | 'USHL' | 'HIGH-MN' | 'NCHC' | 'SWEDEN-JR.' | 'NTDP - USHL' | 'SWEDEN' | 'CZECHIA' | 'FINLAND-JR.' | 'HIGH-ON' | 'CZECHIA-JR.' | 'GERMANY' | 'CCHL' | 'SWE-JR. U18' | 'SWISS-JR.' | 'FINLAND' | 'RUSSIA' | 'BCHL' | 'HIGH-RI' | 'SWISS' | 'HIGH-MA' | string;
+type CountryCode = 'CAN' | 'SWE' | 'USA' | 'CZE' | 'RUS' | 'FIN' | 'CHN' | 'AUS' | 'SVN' | 'SVK' | 'BLR' | 'DEU' | 'ITA' | 'CHE' | 'NOR' | 'DNK' | 'HRV' | string;
+type DisplayAbbrev = Default;
+type TeamName$1 = DefaultWithTranslations;
+
+interface DraftRankings {
+    draftYear: number;
+    categoryId: number;
+    categoryKey: Key;
+    draftYears: number[];
+    categories: Category[];
+    rankings: Ranking[];
+}
+interface Category {
+    id: number;
+    name: Name$1;
+    consumerKey: Key;
+}
+type Key = 'north-american-skater' | 'international-skater' | 'north-american-goalie' | 'international-goalie';
+type Name$1 = 'North American Skater' | 'International Skater' | 'North American Goalie' | 'International Goalie';
+interface Ranking {
+    lastName: string;
+    firstName: string;
+    positionCode: PositionCode;
+    shootsCatches: ShootsCatches;
+    heightInInches: number;
+    weightInPounds: number;
+    lastAmateurClub?: string;
+    lastAmateurLeague?: AmateurLeague;
+    birthDate: Date;
+    birthCity: string;
+    birthCountry: BirthCountry;
+    midtermRank?: number;
+    finalRank?: number;
+    birthStateProvince?: string;
+}
+type BirthCountry = 'RUS' | 'CHE' | 'SWE' | 'FIN' | 'CZE' | 'BLR' | 'CAN' | 'SVK' | 'USA' | 'LVA' | 'SVN' | 'AUS' | 'ITA' | 'DNK' | 'NOR' | 'AUT' | 'NLD' | 'DEU' | 'ESP' | 'BEL' | 'POL' | 'CHN' | 'HRV' | 'GBR' | 'KAZ';
+type AmateurLeague = 'RUSSIA-JR.' | 'SWISS-JR.' | 'SWEDEN-JR.' | 'FINLAND' | 'WHL' | 'SWEDEN-2' | 'FINLAND-JR.' | 'QMJHL' | 'USHL' | 'OHL' | 'H-EAST' | 'CCHL' | 'BCHL' | 'NAHL' | 'CZECHIA' | 'SWEDEN' | 'CZECHIA-JR.' | 'CZECHIA-2' | 'RUSSIA' | 'SWISS' | 'SLOVAKIA' | 'SWISS-2' | 'GERMANY' | 'FRANCE' | 'SLOVAKIA-JR.' | 'BIG10' | 'NCHC' | 'HIGH-MN' | 'NTDP - USHL' | 'HIGH-ON' | 'ECAC' | 'HIGH-RI' | 'HIGH-MA' | 'CCHA' | 'RUSSIA-2';
+
+interface DraftTracker {
+    currentDraftDate: Date;
+    broadcastStartTimeUTC: Date;
+    tvBroadcasts: TvBroadcast$2[];
+    logoUrl: string;
+    logoFrUrl: string;
+    uiAccentColor: HexColorCode;
+    round: number;
+    state: 'over' | string;
+    picks: Pick[];
+}
+interface Pick {
+    pickInRound: number;
+    overallPick: number;
+    teamId: number;
+    teamAbbrev: TeamAbbrev;
+    teamFullName: TeamName;
+    teamCommonName: TeamName;
+    teamPlaceNameWithPreposition: TeamName;
+    teamLogoLight: string;
+    teamLogoDark: string;
+    state: 'confirmed' | string;
+    lastName: Name;
+    firstName: Name;
+    positionCode: PositionCode;
+}
+type Name = DefaultWithTranslations;
+type TeamName = DefaultWithTranslations;
+type HexColorCode = `#${string}`;
+interface TvBroadcast$2 {
+    id: number;
+    market: Market;
+    countryCode: CountryCode$1;
+    network: string;
+    sequenceNumber: number;
+}
+
+interface NetworkTVSchedule {
+    date: string;
+    startDate: string;
+    endDate: string;
+    broadcasts: Broadcast[];
+}
+interface Broadcast {
+    startTime: string;
+    endTime: string;
+    durationSeconds: number;
+    title: string;
+    description: string;
+    houseNumber: string;
+    broadcastType: 'HD' | string;
+    broadcastStatus: 'LIVE' | '' | string;
+    broadcastImageUrl: string;
+}
+
+interface WhereToWatch {
+    id: string;
+    active: boolean;
+    countryCode: string;
+    countryName: string;
+    streamingName?: StreamingName;
+    streamingSiteUrl?: string;
+    streamingLogoUrl?: string;
+    primaryBroadcastName?: string;
+    primaryBroadcastSiteUrl?: string;
+    primaryBroadcastLogoUrl?: string;
+    secondaryBroadcastName?: string;
+    secondaryBroadcastSiteUrl?: string;
+    secondaryBroadcastLogoUrl?: string;
+}
+type StreamingName = 'NHL Live' | 'NHL.TV INTL' | 'ESPN+' | 'ESPN Play' | 'Disney Plus' | 'Disney+' | 'Viaplay' | 'TV24' | 'TV3' | string;
+
+interface GamecenterBoxscore {
+    id: number;
+    season: number;
+    gameType: number;
+    limitedScoring: boolean;
+    gameDate: Date;
+    venue: Default;
+    venueLocation: Default;
+    startTimeUTC: Date;
+    easternUTCOffset: string;
+    venueUTCOffset: string;
+    tvBroadcasts: TvBroadcast$1[];
+    gameState: GameState$1;
+    gameScheduleState: 'OK' | string;
+    periodDescriptor?: PeriodDescriptor$1;
+    regPeriods: number;
+    awayTeam: Team$1;
+    homeTeam: Team$1;
+    clock: Clock;
+    playerByGameStats?: PlayerByGameStats;
+    summary?: Summary;
+    gameOutcome?: GameOutcome$1;
+    situation?: Situation;
+}
+interface Team$1 {
+    id: number;
+    commonName: Default;
+    abbrev: string;
+    score?: number;
+    sog?: number;
+    logo: string;
+    darkLogo: string;
+    placeName: Default;
+    placeNameWithPreposition: DefaultWithTranslations;
+    radioLink?: string;
+}
+interface Clock {
+    timeRemaining: string;
+    secondsRemaining: number;
+    running: boolean;
+    inIntermission: boolean;
+}
+interface GameOutcome$1 {
+    lastPeriodType: string;
+}
+interface PeriodDescriptor$1 {
+    number: number;
+    periodType: string;
+    maxRegulationPeriods: number;
+}
+interface PlayerByGameStats {
+    awayTeam: PlayerByGameStatsTeam;
+    homeTeam: PlayerByGameStatsTeam;
+}
+type Position = 'C' | 'R' | 'L' | 'D';
+interface PlayerByGameStatsTeam {
+    forwards: Forward$1[];
+    defense: Defense[];
+    goalies: Goalie$1[];
+}
+interface Skater {
+    playerId: number;
+    sweaterNumber: number;
+    name: DefaultWithTranslations;
+    position: Exclude<Position, 'G'>;
+    goals: number;
+    assists: number;
+    points: number;
+    plusMinus: number;
+    pim: number;
+    hits: number;
+    powerPlayGoals: number;
+    sog: number;
+    faceoffWinningPctg: number;
+    toi: string;
+    blockedShots: number;
+    shifts: number;
+    giveaways: number;
+    takeaways: number;
+}
+interface Forward$1 extends Skater {
+    position: Exclude<Position, 'D' | 'G'>;
+}
+interface Defense extends Skater {
+    position: 'D';
+}
+interface Goalie$1 {
+    playerId: number;
+    sweaterNumber: number;
+    name: DefaultWithTranslations;
+    position: 'G';
+    evenStrengthShotsAgainst: string;
+    powerPlayShotsAgainst: string;
+    shorthandedShotsAgainst: string;
+    saveShotsAgainst: string;
+    savePctg?: number;
+    evenStrengthGoalsAgainst: number;
+    powerPlayGoalsAgainst: number;
+    shorthandedGoalsAgainst: number;
+    pim?: number;
+    goalsAgainst: number;
+    toi: string;
+    starter?: boolean;
+    decision?: string;
+    shotsAgainst: number;
+    saves: number;
+}
+interface Situation {
+    homeTeam: SituationDetails;
+    awayTeam: SituationDetails;
+    situationCode: string;
+    timeRemaining: string;
+    secondsRemaining: number;
+}
+interface SituationDetails {
+    abbrev: string;
+    situationDescriptions: string[];
+    strength: number;
+}
+type Summary = Record<string, unknown>;
+interface TvBroadcast$1 {
+    id: number;
+    market: Market;
+    countryCode: CountryCode$1;
+    network: string;
+    sequenceNumber: number;
+}
+
+interface NHLStandings {
+    wildCardIndicator: boolean;
+    standings: TeamStanding[];
+    standingsDateTimeUtc?: string;
+}
+interface TeamStanding {
+    conferenceAbbrev?: ConferenceAbbrev;
+    conferenceHomeSequence: number;
+    conferenceL10Sequence: number;
+    conferenceName?: ConferenceName;
+    conferenceRoadSequence: number;
+    conferenceSequence: number;
+    date: string;
+    divisionAbbrev?: DivisionAbbrev;
+    divisionHomeSequence: number;
+    divisionL10Sequence: number;
+    divisionName?: DivisionName;
+    divisionRoadSequence: number;
+    divisionSequence: number;
+    gameTypeId: number;
+    gamesPlayed: number;
+    goalDifferential: number;
+    goalDifferentialPctg: number;
+    goalAgainst: number;
+    goalFor: number;
+    goalsForPctg: number;
+    homeGamesPlayed: number;
+    homeGoalDifferential: number;
+    homeGoalsAgainst: number;
+    homeGoalsFor: number;
+    homeLosses: number;
+    homeOtLosses: number;
+    homePoints: number;
+    homeRegulationPlusOtWins: number;
+    homeRegulationWins: number;
+    homeTies: number;
+    homeWins: number;
+    l10GamesPlayed: number;
+    l10GoalDifferential: number;
+    l10GoalsAgainst: number;
+    l10GoalsFor: number;
+    l10Losses: number;
+    l10OtLosses: number;
+    l10Points: number;
+    l10RegulationPlusOtWins: number;
+    l10RegulationWins: number;
+    l10Ties: number;
+    l10Wins: number;
+    leagueHomeSequence: number;
+    leagueL10Sequence: number;
+    leagueRoadSequence: number;
+    leagueSequence: number;
+    losses: number;
+    otLosses: number;
+    placeName: DefaultWithTranslations;
+    pointPctg: number;
+    points: number;
+    regulationPlusOtWinPctg: number;
+    regulationPlusOtWins: number;
+    regulationWinPctg: number;
+    regulationWins: number;
+    roadGamesPlayed: number;
+    roadGoalDifferential: number;
+    roadGoalsAgainst: number;
+    roadGoalsFor: number;
+    roadLosses: number;
+    roadOtLosses: number;
+    roadPoints: number;
+    roadRegulationPlusOtWins: number;
+    roadRegulationWins: number;
+    roadTies: number;
+    roadWins: number;
+    seasonId: number;
+    shootoutLosses: number;
+    shootoutWins: number;
+    streakCode: StreakCode;
+    streakCount: number;
+    teamName: DefaultWithTranslations;
+    teamCommonName: DefaultWithTranslations;
+    teamAbbrev: Default;
+    teamLogo: string;
+    ties: number;
+    waiversSequence: number;
+    wildcardSequence: number;
+    winPctg: number;
+    wins: number;
+    clinchIndicator?: ClinchIndicator;
+}
+type ClinchIndicator = 'y' | 'x' | 'z' | 'p';
+type ConferenceAbbrev = 'E' | 'W' | 'XVW' | 'XVE' | '';
+type ConferenceName = 'Eastern' | 'Western' | 'Prince of Wales' | 'Clarence Campbell';
+type DivisionAbbrev = 'A' | 'C' | 'P' | 'M' | 'E' | 'W' | 'CEN' | 'ATL' | 'NE' | 'PAC' | 'NW' | 'SE' | 'ADM' | 'SMY' | 'PTK' | 'NRS' | 'EST' | 'WST' | 'NTH' | 'CDN' | 'AMR';
+type DivisionName = 'Atlantic' | 'Central' | 'Pacific' | 'Metropolitan' | 'East' | 'West' | 'Northeast' | 'Northwest' | 'Southeast' | 'Adams' | 'Smythe' | 'Patrick' | 'Norris' | 'Discover Central' | 'MassMutual East' | 'Honda West' | 'Scotia North' | 'Canadian' | 'American';
+type StreakCode = 'W' | 'L' | 'OT' | 'T';
+
+interface NHLStandingsSeason {
+    currentDate: string;
+    seasons: SeasonDetails[];
+}
+interface SeasonDetails {
+    id: number;
+    conferencesInUse: boolean;
+    divisionsInUse: boolean;
+    pointForOTlossInUse: boolean;
+    regulationWinsInUse: boolean;
+    /** Regulation and overtime wins in use for standings tie breaks */
+    rowInUse: boolean;
+    /** ISO 8601 date string */
+    standingsEnd: string;
+    /** ISO 8601 date string */
+    standingsStart: string;
+    tiesInUse: boolean;
+    wildcardInUse: boolean;
+}
+
+interface TeamProspects {
+    forwards: Forward[];
+    defensemen: Defenseman[];
+    goalies: Goalie[];
+}
+interface PlayerBase {
+    id: number;
+    headshot: string;
+    firstName: DefaultWithTranslations;
+    lastName: DefaultWithTranslations;
+    sweaterNumber?: number;
+    shootsCatches: ShootsCatches;
+    heightInInches: number;
+    weightInPounds: number;
+    heightInCentimeters: number;
+    weightInKilograms: number;
+    birthDate: string;
+    birthCity?: DefaultWithTranslations;
+    birthCountry: CountryTLA;
+    birthStateProvince?: DefaultWithTranslations;
+}
+interface Defenseman extends PlayerBase {
+    positionCode: 'D';
+}
+interface Forward extends PlayerBase {
+    positionCode: Exclude<PositionCode, 'D' | 'G'>;
+}
+interface Goalie extends PlayerBase {
+    positionCode: 'G';
+}
+
+interface TeamScheduleSeason {
+    previousSeason?: number;
+    currentSeason?: number;
+    clubTimezone: string;
+    clubUTCOffset: string;
+    games: Game[];
+}
+interface Game {
+    id: number;
+    season: number;
+    gameType: number;
+    gameDate: string;
+    venue: DefaultWithTranslations;
+    neutralSite: boolean;
+    startTimeUTC: string;
+    easternUTCOffset: string;
+    venueUTCOffset: string;
+    venueTimezone: string;
+    gameState: GameState;
+    gameScheduleState: GameScheduleState;
+    tvBroadcasts: TvBroadcast[];
+    awayTeam: Team;
+    homeTeam: Team;
+    periodDescriptor: PeriodDescriptor;
+    gameOutcome?: GameOutcome;
+    winningGoalie?: WinningGoal;
+    winningGoalScorer?: WinningGoal;
+    threeMinRecap?: string;
+    threeMinRecapFr?: string;
+    condensedGame?: string;
+    condensedGameFr?: string;
+    gameCenterLink?: string;
+    ticketsLink?: string;
+    ticketsLinkFr?: string;
+    specialEvent?: SpecialEvent;
+}
+interface Team {
+    id: number;
+    commonName: DefaultWithTranslations;
+    placeName: DefaultWithTranslations;
+    placeNameWithPreposition: DefaultWithTranslations;
+    abbrev: Abbrev;
+    logo: string;
+    darkLogo: string;
+    awaySplitSquad?: boolean;
+    score?: number;
+    airlineLink?: string;
+    airlineDesc?: string;
+    hotelLink?: string;
+    hotelDesc?: string;
+    radioLink?: string;
+    promoLink?: string;
+    promoDesc?: string;
+    homeSplitSquad?: boolean;
+}
+type Abbrev = 'ANA' | 'BOS' | 'BUF' | 'CAR' | 'CBJ' | 'CGY' | 'CHI' | 'COL' | 'DAL' | 'DET' | 'EDM' | 'FLA' | 'LAK' | 'MIN' | 'MTL' | 'NJD' | 'NSH' | 'NYI' | 'NYR' | 'OTT' | 'PHI' | 'PIT' | 'SEA' | 'SJS' | 'STL' | 'TBL' | 'TOR' | 'UTA' | 'VAN' | 'VGK' | 'WPG' | 'WSH';
+interface GameOutcome {
+    lastPeriodType: PeriodType;
+}
+type PeriodType = 'REG' | 'OT' | 'SO';
+type GameScheduleState = 'OK' | 'TBD';
+type GameState = 'FINAL' | 'OFF' | 'FUT' | 'LIVE';
+interface PeriodDescriptor {
+    periodType: PeriodType;
+    maxRegulationPeriods: number;
+}
+interface SpecialEvent {
+    parentId: number;
+    name: DefaultWithTranslations;
+}
+interface TvBroadcast {
+    id: number;
+    market: Market;
+    countryCode: CountryCode$1;
+    network: string;
+    sequenceNumber: number;
+}
+interface WinningGoal {
+    playerId: number;
+    firstInitial: Default;
+    lastName: DefaultWithTranslations;
+}
+
+type GamecenterPlayByPlay = Record<string, unknown>;
+type GamecenterReports = Record<string, unknown>;
+type GamecenterLanding = Record<string, unknown>;
+
+type WSCGameStory = Record<string, unknown>;
+type WSCPlayByPlay = Record<string, unknown>;
+type PPTReplayGoal = Record<string, unknown>;
+type PPTReplayEvent = Record<string, unknown>;
+type LeagueSchedule = Record<string, unknown>;
+type ScheduleCalendar = Record<string, unknown>;
+type PlayoffBracket = Record<string, unknown>;
+type PlayoffSeries = Record<string, unknown>;
+type PlayoffSeriesSchedule = Record<string, unknown>;
+type NHLSeasons = Record<string, unknown>;
+type PlayoffSeriesMeta = Record<string, unknown>;
+type GameMeta = Record<string, unknown>;
+type PostalCodeInfo = Record<string, unknown>;
+type LocationInfo = Record<string, unknown>;
+type PartnerGameInfo = Record<string, unknown>;
+
+type TeamRoster = Record<string, unknown>;
+type TeamRosterSeasons = Record<string, unknown>;
+
+type TeamScheduleMonth = Record<string, unknown>;
+
+type TeamScheduleWeek = Record<string, unknown>;
+type TeamStats = Record<string, unknown>;
+type TeamStatsSeason = Record<string, unknown>;
+type PlayerLanding = Record<string, unknown>;
+type PlayerGameLog = Record<string, unknown>;
+type PlayerSpotlight = Record<string, unknown>;
+type PlayerSearchResult = Record<string, unknown>;
+type SkaterStatsLeaders = Record<string, unknown>;
+type GoalieStatsLeaders = Record<string, unknown>;
+type NHLScore = Record<string, unknown>;
+type NHLScoreboard = Record<string, unknown>;
+
+/**
+ * Draft-related API endpoints
+ */
+
+/**
+ * Get draft picks for a specific year and round
+ * @param year - The draft year
+ * @param round - The draft round
+ * @returns Promise resolving to draft picks for the specified year and round
+ */
+declare const picks: (year?: Year, round?: DraftRound) => Promise<APIResponse<DraftPicks>>;
+/**
+ * Get current draft tracker information
+ * @returns Promise resolving to current draft tracker data
+ */
+declare const tracker: () => Promise<APIResponse<DraftTracker>>;
+/**
+ * Access draft rankings related endpoints
+ */
+declare const rankings: (year?: Year) => {
+    skatersNA: () => Promise<APIResponse<DraftRankings>>;
+    skatersIntl: () => Promise<APIResponse<DraftRankings>>;
+    goaliesNA: () => Promise<APIResponse<DraftRankings>>;
+    goaliesIntl: () => Promise<APIResponse<DraftRankings>>;
+    all: () => Promise<APIResponse<DraftRankings>[]>;
+};
+
+declare const draft_picks: typeof picks;
+declare const draft_rankings: typeof rankings;
+declare const draft_tracker: typeof tracker;
+declare namespace draft {
+  export { draft_picks as picks, draft_rankings as rankings, draft_tracker as tracker };
+}
+
+/**
+ * Get play-by-play data for a specific game
+ * @param gameId - The unique identifier for the game
+ * @returns Promise resolving to play-by-play data
+ */
+declare const playByPlay: (gameId: string | number) => Promise<APIResponse<GamecenterPlayByPlay>>;
+/**
+ * Get reports data for a specific game
+ * @param gameId - The unique identifier for the game
+ * @returns Promise resolving to reports data
+ * @note The official endpoint name is 'right-rail', as it is used
+ * to populate the right rail UI component of the NHL website. The
+ * function has been renamed to 'reports' for clarity.
+ */
+declare const reports: (gameId: string | number) => Promise<APIResponse<GamecenterReports>>;
+/**
+ * Get landing page data for a specific game
+ * @param gameId - The unique identifier for the game
+ * @returns Promise resolving to landing page data
+ */
+declare const landing$1: (gameId: string | number) => Promise<APIResponse<GamecenterLanding>>;
+/**
+ * Get boxscore data for a specific game
+ * @param gameId - The unique identifier for the game
+ * @returns Promise resolving to boxscore data
+ */
+declare const boxscore: (gameId: string | number) => Promise<APIResponse<GamecenterBoxscore>>;
+declare const wsc: {
+    /**
+     * Get game story data for a specific game
+     * @param gameId - The unique identifier for the game
+     * @returns Promise resolving to game story data
+     */
+    gameStory: (gameId: number | string) => Promise<APIResponse<WSCGameStory>>;
+    /**
+     * Get play-by-play data for a specific game
+     * @param gameId - The unique identifier for the game
+     * @returns Promise resolving to play-by-play data
+     */
+    playByPlay: (gameId: number | string) => Promise<APIResponse<WSCPlayByPlay>>;
+};
+/**
+ * Access PPT replay related endpoints
+ */
+declare const pptReplay: {
+    /**
+     * Get goal replay data for a specific game and event
+     * @param gameId - The unique identifier for the game
+     * @param eventId - The unique identifier for the event
+     * @returns Promise resolving to goal replay data
+     */
+    goal: (gameId: number | string, eventId: number | string) => Promise<APIResponse<PPTReplayGoal>>;
+    /**
+     * Get event replay data for a specific date
+     * @param date - Date to get event replay data for (Date object or ISO date string)
+     * @returns Promise resolving to event replay data
+     */
+    event: (date: Date | string) => Promise<APIResponse<PPTReplayEvent>>;
+};
+/**
+ * Access schedule related endpoints
+ */
+declare const schedule$1: (date?: Date | string) => Promise<APIResponse<LeagueSchedule>>;
+/**
+ * Access schedule calendar related endpoints
+ */
+declare const scheduleCalendar: (date?: Date | string) => Promise<APIResponse<ScheduleCalendar>>;
+/**
+ * Access playoff bracket related endpoints
+ */
+declare const playoffBracket: (year?: string) => Promise<APIResponse<PlayoffBracket>>;
+/**
+ * Access playoff series related endpoints
+ */
+declare const playoffSeries: (season?: string) => Promise<APIResponse<PlayoffSeries>>;
+/**
+ * Access playoff series schedule related endpoints
+ */
+declare const playoffSeriesSchedule: (seriesLetter: string, season?: string) => Promise<APIResponse<PlayoffSeriesSchedule>>;
+/**
+ * Access where-to-watch related endpoints
+ */
+declare const whereToWatch: () => Promise<APIResponse<WhereToWatch>>;
+/**
+ * Access network related endpoints
+ */
+/**
+ * Get TV schedule data for a specific date
+ * @param date - Date to get TV schedule data for (optional)
+ * @returns Promise resolving to TV schedule data
+ */
+declare const networkTVSchedule: (date?: Date | string) => Promise<APIResponse<NetworkTVSchedule>>;
+
+declare const game_boxscore: typeof boxscore;
+declare const game_networkTVSchedule: typeof networkTVSchedule;
+declare const game_playByPlay: typeof playByPlay;
+declare const game_playoffBracket: typeof playoffBracket;
+declare const game_playoffSeries: typeof playoffSeries;
+declare const game_playoffSeriesSchedule: typeof playoffSeriesSchedule;
+declare const game_pptReplay: typeof pptReplay;
+declare const game_reports: typeof reports;
+declare const game_scheduleCalendar: typeof scheduleCalendar;
+declare const game_whereToWatch: typeof whereToWatch;
+declare const game_wsc: typeof wsc;
+declare namespace game {
+  export { game_boxscore as boxscore, landing$1 as landing, game_networkTVSchedule as networkTVSchedule, game_playByPlay as playByPlay, game_playoffBracket as playoffBracket, game_playoffSeries as playoffSeries, game_playoffSeriesSchedule as playoffSeriesSchedule, game_pptReplay as pptReplay, game_reports as reports, schedule$1 as schedule, game_scheduleCalendar as scheduleCalendar, game_whereToWatch as whereToWatch, game_wsc as wsc };
+}
+
+/**
+ * @module api/misc
+ * @description Miscellaneous NHL API endpoints for meta information, location data, and other utility functions
+ */
+
+declare const seasons: () => Promise<APIResponse<NHLSeasons>>;
+declare const meta: {
+    /**
+     * Get meta information for a playoff series
+     *
+     * @param year - The year in YYYY format
+     * @param seriesLetter - Single letter identifier for the playoff series
+     * @returns Promise resolving to playoff series meta information
+     */
+    playoffSeries: (seriesLetter: string, year?: number | string) => Promise<APIResponse<PlayoffSeriesMeta>>;
+    /**
+     * Get meta information for a specific game
+     *
+     * @param gameId - The unique game identifier
+     * @returns Promise resolving to game meta information
+     */
+    game: (gameId: string | number) => Promise<APIResponse<GameMeta>>;
+};
+/**
+ * Lookup information based on postal code
+ *
+ * @param postalCode - The postal/zip code to lookup
+ * @returns Promise resolving to postal code information
+ */
+declare const postalLookup: (postalCode: string) => Promise<APIResponse<PostalCodeInfo>>;
+/**
+ * Get location information
+ *
+ * @returns Promise resolving to the location determined by the API
+ *          (assumed to be based on the user's IP address)
+ */
+declare const location: () => Promise<APIResponse<LocationInfo>>;
+/**
+ * Get partner game information for a specific country
+ *
+ * @param countryCode - The two-letter country code (e.g. 'ca', 'se', 'cz', etc.)
+ * @returns Promise resolving to partner game information
+ */
+declare const partnerGame: (countryCode: string) => Promise<APIResponse<PartnerGameInfo>>;
+
+declare const misc_location: typeof location;
+declare const misc_meta: typeof meta;
+declare const misc_partnerGame: typeof partnerGame;
+declare const misc_postalLookup: typeof postalLookup;
+declare const misc_seasons: typeof seasons;
+declare namespace misc {
+  export { misc_location as location, misc_meta as meta, misc_partnerGame as partnerGame, misc_postalLookup as postalLookup, misc_seasons as seasons };
+}
+
+/**
+ *
+ */
+
+/**
+ * Get player landing information
+ * @param playerId - The unique player identifier
+ * @returns Promise resolving to player landing information
+ */
+declare const landing: (playerId: number | string) => Promise<APIResponse<PlayerLanding>>;
+declare const gameLog: (playerId: number | string, season?: number | string, gameType?: number | string) => Promise<APIResponse<PlayerGameLog>>;
+declare const spotlight: () => Promise<APIResponse<PlayerSpotlight>>;
+declare const search: (query: string) => Promise<APIResponse<PlayerSearchResult>>;
+/**
+ * Access stats leaders related endpoints
+ */
+declare const statsLeaders: {
+    /**
+     * Get skater stats leaders
+     * @param season - The season identifier (optional)
+     * @param gameType - The game type identifier (optional)
+     * @returns Promise resolving to skater stats leaders
+     */
+    skaters: (season?: number | string, gameType?: number | string) => Promise<APIResponse<SkaterStatsLeaders>>;
+    /**
+     * Get goalie stats leaders
+     * @param season - The season identifier (optional)
+     * @param gameType - The game type identifier (optional)
+     * @returns Promise resolving to goalie stats leaders
+     */
+    goalies: (season?: number | string, gameType?: number | string) => Promise<APIResponse<GoalieStatsLeaders>>;
+};
+
+declare const player_gameLog: typeof gameLog;
+declare const player_landing: typeof landing;
+declare const player_search: typeof search;
+declare const player_spotlight: typeof spotlight;
+declare const player_statsLeaders: typeof statsLeaders;
+declare namespace player {
+  export { player_gameLog as gameLog, player_landing as landing, player_search as search, player_spotlight as spotlight, player_statsLeaders as statsLeaders };
+}
+
+/**
+ * Access score related endpoints
+ */
+/**
+ * Get scores for a specific date
+ * @param date - Date to get scores for (Date object or ISO date string)
+ * @returns Promise resolving to scores for the specified date
+ */
+declare const score: (date?: Date | string) => Promise<APIResponse<NHLScore>>;
+/**
+ * Access scoreboard related endpoints
+ */
+declare const scoreboard: {
+    (): Promise<APIResponse<NHLScoreboard>>;
+    team(team: TeamAbbrev): Promise<APIResponse<NHLScoreboard>>;
+    date(date: Date | string): Promise<APIResponse<NHLScoreboard>>;
+};
+
+/**
+ * Access roster seasons related endpoints
+ */
+declare const rosterSeasons: (team: string) => Promise<APIResponse<TeamRosterSeasons>>;
+/**
+ * Access roster related endpoints
+ */
+declare const roster: (team: string, season?: string | number) => Promise<APIResponse<TeamRoster>>;
+/**
+ * Access prospects related endpoints
+ */
+declare const prospects: (team: string) => Promise<APIResponse<TeamProspects>>;
+/**
+ * Access club stats related endpoints
+ */
+declare const clubStats: (team: string, season?: string | number, gameType?: string | number) => Promise<APIResponse<TeamStats>>;
+/**
+ * Access club stats season related endpoints
+ */
+declare const clubStatsSeason: (team: string) => Promise<APIResponse<TeamStatsSeason>>;
+/**
+ * Access standings related endpoints
+ */
+declare const standings: (date?: Date | string) => Promise<APIResponse<NHLStandings>>;
+/**
+ * Access standings season related endpoints
+ */
+declare const standingsSeason: () => Promise<APIResponse<NHLStandingsSeason>>;
+declare const schedule: {
+    /** Returns the full season schedule for the provided team and season
+     * @param team - The team abbreviation for the desired team
+     * @param season - The specific season (e.g. 20222023); if not provided, defaults to the current season.
+     * @returns A promise that resolves to the full season schedule for the specified team and season
+     * @example
+     * ```ts
+     * // Get the full season schedule for the Boston Bruins for the 2022-2023 season
+     * schedule.season('BOS', 20222023).then((data) => {
+     *    console.log(data);
+     * });
+     * ```
+     */
+    season: (team: string, season?: number) => Promise<APIResponse<TeamScheduleSeason>>;
+    /**
+     * Get the team schedule for any seven-day period
+     * @param team - The team abbreviation
+     * @param date - The date indicating the start of the seven-day period.
+     * If not provided, defaults to the current date. format: 'YYYY-MM'
+     * @returns A promise that resolves to the club schedule for the specified week
+     *
+     * @example
+     * ```ts
+     * import { schedule } from 'nhle-api';
+     *
+     * // Get the schedule for the Chicago Blackhawks for the week of November 4, 2023
+     * // This returns the schedule from November 4 to November 10, 2023
+     * schedule.week('CHI', '2023-11-04').then((data) => {
+     *    console.log(data);
+     * });
+     * ```
+     */
+    week: (team: string, date?: Date | string) => Promise<APIResponse<TeamScheduleWeek>>;
+    /**
+     * Get the team schedule for any month
+     * @param team - The team abbreviation
+     * @param date - The date indicating the month to get the schedule for.
+     * If not provided, defaults to the current month. format: 'YYYY-MM'
+     * @returns A promise that resolves to the club schedule for the specified month
+     *
+     * @example
+     * ```ts
+     * import { schedule } from 'nhle-api';
+     *
+     * // Get the schedule for the Toronto Maple Leafs for November 2023
+     * schedule.month('TOR', '2023-11').then((data) => {
+     *    console.log(data);
+     * });
+     * ```
+     */
+    month: (team: string, date?: NHLMonth) => Promise<APIResponse<TeamScheduleMonth>>;
+};
+
+declare const team_clubStats: typeof clubStats;
+declare const team_clubStatsSeason: typeof clubStatsSeason;
+declare const team_prospects: typeof prospects;
+declare const team_roster: typeof roster;
+declare const team_rosterSeasons: typeof rosterSeasons;
+declare const team_schedule: typeof schedule;
+declare const team_standings: typeof standings;
+declare const team_standingsSeason: typeof standingsSeason;
+declare namespace team {
+  export { team_clubStats as clubStats, team_clubStatsSeason as clubStatsSeason, team_prospects as prospects, team_roster as roster, team_rosterSeasons as rosterSeasons, team_schedule as schedule, team_standings as standings, team_standingsSeason as standingsSeason };
+}
+
+/**
+ * NHL API Endpoints
+ * This file re-exports all the API endpoint functions
+ */
+
+declare const index_draft: typeof draft;
+declare const index_game: typeof game;
+declare const index_misc: typeof misc;
+declare const index_player: typeof player;
+declare const index_score: typeof score;
+declare const index_scoreboard: typeof scoreboard;
+declare const index_team: typeof team;
+declare namespace index {
+  export { index_draft as draft, index_game as game, index_misc as misc, index_player as player, index_score as score, index_scoreboard as scoreboard, index_team as team };
+}
+
+/**
+ * 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";
+};
+/**
+ * All valid NHL playoff series letters grouped by round.
+ */
+declare const SeriesLetterByRound: {
+    R1: string[];
+    R2: string[];
+    CF: string[];
+    SCF: string[];
+};
+/**
+ * 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;
+};
+/**
+ * All valid NHL game states.
+ */
+declare const GameStateEnum: {
+    /** Future */
+    readonly FUT: "FUT";
+    /** Live */
+    readonly LIV: "LIV";
+    /** Finished */
+    readonly FIN: "FIN";
+};
+/**
+ * All valid NHL period types.
+ */
+declare const PeriodTypeEnum: {
+    /** Regulation */
+    readonly REG: "REG";
+    /** Overtime */
+    readonly OT: "OT";
+    /** Shootout */
+    readonly SO: "SO";
+};
+/**
+ * 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;
+};
+
+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 };
+}
+
+declare const EDGE: {
+    SaveLocationCategoryEnum: {
+        readonly 'SV%': "save-pctg";
+        readonly SV: "saves";
+        readonly SA: "shots-against";
+        readonly GA: "goals-against";
+    };
+    ShotLocationSortEnum: {
+        readonly ALL: "all";
+        readonly HIGH: "high";
+        readonly MID: "mid";
+        readonly LONG: "long";
+    };
+    SaveLocationSortEnum: {
+        readonly ALL: "all";
+        readonly HIGH: "high";
+        readonly MID: "mid";
+        readonly LONG: "long";
+    };
+    SavePercentage5v5SortEnum: {
+        readonly '5v5-SV%': "save-pctg";
+        readonly '5v5-SV%-Close': "save-pctg-close";
+        readonly '5v5-SA': "shots";
+        readonly '5v5-SA/60': "shots-per-60";
+    };
+    SavePercentageSortEnum: {
+        readonly GAMES: "games";
+        readonly PCTG: "pctg";
+    };
+    PositionFilterEnum: {
+        readonly ALL: "all";
+        readonly FWD: "forwards";
+        readonly DEF: "defense";
+    };
+    SkatersStrengthEnum: {
+        readonly ALL: "all";
+        readonly ES: "es";
+        readonly PP: "pp";
+        readonly PK: "pk";
+    };
+    ShotSpeedSortEnum: {
+        readonly MAX: "max";
+        readonly 'OVER-100': "over-100";
+        readonly '90-99': "90-99";
+        readonly '80-89': "80-89";
+        readonly '70-79': "70-79";
+    };
+    SkatingSpeedSortEnum: {
+        readonly TOP: "max";
+        readonly 'OVER-22': "over-22";
+        readonly '20-22': "20-22";
+        readonly '18-20': "18-20";
+    };
+    SkatingDistanceSortEnum: {
+        TOTAL: string;
+        'PER-60': string;
+        'MAX-PERIOD': string;
+        'MAX-GAME': string;
+    };
+    ShotLocationCategoryEnum: {
+        readonly SOG: "sog";
+        readonly G: "goals";
+        readonly 'SH%': "shooting-pctg";
+    };
+    ZoneTimeSortEnum: {
+        readonly OZ: "offensive";
+        readonly DZ: "defensive";
+        readonly NZ: "neutral";
+    };
+};
+
+export { type AmateurLeague, type BirthCountry, type Broadcast, type Category, type CountryCode$2 as CountryCode, type DraftPicks, type DraftRankings, type DraftRound, type DraftTracker, EDGE, type EventId, type GameId, type GameMeta, type GameNumber, type GameState$2 as GameState, type GameType, type GamecenterBoxscore, type GamecenterLanding, type GamecenterPlayByPlay, type GamecenterReports, type GoalieStatsLeaders, type Key, type LeagueSchedule, type LocationInfo, nhl as NHL, type NHLDate, type NHLMonth, type NHLScore, type NHLScoreboard, type NHLSeasons, type NHLStandings, type NHLStandingsSeason, type Name$1 as Name, 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 PostalCodeInfo, type Ranking, type SaveLocationCategory, type SaveLocationSort, type SavePercentage5v5Sort, type SavePercentageSort, type ScheduleCalendar, type Season, type SeasonDetails, type SeriesLetter, type ShotLocationCategory, type ShotLocationSort, type ShotSpeedSort, type SkaterStatsLeaders, type SkatersStrength, type SkatingDistanceSort, type SkatingSpeedSort, type StreamingName, 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 WhereToWatch, type Year, type ZoneTimeSort, index as gc };