@rawcast/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,612 @@
+// src/resources/health.ts
+class HealthResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async check() {
+    return this.transport.request("health");
+  }
+  async providers() {
+    return this.transport.request("health/providers");
+  }
+}
+
+// src/resources/metadata.ts
+class MetadataResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async getMovie(tmdbId, options = {}) {
+    const id = String(tmdbId).trim();
+    const query = new URLSearchParams;
+    if (options.lang)
+      query.set("lang", options.lang);
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return this.transport.request(`meta/movie/${id}${qs}`);
+  }
+  async getTv(tmdbId, options = {}) {
+    const id = String(tmdbId).trim();
+    const query = new URLSearchParams;
+    if (options.season !== undefined)
+      query.set("season", String(options.season));
+    if (options.lang)
+      query.set("lang", options.lang);
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return this.transport.request(`meta/tv/${id}${qs}`);
+  }
+}
+
+// src/response.ts
+var QUALITY_WEIGHTS = {
+  "4k": 6,
+  "2160p": 6,
+  "1080p": 5,
+  "720p": 4,
+  "480p": 3,
+  "360p": 2,
+  auto: 1,
+  "Auto (Adaptive)": 1
+};
+
+class SourcesResponse {
+  servers;
+  subtitles;
+  constructor(data) {
+    this.servers = Array.isArray(data.servers) ? data.servers : [];
+    this.subtitles = Array.isArray(data.subtitles) ? data.subtitles : [];
+  }
+  get allStreams() {
+    return this.servers.flatMap((server) => server.streams);
+  }
+  get hlsStreams() {
+    return this.servers.filter((s) => s.format === "hls").flatMap((s) => s.streams);
+  }
+  get dashStreams() {
+    return this.servers.filter((s) => s.format === "dash").flatMap((s) => s.streams);
+  }
+  get mp4Streams() {
+    return this.servers.filter((s) => s.format === "mp4").flatMap((s) => s.streams);
+  }
+  bestStream(options = {}) {
+    const {
+      preferFormat = "hls",
+      maxQuality,
+      preferredAudio = "English",
+      requireDownload = false
+    } = options;
+    let candidateStreams = [];
+    for (const server of this.servers) {
+      for (const stream of server.streams) {
+        if (requireDownload && !stream.download && !stream.downloadUrl) {
+          continue;
+        }
+        candidateStreams.push({
+          stream,
+          format: server.format
+        });
+      }
+    }
+    if (candidateStreams.length === 0) {
+      return null;
+    }
+    if (maxQuality) {
+      const maxWeight = QUALITY_WEIGHTS[maxQuality.toLowerCase()] ?? 99;
+      candidateStreams = candidateStreams.filter((item) => {
+        const itemWeight = QUALITY_WEIGHTS[item.stream.quality.toLowerCase()] ?? 1;
+        return itemWeight <= maxWeight;
+      });
+    }
+    if (candidateStreams.length === 0) {
+      return this.allStreams[0] ?? null;
+    }
+    candidateStreams.sort((a, b) => {
+      const formatScoreA = a.format === preferFormat ? 10 : 0;
+      const formatScoreB = b.format === preferFormat ? 10 : 0;
+      if (formatScoreA !== formatScoreB) {
+        return formatScoreB - formatScoreA;
+      }
+      const audioMatchA = (a.stream.audio || "").toLowerCase().includes(preferredAudio.toLowerCase()) ? 5 : 0;
+      const audioMatchB = (b.stream.audio || "").toLowerCase().includes(preferredAudio.toLowerCase()) ? 5 : 0;
+      if (audioMatchA !== audioMatchB) {
+        return audioMatchB - audioMatchA;
+      }
+      const qA = QUALITY_WEIGHTS[a.stream.quality.toLowerCase()] ?? 1;
+      const qB = QUALITY_WEIGHTS[b.stream.quality.toLowerCase()] ?? 1;
+      return qB - qA;
+    });
+    return candidateStreams[0].stream;
+  }
+  subtitlesByLang(languageOrCode) {
+    const q = languageOrCode.trim().toLowerCase();
+    return this.subtitles.filter((sub) => {
+      const lang = (sub.language || "").toLowerCase();
+      const label = (sub.label || "").toLowerCase();
+      const id = (sub.id || "").toLowerCase();
+      return lang === q || label.includes(q) || id.includes(q);
+    });
+  }
+}
+
+// src/resources/movies.ts
+class MoviesResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async getSources(tmdbId, options = {}) {
+    const id = String(tmdbId).trim();
+    const query = new URLSearchParams;
+    if (options.lang)
+      query.set("lang", options.lang);
+    if (options.title)
+      query.set("title", options.title);
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    const raw = await this.transport.request(`sources/movie/${id}${qs}`);
+    return new SourcesResponse(raw);
+  }
+  async getDownload(tmdbId, options = {}) {
+    const id = String(tmdbId).trim();
+    const query = new URLSearchParams;
+    if (options.quality)
+      query.set("quality", options.quality);
+    if (options.lang)
+      query.set("lang", options.lang);
+    if (options.title)
+      query.set("title", options.title);
+    query.set("redirect", "false");
+    return this.transport.request(`download/movie/${id}?${query.toString()}`);
+  }
+}
+
+// src/errors.ts
+class RawcastError extends Error {
+  code;
+  statusCode;
+  responseBody;
+  constructor(message, code = "RC_UNKNOWN_ERROR", statusCode, responseBody) {
+    super(message);
+    this.name = "RawcastError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class RawcastAuthenticationError extends RawcastError {
+  constructor(message = "API key is missing or invalid.", responseBody) {
+    super(message, "RC_UNAUTHORIZED", 401, responseBody);
+    this.name = "RawcastAuthenticationError";
+  }
+}
+
+class RawcastForbiddenError extends RawcastError {
+  constructor(message = "Account lacks permission or email is not verified.", code = "RC_FORBIDDEN", responseBody) {
+    super(message, code, 403, responseBody);
+    this.name = "RawcastForbiddenError";
+  }
+}
+
+class RawcastNotFoundError extends RawcastError {
+  constructor(message = "Resource or media streams not found.", code = "RC_NOT_FOUND", responseBody) {
+    super(message, code, 404, responseBody);
+    this.name = "RawcastNotFoundError";
+  }
+}
+
+class RawcastRateLimitError extends RawcastError {
+  retryAfterSeconds;
+  limit;
+  remaining;
+  reset;
+  constructor(message = "Rate limit or monthly quota exceeded.", options) {
+    super(message, "RC_RATE_LIMIT", 429, options?.responseBody);
+    this.name = "RawcastRateLimitError";
+    this.retryAfterSeconds = options?.retryAfterSeconds;
+    this.limit = options?.limit;
+    this.remaining = options?.remaining;
+    this.reset = options?.reset;
+  }
+}
+
+class RawcastUpstreamError extends RawcastError {
+  constructor(message = "Upstream scraper or provider error.", statusCode = 502, responseBody) {
+    super(message, "RC_UPSTREAM_ERROR", statusCode, responseBody);
+    this.name = "RawcastUpstreamError";
+  }
+}
+
+class RawcastTimeoutError extends RawcastError {
+  constructor(timeoutMs) {
+    super(`Request timed out after ${timeoutMs}ms.`, "RC_TIMEOUT");
+    this.name = "RawcastTimeoutError";
+  }
+}
+
+// src/resources/resolve.ts
+class ResolveResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  getStreamUrl(token, options = {}) {
+    const base = this.transport.getBaseUrl().replace(/\/+$/, "");
+    const query = new URLSearchParams;
+    if (options.download)
+      query.set("download", "1");
+    if (options.title)
+      query.set("title", options.title);
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return `${base}/resolve/${encodeURIComponent(token)}${qs}`;
+  }
+  getDownloadUrl(token, options = {}) {
+    const base = this.transport.getBaseUrl().replace(/\/+$/, "");
+    const query = new URLSearchParams;
+    if (options.title)
+      query.set("title", options.title);
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return `${base}/download/${encodeURIComponent(token)}${qs}`;
+  }
+  getHlsManifestUrl(token) {
+    const base = this.transport.getBaseUrl().replace(/\/+$/, "");
+    return `${base}/stream/hls/${encodeURIComponent(token)}/manifest.m3u8`;
+  }
+  async resolveDirect(token, options = {}) {
+    const url = this.getStreamUrl(token, options);
+    const fetchFn = this.transport.getFetch();
+    const response = await fetchFn(url, {
+      method: "GET",
+      redirect: "manual",
+      headers: {
+        "X-API-Key": this.transport.getApiKey()
+      }
+    });
+    if (response.status >= 300 && response.status < 400) {
+      const location = response.headers.get("location");
+      if (location)
+        return location;
+    }
+    if (response.status === 404) {
+      throw new RawcastNotFoundError("Stream token is invalid or has expired", "RC_NOT_FOUND");
+    }
+    if (response.url && response.url !== url) {
+      return response.url;
+    }
+    throw new Error(`Failed to resolve upstream redirect for token (HTTP status: ${response.status})`);
+  }
+}
+
+// src/resources/subtitles.ts
+class SubtitlesResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async getMovie(tmdbId, options = {}) {
+    const id = String(tmdbId).trim();
+    const query = new URLSearchParams;
+    if (options.lang)
+      query.set("lang", options.lang);
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return this.transport.request(`subtitles/movie/${id}${qs}`);
+  }
+  async getTv(tmdbIdOrOptions, season, episode, options = {}) {
+    let id;
+    let s;
+    let ep;
+    let lang;
+    if (typeof tmdbIdOrOptions === "object") {
+      id = String(tmdbIdOrOptions.tmdbId).trim();
+      s = tmdbIdOrOptions.season;
+      ep = tmdbIdOrOptions.episode;
+      lang = tmdbIdOrOptions.lang;
+    } else {
+      id = String(tmdbIdOrOptions).trim();
+      if (season === undefined || episode === undefined) {
+        throw new Error("Missing season or episode. Usage: rawcast.subtitles.getTv(tmdbId, season, episode, options?)");
+      }
+      s = season;
+      ep = episode;
+      lang = options.lang;
+    }
+    const query = new URLSearchParams;
+    if (lang)
+      query.set("lang", lang);
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return this.transport.request(`subtitles/tv/${id}/${s}/${ep}${qs}`);
+  }
+  getVttUrl(rawSubtitleUrl) {
+    const base = this.transport.getBaseUrl().replace(/\/+$/, "");
+    return `${base}/subtitles/vtt?url=${encodeURIComponent(rawSubtitleUrl)}`;
+  }
+  async fetchVtt(rawSubtitleUrl) {
+    const query = new URLSearchParams({ url: rawSubtitleUrl });
+    const response = await this.transport.rawFetch(`subtitles/vtt?${query.toString()}`);
+    return response.text();
+  }
+}
+
+// src/resources/tv.ts
+class TvResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async getSources(tmdbIdOrOptions, season, episode, options = {}) {
+    let id;
+    let s;
+    let ep;
+    let lang;
+    let title;
+    if (typeof tmdbIdOrOptions === "object") {
+      id = String(tmdbIdOrOptions.tmdbId).trim();
+      s = tmdbIdOrOptions.season;
+      ep = tmdbIdOrOptions.episode;
+      lang = tmdbIdOrOptions.lang ?? tmdbIdOrOptions.preferredLang;
+      title = tmdbIdOrOptions.title;
+    } else {
+      id = String(tmdbIdOrOptions).trim();
+      if (season === undefined || episode === undefined) {
+        throw new Error("Missing season or episode. Usage: rawcast.tv.getSources(tmdbId, season, episode, options?)");
+      }
+      s = season;
+      ep = episode;
+      lang = options.lang ?? options.preferredLang;
+      title = options.title;
+    }
+    const query = new URLSearchParams;
+    if (lang)
+      query.set("lang", lang);
+    if (title)
+      query.set("title", title);
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    const raw = await this.transport.request(`sources/tv/${id}/${s}/${ep}${qs}`);
+    return new SourcesResponse(raw);
+  }
+  async getDownload(tmdbIdOrOptions, season, episode, options = {}) {
+    let id;
+    let s;
+    let ep;
+    let quality;
+    let lang;
+    let title;
+    if (typeof tmdbIdOrOptions === "object") {
+      id = String(tmdbIdOrOptions.tmdbId ?? "").trim();
+      s = tmdbIdOrOptions.season;
+      ep = tmdbIdOrOptions.episode;
+      quality = tmdbIdOrOptions.quality;
+      lang = tmdbIdOrOptions.lang;
+      title = tmdbIdOrOptions.title;
+    } else {
+      id = String(tmdbIdOrOptions).trim();
+      if (season === undefined || episode === undefined) {
+        throw new Error("Missing season or episode. Usage: rawcast.tv.getDownload(tmdbId, season, episode, options?)");
+      }
+      s = season;
+      ep = episode;
+      quality = options.quality;
+      lang = options.lang;
+      title = options.title;
+    }
+    const query = new URLSearchParams;
+    if (quality)
+      query.set("quality", quality);
+    if (lang)
+      query.set("lang", lang);
+    if (title)
+      query.set("title", title);
+    query.set("redirect", "false");
+    return this.transport.request(`download/tv/${id}/${s}/${ep}?${query.toString()}`);
+  }
+}
+
+// src/transport.ts
+class HttpTransport {
+  baseUrl;
+  apiKey;
+  timeoutMs;
+  maxRetries;
+  fetchFn;
+  quota = {
+    limit: null,
+    remaining: null,
+    reset: null,
+    lastUpdated: null
+  };
+  constructor(options) {
+    if (!options.apiKey || !options.apiKey.trim()) {
+      throw new RawcastAuthenticationError("Rawcast API key is required. Pass apiKey or set process.env.RAWCAST_API_KEY.");
+    }
+    this.apiKey = options.apiKey.trim();
+    this.baseUrl = (options.baseUrl || "https://zeroms.space/v1").replace(/\/+$/, "");
+    this.timeoutMs = options.timeoutMs ?? 25000;
+    this.maxRetries = Math.max(0, options.maxRetries ?? 2);
+    this.fetchFn = options.fetch ?? globalThis.fetch;
+    if (!this.fetchFn) {
+      throw new RawcastError("Global fetch is not available. Please provide a custom fetch implementation or upgrade Node/runtime.");
+    }
+  }
+  updateQuotaHeaders(headers) {
+    const limit = headers.get("x-ratelimit-limit");
+    const remaining = headers.get("x-ratelimit-remaining");
+    const reset = headers.get("x-ratelimit-reset");
+    if (limit !== null || remaining !== null || reset !== null) {
+      this.quota.limit = limit !== null ? Number.parseInt(limit, 10) : this.quota.limit;
+      this.quota.remaining = remaining !== null ? Number.parseInt(remaining, 10) : this.quota.remaining;
+      this.quota.reset = reset !== null ? Number.parseInt(reset, 10) : this.quota.reset;
+      this.quota.lastUpdated = Date.now();
+    }
+  }
+  async sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  getApiKey() {
+    return this.apiKey;
+  }
+  getFetch() {
+    return this.fetchFn;
+  }
+  async rawFetch(endpoint, options = {}) {
+    const url = endpoint.startsWith("http") ? endpoint : `${this.baseUrl}/${endpoint.replace(/^\/+/, "")}`;
+    const headers = new Headers(options.headers || {});
+    if (!options.skipAuth) {
+      headers.set("X-API-Key", this.apiKey);
+    }
+    return this.fetchFn(url, {
+      ...options,
+      headers
+    });
+  }
+  async request(endpoint, options = {}) {
+    const url = endpoint.startsWith("http") ? endpoint : `${this.baseUrl}/${endpoint.replace(/^\/+/, "")}`;
+    const timeout = options.timeoutMs ?? this.timeoutMs;
+    let attempt = 0;
+    while (attempt <= this.maxRetries) {
+      attempt++;
+      const controller = new AbortController;
+      const timer = setTimeout(() => controller.abort(), timeout);
+      const headers = new Headers(options.headers || {});
+      if (!options.skipAuth) {
+        headers.set("X-API-Key", this.apiKey);
+      }
+      headers.set("Accept", "application/json, text/plain, */*");
+      try {
+        const response = await this.fetchFn(url, {
+          ...options,
+          headers,
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        this.updateQuotaHeaders(response.headers);
+        if (response.ok) {
+          if (response.status === 204) {
+            return;
+          }
+          const contentType = response.headers.get("content-type") || "";
+          if (contentType.includes("application/json")) {
+            return await response.json();
+          }
+          return await response.text();
+        }
+        let errorBody;
+        try {
+          errorBody = await response.json();
+        } catch {
+          try {
+            errorBody = await response.text();
+          } catch {}
+        }
+        const errorMessage = typeof errorBody === "object" && errorBody !== null && "error" in errorBody ? errorBody.error.message || response.statusText : typeof errorBody === "string" && errorBody ? errorBody : response.statusText;
+        if (response.status === 429) {
+          const retryAfterHeader = response.headers.get("retry-after");
+          const retryAfterSeconds = retryAfterHeader ? Number.parseFloat(retryAfterHeader) : 1;
+          if (attempt <= this.maxRetries) {
+            const sleepMs = Math.min(Math.max(retryAfterSeconds * 1000, 500), 1e4);
+            await this.sleep(sleepMs);
+            continue;
+          }
+          throw new RawcastRateLimitError(errorMessage, {
+            retryAfterSeconds,
+            limit: this.quota.limit ?? undefined,
+            remaining: this.quota.remaining ?? undefined,
+            reset: this.quota.reset ?? undefined,
+            responseBody: errorBody
+          });
+        }
+        if ([502, 503, 504].includes(response.status) && attempt <= this.maxRetries) {
+          const backoff = Math.min(400 * 2 ** (attempt - 1), 5000);
+          await this.sleep(backoff);
+          continue;
+        }
+        switch (response.status) {
+          case 401:
+            throw new RawcastAuthenticationError(errorMessage, errorBody);
+          case 403:
+            throw new RawcastForbiddenError(errorMessage, "RC_FORBIDDEN", errorBody);
+          case 404:
+            throw new RawcastNotFoundError(errorMessage, "RC_NOT_FOUND", errorBody);
+          case 502:
+          case 503:
+          case 504:
+            throw new RawcastUpstreamError(errorMessage, response.status, errorBody);
+          default:
+            throw new RawcastError(errorMessage, "RC_API_ERROR", response.status, errorBody);
+        }
+      } catch (err) {
+        clearTimeout(timer);
+        if (err instanceof RawcastError) {
+          throw err;
+        }
+        if (err instanceof Error && err.name === "AbortError") {
+          throw new RawcastTimeoutError(timeout);
+        }
+        if (attempt <= this.maxRetries) {
+          await this.sleep(500 * attempt);
+          continue;
+        }
+        throw new RawcastError(err instanceof Error ? err.message : "Network request failed", "RC_NETWORK_ERROR");
+      }
+    }
+    throw new RawcastError("Request failed after maximum retries exceeded.");
+  }
+}
+
+// src/client.ts
+class Rawcast {
+  transport;
+  movies;
+  tv;
+  subtitles;
+  metadata;
+  meta;
+  resolve;
+  health;
+  constructor(optionsOrApiKey) {
+    let options;
+    if (typeof optionsOrApiKey === "string") {
+      options = { apiKey: optionsOrApiKey };
+    } else if (typeof optionsOrApiKey === "object" && optionsOrApiKey !== null) {
+      options = optionsOrApiKey;
+    } else {
+      const envKey = typeof process !== "undefined" && process.env ? process.env.RAWCAST_API_KEY : undefined;
+      options = { apiKey: envKey ?? "" };
+    }
+    this.transport = new HttpTransport(options);
+    this.movies = new MoviesResource(this.transport);
+    this.tv = new TvResource(this.transport);
+    this.subtitles = new SubtitlesResource(this.transport);
+    this.metadata = new MetadataResource(this.transport);
+    this.meta = this.metadata;
+    this.resolve = new ResolveResource(this.transport);
+    this.health = new HealthResource(this.transport);
+  }
+  get quota() {
+    return this.transport.quota;
+  }
+}
+// src/index.ts
+var src_default = Rawcast;
+export {
+  HealthResource,
+  HttpTransport,
+  MetadataResource,
+  MoviesResource,
+  Rawcast,
+  RawcastAuthenticationError,
+  RawcastError,
+  RawcastForbiddenError,
+  RawcastNotFoundError,
+  RawcastRateLimitError,
+  RawcastTimeoutError,
+  RawcastUpstreamError,
+  ResolveResource,
+  SourcesResponse,
+  SubtitlesResource,
+  TvResource,
+  src_default as default
+};

package/dist/resources/health.d.ts

@@ -0,0 +1,28 @@
+import type { HttpTransport } from '../transport';
+import type { HealthStatus, ProviderHealthDashboard } from '../types';
+export declare class HealthResource {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    /**
+     * Checks core Rawcast API service health, status, uptime, and version.
+     *
+     * @example
+     * ```typescript
+     * const health = await rawcast.health.check();
+     * console.log(health.status, health.uptime);
+     * ```
+     */
+    check(): Promise<HealthStatus>;
+    /**
+     * Retrieves real-time provider health dashboard showing server tier availability,
+     * healthy backend counts, and operational status across all scrapers.
+     *
+     * @example
+     * ```typescript
+     * const dashboard = await rawcast.health.providers();
+     * console.log(dashboard.status, dashboard.healthyCount, dashboard.servers);
+     * ```
+     */
+    providers(): Promise<ProviderHealthDashboard>;
+}
+//# sourceMappingURL=health.d.ts.map

package/dist/resources/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../src/resources/health.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAEtE,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,aAAa;IAErD;;;;;;;;OAQG;IACU,KAAK,IAAI,OAAO,CAAC,YAAY,CAAC;IAI3C;;;;;;;;;OASG;IACU,SAAS,IAAI,OAAO,CAAC,uBAAuB,CAAC;CAG3D"}

package/dist/resources/metadata.d.ts

@@ -0,0 +1,41 @@
+import type { HttpTransport } from '../transport';
+import type { GetTvMetadataOptions, MovieMetadata, TvMetadata } from '../types';
+export declare class MetadataResource {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    /**
+     * Fetches comprehensive metadata for a movie by TMDB ID, including title, overview,
+     * release date, runtime, ratings, genres, posters, backdrops, and cast.
+     *
+     * @param tmdbId TMDB Movie ID (e.g. 550 for Fight Club)
+     * @param options Language options (e.g. { lang: 'en-US' })
+     *
+     * @example
+     * ```typescript
+     * const movie = await rawcast.metadata.getMovie(550);
+     * console.log(movie.title, movie.voteAverage, movie.posterUrl);
+     * ```
+     */
+    getMovie(tmdbId: string | number, options?: {
+        lang?: string;
+    }): Promise<MovieMetadata>;
+    /**
+     * Fetches comprehensive metadata for a TV show by TMDB ID.
+     * If a season number is supplied in options, returns detailed episode breakdown for that season.
+     *
+     * @param tmdbId TMDB TV Show ID (e.g. 1399 for Game of Thrones)
+     * @param options Target season and language options
+     *
+     * @example
+     * ```typescript
+     * // Fetch show overview and list of seasons:
+     * const series = await rawcast.metadata.getTv(1399);
+     *
+     * // Fetch specific season episode list:
+     * const season1 = await rawcast.metadata.getTv(1399, { season: 1 });
+     * console.log(season1.episodes);
+     * ```
+     */
+    getTv(tmdbId: string | number, options?: GetTvMetadataOptions): Promise<TvMetadata>;
+}
+//# sourceMappingURL=metadata.d.ts.map

package/dist/resources/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/resources/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEhF,qBAAa,gBAAgB;IACf,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,aAAa;IAErD;;;;;;;;;;;;OAYG;IACU,QAAQ,CACnB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,OAAO,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAO,GAC9B,OAAO,CAAC,aAAa,CAAC;IASzB;;;;;;;;;;;;;;;;OAgBG;IACU,KAAK,CAChB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,UAAU,CAAC;CASvB"}