@nflmeta/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Philippe Bourdon / ClearOak Studio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,141 @@
+# `@nflmeta/sdk`
+
+Official TypeScript SDK for the NFLMeta API.
+
+## Install
+
+```bash
+npm install @nflmeta/sdk
+```
+
+## Quickstart
+
+```ts
+import { NFLMetaClient } from "@nflmeta/sdk";
+
+const client = new NFLMetaClient({
+  apiKey: process.env.NFLMETA_API_KEY,
+});
+
+const team = await client.teams.get("PIT", { season: 2025 });
+const player = await client.players.identity("josh-allen-1996");
+const usage = await client.usage.get();
+
+console.log(team.data.displayName);
+console.log(player.data.display_name);
+console.log(usage.data.quota_remaining);
+```
+
+## What The SDK Does
+
+- sends `X-NFLMeta-Key` automatically when you provide `apiKey`
+- preserves the API envelope shape: `data`, optional `meta`, plus parsed rate-limit headers
+- throws typed HTTP errors for common failure cases
+- exposes the main API surfaces as resource clients instead of forcing raw URL construction
+- still gives you a low-level `client.get(path, { query })` escape hatch for any route not wrapped yet
+
+## Configuration
+
+```ts
+const client = new NFLMetaClient({
+  apiKey: process.env.NFLMETA_API_KEY,
+  baseUrl: "https://nflmeta.org",
+  timeoutMs: 10_000,
+});
+```
+
+Options:
+
+- `apiKey`: optional API key for authenticated routes
+- `baseUrl`: defaults to `https://nflmeta.org`
+- `timeoutMs`: request timeout in milliseconds
+- `fetch`: optional custom `fetch` implementation
+- `headers`: optional default headers merged into each request
+
+## Returned Shape
+
+Every SDK method returns the API envelope plus request metadata:
+
+```ts
+const response = await client.games.list({ season: 2025, week: 1 });
+
+response.data;
+response.meta;
+response.status;
+response.rateLimit.limit;
+response.rateLimit.remaining;
+```
+
+## Resource Coverage
+
+The SDK wraps the main public surfaces:
+
+- `health`
+- `usage`
+- `metadata`
+- `seasons`
+- `teams`
+- `players`
+- `games`
+- `playoffGames`
+- `standings`
+- `playoffs`
+- `superBowls`
+- `history`
+- `hallOfFame`
+- `contributors`
+- `executives`
+- `staff`
+- `coaches`
+- `assets`
+- `allStarGames`
+- `stats.players`
+- `reference`
+
+Examples:
+
+```ts
+await client.seasons.list({ year_from: 2000, year_to: 2025 });
+await client.teams.profile("PIT", { season: 2025 });
+await client.players.bio("josh-allen-1996");
+await client.players.careerField("josh-allen-1996", "pass_passer_rating");
+await client.games.extras(12001);
+await client.superBowls.byTeam("PIT");
+await client.reference.venue("m-t-bank-stadium");
+await client.stats.players.search({ search: "Mahomes" });
+```
+
+## Errors
+
+The SDK throws typed errors:
+
+- `NFLMetaBadRequestError`
+- `NFLMetaUnauthorizedError`
+- `NFLMetaNotFoundError`
+- `NFLMetaRateLimitError`
+- `NFLMetaTimeoutError`
+- `NFLMetaError`
+
+```ts
+import { NFLMetaNotFoundError } from "@nflmeta/sdk";
+
+try {
+  await client.teams.get("BAD");
+} catch (error) {
+  if (error instanceof NFLMetaNotFoundError) {
+    console.error(error.message);
+  }
+}
+```
+
+## Escape Hatch
+
+You can call any route directly:
+
+```ts
+const raw = await client.get("/api/v1/reference/team-colors", {
+  query: { limit: 10 },
+});
+```
+
+That makes the SDK usable immediately even when a new endpoint lands before a wrapper method is added.

package/dist/client.d.ts

