@checkleaked/spotify-api 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1630 @@
+'use strict';
+
+// src/errors.ts
+var SpotifyApiError = class extends Error {
+  constructor(init) {
+    super(init.message);
+    this.name = "SpotifyApiError";
+    this.status = init.status;
+    this.code = init.code;
+    this.url = init.url;
+    this.body = init.body;
+    if (init.cause !== void 0) {
+      this.cause = init.cause;
+    }
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /** True when the server returned HTTP 429. */
+  get isRateLimit() {
+    return this.status === 429;
+  }
+  /** True for HTTP 5xx responses. */
+  get isServerError() {
+    return typeof this.status === "number" && this.status >= 500;
+  }
+  /** True when the request timed out client-side. */
+  get isTimeout() {
+    return this.code === "TIMEOUT";
+  }
+};
+
+// src/config.ts
+var PROVIDERS = {
+  rapidapi: { baseUrl: "https://spotify81.p.rapidapi.com", host: "spotify81.p.rapidapi.com" },
+  proxy: { baseUrl: "https://spotify-proxy.checkleaked.cc/spotify-data", host: void 0 }
+};
+var DEFAULT_USER_AGENT = "@checkleaked/spotify-api";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_RETRIES = 2;
+var DEFAULT_RETRY_DELAY_MS = 500;
+function readEnvKey() {
+  if (typeof process === "undefined" || !process.env) return void 0;
+  return process.env.SPOTIFY_API_KEY || process.env.RAPIDAPI_KEY || process.env.SPOTIFY_RAPIDAPI_KEY || void 0;
+}
+function resolveConfig(config = {}) {
+  const apiKey = config.apiKey || readEnvKey();
+  if (typeof apiKey !== "string" || apiKey.length === 0) {
+    throw new SpotifyApiError({
+      message: "A non-empty `apiKey` is required (or set SPOTIFY_API_KEY / RAPIDAPI_KEY).",
+      code: "CONFIG"
+    });
+  }
+  const provider = config.provider ?? "rapidapi";
+  const preset = PROVIDERS[provider];
+  if (!preset) {
+    throw new SpotifyApiError({
+      message: `Unknown provider "${provider}". Use "rapidapi" or "proxy".`,
+      code: "CONFIG"
+    });
+  }
+  const baseUrl = (config.baseUrl ?? preset.baseUrl).replace(/\/+$/, "");
+  const host = config.host ?? preset.host;
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new SpotifyApiError({
+      message: "No global `fetch` found. Provide `config.fetch` or run on Node >= 18.",
+      code: "CONFIG"
+    });
+  }
+  const debug = config.debug === true ? (msg, detail) => console.error(`[spotify-api] ${msg}`, detail ?? "") : typeof config.debug === "function" ? config.debug : void 0;
+  return {
+    apiKey,
+    baseUrl,
+    host,
+    timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    retries: config.retries ?? DEFAULT_RETRIES,
+    retryDelayMs: config.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS,
+    headers: config.headers ?? {},
+    fetch: fetchImpl,
+    userAgent: config.userAgent ?? DEFAULT_USER_AGENT,
+    debug,
+    onRequest: config.onRequest,
+    onResponse: config.onResponse,
+    onRetry: config.onRetry
+  };
+}
+
+// src/ids.ts
+var URI_RE = /^spotify:[a-z0-9]+:([A-Za-z0-9]+)$/i;
+var URL_RE = /open\.spotify\.com\/(?:intl-[a-z-]+\/)?[a-z-]+\/([A-Za-z0-9]+)/i;
+function normalizeId(input) {
+  const s = String(input).trim();
+  const uri = URI_RE.exec(s);
+  if (uri) return uri[1];
+  const url = URL_RE.exec(s);
+  if (url) return url[1];
+  return s;
+}
+function normalizeIds(input) {
+  const arr = Array.isArray(input) ? input : String(input).split(",");
+  return arr.map((x) => normalizeId(x)).filter((x) => x.length > 0).join(",");
+}
+
+// src/core.ts
+var SpotifyHttpClient = class {
+  constructor(config) {
+    this.config = resolveConfig(config);
+  }
+  /** Perform a request and return the full {@link SuccessEnvelope}. */
+  async request(options) {
+    const method = options.method ?? "GET";
+    const url = this.buildUrl(options.path, options.query);
+    const cfg = this.config;
+    const headers = {
+      "x-rapidapi-key": cfg.apiKey,
+      accept: "application/json",
+      "user-agent": cfg.userAgent,
+      ...cfg.headers,
+      ...options.headers
+    };
+    if (cfg.host) headers["x-rapidapi-host"] = cfg.host;
+    let bodyInit;
+    if (options.body !== void 0 && options.body !== null) {
+      bodyInit = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
+      if (!("content-type" in headers)) headers["content-type"] = "application/json";
+    }
+    cfg.onRequest?.({ method, url, headers });
+    cfg.debug?.(`\u2192 ${method} ${url}`);
+    const maxAttempts = Math.max(1, cfg.retries + 1);
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const attemptStart = Date.now();
+      const controller = new AbortController();
+      const external = options.signal;
+      const onExternalAbort = () => controller.abort();
+      if (external) {
+        if (external.aborted) controller.abort();
+        else external.addEventListener("abort", onExternalAbort, { once: true });
+      }
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+      }, cfg.timeoutMs);
+      let response;
+      try {
+        response = await cfg.fetch(url, { method, headers, body: bodyInit, signal: controller.signal });
+      } catch (err) {
+        clearTimeout(timer);
+        external?.removeEventListener("abort", onExternalAbort);
+        if (external?.aborted) {
+          throw new SpotifyApiError({ message: "Request aborted by caller.", code: "ABORTED", url, cause: err });
+        }
+        lastError = timedOut ? new SpotifyApiError({
+          message: `Request timed out after ${cfg.timeoutMs}ms.`,
+          code: "TIMEOUT",
+          url,
+          cause: err
+        }) : new SpotifyApiError({ message: `Network error: ${errMessage(err)}`, code: "NETWORK", url, cause: err });
+        if (attempt < maxAttempts - 1) {
+          const delayMs = this.backoff(attempt);
+          cfg.onRetry?.({ attempt: attempt + 1, method, url, error: lastError, delayMs });
+          cfg.debug?.(`retry ${attempt + 1} after ${delayMs}ms (${lastError.code})`);
+          await sleep(delayMs);
+          continue;
+        }
+        throw lastError;
+      }
+      clearTimeout(timer);
+      external?.removeEventListener("abort", onExternalAbort);
+      cfg.onResponse?.({ method, url, status: response.status, durationMs: Date.now() - attemptStart });
+      cfg.debug?.(`\u2190 ${response.status} ${method} ${url} (${Date.now() - attemptStart}ms)`);
+      if ((response.status === 429 || response.status >= 500) && attempt < maxAttempts - 1) {
+        const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+        const delayMs = retryAfter ?? this.backoff(attempt);
+        cfg.onRetry?.({ attempt: attempt + 1, method, url, status: response.status, delayMs });
+        cfg.debug?.(`retry ${attempt + 1} after ${delayMs}ms (status ${response.status})`);
+        await sleep(delayMs);
+        continue;
+      }
+      const raw = await response.text();
+      let json;
+      if (raw.length > 0) {
+        try {
+          json = JSON.parse(raw);
+        } catch {
+          json = raw;
+        }
+      }
+      if (!response.ok) {
+        throw new SpotifyApiError({
+          message: extractMessage(json) ?? `HTTP ${response.status} ${response.statusText}`.trim(),
+          status: response.status,
+          code: extractCode(json),
+          url,
+          body: json
+        });
+      }
+      if (typeof json === "object" && json !== null) {
+        const rec = json;
+        if (rec.success === false) {
+          throw new SpotifyApiError({
+            message: extractMessage(json) ?? "Upstream reported failure.",
+            status: response.status,
+            code: extractCode(json),
+            url,
+            body: json
+          });
+        }
+        if ("success" in rec && "data" in rec) {
+          return json;
+        }
+      }
+      return { success: true, data: json };
+    }
+    throw lastError ?? new SpotifyApiError({ message: "Request failed.", url });
+  }
+  /** GET a path and return the unwrapped `data` payload. */
+  async get(path, query, options) {
+    const env = await this.request({ method: "GET", path, query, ...options });
+    return env.data;
+  }
+  /** POST a JSON body and return the unwrapped `data` payload. */
+  async post(path, body, query, options) {
+    const env = await this.request({ method: "POST", path, body, query, ...options });
+    return env.data;
+  }
+  /** DELETE a path and return the unwrapped `data` payload. */
+  async delete(path, query, options) {
+    const env = await this.request({ method: "DELETE", path, query, ...options });
+    return env.data;
+  }
+  buildUrl(path, query) {
+    const suffix = path.startsWith("/") ? path : `/${path}`;
+    const qs = serializeQuery(query);
+    return `${this.config.baseUrl}${suffix}${qs ? `?${qs}` : ""}`;
+  }
+  backoff(attempt) {
+    const base = this.config.retryDelayMs * 2 ** attempt;
+    return base + Math.floor(Math.random() * this.config.retryDelayMs);
+  }
+};
+var ID_SINGLE_KEYS = /* @__PURE__ */ new Set(["id", "spotify_track_id"]);
+var ID_MULTI_KEYS = /* @__PURE__ */ new Set(["ids", "seed_tracks", "seed_artists"]);
+function serializeQuery(query) {
+  if (!query) return "";
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    if (ID_MULTI_KEYS.has(key)) {
+      const normalized = normalizeIds(value);
+      if (normalized.length > 0) params.append(key, normalized);
+    } else if (ID_SINGLE_KEYS.has(key) && !Array.isArray(value)) {
+      params.append(key, normalizeId(value));
+    } else if (Array.isArray(value)) {
+      if (value.length > 0) params.append(key, value.join(","));
+    } else {
+      params.append(key, String(value));
+    }
+  }
+  return params.toString();
+}
+function extractMessage(json) {
+  if (typeof json === "object" && json !== null) {
+    const rec = json;
+    if (typeof rec.message === "string") return rec.message;
+    if (typeof rec.error === "string") return rec.error;
+  }
+  return void 0;
+}
+function extractCode(json) {
+  if (typeof json === "object" && json !== null) {
+    const rec = json;
+    if (typeof rec.error === "string") return rec.error;
+    if (typeof rec.code === "string") return rec.code;
+  }
+  return void 0;
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const date = Date.parse(value);
+  if (Number.isFinite(date)) return Math.max(0, date - Date.now());
+  return void 0;
+}
+function errMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/resources/base.ts
+var Resource = class {
+  constructor(client) {
+    this.client = client;
+  }
+};
+function buildPath(template, params) {
+  return template.replace(/\{([^}]+)\}/g, (_, key) => {
+    const value = params[key];
+    if (value === void 0 || value === null) {
+      throw new Error(`Missing path parameter "${key}" for "${template}".`);
+    }
+    const normalized = /id$/i.test(key) ? normalizeId(value) : String(value);
+    return encodeURIComponent(normalized);
+  });
+}
+
+// src/resources/ai.ts
+var AiResource = class extends Resource {
+  /** AI module health. */
+  health(query, options) {
+    return this.client.get("/ai/health", query, options);
+  }
+  /** List the supported AI analysis types. */
+  types(query, options) {
+    return this.client.get("/ai/types", query, options);
+  }
+  /** Run a generic AI analysis. */
+  analyze(body, query, options) {
+    return this.client.post("/ai/analyze", body, query, options);
+  }
+  /** Analyze chart trends. */
+  chartTrends(body, query, options) {
+    return this.client.post("/ai/chart-trends", body, query, options);
+  }
+  /** Generate an AI artist summary. */
+  artistSummary(body, query, options) {
+    return this.client.post("/ai/artist-summary", body, query, options);
+  }
+  /** Generate an AI album review. */
+  albumReview(body, query, options) {
+    return this.client.post("/ai/album-review", body, query, options);
+  }
+  /** Generate an AI track deep dive. */
+  trackDeepDive(body, query, options) {
+    return this.client.post("/ai/track-deep-dive", body, query, options);
+  }
+  /** Curate a playlist with AI. */
+  playlistCurator(body, query, options) {
+    return this.client.post("/ai/playlist-curator", body, query, options);
+  }
+  /** Generate an AI market comparison. */
+  marketComparison(body, query, options) {
+    return this.client.post("/ai/market-comparison", body, query, options);
+  }
+  /** Generate an AI genre landscape. */
+  genreLandscape(body, query, options) {
+    return this.client.post("/ai/genre-landscape", body, query, options);
+  }
+  /** Generate an AI mood profile. */
+  moodProfile(body, query, options) {
+    return this.client.post("/ai/mood-profile", body, query, options);
+  }
+  /** Assess viral potential with AI. */
+  viralPotential(body, query, options) {
+    return this.client.post("/ai/viral-potential", body, query, options);
+  }
+  /** Run a custom AI prompt. */
+  custom(body, query, options) {
+    return this.client.post("/ai/custom", body, query, options);
+  }
+};
+
+// src/resources/albums.ts
+var AlbumsResource = class extends Resource {
+  /** Get one or more albums by ID. */
+  get(params, options) {
+    return this.client.get("/albums", { ids: params.ids, contrast: params.contrast }, options);
+  }
+  /** Get an album's tracks (paginated). */
+  tracks(params, options) {
+    return this.client.get(
+      "/album_tracks",
+      { id: params.id, offset: params.offset, limit: params.limit },
+      options
+    );
+  }
+  /** Get extended album metadata. */
+  metadata(params, options) {
+    return this.client.get(
+      "/album_metadata",
+      { id: params.id, contrast: params.contrast },
+      options
+    );
+  }
+};
+
+// src/resources/analysis.ts
+var AnalysisResource = class extends Resource {
+  /** Compare artists side by side. */
+  artistCompare(params, options) {
+    return this.client.get("/artist_compare", { ids: params.ids }, options);
+  }
+  /** Get audio features for a track. */
+  audioFeatures(params, options) {
+    return this.client.get("/audio_features", { id: params.id }, options);
+  }
+  /** Get analysis for a playlist. */
+  playlistAnalysis(params, options) {
+    return this.client.get("/playlist_analysis", { id: params.id }, options);
+  }
+};
+
+// src/resources/artists.ts
+var ArtistsResource = class extends Resource {
+  /** Get one or more artists by ID. */
+  get(params, options) {
+    return this.client.get("/artists", { ids: params.ids, contrast: params.contrast }, options);
+  }
+  /** Get an artist overview. */
+  overview(params, options) {
+    return this.client.get(
+      "/artist_overview",
+      { id: params.id, contrast: params.contrast },
+      options
+    );
+  }
+  /** Get an artist's discography overview. */
+  discographyOverview(params, options) {
+    return this.client.get(
+      "/artist_discography_overview",
+      { id: params.id },
+      options
+    );
+  }
+  /** Get an artist's albums (paginated). */
+  albums(params, options) {
+    return this.client.get(
+      "/artist_albums",
+      { id: params.id, offset: params.offset, limit: params.limit },
+      options
+    );
+  }
+  /** Get an artist's singles (paginated). */
+  singles(params, options) {
+    return this.client.get(
+      "/artist_singles",
+      { id: params.id, offset: params.offset, limit: params.limit },
+      options
+    );
+  }
+  /** Get releases an artist appears on. */
+  appearsOn(params, options) {
+    return this.client.get("/artist_appears_on", { id: params.id }, options);
+  }
+  /** Get playlists an artist was discovered on. */
+  discoveredOn(params, options) {
+    return this.client.get("/artist_discovered_on", { id: params.id }, options);
+  }
+  /** Get tracks featuring an artist. */
+  featuring(params, options) {
+    return this.client.get("/artist_featuring", { id: params.id }, options);
+  }
+  /** Get artists related to an artist. */
+  related(params, options) {
+    return this.client.get("/artist_related", { id: params.id }, options);
+  }
+  /** Get an artist's top tracks. */
+  topTracks(params, options) {
+    return this.client.get(
+      "/artist_top_tracks",
+      { id: params.id, market: params.market },
+      options
+    );
+  }
+};
+
+// src/resources/audiobooks.ts
+var AudiobooksResource = class extends Resource {
+  /** Get one or more audiobooks by ID. */
+  get(params, options) {
+    return this.client.get("/audiobooks", { ids: params.ids, market: params.market }, options);
+  }
+  /** Get a single audiobook by ID. */
+  getById(params, options) {
+    const path = buildPath("/audiobooks/{id}", { id: params.id });
+    return this.client.get(path, { market: params.market }, options);
+  }
+  /** Get an audiobook's chapters (paginated). */
+  chapters(params, options) {
+    const path = buildPath("/audiobooks/{id}/chapters", { id: params.id });
+    return this.client.get(path, { offset: params.offset, limit: params.limit }, options);
+  }
+};
+
+// src/resources/batch.ts
+var BatchResource = class extends Resource {
+  /** Get extended album metadata for many albums at once. */
+  albumMetadata(params, options) {
+    return this.client.get("/album_metadata_batch", { ids: params.ids }, options);
+  }
+  /** Get artist overviews for many artists at once. */
+  artistOverview(params, options) {
+    return this.client.get("/artist_overview_batch", { ids: params.ids }, options);
+  }
+  /** Get credits for many tracks at once. */
+  trackCredits(params, options) {
+    return this.client.get("/track_credits_batch", { ids: params.ids }, options);
+  }
+  /** Get synced lyrics for many tracks at once. */
+  trackLyrics(params, options) {
+    return this.client.get(
+      "/track_lyrics_batch",
+      { ids: params.ids, format: params.format },
+      options
+    );
+  }
+  /** Get popularity scores for many tracks at once. */
+  trackPopularity(params, options) {
+    return this.client.get("/track_popularity_batch", { ids: params.ids }, options);
+  }
+};
+
+// src/resources/browse.ts
+var BrowseResource = class extends Resource {
+  /** List browse categories. */
+  categories(params, options) {
+    return this.client.get(
+      "/browse/categories",
+      {
+        country: params?.country,
+        locale: params?.locale,
+        limit: params?.limit,
+        offset: params?.offset
+      },
+      options
+    );
+  }
+  /** Get a single browse category by ID. */
+  category(params, options) {
+    const path = buildPath("/browse/categories/{id}", { id: params.id });
+    return this.client.get(
+      path,
+      { country: params.country, locale: params.locale },
+      options
+    );
+  }
+  /** Get featured playlists. */
+  featuredPlaylists(params, options) {
+    return this.client.get(
+      "/browse/featured-playlists",
+      {
+        country: params?.country,
+        locale: params?.locale,
+        limit: params?.limit,
+        offset: params?.offset
+      },
+      options
+    );
+  }
+  /** Get new album releases. */
+  newReleases(params, options) {
+    return this.client.get(
+      "/browse/new-releases",
+      { country: params?.country, limit: params?.limit, offset: params?.offset },
+      options
+    );
+  }
+  /** Get track recommendations from seed tracks, artists, and/or genres. */
+  recommendations(params, options) {
+    return this.client.get(
+      "/browse/recommendations",
+      {
+        seed_tracks: params?.seed_tracks,
+        seed_artists: params?.seed_artists,
+        seed_genres: params?.seed_genres,
+        limit: params?.limit
+      },
+      options
+    );
+  }
+};
+
+// src/resources/cache.ts
+var CacheResource = class extends Resource {
+  /** Get cache statistics (hits, misses, size, etc.). */
+  stats(query, options) {
+    return this.client.get("/cache/stats", query, options);
+  }
+  /** Invalidate cached entries by exact key or by matching pattern. */
+  invalidate(params, options) {
+    return this.client.post(
+      "/cache/invalidate",
+      { key: params.key, pattern: params.pattern },
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/charts.ts
+var ChartsResource = class extends Resource {
+  /** Top 20 artists by monthly listeners. */
+  topByMonthlyListeners(query, options) {
+    return this.client.get("/top_20_by_monthly_listeners", query, options);
+  }
+  /** Top 200 tracks chart. */
+  top200Tracks(params, options) {
+    return this.client.get(
+      "/top_200_tracks",
+      { period: params.period, country: params.country, date: params.date },
+      options
+    );
+  }
+  /** Top artists chart. */
+  topArtists(params, options) {
+    return this.client.get(
+      "/top_artists",
+      { period: params.period, country: params.country },
+      options
+    );
+  }
+  /** Top albums chart. */
+  topAlbums(params, options) {
+    return this.client.get(
+      "/top_albums",
+      { period: params.period, country: params.country },
+      options
+    );
+  }
+  /** Viral tracks chart. */
+  viralTracks(params, options) {
+    return this.client.get("/viral_tracks", { country: params.country }, options);
+  }
+  /** Top 20 artists by followers. */
+  topByFollowers(query, options) {
+    return this.client.get("/top_20_by_followers", query, options);
+  }
+};
+
+// src/resources/concerts.ts
+var ConcertsResource = class extends Resource {
+  /** Search concert locations by city, venue, or place name. */
+  locations(params, options) {
+    return this.client.get(
+      "/partner/concert-locations",
+      { query: params.query },
+      options
+    );
+  }
+  /** Get the concert feed for a location. */
+  feed(params, options) {
+    return this.client.get(
+      "/partner/concert-feed",
+      {
+        geoHash: params.geoHash,
+        geonameId: params.geonameId,
+        from: params.from,
+        to: params.to,
+        radiusInKm: params.radiusInKm,
+        conceptUris: params.conceptUris,
+        paginationKey: params.paginationKey,
+        details: params.details,
+        detailsLimit: params.detailsLimit,
+        parsed: params.parsed
+      },
+      options
+    );
+  }
+  /** Get details for a single concert. */
+  get(params, options) {
+    return this.client.get(
+      "/partner/concert",
+      { id: params.id, parsed: params.parsed, authenticated: params.authenticated },
+      options
+    );
+  }
+  /** Get an artist's upcoming concerts. */
+  byArtist(params, options) {
+    return this.client.get(
+      "/partner/artist-concerts",
+      {
+        id: params.id,
+        geoHash: params.geoHash,
+        includeNearby: params.includeNearby,
+        details: params.details,
+        detailsLimit: params.detailsLimit,
+        parsed: params.parsed
+      },
+      options
+    );
+  }
+  /** Search concerts by artist name. */
+  searchArtists(params, options) {
+    return this.client.get(
+      "/partner/search-concert-artists",
+      {
+        query: params.query,
+        geoHash: params.geoHash,
+        includeNearby: params.includeNearby,
+        limit: params.limit,
+        details: params.details,
+        detailsLimit: params.detailsLimit,
+        parsed: params.parsed
+      },
+      options
+    );
+  }
+};
+
+// src/resources/credentials.ts
+var CredentialsResource = class extends Resource {
+  /** Get the current credentials status. */
+  status(query, options) {
+    return this.client.get("/credentials/status", query, options);
+  }
+  /** Get the Redis-backed cookie pool status. */
+  redisCookies(query, options) {
+    return this.client.get("/cookies/redis", query, options);
+  }
+};
+
+// src/resources/downloads.ts
+var DownloadsResource = class extends Resource {
+  /** Download a track. */
+  track(params, options) {
+    return this.client.get("/download_track", { q: params.q }, options);
+  }
+  /** Download a track from SoundCloud. */
+  soundcloud(params, options) {
+    return this.client.get("/download_track_sc", { q: params.q }, options);
+  }
+};
+
+// src/resources/episodes.ts
+var EpisodesResource = class extends Resource {
+  /** Get one or more episodes by ID. */
+  get(params, options) {
+    return this.client.get("/episodes", { ids: params.ids, market: params.market }, options);
+  }
+  /** Get a single episode by ID. */
+  byId(params, options) {
+    const path = buildPath("/episodes/{id}", { id: params.id });
+    return this.client.get(path, { market: params.market }, options);
+  }
+};
+
+// src/resources/health.ts
+var HealthResource = class extends Resource {
+  /** Lightweight liveness probe. */
+  ping(query, options) {
+    return this.client.get("/ping", query, options);
+  }
+  /** Overall cluster health summary. */
+  get(query, options) {
+    return this.client.get("/health", query, options);
+  }
+  /** Health of the individual instance serving the request. */
+  instance(query, options) {
+    return this.client.get("/health/instance", query, options);
+  }
+  /** Cluster-wide health overview. */
+  cluster(query, options) {
+    return this.client.get("/health/cluster", query, options);
+  }
+  /** Strict cluster health check (fails unless every instance is healthy). */
+  clusterStrict(query, options) {
+    return this.client.get("/health/cluster/strict", query, options);
+  }
+  /** Health and statistics for the proxy pool. */
+  proxies(query, options) {
+    return this.client.get("/health/proxies", query, options);
+  }
+  /** Clear accumulated proxy statistics. */
+  clearProxies(body, query, options) {
+    return this.client.post("/health/proxies/clear", body, query, options);
+  }
+  /** Clear accumulated error counters. */
+  clearErrors(body, query, options) {
+    return this.client.post("/health/clear-errors", body, query, options);
+  }
+};
+
+// src/resources/lookups.ts
+var LookupsResource = class extends Resource {
+  /** Lookup a track by its ISRC. */
+  isrc(params, options) {
+    return this.client.get("/isrc_lookup", { isrc: params.isrc }, options);
+  }
+  /** Lookup an album by its UPC. */
+  upc(params, options) {
+    return this.client.get("/upc_lookup", { upc: params.upc }, options);
+  }
+};
+
+// src/resources/markets.ts
+var MarketsResource = class extends Resource {
+  /** List the markets (countries) where Spotify is available. */
+  get(query, options) {
+    return this.client.get("/markets", query, options);
+  }
+};
+
+// src/resources/partner.ts
+var PartnerResource = class extends Resource {
+  /** Get partner playlist data (paginated). */
+  playlist(params, options) {
+    return this.client.get(
+      "/partner/playlist",
+      { id: params.id, offset: params.offset, limit: params.limit },
+      options
+    );
+  }
+  /** Get partner track data. */
+  track(params, options) {
+    return this.client.get("/partner/track", { id: params.id }, options);
+  }
+  /** Get a track's play count by Spotify ID or ISRC. */
+  trackCount(params, options) {
+    return this.client.get(
+      "/partner/track/count",
+      { spotify_track_id: params.spotify_track_id, isrc: params.isrc },
+      options
+    );
+  }
+  /** Get partner album data (paginated). */
+  album(params, options) {
+    return this.client.get(
+      "/partner/album",
+      { id: params.id, locale: params.locale, offset: params.offset, limit: params.limit },
+      options
+    );
+  }
+  /** Get partner artist overview. */
+  artistOverview(params, options) {
+    return this.client.get(
+      "/partner/artist-overview",
+      { id: params.id, locale: params.locale, includePrerelease: params.includePrerelease },
+      options
+    );
+  }
+  /** Get partner artist discography (paginated). */
+  artistDiscography(params, options) {
+    return this.client.get(
+      "/partner/artist-discography",
+      { id: params.id, offset: params.offset, limit: params.limit },
+      options
+    );
+  }
+};
+
+// src/resources/playlists.ts
+var PlaylistsResource = class extends Resource {
+  /** Get a playlist by ID. */
+  get(params, options) {
+    return this.client.get("/playlist", { id: params.id }, options);
+  }
+  /** Get a playlist's tracks (paginated). */
+  tracks(params, options) {
+    return this.client.get(
+      "/playlist_tracks",
+      { id: params.id, offset: params.offset, limit: params.limit },
+      options
+    );
+  }
+  /** Generate a playlist from a seed URI. */
+  fromSeed(params, options) {
+    return this.client.get("/seed_to_playlist", { uri: params.uri }, options);
+  }
+};
+
+// src/resources/search.ts
+var SearchResource = class extends Resource {
+  /** Search Spotify across one or more types. */
+  search(params, options) {
+    return this.client.get(
+      "/search",
+      {
+        q: params.q,
+        type: params.type,
+        offset: params.offset,
+        limit: params.limit,
+        numberOfTopResults: params.numberOfTopResults,
+        contrast: params.contrast
+      },
+      options
+    );
+  }
+  /** Search returning only the top results. */
+  topResults(params, options) {
+    return this.client.get(
+      "/search_top_results",
+      { q: params.q, numberOfTopResults: params.numberOfTopResults, contrast: params.contrast },
+      options
+    );
+  }
+  /** Search and return synced lyrics for the best match. */
+  lyrics(params, options) {
+    return this.client.get("/search_lyrics", { q: params.q, format: params.format }, options);
+  }
+  /** Search suggestions / autocomplete. */
+  suggestions(params, options) {
+    return this.client.get(
+      "/search_suggestions",
+      {
+        q: params.q,
+        offset: params.offset,
+        limit: params.limit,
+        numberOfTopResults: params.numberOfTopResults,
+        includeAuthors: params.includeAuthors,
+        debug: params.debug,
+        timeout: params.timeout,
+        contrast: params.contrast
+      },
+      options
+    );
+  }
+  /** Search across multiple markets at once. */
+  multiMarket(params, options) {
+    return this.client.get(
+      "/search_multi_market",
+      { q: params.q, type: params.type, markets: params.markets, limit: params.limit },
+      options
+    );
+  }
+};
+
+// src/resources/shows.ts
+var ShowsResource = class extends Resource {
+  /** Get one or more shows by ID. */
+  get(params, options) {
+    return this.client.get("/shows", { ids: params.ids, market: params.market }, options);
+  }
+  /** Get a single show by ID. */
+  getById(params, options) {
+    const path = buildPath("/shows/{id}", { id: params.id });
+    return this.client.get(path, { market: params.market }, options);
+  }
+  /** Get a show's episodes (paginated). */
+  episodes(params, options) {
+    const path = buildPath("/shows/{id}/episodes", { id: params.id });
+    return this.client.get(path, { offset: params.offset, limit: params.limit }, options);
+  }
+};
+
+// src/resources/snapshots.ts
+var SnapshotsResource = class extends Resource {
+  /** List the snapshots taken for a playlist. */
+  list(params, options) {
+    return this.client.get("/playlist_snapshot", { id: params.id }, options);
+  }
+  /** Create a new snapshot of a playlist. */
+  create(params, options) {
+    return this.client.post(
+      "/playlist_snapshot",
+      { id: params.id, webhook: params.webhook },
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/tracking.ts
+var TrackingResource = class extends Resource {
+  /** Start tracking a Spotify item. */
+  track(params, options) {
+    return this.client.post("/tracking/track", { type: params.type, id: params.id }, void 0, options);
+  }
+  /** Stop tracking a Spotify item. */
+  untrack(params, options) {
+    return this.client.delete("/tracking/untrack", { type: params.type, id: params.id }, options);
+  }
+  /** List tracked items (paginated). */
+  items(params, options) {
+    return this.client.get(
+      "/tracking/items",
+      { offset: params.offset, limit: params.limit },
+      options
+    );
+  }
+  /** Get the detail of a single tracked item. */
+  item(params, options) {
+    const path = buildPath("/tracking/items/{spotifyType}/{spotifyId}", {
+      spotifyType: params.spotifyType,
+      spotifyId: params.spotifyId
+    });
+    return this.client.get(path, void 0, options);
+  }
+  /** Get the tracking change log (paginated). */
+  logs(params, options) {
+    return this.client.get(
+      "/tracking/logs",
+      { offset: params.offset, limit: params.limit },
+      options
+    );
+  }
+  /** Get tracking statistics. */
+  stats(query, options) {
+    return this.client.get("/tracking/stats", query, options);
+  }
+  /** Get tracking subsystem health. */
+  health(query, options) {
+    return this.client.get("/tracking/health", query, options);
+  }
+};
+
+// src/resources/tracks.ts
+var TracksResource = class extends Resource {
+  /** Get one or more tracks by ID. */
+  get(params, options) {
+    return this.client.get("/tracks", { ids: params.ids, contrast: params.contrast }, options);
+  }
+  /** Get a track's credits (writers, producers, performers). */
+  credits(params, options) {
+    return this.client.get("/track_credits", { id: params.id }, options);
+  }
+  /** Get a track's lyrics. */
+  lyrics(params, options) {
+    return this.client.get(
+      "/track_lyrics",
+      { id: params.id, format: params.format, vocalRemoval: params.vocalRemoval },
+      options
+    );
+  }
+  /** Get track recommendations from seed tracks, artists and/or genres. */
+  recommendations(params, options) {
+    return this.client.get(
+      "/recommendations",
+      {
+        limit: params.limit,
+        seed_tracks: params.seed_tracks,
+        seed_artists: params.seed_artists,
+        seed_genres: params.seed_genres
+      },
+      options
+    );
+  }
+};
+
+// src/resources/users.ts
+var UsersResource = class extends Resource {
+  /** Get a public user profile, including their playlists, artists and episodes. */
+  profile(params, options) {
+    return this.client.get(
+      "/user_profile",
+      {
+        id: params.id,
+        playlistLimit: params.playlistLimit,
+        artistLimit: params.artistLimit,
+        episodeLimit: params.episodeLimit
+      },
+      options
+    );
+  }
+  /** Get a user's followers. */
+  followers(params, options) {
+    return this.client.get("/user_followers", { id: params.id }, options);
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class extends Resource {
+  /** List registered webhooks. */
+  get(query, options) {
+    return this.client.get("/webhooks", query, options);
+  }
+  /** Register a new webhook. */
+  register(params, options) {
+    return this.client.post(
+      "/webhooks/register",
+      { url: params.url, events: params.events },
+      void 0,
+      options
+    );
+  }
+  /** Get aggregate webhook delivery statistics. */
+  stats(query, options) {
+    return this.client.get("/webhooks/stats", query, options);
+  }
+  /** Delete a webhook by ID. */
+  delete(params, options) {
+    return this.client.delete(buildPath("/webhooks/{id}", { id: params.id }), void 0, options);
+  }
+  /** Trigger a test delivery for a webhook. */
+  test(params, options) {
+    return this.client.post(
+      buildPath("/webhooks/{id}/test", { id: params.id }),
+      void 0,
+      void 0,
+      options
+    );
+  }
+  /** Get the delivery log for a webhook. */
+  deliveries(params, options) {
+    return this.client.get(buildPath("/webhooks/{id}/deliveries", { id: params.id }), void 0, options);
+  }
+};
+
+// src/client.ts
+var SpotifyApiClient = class extends SpotifyHttpClient {
+  constructor(config) {
+    super(config);
+    this.ai = new AiResource(this);
+    this.albums = new AlbumsResource(this);
+    this.analysis = new AnalysisResource(this);
+    this.artists = new ArtistsResource(this);
+    this.audiobooks = new AudiobooksResource(this);
+    this.batch = new BatchResource(this);
+    this.browse = new BrowseResource(this);
+    this.cache = new CacheResource(this);
+    this.charts = new ChartsResource(this);
+    this.concerts = new ConcertsResource(this);
+    this.credentials = new CredentialsResource(this);
+    this.downloads = new DownloadsResource(this);
+    this.episodes = new EpisodesResource(this);
+    this.health = new HealthResource(this);
+    this.lookups = new LookupsResource(this);
+    this.markets = new MarketsResource(this);
+    this.partner = new PartnerResource(this);
+    this.playlists = new PlaylistsResource(this);
+    this.search = new SearchResource(this);
+    this.shows = new ShowsResource(this);
+    this.snapshots = new SnapshotsResource(this);
+    this.tracking = new TrackingResource(this);
+    this.tracks = new TracksResource(this);
+    this.users = new UsersResource(this);
+    this.webhooks = new WebhooksResource(this);
+  }
+};
+function createClient(config) {
+  return new SpotifyApiClient(config);
+}
+
+// src/pagination.ts
+function defaultGetItems(page) {
+  return Array.isArray(page) ? page : [];
+}
+async function* paginate(fetcher, options = {}) {
+  const getItems = options.getItems ?? defaultGetItems;
+  const limit = options.limit ?? 50;
+  let offset = options.offset ?? 0;
+  const maxPages = options.maxPages ?? 100;
+  let seen = 0;
+  for (let page = 0; page < maxPages; page++) {
+    const result = await fetcher({ offset, limit });
+    const items = getItems(result);
+    yield result;
+    seen += items.length;
+    if (items.length < limit) return;
+    if (options.maxItems !== void 0 && seen >= options.maxItems) return;
+    offset += limit;
+  }
+}
+async function collect(fetcher, options = {}) {
+  const getItems = options.getItems ?? defaultGetItems;
+  const out = [];
+  for await (const page of paginate(fetcher, options)) {
+    for (const item of getItems(page)) {
+      out.push(item);
+      if (options.maxItems !== void 0 && out.length >= options.maxItems) return out;
+    }
+  }
+  return out;
+}
+
+// src/generated/responses.ts
+var BiographyType = /* @__PURE__ */ ((BiographyType2) => {
+  BiographyType2["Autobiography"] = "AUTOBIOGRAPHY";
+  BiographyType2["C"] = "C";
+  BiographyType2["P"] = "P";
+  return BiographyType2;
+})(BiographyType || {});
+var Precision = /* @__PURE__ */ ((Precision2) => {
+  Precision2["Day"] = "DAY";
+  Precision2["Minute"] = "MINUTE";
+  return Precision2;
+})(Precision || {});
+var PurpleReason = /* @__PURE__ */ ((PurpleReason2) => {
+  PurpleReason2["CountryRestricted"] = "COUNTRY_RESTRICTED";
+  PurpleReason2["Playable"] = "PLAYABLE";
+  return PurpleReason2;
+})(PurpleReason || {});
+var LatestType = /* @__PURE__ */ ((LatestType2) => {
+  LatestType2["Album"] = "ALBUM";
+  LatestType2["Compilation"] = "COMPILATION";
+  LatestType2["Ep"] = "EP";
+  LatestType2["Single"] = "SINGLE";
+  return LatestType2;
+})(LatestType || {});
+var Label = /* @__PURE__ */ ((Label2) => {
+  Label2["Explicit"] = "EXPLICIT";
+  Label2["None"] = "NONE";
+  return Label2;
+})(Label || {});
+var AlbumAlbumType = /* @__PURE__ */ ((AlbumAlbumType2) => {
+  AlbumAlbumType2["Album"] = "album";
+  AlbumAlbumType2["Compilation"] = "compilation";
+  AlbumAlbumType2["Ep"] = "ep";
+  AlbumAlbumType2["Single"] = "single";
+  return AlbumAlbumType2;
+})(AlbumAlbumType || {});
+var OwnerEnum = /* @__PURE__ */ ((OwnerEnum2) => {
+  OwnerEnum2["Spotify"] = "Spotify";
+  return OwnerEnum2;
+})(OwnerEnum || {});
+var OwnerType = /* @__PURE__ */ ((OwnerType2) => {
+  OwnerType2["Artist"] = "artist";
+  OwnerType2["User"] = "user";
+  return OwnerType2;
+})(OwnerType || {});
+var ReleaseDatePrecision = /* @__PURE__ */ ((ReleaseDatePrecision2) => {
+  ReleaseDatePrecision2["Day"] = "day";
+  ReleaseDatePrecision2["Empty"] = "";
+  return ReleaseDatePrecision2;
+})(ReleaseDatePrecision || {});
+var Market = /* @__PURE__ */ ((Market2) => {
+  Market2["AE"] = "AE";
+  Market2["Ad"] = "AD";
+  Market2["Ag"] = "AG";
+  Market2["Al"] = "AL";
+  Market2["Am"] = "AM";
+  Market2["Ao"] = "AO";
+  Market2["Ar"] = "AR";
+  Market2["At"] = "AT";
+  Market2["Au"] = "AU";
+  Market2["Az"] = "AZ";
+  Market2["BI"] = "BI";
+  Market2["BT"] = "BT";
+  Market2["BW"] = "BW";
+  Market2["Ba"] = "BA";
+  Market2["Bb"] = "BB";
+  Market2["Bd"] = "BD";
+  Market2["Be"] = "BE";
+  Market2["Bf"] = "BF";
+  Market2["Bg"] = "BG";
+  Market2["Bh"] = "BH";
+  Market2["Bj"] = "BJ";
+  Market2["Bn"] = "BN";
+  Market2["Bo"] = "BO";
+  Market2["Br"] = "BR";
+  Market2["Bs"] = "BS";
+  Market2["By"] = "BY";
+  Market2["Bz"] = "BZ";
+  Market2["CA"] = "CA";
+  Market2["CD"] = "CD";
+  Market2["CG"] = "CG";
+  Market2["CM"] = "CM";
+  Market2["CR"] = "CR";
+  Market2["Ch"] = "CH";
+  Market2["Ci"] = "CI";
+  Market2["Cl"] = "CL";
+  Market2["Co"] = "CO";
+  Market2["Cv"] = "CV";
+  Market2["Cw"] = "CW";
+  Market2["Cy"] = "CY";
+  Market2["Cz"] = "CZ";
+  Market2["De"] = "DE";
+  Market2["Dj"] = "DJ";
+  Market2["Dk"] = "DK";
+  Market2["Dm"] = "DM";
+  Market2["Do"] = "DO";
+  Market2["Dz"] = "DZ";
+  Market2["Ec"] = "EC";
+  Market2["Ee"] = "EE";
+  Market2["Eg"] = "EG";
+  Market2["Es"] = "ES";
+  Market2["Et"] = "ET";
+  Market2["Fi"] = "FI";
+  Market2["Fj"] = "FJ";
+  Market2["Fm"] = "FM";
+  Market2["Fr"] = "FR";
+  Market2["GB"] = "GB";
+  Market2["Ga"] = "GA";
+  Market2["Gd"] = "GD";
+  Market2["Ge"] = "GE";
+  Market2["Gh"] = "GH";
+  Market2["Gm"] = "GM";
+  Market2["Gn"] = "GN";
+  Market2["Gq"] = "GQ";
+  Market2["Gr"] = "GR";
+  Market2["Gt"] = "GT";
+  Market2["Gw"] = "GW";
+  Market2["Gy"] = "GY";
+  Market2["HT"] = "HT";
+  Market2["Hk"] = "HK";
+  Market2["Hn"] = "HN";
+  Market2["Hr"] = "HR";
+  Market2["Hu"] = "HU";
+  Market2["ID"] = "ID";
+  Market2["IL"] = "IL";
+  Market2["Ie"] = "IE";
+  Market2["In"] = "IN";
+  Market2["Iq"] = "IQ";
+  Market2["Is"] = "IS";
+  Market2["It"] = "IT";
+  Market2["Jm"] = "JM";
+  Market2["Jo"] = "JO";
+  Market2["Jp"] = "JP";
+  Market2["KM"] = "KM";
+  Market2["Ke"] = "KE";
+  Market2["Kg"] = "KG";
+  Market2["Kh"] = "KH";
+  Market2["Ki"] = "KI";
+  Market2["Kn"] = "KN";
+  Market2["Kr"] = "KR";
+  Market2["Kw"] = "KW";
+  Market2["Kz"] = "KZ";
+  Market2["LB"] = "LB";
+  Market2["LV"] = "LV";
+  Market2["La"] = "LA";
+  Market2["Lc"] = "LC";
+  Market2["Li"] = "LI";
+  Market2["Lk"] = "LK";
+  Market2["Lr"] = "LR";
+  Market2["Ls"] = "LS";
+  Market2["Lt"] = "LT";
+  Market2["Lu"] = "LU";
+  Market2["Ly"] = "LY";
+  Market2["MT"] = "MT";
+  Market2["MX"] = "MX";
+  Market2["Ma"] = "MA";
+  Market2["Mc"] = "MC";
+  Market2["Md"] = "MD";
+  Market2["Me"] = "ME";
+  Market2["Mg"] = "MG";
+  Market2["Mh"] = "MH";
+  Market2["Mk"] = "MK";
+  Market2["Ml"] = "ML";
+  Market2["Mn"] = "MN";
+  Market2["Mo"] = "MO";
+  Market2["Mr"] = "MR";
+  Market2["Mu"] = "MU";
+  Market2["Mv"] = "MV";
+  Market2["Mw"] = "MW";
+  Market2["My"] = "MY";
+  Market2["Mz"] = "MZ";
+  Market2["NI"] = "NI";
+  Market2["NP"] = "NP";
+  Market2["Na"] = "NA";
+  Market2["Ne"] = "NE";
+  Market2["Ng"] = "NG";
+  Market2["Nl"] = "NL";
+  Market2["No"] = "NO";
+  Market2["Nr"] = "NR";
+  Market2["Nz"] = "NZ";
+  Market2["Om"] = "OM";
+  Market2["PE"] = "PE";
+  Market2["PG"] = "PG";
+  Market2["PR"] = "PR";
+  Market2["PS"] = "PS";
+  Market2["Pa"] = "PA";
+  Market2["Ph"] = "PH";
+  Market2["Pk"] = "PK";
+  Market2["Pl"] = "PL";
+  Market2["Pt"] = "PT";
+  Market2["Pw"] = "PW";
+  Market2["Py"] = "PY";
+  Market2["QA"] = "QA";
+  Market2["Ro"] = "RO";
+  Market2["Rs"] = "RS";
+  Market2["Rw"] = "RW";
+  Market2["SE"] = "SE";
+  Market2["Sa"] = "SA";
+  Market2["Sb"] = "SB";
+  Market2["Sc"] = "SC";
+  Market2["Sg"] = "SG";
+  Market2["Si"] = "SI";
+  Market2["Sk"] = "SK";
+  Market2["Sl"] = "SL";
+  Market2["Sm"] = "SM";
+  Market2["Sn"] = "SN";
+  Market2["Sr"] = "SR";
+  Market2["St"] = "ST";
+  Market2["Sv"] = "SV";
+  Market2["Sz"] = "SZ";
+  Market2["Td"] = "TD";
+  Market2["Tg"] = "TG";
+  Market2["Th"] = "TH";
+  Market2["Tj"] = "TJ";
+  Market2["Tl"] = "TL";
+  Market2["Tn"] = "TN";
+  Market2["To"] = "TO";
+  Market2["Tr"] = "TR";
+  Market2["Tt"] = "TT";
+  Market2["Tv"] = "TV";
+  Market2["Tw"] = "TW";
+  Market2["Tz"] = "TZ";
+  Market2["Ua"] = "UA";
+  Market2["Ug"] = "UG";
+  Market2["Us"] = "US";
+  Market2["Uy"] = "UY";
+  Market2["Uz"] = "UZ";
+  Market2["Vc"] = "VC";
+  Market2["Ve"] = "VE";
+  Market2["Vn"] = "VN";
+  Market2["Vu"] = "VU";
+  Market2["Ws"] = "WS";
+  Market2["Xk"] = "XK";
+  Market2["Za"] = "ZA";
+  Market2["Zm"] = "ZM";
+  Market2["Zw"] = "ZW";
+  return Market2;
+})(Market || {});
+var RestrictionsReason = /* @__PURE__ */ ((RestrictionsReason2) => {
+  RestrictionsReason2["Empty"] = "";
+  RestrictionsReason2["Playable"] = "PLAYABLE";
+  return RestrictionsReason2;
+})(RestrictionsReason || {});
+var TrackType = /* @__PURE__ */ ((TrackType2) => {
+  TrackType2["Track"] = "track";
+  return TrackType2;
+})(TrackType || {});
+var LabelEnum = /* @__PURE__ */ ((LabelEnum2) => {
+  LabelEnum2["CashMoneyDrakeLP6"] = "Cash Money/Drake LP6";
+  LabelEnum2["CashMoneyRecordsYoungMoneyEntUniversalRec"] = "Cash Money Records/Young Money Ent./Universal Rec.";
+  LabelEnum2["OVORepublic"] = "OVO/Republic";
+  LabelEnum2["OVORepublicRecords"] = "OVO / Republic Records";
+  LabelEnum2["OVOSound"] = "OVO Sound";
+  LabelEnum2["Ovo"] = "OVO";
+  LabelEnum2["TaylorSwift"] = "Taylor Swift";
+  LabelEnum2["The4BatzOVOSound"] = "4batz / OVO Sound";
+  LabelEnum2["UltraRecordsLLC"] = "Ultra Records, LLC";
+  LabelEnum2["WaltDisneyRecordsPixar"] = "Walt Disney Records / Pixar";
+  return LabelEnum2;
+})(LabelEnum || {});
+var PurpleType = /* @__PURE__ */ ((PurpleType2) => {
+  PurpleType2["Artist"] = "artist";
+  PurpleType2["Single"] = "SINGLE";
+  return PurpleType2;
+})(PurpleType || {});
+var ArtistUnionTypename = /* @__PURE__ */ ((ArtistUnionTypename2) => {
+  ArtistUnionTypename2["Album"] = "Album";
+  ArtistUnionTypename2["Artist"] = "Artist";
+  ArtistUnionTypename2["Playlist"] = "Playlist";
+  ArtistUnionTypename2["Track"] = "Track";
+  ArtistUnionTypename2["User"] = "User";
+  return ArtistUnionTypename2;
+})(ArtistUnionTypename || {});
+var PurpleTypename = /* @__PURE__ */ ((PurpleTypename2) => {
+  PurpleTypename2["GenericError"] = "GenericError";
+  PurpleTypename2["Playlist"] = "Playlist";
+  return PurpleTypename2;
+})(PurpleTypename || {});
+var PrimaryColor = /* @__PURE__ */ ((PrimaryColor2) => {
+  PrimaryColor2["Eb1E32"] = "#eb1e32";
+  PrimaryColor2["Ffffff"] = "#ffffff";
+  PrimaryColor2["PrimaryColorFFFFFF"] = "#FFFFFF";
+  PrimaryColor2["The509Bf5"] = "#509BF5";
+  return PrimaryColor2;
+})(PrimaryColor || {});
+var GetPlaylistDataType = /* @__PURE__ */ ((GetPlaylistDataType2) => {
+  GetPlaylistDataType2["Playlist"] = "playlist";
+  return GetPlaylistDataType2;
+})(GetPlaylistDataType || {});
+var Status = /* @__PURE__ */ ((Status2) => {
+  Status2["Healthy"] = "healthy";
+  return Status2;
+})(Status || {});
+var InstanceName = /* @__PURE__ */ ((InstanceName2) => {
+  InstanceName2["Trustpilot"] = "trustpilot";
+  InstanceName2["Trustpilotiso"] = "trustpilot_iso";
+  return InstanceName2;
+})(InstanceName || {});
+var SquareCoverImageTypename = /* @__PURE__ */ ((SquareCoverImageTypename2) => {
+  SquareCoverImageTypename2["VisualIdentityImage"] = "VisualIdentityImage";
+  return SquareCoverImageTypename2;
+})(SquareCoverImageTypename || {});
+var FluffyTypename = /* @__PURE__ */ ((FluffyTypename2) => {
+  FluffyTypename2["ImageV2"] = "ImageV2";
+  return FluffyTypename2;
+})(FluffyTypename || {});
+var ItemV2Typename = /* @__PURE__ */ ((ItemV2Typename2) => {
+  ItemV2Typename2["AlbumResponseWrapper"] = "AlbumResponseWrapper";
+  ItemV2Typename2["ArtistResponseWrapper"] = "ArtistResponseWrapper";
+  ItemV2Typename2["PlaylistResponseWrapper"] = "PlaylistResponseWrapper";
+  ItemV2Typename2["SearchAutoCompleteEntity"] = "SearchAutoCompleteEntity";
+  ItemV2Typename2["TrackResponseWrapper"] = "TrackResponseWrapper";
+  ItemV2Typename2["UserResponseWrapper"] = "UserResponseWrapper";
+  return ItemV2Typename2;
+})(ItemV2Typename || {});
+var AudioAssociationsTypename = /* @__PURE__ */ ((AudioAssociationsTypename2) => {
+  AudioAssociationsTypename2["TrackAudioAssociationPage"] = "TrackAudioAssociationPage";
+  return AudioAssociationsTypename2;
+})(AudioAssociationsTypename || {});
+var MediaType = /* @__PURE__ */ ((MediaType2) => {
+  MediaType2["Audio"] = "AUDIO";
+  MediaType2["Video"] = "VIDEO";
+  return MediaType2;
+})(MediaType || {});
+var Format = /* @__PURE__ */ ((Format2) => {
+  Format2["ArtistMixReader"] = "artist-mix-reader";
+  Format2["Editorial"] = "editorial";
+  Format2["Empty"] = "";
+  Format2["FormatShowsShuffle"] = "format-shows-shuffle";
+  Format2["InspiredbyMix"] = "inspiredby-mix";
+  return Format2;
+})(Format || {});
+var RelatedEntityTypename = /* @__PURE__ */ ((RelatedEntityTypename2) => {
+  RelatedEntityTypename2["EpisodeResponseWrapper"] = "EpisodeResponseWrapper";
+  return RelatedEntityTypename2;
+})(RelatedEntityTypename || {});
+var TentacledTypename = /* @__PURE__ */ ((TentacledTypename2) => {
+  TentacledTypename2["Podcast"] = "Podcast";
+  return TentacledTypename2;
+})(TentacledTypename || {});
+var StateEnum = /* @__PURE__ */ ((StateEnum2) => {
+  StateEnum2["NotStarted"] = "NOT_STARTED";
+  return StateEnum2;
+})(StateEnum || {});
+var PodcastV2Typename = /* @__PURE__ */ ((PodcastV2Typename2) => {
+  PodcastV2Typename2["PodcastResponseWrapper"] = "PodcastResponseWrapper";
+  return PodcastV2Typename2;
+})(PodcastV2Typename || {});
+var PurpleMediaType = /* @__PURE__ */ ((PurpleMediaType2) => {
+  PurpleMediaType2["Audio"] = "AUDIO";
+  PurpleMediaType2["Mixed"] = "MIXED";
+  return PurpleMediaType2;
+})(PurpleMediaType || {});
+var StickyTypename = /* @__PURE__ */ ((StickyTypename2) => {
+  StickyTypename2["GenreResponseWrapper"] = "GenreResponseWrapper";
+  return StickyTypename2;
+})(StickyTypename || {});
+var ItemsV2Typename = /* @__PURE__ */ ((ItemsV2Typename2) => {
+  ItemsV2Typename2["TopResultHit"] = "TopResultHit";
+  return ItemsV2Typename2;
+})(ItemsV2Typename || {});
+var Language = /* @__PURE__ */ ((Language2) => {
+  Language2["En"] = "en";
+  return Language2;
+})(Language || {});
+var FluffyType = /* @__PURE__ */ ((FluffyType2) => {
+  FluffyType2["Episode"] = "episode";
+  return FluffyType2;
+})(FluffyType || {});
+var EntryStatus = /* @__PURE__ */ ((EntryStatus2) => {
+  EntryStatus2["MovedDown"] = "MOVED_DOWN";
+  EntryStatus2["MovedUp"] = "MOVED_UP";
+  EntryStatus2["NewEntry"] = "NEW_ENTRY";
+  EntryStatus2["NoChange"] = "NO_CHANGE";
+  EntryStatus2["ReEntry"] = "RE_ENTRY";
+  return EntryStatus2;
+})(EntryStatus || {});
+var RankingMetricType = /* @__PURE__ */ ((RankingMetricType2) => {
+  RankingMetricType2["Streams"] = "STREAMS";
+  return RankingMetricType2;
+})(RankingMetricType || {});
+var Subrole = /* @__PURE__ */ ((Subrole2) => {
+  Subrole2["MainArtist"] = "main artist";
+  Subrole2["Producer"] = "producer";
+  Subrole2["Writer"] = "writer";
+  return Subrole2;
+})(Subrole || {});
+var Uri = /* @__PURE__ */ ((Uri2) => {
+  Uri2["SpotifyUserSpotify"] = "spotify:user:spotify";
+  return Uri2;
+})(Uri || {});
+
+exports.AiResource = AiResource;
+exports.AlbumAlbumType = AlbumAlbumType;
+exports.AlbumsResource = AlbumsResource;
+exports.AnalysisResource = AnalysisResource;
+exports.ArtistUnionTypename = ArtistUnionTypename;
+exports.ArtistsResource = ArtistsResource;
+exports.AudioAssociationsTypename = AudioAssociationsTypename;
+exports.AudiobooksResource = AudiobooksResource;
+exports.BatchResource = BatchResource;
+exports.BiographyType = BiographyType;
+exports.BrowseResource = BrowseResource;
+exports.CacheResource = CacheResource;
+exports.ChartsResource = ChartsResource;
+exports.ConcertsResource = ConcertsResource;
+exports.CredentialsResource = CredentialsResource;
+exports.DEFAULT_RETRIES = DEFAULT_RETRIES;
+exports.DEFAULT_RETRY_DELAY_MS = DEFAULT_RETRY_DELAY_MS;
+exports.DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_MS;
+exports.DEFAULT_USER_AGENT = DEFAULT_USER_AGENT;
+exports.DownloadsResource = DownloadsResource;
+exports.EntryStatus = EntryStatus;
+exports.EpisodesResource = EpisodesResource;
+exports.FluffyType = FluffyType;
+exports.FluffyTypename = FluffyTypename;
+exports.Format = Format;
+exports.GetPlaylistDataType = GetPlaylistDataType;
+exports.HealthResource = HealthResource;
+exports.InstanceName = InstanceName;
+exports.ItemV2Typename = ItemV2Typename;
+exports.ItemsV2Typename = ItemsV2Typename;
+exports.Label = Label;
+exports.LabelEnum = LabelEnum;
+exports.Language = Language;
+exports.LatestType = LatestType;
+exports.LookupsResource = LookupsResource;
+exports.Market = Market;
+exports.MarketsResource = MarketsResource;
+exports.MediaType = MediaType;
+exports.OwnerEnum = OwnerEnum;
+exports.OwnerType = OwnerType;
+exports.PROVIDERS = PROVIDERS;
+exports.PartnerResource = PartnerResource;
+exports.PlaylistsResource = PlaylistsResource;
+exports.PodcastV2Typename = PodcastV2Typename;
+exports.Precision = Precision;
+exports.PrimaryColor = PrimaryColor;
+exports.PurpleMediaType = PurpleMediaType;
+exports.PurpleReason = PurpleReason;
+exports.PurpleType = PurpleType;
+exports.PurpleTypename = PurpleTypename;
+exports.RankingMetricType = RankingMetricType;
+exports.RelatedEntityTypename = RelatedEntityTypename;
+exports.ReleaseDatePrecision = ReleaseDatePrecision;
+exports.RestrictionsReason = RestrictionsReason;
+exports.SearchResource = SearchResource;
+exports.ShowsResource = ShowsResource;
+exports.SnapshotsResource = SnapshotsResource;
+exports.SpotifyApiClient = SpotifyApiClient;
+exports.SpotifyApiError = SpotifyApiError;
+exports.SpotifyHttpClient = SpotifyHttpClient;
+exports.SquareCoverImageTypename = SquareCoverImageTypename;
+exports.StateEnum = StateEnum;
+exports.Status = Status;
+exports.StickyTypename = StickyTypename;
+exports.Subrole = Subrole;
+exports.TentacledTypename = TentacledTypename;
+exports.TrackType = TrackType;
+exports.TrackingResource = TrackingResource;
+exports.TracksResource = TracksResource;
+exports.Uri = Uri;
+exports.UsersResource = UsersResource;
+exports.WebhooksResource = WebhooksResource;
+exports.buildPath = buildPath;
+exports.collect = collect;
+exports.createClient = createClient;
+exports.normalizeId = normalizeId;
+exports.normalizeIds = normalizeIds;
+exports.paginate = paginate;
+exports.resolveConfig = resolveConfig;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map