@rawcast/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,654 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  HealthResource: () => HealthResource,
+  HttpTransport: () => HttpTransport,
+  MetadataResource: () => MetadataResource,
+  MoviesResource: () => MoviesResource,
+  Rawcast: () => Rawcast,
+  RawcastAuthenticationError: () => RawcastAuthenticationError,
+  RawcastError: () => RawcastError,
+  RawcastForbiddenError: () => RawcastForbiddenError,
+  RawcastNotFoundError: () => RawcastNotFoundError,
+  RawcastRateLimitError: () => RawcastRateLimitError,
+  RawcastTimeoutError: () => RawcastTimeoutError,
+  RawcastUpstreamError: () => RawcastUpstreamError,
+  ResolveResource: () => ResolveResource,
+  SourcesResponse: () => SourcesResponse,
+  SubtitlesResource: () => SubtitlesResource,
+  TvResource: () => TvResource,
+  default: () => src_default
+});
+module.exports = __toCommonJS(exports_src);
+
+// 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;

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { Rawcast } from './client';
+export { Rawcast };
+export default Rawcast;
+export { SourcesResponse } from './response';
+export { HttpTransport } from './transport';
+export { RawcastError, RawcastAuthenticationError, RawcastForbiddenError, RawcastNotFoundError, RawcastRateLimitError, RawcastUpstreamError, RawcastTimeoutError, } from './errors';
+export { MoviesResource } from './resources/movies';
+export { TvResource } from './resources/tv';
+export { SubtitlesResource } from './resources/subtitles';
+export { MetadataResource } from './resources/metadata';
+export { ResolveResource } from './resources/resolve';
+export { HealthResource } from './resources/health';
+export type { RawcastOptions, QuotaState, GetMovieSourcesOptions, GetTvSourcesOptions, GetMovieDownloadOptions, GetTvDownloadOptions, DownloadResult, GetSubtitlesOptions, GetTvSubtitlesOptions, GetTvMetadataOptions, BestStreamOptions, HealthStatus, ProviderHealthDashboard, MovieMetadata, TvMetadata, TvEpisodeMetadata, TvSeasonInfo, ServerGroup, StreamItem, SubtitleTrack, MediaDownloadResult, DownloadOption, } from './types';
+//# 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,OAAO,EAAE,MAAM,UAAU,CAAC;AAEnC,OAAO,EAAE,OAAO,EAAE,CAAC;AACnB,eAAe,OAAO,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EACL,YAAY,EACZ,0BAA0B,EAC1B,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,YAAY,EACV,cAAc,EACd,UAAU,EACV,sBAAsB,EACtB,mBAAmB,EACnB,uBAAuB,EACvB,oBAAoB,EACpB,cAAc,EACd,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,YAAY,EACZ,uBAAuB,EAEvB,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,YAAY,EACZ,WAAW,EACX,UAAU,EACV,aAAa,EACb,mBAAmB,EACnB,cAAc,GACf,MAAM,SAAS,CAAC"}