@@ -0,0 +1,11 @@
+import type { NFLMetaClientOptions, NFLMetaEnvelope, RequestOptions, UnknownRecord } from "./types.js";
+export declare class NFLMetaClientCore {
+    readonly apiKey?: string;
+    readonly baseUrl: string;
+    readonly timeoutMs?: number;
+    readonly fetchImpl: typeof fetch;
+    readonly defaultHeaders?: HeadersInit;
+    constructor(options?: NFLMetaClientOptions);
+    get<TData = UnknownRecord, TMeta = unknown>(path: string, options?: RequestOptions): Promise<NFLMetaEnvelope<TData, TMeta>>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EACpB,eAAe,EAGf,cAAc,EACd,aAAa,EACd,MAAM,YAAY,CAAC;AA0GpB,qBAAa,iBAAiB;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,OAAO,KAAK,CAAC;IACjC,QAAQ,CAAC,cAAc,CAAC,EAAE,WAAW,CAAC;gBAE1B,OAAO,GAAE,oBAAyB;IAQxC,GAAG,CAAC,KAAK,GAAG,aAAa,EAAE,KAAK,GAAG,OAAO,EAC9C,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CA8C1C"}

package/dist/client.js

@@ -0,0 +1,156 @@
+import { NFLMetaTimeoutError, createHttpError } from "./errors.js";
+function isAbsoluteUrl(value) {
+    return /^https?:\/\//i.test(value);
+}
+function normalizeBaseUrl(baseUrl) {
+    const base = (baseUrl || "https://nflmeta.org").trim();
+    return base.replace(/\/+$/, "");
+}
+function encodeQueryValue(value) {
+    if (value instanceof Date)
+        return value.toISOString();
+    return String(value);
+}
+function appendQuery(url, query) {
+    if (!query)
+        return;
+    for (const [key, rawValue] of Object.entries(query)) {
+        if (rawValue == null)
+            continue;
+        const values = Array.isArray(rawValue) ? rawValue : [rawValue];
+        for (const value of values) {
+            if (value == null)
+                continue;
+            if (value instanceof Date || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+                url.searchParams.append(key, encodeQueryValue(value));
+            }
+        }
+    }
+}
+function parseNumberHeader(headers, name) {
+    const value = headers.get(name);
+    if (!value)
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function parseRateLimit(headers) {
+    return {
+        limit: parseNumberHeader(headers, "X-RateLimit-Limit"),
+        remaining: parseNumberHeader(headers, "X-RateLimit-Remaining"),
+        reset: headers.get("X-RateLimit-Reset") || undefined,
+        policy: headers.get("X-RateLimit-Policy") || undefined,
+    };
+}
+function mergeHeaders(base, extra) {
+    const headers = new Headers(base);
+    if (extra) {
+        const additions = new Headers(extra);
+        additions.forEach((value, key) => {
+            headers.set(key, value);
+        });
+    }
+    return headers;
+}
+async function parsePayload(response) {
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+        return response.json();
+    }
+    const text = await response.text();
+    return text ? { message: text } : undefined;
+}
+function createAbortContext(signal, timeoutMs) {
+    if (!signal && (!timeoutMs || timeoutMs <= 0)) {
+        return {
+            signal: undefined,
+            cleanup: () => undefined,
+            didTimeout: () => false,
+        };
+    }
+    const controller = new AbortController();
+    let timedOut = false;
+    let timeoutId;
+    let onAbort;
+    if (signal) {
+        if (signal.aborted) {
+            controller.abort(signal.reason);
+        }
+        else {
+            onAbort = () => controller.abort(signal.reason);
+            signal.addEventListener("abort", onAbort, { once: true });
+        }
+    }
+    if (timeoutMs && timeoutMs > 0) {
+        timeoutId = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, timeoutMs);
+    }
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (signal && onAbort)
+                signal.removeEventListener("abort", onAbort);
+        },
+        didTimeout: () => timedOut,
+    };
+}
+export class NFLMetaClientCore {
+    apiKey;
+    baseUrl;
+    timeoutMs;
+    fetchImpl;
+    defaultHeaders;
+    constructor(options = {}) {
+        this.apiKey = options.apiKey?.trim() || undefined;
+        this.baseUrl = normalizeBaseUrl(options.baseUrl);
+        this.timeoutMs = options.timeoutMs;
+        this.fetchImpl = options.fetch || fetch;
+        this.defaultHeaders = options.headers;
+    }
+    async get(path, options = {}) {
+        const url = isAbsoluteUrl(path) ? new URL(path) : new URL(path, `${this.baseUrl}/`);
+        appendQuery(url, options.query);
+        const headers = mergeHeaders(this.defaultHeaders, options.headers);
+        headers.set("Accept", "application/json");
+        if (this.apiKey && !headers.has("X-NFLMeta-Key")) {
+            headers.set("X-NFLMeta-Key", this.apiKey);
+        }
+        const abort = createAbortContext(options.signal, this.timeoutMs);
+        try {
+            const response = await this.fetchImpl(url, {
+                method: "GET",
+                headers,
+                signal: abort.signal,
+            });
+            const rateLimit = parseRateLimit(response.headers);
+            const payload = await parsePayload(response);
+            if (!response.ok) {
+                throw createHttpError(response.status, payload, rateLimit);
+            }
+            if (typeof payload !== "object" || payload === null || !("data" in payload)) {
+                throw createHttpError(response.status, payload, rateLimit);
+            }
+            const body = payload;
+            return {
+                data: body.data,
+                meta: body.meta,
+                status: response.status,
+                rateLimit,
+                headers: response.headers,
+            };
+        }
+        catch (error) {
+            if (abort.didTimeout()) {
+                throw new NFLMetaTimeoutError(this.timeoutMs || 0);
+            }
+            throw error;
+        }
+        finally {
+            abort.cleanup();
+        }
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,30 @@
+import type { RateLimitInfo } from "./types.js";
+export interface NFLMetaErrorDetails {
+    code?: string;
+    payload?: unknown;
+    rateLimit?: RateLimitInfo;
+}
+export declare class NFLMetaError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    readonly payload?: unknown;
+    readonly rateLimit?: RateLimitInfo;
+    constructor(message: string, status: number, details?: NFLMetaErrorDetails);
+}
+export declare class NFLMetaBadRequestError extends NFLMetaError {
+    constructor(message: string, details?: NFLMetaErrorDetails);
+}
+export declare class NFLMetaUnauthorizedError extends NFLMetaError {
+    constructor(message: string, details?: NFLMetaErrorDetails);
+}
+export declare class NFLMetaNotFoundError extends NFLMetaError {
+    constructor(message: string, details?: NFLMetaErrorDetails);
+}
+export declare class NFLMetaRateLimitError extends NFLMetaError {
+    constructor(message: string, details?: NFLMetaErrorDetails);
+}
+export declare class NFLMetaTimeoutError extends Error {
+    constructor(timeoutMs: number);
+}
+export declare function createHttpError(status: number, payload: unknown, rateLimit?: RateLimitInfo): NFLMetaError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAiB,MAAM,YAAY,CAAC;AAE/D,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B;AAED,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC;gBAEvB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB;CAQ/E;AAED,qBAAa,sBAAuB,SAAQ,YAAY;gBAC1C,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB;CAI/D;AAED,qBAAa,wBAAyB,SAAQ,YAAY;gBAC5C,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB;CAI/D;AAED,qBAAa,oBAAqB,SAAQ,YAAY;gBACxC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB;CAI/D;AAED,qBAAa,qBAAsB,SAAQ,YAAY;gBACzC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB;CAI/D;AAED,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,SAAS,EAAE,MAAM;CAI9B;AAqBD,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,YAAY,CAczG"}

package/dist/errors.js

@@ -0,0 +1,82 @@
+export class NFLMetaError extends Error {
+    status;
+    code;
+    payload;
+    rateLimit;
+    constructor(message, status, details = {}) {
+        super(message);
+        this.name = "NFLMetaError";
+        this.status = status;
+        this.code = details.code;
+        this.payload = details.payload;
+        this.rateLimit = details.rateLimit;
+    }
+}
+export class NFLMetaBadRequestError extends NFLMetaError {
+    constructor(message, details = {}) {
+        super(message, 400, details);
+        this.name = "NFLMetaBadRequestError";
+    }
+}
+export class NFLMetaUnauthorizedError extends NFLMetaError {
+    constructor(message, details = {}) {
+        super(message, 401, details);
+        this.name = "NFLMetaUnauthorizedError";
+    }
+}
+export class NFLMetaNotFoundError extends NFLMetaError {
+    constructor(message, details = {}) {
+        super(message, 404, details);
+        this.name = "NFLMetaNotFoundError";
+    }
+}
+export class NFLMetaRateLimitError extends NFLMetaError {
+    constructor(message, details = {}) {
+        super(message, 429, details);
+        this.name = "NFLMetaRateLimitError";
+    }
+}
+export class NFLMetaTimeoutError extends Error {
+    constructor(timeoutMs) {
+        super(`NFLMeta request timed out after ${timeoutMs}ms`);
+        this.name = "NFLMetaTimeoutError";
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function messageFromPayload(payload, fallback) {
+    if (!isRecord(payload))
+        return fallback;
+    const error = payload.error;
+    if (!isRecord(error))
+        return fallback;
+    const message = error.message;
+    return typeof message === "string" && message.trim() ? message : fallback;
+}
+function codeFromPayload(payload) {
+    if (!isRecord(payload))
+        return undefined;
+    const error = payload.error;
+    if (!isRecord(error))
+        return undefined;
+    return typeof error.code === "string" && error.code.trim() ? error.code : undefined;
+}
+export function createHttpError(status, payload, rateLimit) {
+    const fallback = `NFLMeta request failed with status ${status}`;
+    const message = messageFromPayload(payload, fallback);
+    const details = {
+        code: codeFromPayload(payload),
+        payload,
+        rateLimit,
+    };
+    if (status === 400)
+        return new NFLMetaBadRequestError(message, details);
+    if (status === 401)
+        return new NFLMetaUnauthorizedError(message, details);
+    if (status === 404)
+        return new NFLMetaNotFoundError(message, details);
+    if (status === 429)
+        return new NFLMetaRateLimitError(message, details);
+    return new NFLMetaError(message, status, details);
+}

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import { NFLMetaClientCore } from "./client.js";
+import { AllStarGamesResource, AssetsResource, CoachesResource, ContributorsResource, ExecutivesResource, GamesResource, HallOfFameResource, HealthResource, HistoryResource, MetadataResource, PlayoffGamesResource, PlayoffsResource, PlayersResource, ReferenceResource, SeasonsResource, StaffResource, StandingsResource, StatsResource, SuperBowlsResource, TeamsResource, UsageResource } from "./resources.js";
+import { NFLMetaError, NFLMetaBadRequestError, NFLMetaNotFoundError, NFLMetaRateLimitError, NFLMetaTimeoutError, NFLMetaUnauthorizedError } from "./errors.js";
+export * from "./errors.js";
+export * from "./types.js";
+export declare class NFLMetaClient extends NFLMetaClientCore {
+    readonly health: HealthResource;
+    readonly usage: UsageResource;
+    readonly metadata: MetadataResource;
+    readonly seasons: SeasonsResource;
+    readonly teams: TeamsResource;
+    readonly players: PlayersResource;
+    readonly games: GamesResource;
+    readonly playoffGames: PlayoffGamesResource;
+    readonly standings: StandingsResource;
+    readonly playoffs: PlayoffsResource;
+    readonly superBowls: SuperBowlsResource;
+    readonly history: HistoryResource;
+    readonly hallOfFame: HallOfFameResource;
+    readonly contributors: ContributorsResource;
+    readonly executives: ExecutivesResource;
+    readonly staff: StaffResource;
+    readonly coaches: CoachesResource;
+    readonly assets: AssetsResource;
+    readonly allStarGames: AllStarGamesResource;
+    readonly stats: StatsResource;
+    readonly reference: ReferenceResource;
+    constructor(options?: ConstructorParameters<typeof NFLMetaClientCore>[0]);
+}
+export declare function createNFLMetaClient(options?: ConstructorParameters<typeof NFLMetaClient>[0]): NFLMetaClient;
+export { NFLMetaBadRequestError, NFLMetaError, NFLMetaNotFoundError, NFLMetaRateLimitError, NFLMetaTimeoutError, NFLMetaUnauthorizedError, };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,eAAe,EACf,oBAAoB,EACpB,kBAAkB,EAClB,aAAa,EACb,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,kBAAkB,EAClB,aAAa,EACb,aAAa,EACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAE/J,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAE3B,qBAAa,aAAc,SAAQ,iBAAiB;IAClD,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;IAC5C,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAC;gBAE1B,OAAO,GAAE,qBAAqB,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC,CAAM;CAwB7E;AAED,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,qBAAqB,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC,CAAM,GAAG,aAAa,CAE/G;AAED,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,wBAAwB,GACzB,CAAC"}

package/dist/index.js

@@ -0,0 +1,56 @@
+import { NFLMetaClientCore } from "./client.js";
+import { AllStarGamesResource, AssetsResource, CoachesResource, ContributorsResource, ExecutivesResource, GamesResource, HallOfFameResource, HealthResource, HistoryResource, MetadataResource, PlayoffGamesResource, PlayoffsResource, PlayersResource, ReferenceResource, SeasonsResource, StaffResource, StandingsResource, StatsResource, SuperBowlsResource, TeamsResource, UsageResource, } from "./resources.js";
+import { NFLMetaError, NFLMetaBadRequestError, NFLMetaNotFoundError, NFLMetaRateLimitError, NFLMetaTimeoutError, NFLMetaUnauthorizedError } from "./errors.js";
+export * from "./errors.js";
+export * from "./types.js";
+export class NFLMetaClient extends NFLMetaClientCore {
+    health;
+    usage;
+    metadata;
+    seasons;
+    teams;
+    players;
+    games;
+    playoffGames;
+    standings;
+    playoffs;
+    superBowls;
+    history;
+    hallOfFame;
+    contributors;
+    executives;
+    staff;
+    coaches;
+    assets;
+    allStarGames;
+    stats;
+    reference;
+    constructor(options = {}) {
+        super(options);
+        this.health = new HealthResource(this);
+        this.usage = new UsageResource(this);
+        this.metadata = new MetadataResource(this);
+        this.seasons = new SeasonsResource(this);
+        this.teams = new TeamsResource(this);
+        this.players = new PlayersResource(this);
+        this.games = new GamesResource(this);
+        this.playoffGames = new PlayoffGamesResource(this);
+        this.standings = new StandingsResource(this);
+        this.playoffs = new PlayoffsResource(this);
+        this.superBowls = new SuperBowlsResource(this);
+        this.history = new HistoryResource(this);
+        this.hallOfFame = new HallOfFameResource(this);
+        this.contributors = new ContributorsResource(this, ["contributors"]);
+        this.executives = new ExecutivesResource(this, ["executives"]);
+        this.staff = new StaffResource(this, ["staff"]);
+        this.coaches = new CoachesResource(this, ["coaches"]);
+        this.assets = new AssetsResource(this);
+        this.allStarGames = new AllStarGamesResource(this);
+        this.stats = new StatsResource(this);
+        this.reference = new ReferenceResource(this);
+    }
+}
+export function createNFLMetaClient(options = {}) {
+    return new NFLMetaClient(options);
+}
+export { NFLMetaBadRequestError, NFLMetaError, NFLMetaNotFoundError, NFLMetaRateLimitError, NFLMetaTimeoutError, NFLMetaUnauthorizedError, };