@checkleaked/spotify-api 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,4068 @@
+/**
+ * Core shared types for the Spotify Data API client.
+ */
+/** Built-in base-URL presets. */
+type Provider = 'rapidapi' | 'proxy';
+/** Minimal `fetch` shape the client depends on (injectable for tests / custom runtimes). */
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+/**
+ * The standard success envelope every endpoint returns.
+ * `data` holds the useful payload; SDK methods return it unwrapped.
+ */
+interface SuccessEnvelope<T = unknown> {
+    success: boolean;
+    data: T;
+    metadata?: Record<string, unknown>;
+}
+/** The standard error envelope returned on failure. */
+interface ErrorEnvelope {
+    success: boolean;
+    error?: string;
+    message?: string;
+}
+/** A value acceptable in a query string. Arrays are serialized as comma-separated. */
+type QueryValue = string | number | boolean | null | undefined | ReadonlyArray<string | number>;
+/** A bag of query parameters. `undefined`/`null` entries are dropped. */
+type QueryParams$1 = Record<string, QueryValue>;
+/**
+ * Anywhere an ID list is accepted you may pass a comma-separated string, or an
+ * array of IDs / URIs / URLs — all are normalized to bare comma-joined IDs.
+ */
+type IdList = string | ReadonlyArray<string>;
+/** Lifecycle info passed to the retry hook. */
+interface RetryInfo {
+    attempt: number;
+    method: string;
+    url: string;
+    status?: number;
+    error?: unknown;
+    delayMs: number;
+}
+/** Per-request overrides shared by every verb helper. */
+interface RequestOverrides {
+    /** Abort the request from the caller side. */
+    signal?: AbortSignal;
+    /** Extra headers merged over the defaults for this request only. */
+    headers?: Record<string, string>;
+}
+/** Full description of a single HTTP request. */
+interface RequestOptions extends RequestOverrides {
+    method?: string;
+    path: string;
+    query?: QueryParams$1;
+    body?: unknown;
+}
+/** User-facing client configuration. */
+interface ClientConfig {
+    /**
+     * API key sent as `x-rapidapi-key`. If omitted, the client falls back to the
+     * `SPOTIFY_API_KEY` or `RAPIDAPI_KEY` environment variable (Node only).
+     */
+    apiKey?: string;
+    /**
+     * Base-URL preset. `rapidapi` (default) targets `https://spotify81.p.rapidapi.com`
+     * and adds the `x-rapidapi-host` header; `proxy` targets the direct proxy.
+     */
+    provider?: Provider;
+    /** Override the base URL entirely (takes precedence over `provider`). */
+    baseUrl?: string;
+    /** Override the `x-rapidapi-host` header (takes precedence over `provider`). */
+    host?: string;
+    /** Per-request timeout in milliseconds. Default `30000`. */
+    timeoutMs?: number;
+    /** Number of retries on 429 / 5xx / network errors. Default `2`. */
+    retries?: number;
+    /** Base backoff delay in milliseconds (exponential w/ jitter). Default `500`. */
+    retryDelayMs?: number;
+    /** Extra headers merged into every request. */
+    headers?: Record<string, string>;
+    /** Custom `fetch` implementation. Defaults to the global `fetch`. */
+    fetch?: FetchLike;
+    /** Value for the `user-agent` header. */
+    userAgent?: string;
+    /** Log every request/response/retry to the console (or the provided logger). */
+    debug?: boolean | ((message: string, detail?: unknown) => void);
+    /** Called just before each request goes out. */
+    onRequest?: (info: {
+        method: string;
+        url: string;
+        headers: Record<string, string>;
+    }) => void;
+    /** Called after each response is received. */
+    onResponse?: (info: {
+        method: string;
+        url: string;
+        status: number;
+        durationMs: number;
+    }) => void;
+    /** Called before each retry (429 / 5xx / network). */
+    onRetry?: (info: RetryInfo) => void;
+}
+
+/** Base-URL / host presets for each provider. */
+declare const PROVIDERS: {
+    rapidapi: {
+        baseUrl: string;
+        host: string;
+    };
+    proxy: {
+        baseUrl: string;
+        host: undefined;
+    };
+};
+declare const DEFAULT_USER_AGENT = "@checkleaked/spotify-api";
+declare const DEFAULT_TIMEOUT_MS = 30000;
+declare const DEFAULT_RETRIES = 2;
+declare const DEFAULT_RETRY_DELAY_MS = 500;
+/** Fully-resolved configuration used internally by the client. */
+interface ResolvedConfig {
+    apiKey: string;
+    baseUrl: string;
+    host?: string;
+    timeoutMs: number;
+    retries: number;
+    retryDelayMs: number;
+    headers: Record<string, string>;
+    fetch: FetchLike;
+    userAgent: string;
+    debug?: (message: string, detail?: unknown) => void;
+    onRequest?: (info: {
+        method: string;
+        url: string;
+        headers: Record<string, string>;
+    }) => void;
+    onResponse?: (info: {
+        method: string;
+        url: string;
+        status: number;
+        durationMs: number;
+    }) => void;
+    onRetry?: (info: RetryInfo) => void;
+}
+/** Validate and normalize user config into a {@link ResolvedConfig}. */
+declare function resolveConfig(config?: ClientConfig): ResolvedConfig;
+
+/**
+ * Low-level HTTP transport for the Spotify Data API.
+ *
+ * Handles URL/query building, header injection (`x-rapidapi-key` + host),
+ * timeouts, retries with backoff (429 / 5xx / network, honoring `Retry-After`),
+ * envelope unwrapping and uniform error mapping.
+ *
+ * The high-level {@link SpotifyApiClient} extends this and adds the typed
+ * resource namespaces.
+ */
+declare class SpotifyHttpClient {
+    readonly config: ResolvedConfig;
+    constructor(config: ClientConfig);
+    /** Perform a request and return the full {@link SuccessEnvelope}. */
+    request<T = unknown>(options: RequestOptions): Promise<SuccessEnvelope<T>>;
+    /** GET a path and return the unwrapped `data` payload. */
+    get<T = unknown>(path: string, query?: QueryParams$1, options?: RequestOverrides): Promise<T>;
+    /** POST a JSON body and return the unwrapped `data` payload. */
+    post<T = unknown>(path: string, body?: unknown, query?: QueryParams$1, options?: RequestOverrides): Promise<T>;
+    /** DELETE a path and return the unwrapped `data` payload. */
+    delete<T = unknown>(path: string, query?: QueryParams$1, options?: RequestOverrides): Promise<T>;
+    private buildUrl;
+    private backoff;
+}
+
+/**
+ * Base class for every resource namespace. Holds a reference to the transport
+ * client so resource methods can call `this.client.get/post/delete`.
+ */
+declare abstract class Resource {
+    protected readonly client: SpotifyHttpClient;
+    constructor(client: SpotifyHttpClient);
+}
+/**
+ * Interpolate `{name}` placeholders in a path template, URL-encoding each value.
+ * `id`-like params accept a Spotify ID, URI, or URL (reduced to the bare ID).
+ */
+declare function buildPath(template: string, params: Record<string, string | number>): string;
+
+/**
+ * AI-powered analysis endpoints.
+ *
+ * Every analysis endpoint accepts a free-form JSON body (the subject to
+ * analyze plus any options), so these methods take an untyped `body`.
+ * Responses are not part of the generated type set and are returned as
+ * `unknown`.
+ */
+declare class AiResource extends Resource {
+    /** AI module health. */
+    health(query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** List the supported AI analysis types. */
+    types(query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Run a generic AI analysis. */
+    analyze(body?: unknown, query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Analyze chart trends. */
+    chartTrends(body?: unknown, query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Generate an AI artist summary. */
+    artistSummary(body?: unknown, query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Generate an AI album review. */
+    albumReview(body?: unknown, query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Generate an AI track deep dive. */
+    trackDeepDive(body?: unknown, query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Curate a playlist with AI. */
+    playlistCurator(body?: unknown, query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Generate an AI market comparison. */
+    marketComparison(body?: unknown, query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Generate an AI genre landscape. */
+    genreLandscape(body?: unknown, query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Generate an AI mood profile. */
+    moodProfile(body?: unknown, query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Assess viral potential with AI. */
+    viralPotential(body?: unknown, query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Run a custom AI prompt. */
+    custom(body?: unknown, query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+}
+
+type GetAlbumMetadataData = GetAlbumMetadataDataClass;
+type GetArtistAppearsOnData = GetArtistData;
+type GetArtistDiscographyOverviewData = GetArtistData;
+type GetArtistDiscoveredOnData = GetArtistData;
+type GetArtistFeaturingData = GetArtistData;
+type GetArtistTopTracksData = GetTracksData;
+type GetBrowseCategoriesIdData = GetBrowseCategoriesidData;
+type GetBrowseRecommendationsData = string;
+type GetShowsIdData = GetShowsidData;
+type GetTop200TracksData = GetTop200TracksDatum[];
+type GetTop20ByFollowersData = GetTop20ByFollowersDatum[];
+type GetTop20ByMonthlyListenersData = GetTop20ByMonthlyListenersDatum[];
+type GetTopAlbumsData = GetSDatum[];
+type GetTopArtistsData = GetSDatum[];
+type GetTrackLyricsData = GetSearchLyricsData;
+type GetViralTracksData = GetSDatum[];
+interface GetAlbumMetadataBatchData {
+    results: GetAlbumMetadataBatchDataResult[];
+}
+interface GetAlbumMetadataBatchDataResult {
+    id: string;
+    metadata: Metadata;
+    error: null;
+}
+interface Metadata {
+    data: GetAlbumMetadataDataClass;
+}
+interface GetAlbumMetadataDataClass {
+    album: GetAlbumMetadataDataAlbum;
+}
+interface GetAlbumMetadataDataAlbum {
+    uri: string;
+    name: string;
+    artists: ReleasesClass;
+    coverArt: CoverArt;
+    discs: Discs;
+    tracks: PurpleTracks;
+    releases: ReleasesClass;
+    type: LatestType;
+    date: ReleaseDateClass;
+    playability: LatestPlayability;
+    label: string;
+    copyright: AlbumCopyright;
+    courtesyLine: string;
+    sharingInfo: AlbumSharingInfo;
+    moreAlbumsByArtist: AlbumMoreAlbumsByArtist;
+}
+interface ReleasesClass {
+    totalCount: number;
+    items: ItemClass[];
+}
+interface ItemClass {
+    id: string;
+    uri: string;
+    profile: UserLocationClass;
+    visuals?: ItemVisuals;
+    sharingInfo?: PurpleSharingInfo;
+    relatedContent?: ItemRelatedContent;
+}
+interface UserLocationClass {
+    name: string;
+}
+interface ItemRelatedContent {
+    relatedArtists: RelatedArtists;
+}
+interface RelatedArtists {
+    totalCount: number;
+    items: RelatedArtistsItem[];
+}
+interface RelatedArtistsItem {
+    id: string;
+    uri: string;
+    profile: UserLocationClass;
+    visuals: ItemVisuals;
+}
+interface ItemVisuals {
+    avatarImage: AvatarImageElement;
+}
+interface AvatarImageElement {
+    sources: Icon[];
+}
+interface Icon {
+    url: string;
+    height: number | null;
+    width: number | null;
+}
+interface PurpleSharingInfo {
+    shareUrl: string;
+}
+interface AlbumCopyright {
+    totalCount: number;
+    items: BiographyElement[];
+}
+interface BiographyElement {
+    type: BiographyType;
+    text: string;
+}
+declare enum BiographyType {
+    Autobiography = "AUTOBIOGRAPHY",
+    C = "C",
+    P = "P"
+}
+interface CoverArt {
+    extractedColors: PurpleExtractedColors;
+    sources: Icon[];
+}
+interface PurpleExtractedColors {
+    colorRaw: Color;
+    colorLight: Color;
+    colorDark: Color;
+}
+interface Color {
+    hex: string;
+}
+interface ReleaseDateClass {
+    isoString: Date;
+    precision: Precision;
+}
+declare enum Precision {
+    Day = "DAY",
+    Minute = "MINUTE"
+}
+interface Discs {
+    totalCount: number;
+    items: DiscsItem[];
+}
+interface DiscsItem {
+    number: number;
+    tracks: AlbumsV2;
+}
+interface AlbumsV2 {
+    totalCount: number;
+}
+interface AlbumMoreAlbumsByArtist {
+    items: PurpleItem[];
+}
+interface PurpleItem {
+    discography: PurpleDiscography;
+}
+interface PurpleDiscography {
+    popularReleases: PopularReleases;
+}
+interface PopularReleases {
+    items: FluffyItem[];
+}
+interface FluffyItem {
+    releases: PurplePopularReleasesAlbums;
+}
+interface PurplePopularReleasesAlbums {
+    items: TentacledItem[];
+}
+interface TentacledItem {
+    id: string;
+    uri: string;
+    name: string;
+    date: PurpleDate;
+    coverArt: AvatarImageElement;
+    playability?: LatestPlayability;
+    sharingInfo: AlbumSharingInfo;
+    artists?: ItemArtists;
+    type?: LatestType;
+}
+interface ItemArtists {
+    items: StickyItem[];
+}
+interface StickyItem {
+    uri: string;
+    profile: UserLocationClass;
+}
+interface PurpleDate {
+    year: number;
+}
+interface LatestPlayability {
+    playable: boolean;
+    reason: PurpleReason;
+}
+declare enum PurpleReason {
+    CountryRestricted = "COUNTRY_RESTRICTED",
+    Playable = "PLAYABLE"
+}
+interface AlbumSharingInfo {
+    shareId: string;
+    shareUrl: string;
+}
+declare enum LatestType {
+    Album = "ALBUM",
+    Compilation = "COMPILATION",
+    Ep = "EP",
+    Single = "SINGLE"
+}
+interface PurpleTracks {
+    totalCount: number;
+    items: IndigoItem[];
+}
+interface IndigoItem {
+    track: PurpleTrack;
+}
+interface PurpleTrack {
+    playability: LatestPlayability;
+    duration: TrackDurationClass;
+}
+interface TrackDurationClass {
+    totalMilliseconds: number;
+}
+interface GetAlbumTracksData {
+    album: GetAlbumTracksDataAlbum;
+}
+interface GetAlbumTracksDataAlbum {
+    playability: AlbumOfTrackPlayability;
+    tracks: FluffyTracks;
+}
+interface AlbumOfTrackPlayability {
+    playable: boolean;
+}
+interface FluffyTracks {
+    totalCount: number;
+    items: IndecentItem[];
+}
+interface IndecentItem {
+    uid: string;
+    track: FluffyTrack;
+}
+interface FluffyTrack {
+    uri: string;
+    name: string;
+    playcount: string;
+    discNumber: number;
+    trackNumber: number;
+    contentRating: ContentRating;
+    relinkingInformation: PurpleRelinkingInformation;
+    duration: TrackDurationClass;
+    playability: AlbumOfTrackPlayability;
+    artists: ItemArtists;
+}
+interface ContentRating {
+    label: Label;
+}
+declare enum Label {
+    Explicit = "EXPLICIT",
+    None = "NONE"
+}
+interface PurpleRelinkingInformation {
+    uri: string;
+    isRelinked: boolean;
+}
+interface GetAlbumsData {
+    albums: GetAlbumsDataAlbum[];
+}
+interface GetAlbumsDataAlbum {
+    album_type: AlbumAlbumType;
+    total_tracks: number;
+    available_markets: any[];
+    external_urls: ExternalUrls;
+    href: string;
+    id: string;
+    images: Icon[];
+    name: string;
+    release_date: Date;
+    release_date_precision: ReleaseDatePrecision;
+    type: AlbumAlbumType;
+    uri: string;
+    artists: Owner[];
+    tracks: AlbumsClass;
+    copyrights: BiographyElement[];
+    external_ids: AlbumExternalids;
+    genres: any[];
+    label: string;
+    popularity: number;
+}
+declare enum AlbumAlbumType {
+    Album = "album",
+    Compilation = "compilation",
+    Ep = "ep",
+    Single = "single"
+}
+interface Owner {
+    external_urls: ExternalUrls;
+    href: string;
+    id: string;
+    name?: string;
+    type: OwnerType;
+    uri: string;
+    display_name?: OwnerEnum;
+}
+declare enum OwnerEnum {
+    Spotify = "Spotify"
+}
+interface ExternalUrls {
+    spotify: string;
+}
+declare enum OwnerType {
+    Artist = "artist",
+    User = "user"
+}
+interface AlbumExternalids {
+    upc: string;
+}
+declare enum ReleaseDatePrecision {
+    Day = "day",
+    Empty = ""
+}
+interface AlbumsClass {
+    href: string;
+    limit: number;
+    next: null;
+    offset: number;
+    previous: null;
+    total: number;
+    items: TracksTrack[];
+}
+interface TracksTrack {
+    artists: Owner[];
+    disc_number: number;
+    track_number: number;
+    duration_ms: number;
+    explicit: boolean;
+    external_urls: ExternalUrls;
+    href: string;
+    id: string;
+    is_local: boolean;
+    name: string;
+    preview_url: null;
+    type: TrackType;
+    uri: string;
+    external_ids: ItemExternalids;
+    album?: ItemElement;
+    is_playable?: boolean;
+    popularity?: number;
+    available_markets?: Market[];
+}
+interface ItemElement {
+    album_type: AlbumAlbumType;
+    artists: Owner[];
+    external_urls: ExternalUrls;
+    href: string;
+    id: string;
+    images: Icon[];
+    is_playable?: boolean;
+    name: string;
+    release_date: string;
+    release_date_precision: ReleaseDatePrecision;
+    total_tracks: number | null;
+    type: AlbumAlbumType;
+    uri: string;
+    available_markets?: Market[];
+    restrictions?: PlayabilityClass;
+}
+declare enum Market {
+    AE = "AE",
+    Ad = "AD",
+    Ag = "AG",
+    Al = "AL",
+    Am = "AM",
+    Ao = "AO",
+    Ar = "AR",
+    At = "AT",
+    Au = "AU",
+    Az = "AZ",
+    BI = "BI",
+    BT = "BT",
+    BW = "BW",
+    Ba = "BA",
+    Bb = "BB",
+    Bd = "BD",
+    Be = "BE",
+    Bf = "BF",
+    Bg = "BG",
+    Bh = "BH",
+    Bj = "BJ",
+    Bn = "BN",
+    Bo = "BO",
+    Br = "BR",
+    Bs = "BS",
+    By = "BY",
+    Bz = "BZ",
+    CA = "CA",
+    CD = "CD",
+    CG = "CG",
+    CM = "CM",
+    CR = "CR",
+    Ch = "CH",
+    Ci = "CI",
+    Cl = "CL",
+    Co = "CO",
+    Cv = "CV",
+    Cw = "CW",
+    Cy = "CY",
+    Cz = "CZ",
+    De = "DE",
+    Dj = "DJ",
+    Dk = "DK",
+    Dm = "DM",
+    Do = "DO",
+    Dz = "DZ",
+    Ec = "EC",
+    Ee = "EE",
+    Eg = "EG",
+    Es = "ES",
+    Et = "ET",
+    Fi = "FI",
+    Fj = "FJ",
+    Fm = "FM",
+    Fr = "FR",
+    GB = "GB",
+    Ga = "GA",
+    Gd = "GD",
+    Ge = "GE",
+    Gh = "GH",
+    Gm = "GM",
+    Gn = "GN",
+    Gq = "GQ",
+    Gr = "GR",
+    Gt = "GT",
+    Gw = "GW",
+    Gy = "GY",
+    HT = "HT",
+    Hk = "HK",
+    Hn = "HN",
+    Hr = "HR",
+    Hu = "HU",
+    ID = "ID",
+    IL = "IL",
+    Ie = "IE",
+    In = "IN",
+    Iq = "IQ",
+    Is = "IS",
+    It = "IT",
+    Jm = "JM",
+    Jo = "JO",
+    Jp = "JP",
+    KM = "KM",
+    Ke = "KE",
+    Kg = "KG",
+    Kh = "KH",
+    Ki = "KI",
+    Kn = "KN",
+    Kr = "KR",
+    Kw = "KW",
+    Kz = "KZ",
+    LB = "LB",
+    LV = "LV",
+    La = "LA",
+    Lc = "LC",
+    Li = "LI",
+    Lk = "LK",
+    Lr = "LR",
+    Ls = "LS",
+    Lt = "LT",
+    Lu = "LU",
+    Ly = "LY",
+    MT = "MT",
+    MX = "MX",
+    Ma = "MA",
+    Mc = "MC",
+    Md = "MD",
+    Me = "ME",
+    Mg = "MG",
+    Mh = "MH",
+    Mk = "MK",
+    Ml = "ML",
+    Mn = "MN",
+    Mo = "MO",
+    Mr = "MR",
+    Mu = "MU",
+    Mv = "MV",
+    Mw = "MW",
+    My = "MY",
+    Mz = "MZ",
+    NI = "NI",
+    NP = "NP",
+    Na = "NA",
+    Ne = "NE",
+    Ng = "NG",
+    Nl = "NL",
+    No = "NO",
+    Nr = "NR",
+    Nz = "NZ",
+    Om = "OM",
+    PE = "PE",
+    PG = "PG",
+    PR = "PR",
+    PS = "PS",
+    Pa = "PA",
+    Ph = "PH",
+    Pk = "PK",
+    Pl = "PL",
+    Pt = "PT",
+    Pw = "PW",
+    Py = "PY",
+    QA = "QA",
+    Ro = "RO",
+    Rs = "RS",
+    Rw = "RW",
+    SE = "SE",
+    Sa = "SA",
+    Sb = "SB",
+    Sc = "SC",
+    Sg = "SG",
+    Si = "SI",
+    Sk = "SK",
+    Sl = "SL",
+    Sm = "SM",
+    Sn = "SN",
+    Sr = "SR",
+    St = "ST",
+    Sv = "SV",
+    Sz = "SZ",
+    Td = "TD",
+    Tg = "TG",
+    Th = "TH",
+    Tj = "TJ",
+    Tl = "TL",
+    Tn = "TN",
+    To = "TO",
+    Tr = "TR",
+    Tt = "TT",
+    Tv = "TV",
+    Tw = "TW",
+    Tz = "TZ",
+    Ua = "UA",
+    Ug = "UG",
+    Us = "US",
+    Uy = "UY",
+    Uz = "UZ",
+    Vc = "VC",
+    Ve = "VE",
+    Vn = "VN",
+    Vu = "VU",
+    Ws = "WS",
+    Xk = "XK",
+    Za = "ZA",
+    Zm = "ZM",
+    Zw = "ZW"
+}
+interface PlayabilityClass {
+    reason: RestrictionsReason;
+}
+declare enum RestrictionsReason {
+    Empty = "",
+    Playable = "PLAYABLE"
+}
+interface ItemExternalids {
+    isrc: string;
+}
+declare enum TrackType {
+    Track = "track"
+}
+interface GetArtistAlbumsData {
+    artist: GetArtistAlbumsDataArtist;
+}
+interface GetArtistAlbumsDataArtist {
+    discography: FluffyDiscography;
+}
+interface FluffyDiscography {
+    albums: PurpleAlbums;
+}
+interface PurpleAlbums {
+    totalCount: number;
+    items: HilariousItem[];
+}
+interface HilariousItem {
+    releases: PurpleReleases;
+}
+interface PurpleReleases {
+    items: AmbitiousItem[];
+}
+interface AmbitiousItem {
+    id: string;
+    uri: string;
+    name: string;
+    type: LatestType;
+    date: FluffyDate;
+    coverArt: AvatarImageElement;
+    playability: LatestPlayability;
+    sharingInfo: AlbumSharingInfo;
+    tracks: AlbumsV2;
+}
+interface FluffyDate {
+    year: number;
+    isoString: Date;
+}
+interface GetArtistData {
+    artist: GetArtistAppearsOnDataArtist;
+}
+interface GetArtistAppearsOnDataArtist {
+    id: string;
+    uri: string;
+    profile: UserLocationClass;
+    relatedContent?: PurpleRelatedContent;
+    discography?: TentacledDiscography;
+    visuals?: ItemVisuals;
+}
+interface TentacledDiscography {
+    albums: AlbumsV2;
+    singles: AlbumsV2;
+    compilations: AlbumsV2;
+    all: AlbumsV2;
+}
+interface PurpleRelatedContent {
+    appearsOn?: PurpleAppearsOn;
+    discoveredOn?: DiscoveredOn;
+    featuring?: DiscoveredOn;
+}
+interface PurpleAppearsOn {
+    totalCount: number;
+    items: CunningItem[];
+}
+interface CunningItem {
+    releases: FluffyReleases;
+}
+interface FluffyReleases {
+    totalCount: number;
+    items: MagentaItem[];
+}
+interface MagentaItem {
+    uri: string;
+    id: string;
+    name: string;
+    artists: ItemArtists;
+    coverArt: AvatarImageElement;
+    sharingInfo: AlbumSharingInfo;
+    type?: LatestType;
+    date?: PurpleDate;
+}
+interface DiscoveredOn {
+    totalCount: number;
+    items: DiscoveredOnItem[];
+}
+interface DiscoveredOnItem {
+    uri: string;
+    id: string;
+    owner: UserLocationClass;
+    name: string;
+    description: string;
+    images: ItemImages;
+}
+interface ItemImages {
+    totalCount: number;
+    items: AvatarImageElement[];
+}
+interface GetArtistCompareData {
+    artists: GetArtistCompareDataArtist[];
+    comparison: Comparison;
+}
+interface GetArtistCompareDataArtist {
+    id: string;
+    name: string;
+    popularity: number;
+    followers: number;
+    genres: string[];
+    images: Icon[];
+    topTracks: TopTrack[];
+}
+interface TopTrack {
+    id: string;
+    name: string;
+    popularity: number;
+    album: string;
+}
+interface Comparison {
+    genreOverlap: any[];
+    relatedArtistOverlap: any[];
+    followerRatios: FollowerRatio[];
+}
+interface FollowerRatio {
+    id: string;
+    name: string;
+    ratio: number;
+}
+interface GetArtistOverviewBatchData {
+    results: GetArtistOverviewBatchDataResult[];
+}
+interface GetArtistOverviewBatchDataResult {
+    id: string;
+    overview: Overview;
+    error: null;
+}
+interface Overview {
+    data: OverviewData;
+}
+interface OverviewData {
+    artist: DataArtist;
+}
+interface DataArtist {
+    id: string;
+    uri: string;
+    following: boolean;
+    sharingInfo: AlbumSharingInfo;
+    profile: PurpleProfile;
+    visuals: PurpleVisuals;
+    discography: StickyDiscography;
+    stats: ArtistStats;
+    relatedContent: FluffyRelatedContent;
+    goods: ArtistGoods;
+}
+interface StickyDiscography {
+    latest: PurpleLatest;
+    popularReleases: CompilationsClass;
+    singles: CompilationsClass;
+    albums: CompilationsClass;
+    compilations: CompilationsClass;
+    topTracks: PurpleTopTracks;
+}
+interface CompilationsClass {
+    totalCount: number;
+    items: CompilationsItem[];
+}
+interface CompilationsItem {
+    releases: TentacledReleases;
+}
+interface TentacledReleases {
+    items: LatestElement[];
+}
+interface LatestElement {
+    id: string;
+    uri: string;
+    name: string;
+    type: LatestType;
+    copyright: LatestCopyright;
+    date: TentacledDate;
+    coverArt: AvatarImageElement;
+    tracks: AlbumsV2;
+    label: LabelEnum;
+    playability: LatestPlayability;
+    sharingInfo: AlbumSharingInfo;
+}
+interface LatestCopyright {
+    items: BiographyElement[];
+}
+interface TentacledDate {
+    year: number;
+    month: number;
+    day: number;
+    precision: Precision;
+}
+declare enum LabelEnum {
+    CashMoneyDrakeLP6 = "Cash Money/Drake LP6",
+    CashMoneyRecordsYoungMoneyEntUniversalRec = "Cash Money Records/Young Money Ent./Universal Rec.",
+    OVORepublic = "OVO/Republic",
+    OVORepublicRecords = "OVO / Republic Records",
+    OVOSound = "OVO Sound",
+    Ovo = "OVO",
+    TaylorSwift = "Taylor Swift",
+    The4BatzOVOSound = "4batz / OVO Sound",
+    UltraRecordsLLC = "Ultra Records, LLC",
+    WaltDisneyRecordsPixar = "Walt Disney Records / Pixar"
+}
+interface PurpleLatest {
+    id: string;
+    uri: string;
+    name: string;
+    type: LatestType;
+    copyright: LatestCopyright;
+    date: PurpleDate;
+    coverArt: AvatarImageElement;
+    tracks: AlbumsV2;
+    label: LabelEnum;
+    playability: LatestPlayability;
+}
+interface PurpleTopTracks {
+    items: FriskyItem[];
+}
+interface FriskyItem {
+    uid: string;
+    track: TentacledTrack;
+}
+interface TentacledTrack {
+    id: string;
+    uri: string;
+    name: string;
+    playcount: string;
+    discNumber: number;
+    duration: TrackDurationClass;
+    playability: LatestPlayability;
+    contentRating: ContentRating;
+    artists: ItemArtists;
+    album?: AlbumOfTrackClass;
+    albumOfTrack?: AlbumOfTrackClass;
+    associationsV3?: PurpleAssociationsV3;
+}
+interface AlbumOfTrackClass {
+    uri: string;
+    coverArt: BackgroundImageClass;
+}
+interface BackgroundImageClass {
+    sources: VideoThumbnail[];
+}
+interface VideoThumbnail {
+    url: null | string;
+}
+interface PurpleAssociationsV3 {
+    videoAssociations: AlbumsV2;
+}
+interface ArtistGoods {
+    events: Events;
+    merch: PurpleMerch;
+}
+interface Events {
+    userLocation: UserLocationClass;
+    concerts: EventsConcerts;
+}
+interface EventsConcerts {
+    totalCount: number;
+    items: any[];
+    pagingInfo: ConcertsPagingInfo;
+}
+interface ConcertsPagingInfo {
+    limit: number;
+}
+interface PurpleMerch {
+    items: MischievousItem[];
+}
+interface MischievousItem {
+    uri: string;
+    description: string;
+    imageUri: string;
+    name: string;
+    url: string;
+}
+interface PurpleProfile {
+    name: string;
+    verified: boolean;
+    pinnedItem: PurplePinnedItem;
+    biography: SignifierClass;
+    externalLinks: ExternalLinks;
+    playlists: ProfilePlaylists;
+}
+interface SignifierClass {
+    text: string;
+}
+interface ExternalLinks {
+    items: ExternalLinksItem[];
+}
+interface ExternalLinksItem {
+    name: string;
+    url: string;
+}
+interface PurplePinnedItem {
+    comment: string;
+    type: string;
+    item: ArtistElement;
+}
+interface ArtistElement {
+    uri: string;
+    name: string;
+    coverArt?: AvatarImageElement;
+    type?: PurpleType;
+    images?: ImagesClass;
+    artists?: ItemArtists;
+    id?: string;
+}
+interface ImagesClass {
+    items: AvatarImageElement[];
+}
+declare enum PurpleType {
+    Artist = "artist",
+    Single = "SINGLE"
+}
+interface ProfilePlaylists {
+    totalCount: number;
+    items: BraggadociousItem[];
+}
+interface BraggadociousItem {
+    uri: string;
+    name: string;
+    description: string;
+    owner: UserLocationClass;
+    images: ImagesClass;
+}
+interface FluffyRelatedContent {
+    appearsOn: FluffyAppearsOn;
+    featuring: DiscoveredOn;
+    discoveredOn: DiscoveredOn;
+    relatedArtists: RelatedArtists;
+}
+interface FluffyAppearsOn {
+    totalCount: number;
+    items: Item1[];
+}
+interface Item1 {
+    releases: StickyReleases;
+}
+interface StickyReleases {
+    totalCount: number;
+    items: TentacledItem[];
+}
+interface ArtistStats {
+    followers: number;
+    monthlyListeners: number;
+    worldRank: number;
+    topCities: TopCities;
+}
+interface TopCities {
+    items: TopCitiesItem[];
+}
+interface TopCitiesItem {
+    numberOfListeners: number;
+    city: string;
+    country: Market;
+    region: string;
+}
+interface PurpleVisuals {
+    gallery: ImagesClass;
+    avatarImage: HeaderImageClass;
+    headerImage: HeaderImageClass;
+}
+interface HeaderImageClass {
+    sources: Icon[];
+    extractedColors: HeaderImageExtractedColors;
+}
+interface HeaderImageExtractedColors {
+    colorRaw: Color;
+}
+interface GetArtistOverviewData {
+    artistUnion: GetArtistOverviewDataArtistUnion;
+}
+interface GetArtistOverviewDataArtistUnion {
+    __typename: ArtistUnionTypename;
+    id: string;
+    uri: string;
+    sharingInfo: AlbumSharingInfo;
+    profile: FluffyProfile;
+    visuals: PurpleVisuals;
+    discography: IndigoDiscography;
+    stats: ArtistStats;
+    relatedContent: ArtistUnionRelatedContent;
+    goods: PurpleGoods;
+}
+declare enum ArtistUnionTypename {
+    Album = "Album",
+    Artist = "Artist",
+    Playlist = "Playlist",
+    Track = "Track",
+    User = "User"
+}
+interface IndigoDiscography {
+    latest: LatestElement;
+    popularReleasesAlbums: PopularReleasesAlbums;
+    singles: CompilationsClass;
+    albums: CompilationsClass;
+    compilations: CompilationsClass;
+    topTracks: PurpleTopTracks;
+}
+interface PopularReleasesAlbums {
+    totalCount: number;
+    items: LatestElement[];
+}
+interface PurpleGoods {
+    events: Events;
+    merch: FluffyMerch;
+}
+interface FluffyMerch {
+    items: Item2[];
+}
+interface Item2 {
+    image: BackgroundImageClass;
+    name?: string;
+    description: string;
+    price: string;
+    uri: string;
+    url: string;
+    nameV2?: string;
+}
+interface FluffyProfile {
+    name: LabelEnum;
+    verified: boolean;
+    pinnedItem: FluffyPinnedItem;
+    biography: BiographyElement;
+    externalLinks: ExternalLinks;
+    playlistsV2: PlaylistsV2;
+}
+interface FluffyPinnedItem {
+    comment: string;
+    type: LatestType;
+    backgroundImage: BackgroundImageClass;
+    itemV2: SearchTests;
+    item: ArtistElement;
+}
+interface SearchTests {
+}
+interface PlaylistsV2 {
+    totalCount: number;
+    items: PlaylistsV2Item[];
+}
+interface PlaylistsV2Item {
+    data: PurpleData;
+}
+interface PurpleData {
+    __typename: ArtistUnionTypename;
+    uri: string;
+    name: string;
+    description: string;
+    ownerV2: PurpleOwnerV2;
+    images: ImagesClass;
+}
+interface PurpleOwnerV2 {
+    data: FluffyData;
+}
+interface FluffyData {
+    __typename: ArtistUnionTypename;
+    name: string;
+}
+interface ArtistUnionRelatedContent {
+    appearsOn: PurpleAppearsOn;
+    featuringV2: V2;
+    discoveredOnV2: V2;
+    relatedArtists: RelatedArtists;
+}
+interface V2 {
+    totalCount: number;
+    items: DiscoveredOnV2Item[];
+}
+interface DiscoveredOnV2Item {
+    data: TentacledData;
+}
+interface TentacledData {
+    __typename: PurpleTypename;
+    uri?: string;
+    id?: string;
+    ownerV2?: PurpleOwnerV2;
+    name?: string;
+    description?: string;
+    images?: ItemImages;
+}
+declare enum PurpleTypename {
+    GenericError = "GenericError",
+    Playlist = "Playlist"
+}
+interface GetArtistRelatedData {
+    artist: ItemClass;
+}
+interface GetArtistSinglesData {
+    artistUnion: GetArtistSinglesDataArtistUnion;
+}
+interface GetArtistSinglesDataArtistUnion {
+    __typename: ArtistUnionTypename;
+    discography: IndecentDiscography;
+}
+interface IndecentDiscography {
+    singles: Singles;
+}
+interface Singles {
+    items: AllItem[];
+    totalCount: number;
+}
+interface AllItem {
+    releases: IndigoReleases;
+}
+interface IndigoReleases {
+    items: Item3[];
+}
+interface Item3 {
+    coverArt: AvatarImageElement;
+    date: AlbumOfTrackDate;
+    id: string;
+    name: string;
+    playability: LatestPlayability;
+    sharingInfo: AlbumSharingInfo;
+    tracks: AlbumsV2;
+    type: LatestType;
+    uri: string;
+}
+interface AlbumOfTrackDate {
+    isoString: Date;
+    precision: Precision;
+    year: number;
+}
+interface GetTracksData {
+    tracks: TracksTrack[];
+}
+interface GetArtistsData {
+    artists: GetArtistsDataArtist[];
+}
+interface GetArtistsDataArtist {
+    external_urls: ExternalUrls;
+    followers: Followers;
+    genres: any[];
+    href: string;
+    id: string;
+    images: Icon[];
+    name: string;
+    popularity: number;
+    type: OwnerType;
+    uri: string;
+}
+interface Followers {
+    href: null | string;
+    total: number | null;
+}
+interface GetAudiobooksData {
+    audiobooks: null[];
+}
+interface GetBrowseCategoriesData {
+    categories: Categories;
+}
+interface Categories {
+    href: string;
+    items: GetBrowseCategoriesidData[];
+    limit: number;
+    next: string;
+    offset: number;
+    previous: null;
+    total: number;
+}
+interface GetBrowseCategoriesidData {
+    href: string;
+    id: string;
+    icons: Icon[];
+    name: string;
+}
+interface GetBrowseFeaturedPlaylistsData {
+    message: string;
+    playlists: GetBrowseFeaturedPlaylistsDataPlaylists;
+}
+interface GetBrowseFeaturedPlaylistsDataPlaylists {
+    href: string;
+    items: Item4[];
+    limit: number;
+    next: string;
+    offset: number;
+    previous: null;
+    total: number;
+}
+interface Item4 {
+    collaborative: boolean;
+    description: string;
+    external_urls: ExternalUrls;
+    href: string;
+    id: string;
+    images: Icon[];
+    name: string;
+    owner: Owner;
+    primary_color: PrimaryColor | null;
+    public: boolean;
+    snapshot_id: string;
+    tracks: Followers;
+    items: Followers;
+    type: GetPlaylistDataType;
+    uri: string;
+}
+declare enum PrimaryColor {
+    Eb1E32 = "#eb1e32",
+    Ffffff = "#ffffff",
+    PrimaryColorFFFFFF = "#FFFFFF",
+    The509Bf5 = "#509BF5"
+}
+declare enum GetPlaylistDataType {
+    Playlist = "playlist"
+}
+interface GetBrowseNewReleasesData {
+    albums: GetBrowseNewReleasesDataAlbums;
+}
+interface GetBrowseNewReleasesDataAlbums {
+    href: string;
+    items: ItemElement[];
+    limit: number;
+    next: string;
+    offset: number;
+    previous: null;
+    total: number;
+}
+interface GetCacheStatsData {
+    hits: number;
+    misses: number;
+    bypasses: number;
+    errors: number;
+    hitRate: string;
+}
+interface GetCookiesRedisData {
+    status: string;
+    instance: string;
+    timestamp: Date;
+    redis: Redis;
+    stats: GetCookiesRedisDataStats;
+    usage: GetCookiesRedisDataUsage;
+}
+interface Redis {
+    connected: boolean;
+    useRedis: boolean;
+}
+interface GetCookiesRedisDataStats {
+    totalCookies: number;
+    rotationIndex: number;
+    removedCookies: number;
+    validationAttempts: number;
+    successfulValidations: number;
+    failedValidations: number;
+    validationSuccessRate: string;
+}
+interface GetCookiesRedisDataUsage {
+    examples: PurpleExamples;
+    notes: string[];
+}
+interface PurpleExamples {
+    basic: string;
+    showCookies: string;
+    withMetadata: string;
+    limited: string;
+}
+interface GetCredentialsStatusData {
+    status: string;
+    instance: string;
+    timestamp: Date;
+    primary: Dev;
+    dev: Dev;
+    redisKeys: RedisKeys;
+    state: StateClass;
+    chartsOAuth: OAuth;
+    primaryOAuth: OAuth;
+    usage: GetCredentialsStatusDataUsage;
+}
+interface OAuth {
+    hasToken: boolean;
+    hasRefreshToken: boolean;
+    isExpired: boolean;
+    expiresIn: number;
+    scope: string;
+    storageType: string;
+    status?: Status;
+    rotation?: Rotation;
+}
+interface Rotation {
+    enabled: boolean;
+    totalFiles: number;
+    availableFiles: number;
+    permanentlyRevokedFiles: number;
+    assignedFile: string;
+    currentFile: string;
+    files: File[];
+}
+interface File {
+    name: string;
+    available: boolean;
+    failureCount: number;
+    assigned: boolean;
+    permanentlyRevoked: boolean;
+}
+declare enum Status {
+    Healthy = "healthy"
+}
+interface Dev {
+    hasCookie: boolean;
+    cookieLength: number;
+    cookiePreview: string;
+    cookieSource: string;
+    hasToken: boolean;
+    tokenLength: number;
+    tokenPreview: string;
+    tokenSource: string;
+    cookieValid: null;
+}
+interface RedisKeys {
+    cookies: string;
+    devCookies: string;
+    token: string;
+    devToken: string;
+}
+interface StateClass {
+    usingDevCredentials: boolean;
+    isRefreshingCredentials: boolean;
+}
+interface GetCredentialsStatusDataUsage {
+    examples: FluffyExamples;
+    notes: string[];
+}
+interface FluffyExamples {
+    basic: string;
+    showSecrets: string;
+    testCookies: string;
+    full: string;
+}
+interface GetEpisodesData {
+    episodes: null[];
+}
+interface GetHealthClusterData {
+    clusterStatus: Status;
+    totalInstances: number;
+    healthyInstances: number;
+    degradedInstances: number;
+    unhealthyInstances: number;
+    instances: GetHealthClusterDataInstance[];
+    aggregatedMetrics: Metrics;
+    timestamp: Date;
+    diagnosticInfo: null;
+}
+interface Metrics {
+    totalRequests: number;
+    successCount: number;
+    errorCount: number;
+    successRate: number;
+    averageResponseTime: number;
+}
+interface GetHealthClusterDataInstance {
+    instanceId: string;
+    instanceName: InstanceName;
+    pid: number;
+    uptime: number;
+    lastHeartbeat: Date;
+    metrics: Metrics;
+    lastRequests: LastRequest[];
+    status: Status;
+    isClusterMode: boolean;
+}
+declare enum InstanceName {
+    Trustpilot = "trustpilot",
+    Trustpilotiso = "trustpilot_iso"
+}
+interface LastRequest {
+    timestamp: Date;
+    statusCode: number;
+    endpoint: string;
+    responseTime: number;
+    success: boolean;
+}
+interface GetHealthClusterStrictData {
+    healthy: boolean;
+    status: Status;
+    clusterStatus: Status;
+    totalInstances: number;
+    healthyInstances: number;
+    degradedInstances: number;
+    unhealthyInstances: number;
+    instances: GetHealthClusterDataInstance[];
+    aggregatedMetrics: Metrics;
+    timestamp: Date;
+    oauthTokenStatus: OauthTokenStatus;
+    searchTests: SearchTests;
+    lastRequestsTracking: LastRequestsTracking;
+    note: string;
+}
+interface LastRequestsTracking {
+    allHealthy: boolean;
+    totalInstances: number;
+    healthyInstances: number;
+    unhealthyInstances: number;
+    instances: LastRequestsTrackingInstance[];
+    timestamp: number;
+}
+interface LastRequestsTrackingInstance {
+    instanceId: string;
+    healthy: boolean;
+    lastRequests: Request[];
+    failedRequests: Request[];
+    lastUpdateTimestamp: number;
+}
+interface Request {
+    endpoint: string;
+    statusCode: number;
+    duration: number;
+    timestamp: number;
+    success: boolean;
+    queryParams?: QueryParams;
+}
+interface QueryParams {
+    videoId: string;
+}
+interface OauthTokenStatus {
+    chartsOAuth: OAuth;
+    primaryOAuth: OAuth;
+}
+interface GetHealthInstanceData {
+    status: Status;
+    instance: string;
+    timestamp: Date;
+    windowSeconds: number;
+    totalRequests: number;
+    successCount: number;
+    errorCount: number;
+    successRate: number;
+    averageResponseTime: number;
+    statusCodeDistribution: StatusCodeDistribution;
+    endpoints: {
+        [key: string]: Endpoint;
+    };
+    lastRequests: LastRequest[];
+}
+interface Endpoint {
+    count: number;
+    successRate: number;
+}
+interface StatusCodeDistribution {
+    '200': number;
+}
+interface GetHealthProxiesData {
+    success: boolean;
+    stats: GetHealthProxiesDataStats;
+    instance: string;
+    timestamp: Date;
+}
+interface GetHealthProxiesDataStats {
+    totalCached: number;
+    healthyCached: number;
+    badProxies: number;
+    avgLatencyMs: number;
+}
+interface GetIsrcLookupData {
+    tracks: AlbumsClass;
+}
+interface GetMarketsData {
+    markets: Market[];
+}
+interface GetPartnerAlbumData {
+    albumUnion: AlbumUnion;
+}
+interface AlbumUnion {
+    __typename: ArtistUnionTypename;
+    copyright: AlbumCopyright;
+    courtesyLine: string;
+    date: ReleaseDateClass;
+    isPreRelease: boolean;
+    label: string;
+    name: string;
+    playability: LatestPlayability;
+    preReleaseEndDateTime: null;
+    sharingInfo: AlbumSharingInfo;
+    tracksV2: TracksV2;
+    type: LatestType;
+    uri: string;
+    visualIdentity: AlbumUnionVisualIdentity;
+    watchFeedEntrypoint: WatchFeedEntrypoint;
+    artists: ReleasesClass;
+    coverArt: CoverArt;
+    discs: Discs;
+    releases: ReleasesClass;
+    moreAlbumsByArtist: AlbumUnionMoreAlbumsByArtist;
+}
+interface AlbumUnionMoreAlbumsByArtist {
+    items: Item5[];
+}
+interface Item5 {
+    discography: HilariousDiscography;
+}
+interface HilariousDiscography {
+    popularReleasesAlbums: PurplePopularReleasesAlbums;
+}
+interface TracksV2 {
+    items: TracksV2Item[];
+    totalCount: number;
+}
+interface TracksV2Item {
+    track: StickyTrack;
+    uid: string;
+}
+interface StickyTrack {
+    artists: ItemArtists;
+    associationsV3: PurpleAssociationsV3;
+    contentRating: ContentRating;
+    discNumber: number;
+    duration: TrackDurationClass;
+    name: string;
+    playability: AlbumOfTrackPlayability;
+    playcount: string;
+    relinkingInformation: FluffyRelinkingInformation | null;
+    trackNumber: number;
+    uri: string;
+}
+interface FluffyRelinkingInformation {
+    linkedTrack: LinkedTrack;
+}
+interface LinkedTrack {
+    __typename: ArtistUnionTypename;
+    uri: string;
+}
+interface AlbumUnionVisualIdentity {
+    squareCoverImage: SquareCoverImageClass;
+}
+interface SquareCoverImageClass {
+    __typename: SquareCoverImageTypename;
+    extractedColorSet: ExtractedColorSet;
+}
+declare enum SquareCoverImageTypename {
+    VisualIdentityImage = "VisualIdentityImage"
+}
+interface ExtractedColorSet {
+    encoreBaseSetTextColor: EncoreBaseSetTextColor;
+    highContrast: Contrast;
+    higherContrast: Contrast;
+    minContrast: Contrast;
+}
+interface EncoreBaseSetTextColor {
+    alpha: number;
+    blue: number;
+    green: number;
+    red: number;
+}
+interface Contrast {
+    backgroundBase: EncoreBaseSetTextColor;
+    backgroundTintedBase: EncoreBaseSetTextColor;
+    textBase: EncoreBaseSetTextColor;
+    textBrightAccent: EncoreBaseSetTextColor;
+    textSubdued: EncoreBaseSetTextColor;
+}
+interface WatchFeedEntrypoint {
+    entrypointUri: string;
+    thumbnailImage: ThumbnailImage;
+    video: Video | null;
+}
+interface ThumbnailImage {
+    data: StickyData;
+}
+interface StickyData {
+    __typename: FluffyTypename;
+    imageId: string;
+    imageIdType: string;
+    sources: Source[];
+}
+declare enum FluffyTypename {
+    ImageV2 = "ImageV2"
+}
+interface Source {
+    imageFormat?: string;
+    maxHeight: number;
+    maxWidth: number;
+    url: string;
+}
+interface Video {
+    endTime: number;
+    fileId: string;
+    startTime: number;
+    videoType: string;
+}
+interface GetPartnerArtistConcertsData {
+    artistUnion: GetPartnerArtistConcertsDataArtistUnion;
+    nearby: Nearby;
+    concerts: GetPartnerArtistConcertsDataConcerts;
+}
+interface GetPartnerArtistConcertsDataArtistUnion {
+    headerImage: ThumbnailImageClass;
+    profile: UserLocationClass;
+    uri: string;
+    visuals: FluffyVisuals;
+}
+interface ThumbnailImageClass {
+    data: BackgroundImageClass;
+}
+interface FluffyVisuals {
+    avatarImage: AvatarImage;
+}
+interface AvatarImage {
+    extractedColors: FluffyExtractedColors;
+}
+interface FluffyExtractedColors {
+    colorDark: Color;
+}
+interface GetPartnerArtistConcertsDataConcerts {
+    concerts: ImagesClass;
+}
+interface Nearby {
+    concerts: ImagesClass;
+    locationName: string;
+}
+interface GetPartnerArtistDiscographyData {
+    artistUnion: GetPartnerArtistDiscographyDataArtistUnion;
+}
+interface GetPartnerArtistDiscographyDataArtistUnion {
+    __typename: ArtistUnionTypename;
+    discography: AmbitiousDiscography;
+}
+interface AmbitiousDiscography {
+    all: Singles;
+}
+interface GetPartnerArtistOverviewData {
+    artistUnion: GetPartnerArtistOverviewDataArtistUnion;
+}
+interface GetPartnerArtistOverviewDataArtistUnion {
+    __typename: ArtistUnionTypename;
+    discography: IndigoDiscography;
+    goods: FluffyGoods;
+    headerImage: HeaderImage;
+    id: string;
+    onPlatformReputationTrait: OnPlatformReputationTrait;
+    preRelease: null;
+    profile: TentacledProfile;
+    relatedContent: ArtistUnionRelatedContent;
+    relatedMusicVideos: RelatedMusicVideosClass;
+    sharingInfo: AlbumSharingInfo;
+    stats: ArtistStats;
+    unmappedMusicVideosV2: RelatedMusicVideosClass;
+    uri: string;
+    visualIdentity: ArtistUnionVisualIdentity;
+    visuals: TentacledVisuals;
+    watchFeedEntrypoint: WatchFeedEntrypoint;
+}
+interface FluffyGoods {
+    concerts: ReleasesClass;
+    merch: FluffyMerch;
+}
+interface HeaderImage {
+    data: ImageData;
+}
+interface ImageData {
+    __typename: FluffyTypename;
+    sources: Source[];
+}
+interface OnPlatformReputationTrait {
+    verification: Verification;
+}
+interface Verification {
+    isRegistered: boolean;
+    isVerified: boolean;
+}
+interface TentacledProfile {
+    biography: BiographyElement;
+    externalLinks: ExternalLinks;
+    name: LabelEnum;
+    pinnedItem: TentacledPinnedItem;
+    playlistsV2: PlaylistsV2;
+}
+interface TentacledPinnedItem {
+    backgroundImageV2: null;
+    comment: string;
+    itemV2: PinnedItemItemV2;
+    subtitle: string;
+    thumbnailImage: ThumbnailImageClass;
+    title: string;
+    type: LatestType;
+    uri: string;
+}
+interface PinnedItemItemV2 {
+    __typename: ItemV2Typename;
+    data: IndigoData;
+}
+declare enum ItemV2Typename {
+    AlbumResponseWrapper = "AlbumResponseWrapper",
+    ArtistResponseWrapper = "ArtistResponseWrapper",
+    PlaylistResponseWrapper = "PlaylistResponseWrapper",
+    SearchAutoCompleteEntity = "SearchAutoCompleteEntity",
+    TrackResponseWrapper = "TrackResponseWrapper",
+    UserResponseWrapper = "UserResponseWrapper"
+}
+interface IndigoData {
+    __typename: ArtistUnionTypename;
+    coverArt: AvatarImageElement;
+    name: string;
+    preReleaseEndDateTime: null;
+    type: LatestType;
+    uri: string;
+}
+interface RelatedMusicVideosClass {
+    __typename?: string;
+    items: RelatedMusicVideosItem[];
+    pagingInfo?: AlbumsPagingInfo;
+    totalCount: number;
+}
+interface RelatedMusicVideosItem {
+    __typename: ItemV2Typename;
+    data: IndecentData;
+}
+interface IndecentData {
+    __typename: null;
+    artists: ItemArtists;
+    coverArt: CoverArtElement;
+    date: PurpleDate;
+    name: string;
+    playability: LatestPlayability;
+    type: LatestType;
+    uri: string;
+    visualIdentity: AlbumUnionVisualIdentity;
+}
+interface CoverArtElement {
+    extractedColors: ImageExtractedColors;
+    sources: Icon[];
+}
+interface ImageExtractedColors {
+    colorDark: ColorDark;
+}
+interface ColorDark {
+    hex: string;
+    isFallback: boolean;
+}
+interface AlbumsPagingInfo {
+    nextOffset: null;
+}
+interface ArtistUnionVisualIdentity {
+    wideFullBleedImage: SquareCoverImageClass;
+}
+interface TentacledVisuals {
+    avatarImage: HeaderImageClass;
+    gallery: ImagesClass;
+}
+interface GetPartnerConcertData {
+    concert: Concert;
+}
+interface Concert {
+    __typename: string;
+    message: string;
+}
+interface GetPartnerConcertLocationsData {
+    concertLocations: ConcertLocations;
+}
+interface ConcertLocations {
+    items: ConcertLocationsItem[];
+}
+interface ConcertLocationsItem {
+    country: Market;
+    fullName: string;
+    geoHash: string;
+    geonameId: string;
+    name: string;
+}
+interface GetPartnerPlaylistData {
+    playlistV2: PlaylistV2;
+}
+interface PlaylistV2 {
+    __typename: ArtistUnionTypename;
+    content: Content;
+    attributes: Attribute[];
+    basePermission: string;
+    currentUserCapabilities: CurrentUserCapabilities;
+    description: string;
+    followers: number;
+    following: boolean;
+    format: Format;
+    images: ImagesClass;
+    members: Members;
+    name: string;
+    ownerV2: OwnerV2;
+    revisionId: string;
+    sharingInfo: AlbumSharingInfo;
+    uri: string;
+    visualIdentity: AlbumUnionVisualIdentity;
+    watchFeedEntrypoint: WatchFeedEntrypoint;
+}
+interface Attribute {
+    key: string;
+    value: string;
+}
+interface Content {
+    __typename: string;
+    items: ContentItem[];
+    pagingInfo: ContentPagingInfo;
+    totalCount: number;
+}
+interface ContentItem {
+    addedAt: AddedAt;
+    addedBy: null;
+    attributes: Attribute[];
+    itemV2: ItemItemV2;
+    uid: string;
+}
+interface AddedAt {
+    isoString: Date;
+}
+interface ItemItemV2 {
+    __typename: ItemV2Typename;
+    data: HilariousData;
+}
+interface HilariousData {
+    __typename: ArtistUnionTypename;
+    albumOfTrack: ArtistElement;
+    artists: ItemArtists;
+    associationsV3: TrackUnionAssociationsV3;
+    contentRating: ContentRating;
+    discNumber: number;
+    trackDuration: TrackDurationClass;
+    mediaType: MediaType;
+    name: string;
+    playability: LatestPlayability;
+    playcount: string;
+    trackNumber: number;
+    uri: string;
+}
+interface TrackUnionAssociationsV3 {
+    audioAssociations: AudioAssociations;
+    videoAssociations: AlbumsV2;
+}
+interface AudioAssociations {
+    __typename: AudioAssociationsTypename;
+    items: any[];
+}
+declare enum AudioAssociationsTypename {
+    TrackAudioAssociationPage = "TrackAudioAssociationPage"
+}
+declare enum MediaType {
+    Audio = "AUDIO",
+    Video = "VIDEO"
+}
+interface ContentPagingInfo {
+    limit: number;
+    offset: number;
+}
+interface CurrentUserCapabilities {
+    canAdministratePermissions: boolean;
+    canCancelMembership: boolean;
+    canEditItems: boolean;
+    canView: boolean;
+}
+declare enum Format {
+    ArtistMixReader = "artist-mix-reader",
+    Editorial = "editorial",
+    Empty = "",
+    FormatShowsShuffle = "format-shows-shuffle",
+    InspiredbyMix = "inspiredby-mix"
+}
+interface Members {
+    items: MembersItem[];
+    totalCount: number;
+}
+interface MembersItem {
+    isOwner: boolean;
+    permissionLevel: string;
+    user: OwnerV2;
+}
+interface OwnerV2 {
+    data: UserData;
+}
+interface UserData {
+    __typename: ArtistUnionTypename;
+    avatar: AvatarImageElement | null;
+    name: string;
+    uri: string;
+    username: string;
+}
+interface GetPartnerSearchConcertArtistsData {
+    artist: GetPartnerSearchConcertArtistsDataArtist;
+    concerts: GetPartnerArtistConcertsData;
+    detailsEnriched: null;
+    error: null;
+}
+interface GetPartnerSearchConcertArtistsDataArtist {
+    id: string;
+    uri: string;
+    name: string;
+    imageUrl: string;
+    followers: null;
+    genres: null;
+}
+interface GetPartnerTrackCountData {
+    result: string;
+    message: string;
+    spotify_track_id: string;
+    isrc: string;
+    streams: number;
+}
+interface GetPartnerTrackData {
+    trackUnion: TrackUnion;
+}
+interface TrackUnion {
+    __typename: ArtistUnionTypename;
+    associationsV3: TrackUnionAssociationsV3;
+    contentRating: ContentRating;
+    duration: TrackDurationClass;
+    id: string;
+    mediaType: MediaType;
+    name: string;
+    playability: LatestPlayability;
+    playcount: string;
+    sharingInfo: AlbumSharingInfo;
+    trackNumber: number;
+    uri: string;
+    visualIdentity: AlbumUnionVisualIdentity;
+    albumOfTrack: TrackUnionAlbumOfTrack;
+    firstArtist: FirstArtist;
+    otherArtists: ImagesClass;
+}
+interface TrackUnionAlbumOfTrack {
+    copyright: AlbumCopyright;
+    courtesyLine: string;
+    id: string;
+    date: AlbumOfTrackDate;
+    name: string;
+    playability: AlbumOfTrackPlayability;
+    sharingInfo: AlbumSharingInfo;
+    tracks: AlbumOfTrackTracks;
+    type: LatestType;
+    uri: string;
+    coverArt: HeaderImageClass;
+}
+interface AlbumOfTrackTracks {
+    items: Item6[];
+    totalCount: number;
+}
+interface Item6 {
+    track: IndigoTrack;
+}
+interface IndigoTrack {
+    trackNumber: number;
+    uri: string;
+}
+interface FirstArtist {
+    items: FirstArtistItem[];
+    totalCount: number;
+}
+interface FirstArtistItem {
+    discography: CunningDiscography;
+    id: string;
+    profile: UserLocationClass;
+    relatedContent: ItemRelatedContent;
+    uri: string;
+    visuals: ItemVisuals;
+}
+interface CunningDiscography {
+    albums: FluffyAlbums;
+    popularReleasesAlbums: FluffyPopularReleasesAlbums;
+    singles: FluffyAlbums;
+    topTracks: FluffyTopTracks;
+}
+interface FluffyAlbums {
+    items: Item7[];
+    totalCount: number;
+}
+interface Item7 {
+    releases: FluffyPopularReleasesAlbums;
+}
+interface FluffyPopularReleasesAlbums {
+    items: Item8[];
+}
+interface Item8 {
+    date: AlbumOfTrackDate;
+    name: string;
+    playability: AlbumOfTrackPlayability;
+    sharingInfo: AlbumSharingInfo;
+    tracks: AlbumOfTrackTracks;
+    type: LatestType;
+    uri: string;
+    coverArt: HeaderImageClass;
+}
+interface FluffyTopTracks {
+    items: Item9[];
+}
+interface Item9 {
+    track: IndecentTrack;
+}
+interface IndecentTrack {
+    albumOfTrack: TrackAlbumOfTrack;
+    artists: ItemArtists;
+    associationsV3: TrackUnionAssociationsV3;
+    contentRating: ContentRating;
+    duration: TrackDurationClass;
+    id: string;
+    name: string;
+    playability: AlbumOfTrackPlayability;
+    playcount: string;
+    previews: Previews;
+    uri: string;
+}
+interface TrackAlbumOfTrack {
+    name: string;
+    uri: string;
+    coverArt: HeaderImageClass;
+}
+interface Previews {
+    audioPreviews: AudioPreviews;
+}
+interface AudioPreviews {
+    items: VideoThumbnail[];
+}
+interface GetPingData {
+    request_id: string;
+    status: string;
+    message: string;
+    timestamp: Date;
+    instance: string;
+}
+interface GetPlaylistAnalysisData {
+    playlist: Playlist;
+    trackCount: number;
+    audioFeatures: AudioFeatures;
+    decadeDistribution: SearchTests;
+    explicitPercentage: number;
+    duration: GetPlaylistAnalysisDataDuration;
+}
+interface AudioFeatures {
+    analyzed: number;
+    aggregates: SearchTests;
+}
+interface GetPlaylistAnalysisDataDuration {
+    totalMs: number;
+    totalFormatted: string;
+    averageMs: number;
+    averageFormatted: string;
+}
+interface Playlist {
+    id: string;
+    name: string;
+    description: string;
+    owner: OwnerEnum;
+    followers: number;
+    totalTracks: number;
+    snapshotId: string;
+    images: Icon[];
+}
+interface GetPlaylistData {
+    collaborative: boolean;
+    description: string;
+    external_urls: ExternalUrls;
+    followers: Followers;
+    href: string;
+    id: string;
+    images: Icon[];
+    name: string;
+    owner: Owner;
+    primary_color: PrimaryColor;
+    public: boolean;
+    snapshot_id: string;
+    tracks: Items;
+    items: Items;
+    type: GetPlaylistDataType;
+    uri: string;
+}
+interface Items {
+    href: string;
+    items: ItemsItem[];
+    limit: number;
+    next: null;
+    offset: number;
+    previous: null;
+    total: number;
+}
+interface ItemsItem {
+    added_at: Date;
+    added_by: Owner;
+    is_local: boolean;
+    primary_color: null;
+    track: TrackClass;
+    item: TrackClass;
+    video_thumbnail: VideoThumbnail;
+}
+interface TrackClass {
+    preview_url: null | string;
+    available_markets: Market[];
+    explicit: boolean;
+    type: TrackType;
+    episode: boolean;
+    track: boolean;
+    album: ItemElement;
+    artists: Owner[];
+    disc_number: number;
+    track_number: number;
+    duration_ms: number;
+    external_ids: ItemExternalids;
+    external_urls: ExternalUrls;
+    href: string;
+    id: string;
+    name: string;
+    popularity: number;
+    uri: string;
+    is_local: boolean;
+}
+interface GetPlaylistSnapshotData {
+    playlistId: string;
+    total: number;
+    offset: number;
+    limit: number;
+    snapshots: Snapshot[];
+}
+interface Snapshot {
+    _id: Id;
+    playlistId: string;
+    snapshotId: string;
+    name: string;
+    description: string;
+    owner: OwnerEnum;
+    isPublic: boolean;
+    collaborative: boolean;
+    followerCount: number;
+    totalTracks: number;
+    tracks: SnapshotTrack[];
+    imageUrl: string;
+    capturedBy: string;
+    diff: Diff | null;
+    capturedAt: SearchTests;
+    __v: number;
+}
+interface Id {
+    buffer: {
+        [key: string]: number;
+    };
+}
+interface Diff {
+    added: any[];
+    removed: any[];
+    reordered: boolean;
+    metadataChanged: boolean;
+}
+interface SnapshotTrack {
+    trackId: string;
+    name: string;
+    artists: string[];
+    album: string;
+    duration_ms: number;
+    position: number;
+    addedAt: Date;
+    addedBy: null;
+}
+interface GetPlaylistTracksData {
+    href: string;
+    items: GetPlaylistTracksDataItem[];
+    limit: number;
+    offset: number;
+    total: number;
+    source: string;
+}
+interface GetPlaylistTracksDataItem {
+    added_at: Date;
+    added_by: null;
+    track: HilariousTrack;
+}
+interface HilariousTrack {
+    id: string;
+    uri: string;
+    type: TrackType;
+    name: string;
+    duration_ms: number;
+    explicit: boolean;
+    disc_number: number;
+    track_number: number;
+    playcount: string;
+    is_playable: boolean;
+    artists: ArtistElement[];
+    album: PurpleAlbum;
+}
+interface PurpleAlbum {
+    name: string;
+    uri: string;
+    id: string;
+    type: AlbumAlbumType;
+    images: Icon[];
+    artists: ArtistElement[];
+}
+interface GetRecommendationsData {
+    seeds: Seed[];
+    tracks: GetRecommendationsDataTrack[];
+}
+interface Seed {
+    afterFilteringSize: number;
+    afterRelinkingSize: number;
+    href: string;
+    id: string;
+    initialPoolSize: number;
+    type: string;
+}
+interface GetRecommendationsDataTrack {
+    album: ItemElement;
+    artists: Owner[];
+    available_markets: Market[];
+    disc_number: number;
+    duration_ms: number;
+    explicit: boolean;
+    external_ids: PurpleExternalids;
+    external_urls: ExternalUrls;
+    href: string;
+    id: string;
+    is_playable: boolean;
+    linked_from: SearchTests;
+    restrictions: PlayabilityClass;
+    name: string;
+    popularity: number;
+    preview_url: string;
+    track_number: number;
+    type: TrackType;
+    uri: string;
+    is_local: boolean;
+}
+interface PurpleExternalids {
+    isrc: string;
+    ean: string;
+    upc: string;
+}
+interface GetSearchData {
+    albums: RelatedMusicVideosClass;
+    artists: GetSearchDataArtists;
+    episodes: GetSearchDataEpisodes;
+    genres: Genres;
+    playlists: GetSearchDataPlaylists;
+    podcasts: Podcasts;
+    topResults: TopResults;
+    tracks: GetSearchDataTrack[];
+    users: Users;
+}
+interface GetSearchDataArtists {
+    items: Item10[];
+    totalCount: number;
+}
+interface Item10 {
+    __typename: ItemV2Typename;
+    data: AmbitiousData;
+}
+interface AmbitiousData {
+    __typename: null;
+    profile: UserLocationClass;
+    uri: string;
+    visualIdentity: AlbumUnionVisualIdentity | null;
+    visuals: DataVisuals;
+}
+interface DataVisuals {
+    avatarImage: CoverArtElement | null;
+}
+interface GetSearchDataEpisodes {
+    items: Item11[];
+    totalCount: number;
+}
+interface Item11 {
+    __typename: RelatedEntityTypename;
+    data: CunningData;
+}
+declare enum RelatedEntityTypename {
+    EpisodeResponseWrapper = "EpisodeResponseWrapper"
+}
+interface CunningData {
+    __typename: null;
+    contentRating: ContentRating;
+    coverArt: CoverArtElement;
+    description: string;
+    duration: TrackDurationClass;
+    gatedEntityRelations: GatedEntityRelation[];
+    mediaTypes: MediaType[];
+    name: string;
+    playability: PlayabilityClass;
+    playedState: PlayedState;
+    podcastV2: FluffyPodcastV2;
+    releaseDate: ReleaseDateClass;
+    restrictions: PurpleRestrictions;
+    uri: string;
+    videoPreviewThumbnail: VideoPreviewThumbnail | null;
+    visualIdentity: AlbumUnionVisualIdentity;
+}
+interface GatedEntityRelation {
+    badges: Badge[];
+    fallbackGatedEntity: null;
+    relatedEntity: RelatedEntity;
+    summary: Summary;
+}
+interface Badge {
+    displayText: string;
+}
+interface RelatedEntity {
+    __typename: RelatedEntityTypename;
+    _uri: string;
+    data: RelatedEntityData;
+}
+interface RelatedEntityData {
+    __typename: string;
+    podcastV2: PurplePodcastV2;
+}
+interface PurplePodcastV2 {
+    data: MagentaData;
+}
+interface MagentaData {
+    __typename: TentacledTypename;
+    accessInfo: AccessInfo;
+    coverArt: AvatarImageElement;
+}
+declare enum TentacledTypename {
+    Podcast = "Podcast"
+}
+interface AccessInfo {
+    accessExplanation: AccessExplanation;
+    isUserMemberOfAtLeastOneGroup: boolean;
+    signifier: SignifierClass;
+    unlockedBy: any[];
+}
+interface AccessExplanation {
+    __typename: string;
+    actionText: string;
+    body: string;
+    title: string;
+    url: string;
+}
+interface Summary {
+    forUserWithAccess: string;
+    forUserWithoutAccess: string;
+}
+interface PlayedState {
+    playPositionMilliseconds: number;
+    state: StateEnum;
+}
+declare enum StateEnum {
+    NotStarted = "NOT_STARTED"
+}
+interface FluffyPodcastV2 {
+    __typename: PodcastV2Typename;
+    data: FriskyData;
+}
+declare enum PodcastV2Typename {
+    PodcastResponseWrapper = "PodcastResponseWrapper"
+}
+interface FriskyData {
+    __typename: TentacledTypename;
+    coverArt: AvatarImageElement;
+    mediaType: PurpleMediaType;
+    name: string;
+    publisher: UserLocationClass;
+    uri: string;
+}
+declare enum PurpleMediaType {
+    Audio = "AUDIO",
+    Mixed = "MIXED"
+}
+interface PurpleRestrictions {
+    paywallContent: boolean;
+}
+interface VideoPreviewThumbnail {
+    __typename: string;
+    imagePreview: HeaderImage;
+}
+interface Genres {
+    items: GenresItem[];
+    totalCount: number;
+}
+interface GenresItem {
+    __typename: StickyTypename;
+    data: MischievousData;
+}
+declare enum StickyTypename {
+    GenreResponseWrapper = "GenreResponseWrapper"
+}
+interface MischievousData {
+    __typename: null;
+    image: CoverArtElement;
+    name: string;
+    uri: string;
+}
+interface GetSearchDataPlaylists {
+    items: Item12[];
+    totalCount: number;
+}
+interface Item12 {
+    __typename: ItemV2Typename;
+    data: FeaturedData;
+}
+interface FeaturedData {
+    __typename: null;
+    attributes: Attribute[];
+    description: string;
+    format: Format;
+    images: PurpleImages;
+    name: string;
+    ownerV2: FluffyOwnerV2;
+    uri: string;
+    visualIdentity: AlbumUnionVisualIdentity;
+}
+interface PurpleImages {
+    items: CoverArtElement[];
+}
+interface FluffyOwnerV2 {
+    __typename: ItemV2Typename;
+    data: UserData;
+}
+interface Podcasts {
+    items: PodcastsItem[];
+    totalCount: number;
+}
+interface PodcastsItem {
+    __typename: PodcastV2Typename;
+    data: BraggadociousData;
+}
+interface BraggadociousData {
+    __typename: null;
+    coverArt: CoverArtElement;
+    mediaType: PurpleMediaType;
+    name: string;
+    publisher: UserLocationClass;
+    topics: Topics;
+    uri: string;
+    visualIdentity: AlbumUnionVisualIdentity;
+}
+interface Topics {
+    items: TopicsItem[];
+}
+interface TopicsItem {
+    __typename: string;
+    title: string;
+    uri: string;
+}
+interface TopResults {
+    items: TopResultsItem[];
+    featured: Featured[];
+}
+interface Featured {
+    data: FeaturedData;
+}
+interface TopResultsItem {
+    __typename: ItemV2Typename;
+    data: Data1;
+}
+interface Data1 {
+    __typename: null;
+    attributes?: any[];
+    description?: string;
+    format?: string;
+    images?: PurpleImages;
+    name?: string;
+    ownerV2?: FluffyOwnerV2;
+    uri: string;
+    visualIdentity: PurpleVisualIdentity;
+    profile?: UserLocationClass;
+    visuals?: DataVisuals;
+    albumOfTrack?: DataAlbumOfTrack;
+    artists?: ItemArtists;
+    associationsV3?: FluffyAssociationsV3;
+    contentRating?: ContentRating;
+    duration?: TrackDurationClass;
+    id?: string;
+    trackMediaType?: MediaType;
+    playability?: LatestPlayability;
+}
+interface DataAlbumOfTrack {
+    coverArt: CoverArtElement;
+    id: string;
+    name: string;
+    uri: string;
+    visualIdentity: AlbumUnionVisualIdentity;
+}
+interface FluffyAssociationsV3 {
+    audioAssociations: AlbumsV2;
+    videoAssociations: AlbumsV2;
+}
+interface PurpleVisualIdentity {
+    squareCoverImage?: SquareCoverImageClass;
+    sixteenByNineCoverImage?: SixteenByNineCoverImage | null;
+}
+interface SixteenByNineCoverImage {
+    image: HeaderImage;
+}
+interface GetSearchDataTrack {
+    __typename: ItemV2Typename;
+    data: TrackData;
+}
+interface TrackData {
+    __typename: null;
+    albumOfTrack: DataAlbumOfTrack;
+    artists: ItemArtists;
+    associationsV3: FluffyAssociationsV3;
+    contentRating: ContentRating;
+    duration: TrackDurationClass;
+    id: string;
+    trackMediaType: MediaType;
+    name: string;
+    playability: LatestPlayability;
+    uri: string;
+    visualIdentity: FluffyVisualIdentity;
+}
+interface FluffyVisualIdentity {
+    sixteenByNineCoverImage: SixteenByNineCoverImage;
+}
+interface Users {
+    items: UsersItem[];
+    totalCount: number;
+}
+interface UsersItem {
+    __typename: ItemV2Typename;
+    data: Data2;
+}
+interface Data2 {
+    __typename: null;
+    avatar: CoverArtElement;
+    id: string;
+    displayName: string;
+    uri: string;
+    username: string;
+}
+interface GetSearchLyricsData {
+    error: boolean;
+    track?: GetSearchLyricsDataTrack;
+    syncType: string;
+    lines: Line[];
+}
+interface Line {
+    startTimeMs: string;
+    words: string;
+    syllables: any[];
+    endTimeMs: string;
+}
+interface GetSearchLyricsDataTrack {
+    id: string;
+    name: string;
+    artists: TrackArtist[];
+    album: FluffyAlbum;
+    duration_ms: number;
+    uri: string;
+}
+interface FluffyAlbum {
+    id: string;
+    name: string;
+    images: Icon[];
+}
+interface TrackArtist {
+    id: string;
+    name: string;
+}
+interface GetSearchSuggestionsData {
+    searchV2: GetSearchSuggestionsDataSearchV2;
+}
+interface GetSearchSuggestionsDataSearchV2 {
+    __typename: string;
+    query: string;
+    topResultsV2: PurpleTopResultsV2;
+}
+interface PurpleTopResultsV2 {
+    itemsV2: PurpleItemsV2[];
+}
+interface PurpleItemsV2 {
+    __typename: ItemsV2Typename;
+    item: Item13;
+}
+declare enum ItemsV2Typename {
+    TopResultHit = "TopResultHit"
+}
+interface Item13 {
+    __typename: ItemV2Typename;
+    data: Data3;
+}
+interface Data3 {
+    text?: string;
+    uri: string;
+    __typename?: ArtistUnionTypename;
+    attributes?: any[];
+    description?: string;
+    format?: string;
+    images?: PurpleImages;
+    name?: string;
+    ownerV2?: FluffyOwnerV2;
+    visualIdentity?: PurpleVisualIdentity;
+    profile?: UserLocationClass;
+    visuals?: DataVisuals;
+    albumOfTrack?: DataAlbumOfTrack;
+    artists?: ItemArtists;
+    associationsV3?: FluffyAssociationsV3;
+    contentRating?: ContentRating;
+    duration?: TrackDurationClass;
+    id?: string;
+    trackMediaType?: MediaType;
+    playability?: LatestPlayability;
+    coverArt?: CoverArtElement;
+    date?: PurpleDate;
+    type?: LatestType;
+    avatar?: CoverArtElement;
+    displayName?: string;
+    username?: string;
+}
+interface GetSearchTopResultsData {
+    searchV2: GetSearchTopResultsDataSearchV2;
+}
+interface GetSearchTopResultsDataSearchV2 {
+    __typename: string;
+    albumsV2: AlbumsV2;
+    artists: AlbumsV2;
+    chipOrder: ChipOrder;
+    episodes: AlbumsV2;
+    genres: AlbumsV2;
+    playlists: AlbumsV2;
+    podcasts: AlbumsV2;
+    query: string;
+    topResultsV2: FluffyTopResultsV2;
+    tracksV2: AlbumsV2;
+    users: AlbumsV2;
+}
+interface ChipOrder {
+    items: ChipOrderItem[];
+}
+interface ChipOrderItem {
+    typeName: string;
+}
+interface FluffyTopResultsV2 {
+    itemsV2: FluffyItemsV2[];
+}
+interface FluffyItemsV2 {
+    __typename: ItemsV2Typename;
+    item: Item14;
+    matchedFields: any[];
+}
+interface Item14 {
+    __typename: ItemV2Typename;
+    data: Data4;
+}
+interface Data4 {
+    __typename: ArtistUnionTypename;
+    attributes?: Attribute[];
+    description?: string;
+    format?: Format;
+    images?: PurpleImages;
+    name?: string;
+    ownerV2?: FluffyOwnerV2;
+    uri: string;
+    visualIdentity?: AlbumUnionVisualIdentity;
+    profile?: UserLocationClass;
+    visuals?: DataVisuals;
+    albumOfTrack?: DataAlbumOfTrack;
+    artists?: ItemArtists;
+    associationsV3?: FluffyAssociationsV3;
+    contentRating?: ContentRating;
+    duration?: TrackDurationClass;
+    id?: string;
+    trackMediaType?: MediaType;
+    playability?: LatestPlayability;
+    coverArt?: CoverArtElement;
+    date?: PurpleDate;
+    type?: LatestType;
+    avatar?: CoverArtElement;
+    displayName?: string;
+    username?: string;
+}
+interface GetSeedToPlaylistData {
+    total: number;
+    mediaItems: MediaItem[];
+}
+interface MediaItem {
+    uri: string;
+}
+interface GetShowsData {
+    shows: GetShowsidData[];
+}
+interface GetShowsidData {
+    copyrights: any[];
+    description: string;
+    html_description: string;
+    explicit: boolean;
+    external_urls: ExternalUrls;
+    href: string;
+    id: string;
+    images: Icon[];
+    is_externally_hosted: boolean;
+    languages: Language[];
+    media_type: string;
+    name: string;
+    publisher: string;
+    type: string;
+    uri: string;
+    total_episodes: number;
+    episodes?: GetShowsIdDataEpisodes;
+}
+interface GetShowsIdDataEpisodes {
+    href: string;
+    limit: number;
+    next: string;
+    offset: number;
+    previous: null;
+    total: number;
+    items: Item15[];
+}
+interface Item15 {
+    audio_preview_url: string;
+    description: string;
+    html_description: string;
+    duration_ms: number;
+    explicit: boolean;
+    external_urls: ExternalUrls;
+    href: string;
+    id: string;
+    images: Icon[];
+    is_externally_hosted: boolean;
+    is_playable: boolean;
+    language: Language;
+    languages: Language[];
+    name: string;
+    release_date: Date;
+    release_date_precision: ReleaseDatePrecision;
+    type: FluffyType;
+    uri: string;
+}
+declare enum Language {
+    En = "en"
+}
+declare enum FluffyType {
+    Episode = "episode"
+}
+interface GetTop200TracksDatum {
+    chartEntryData: ChartEntryData;
+    missingRequiredFields: boolean;
+    trackMetadata: TrackMetadata;
+    chartDate?: string;
+    requestedDate?: string;
+    daysBack?: number;
+}
+interface ChartEntryData {
+    currentRank: number;
+    previousRank: number;
+    peakRank: number;
+    appearancesOnChart: number;
+    consecutiveAppearancesOnChart: number;
+    rankingMetric?: RankingMetric;
+    entryStatus: EntryStatus;
+    peakDate: Date;
+    entryRank: number;
+    entryDate: Date;
+}
+declare enum EntryStatus {
+    MovedDown = "MOVED_DOWN",
+    MovedUp = "MOVED_UP",
+    NewEntry = "NEW_ENTRY",
+    NoChange = "NO_CHANGE",
+    ReEntry = "RE_ENTRY"
+}
+interface RankingMetric {
+    value: string;
+    type: RankingMetricType;
+}
+declare enum RankingMetricType {
+    Streams = "STREAMS"
+}
+interface TrackMetadata {
+    trackName: string;
+    trackUri: string;
+    displayImageUri: string;
+    artists: LabelElement[];
+    producers: any[];
+    labels: LabelElement[];
+    songWriters: any[];
+    releaseDate: string;
+}
+interface LabelElement {
+    name: string;
+    spotifyUri: string;
+    externalUrl: string;
+}
+interface GetTop20ByFollowersDatum {
+    rank: number;
+    artist: string;
+    followers: number;
+    followersMillions: number;
+}
+interface GetTop20ByMonthlyListenersDatum {
+    rank: number;
+    artist: string;
+    monthlyListeners: number;
+}
+interface GetSDatum {
+    chartEntryData: ChartEntryData;
+    missingRequiredFields: boolean;
+    albumMetadata?: AlbumMetadata;
+    chartDate?: string;
+    requestedDate?: string;
+    daysBack?: number;
+    artistMetadata?: ArtistMetadata;
+    trackMetadata?: TrackMetadata;
+}
+interface AlbumMetadata {
+    albumName: string;
+    albumUri: string;
+    displayImageUri: string;
+    artists: LabelElement[];
+    labels: LabelElement[];
+    releaseDate: string;
+}
+interface ArtistMetadata {
+    artistName: string;
+    artistUri: string;
+    displayImageUri: string;
+    socialMedia: any[];
+}
+interface GetTrackCreditsBatchData {
+    results: GetTrackCreditsBatchDataResult[];
+}
+interface GetTrackCreditsBatchDataResult {
+    id: string;
+    credits: GetTrackCreditsData;
+    error: null;
+}
+interface GetTrackCreditsData {
+    trackUri: string;
+    trackTitle: string;
+    roleCredits: RoleCredit[];
+    extendedCredits: any[];
+    sourceNames: string[];
+}
+interface RoleCredit {
+    roleTitle: string;
+    artists: RoleCreditArtist[];
+}
+interface RoleCreditArtist {
+    uri?: string;
+    name: string;
+    imageUri?: string;
+    subroles: Subrole[];
+    weight: number;
+    externalUrl?: string;
+    creatorUri?: string;
+}
+declare enum Subrole {
+    MainArtist = "main artist",
+    Producer = "producer",
+    Writer = "writer"
+}
+interface GetTrackLyricsBatchData {
+    results: GetTrackLyricsBatchDataResult[];
+}
+interface GetTrackLyricsBatchDataResult {
+    id: string;
+    lyrics: GetSearchLyricsData;
+    error: null;
+}
+interface GetTrackPopularityBatchData {
+    results: GetTrackPopularityBatchDataResult[];
+}
+interface GetTrackPopularityBatchDataResult {
+    id: string;
+    name: string;
+    popularity: number;
+    album: string;
+    artists: string[];
+    explicit: boolean;
+    duration_ms: number;
+}
+interface GetTrackingHealthData {
+    success: boolean;
+    service: string;
+    status: string;
+    stats: GetTrackingHealthDataStats;
+}
+interface GetTrackingHealthDataStats {
+    totalTrackedItems: number;
+    activeTrackedItems: number;
+    totalSubscriptions: number;
+    recentChanges: number;
+}
+interface GetTrackingItemsData {
+    success: boolean;
+    count: number;
+    limit: number;
+    authSource: string;
+    subscriptionTier: null;
+    items: any[];
+}
+interface GetTrackingLogsData {
+    success: boolean;
+    total: number;
+    returned: number;
+    logs: any[];
+}
+interface GetTrackingStatsData {
+    success: boolean;
+    authSource: string;
+    subscriptionTier: null;
+    totalTrackedItems: number;
+    activeTrackedItems: number;
+    totalSubscriptions: number;
+    userSubscriptions: number;
+    userItemLimit: number;
+    recentChanges: number;
+    workerStatus: string;
+}
+interface GetUpcLookupData {
+    albums: AlbumsClass;
+}
+interface GetUserFollowersData {
+    profiles: ProfileElement[];
+}
+interface ProfileElement {
+    uri: string;
+    name: string;
+    followers_count: number;
+    color: number;
+    account_id: string;
+    image_url?: string;
+}
+interface GetUserProfileData {
+    uri: Uri;
+    name: OwnerEnum;
+    image_url: string;
+    followers_count: number;
+    following_count: number;
+    public_playlists: PublicPlaylist[];
+    total_public_playlists_count: number;
+    is_verified: boolean;
+    report_abuse_disabled: boolean;
+    has_spotify_name: boolean;
+    has_spotify_image: boolean;
+    color: number;
+    allow_follows: boolean;
+    show_follows: boolean;
+    account_id: string;
+}
+interface PublicPlaylist {
+    uri: string;
+    name: string;
+    image_url: string;
+    followers_count: number;
+    owner_name: OwnerEnum;
+    owner_uri: Uri;
+}
+declare enum Uri {
+    SpotifyUserSpotify = "spotify:user:spotify"
+}
+
+/** Parameters for {@link AlbumsResource.get}. */
+interface AlbumsGetParams {
+    /** Comma-separated Spotify album IDs. */
+    ids: string | readonly string[];
+    /** Comma-separated providers to contrast against, e.g. `ytmusic,applemusic`. */
+    contrast?: string;
+}
+/** Parameters for {@link AlbumsResource.tracks}. */
+interface AlbumTracksParams {
+    /** Spotify album ID. */
+    id: string;
+    offset?: number;
+    limit?: number;
+}
+/** Parameters for {@link AlbumsResource.metadata}. */
+interface AlbumMetadataParams {
+    /** Spotify album ID. */
+    id: string;
+    contrast?: string;
+}
+/** Album endpoints. */
+declare class AlbumsResource extends Resource {
+    /** Get one or more albums by ID. */
+    get(params: AlbumsGetParams, options?: RequestOverrides): Promise<GetAlbumsData>;
+    /** Get an album's tracks (paginated). */
+    tracks(params: AlbumTracksParams, options?: RequestOverrides): Promise<GetAlbumTracksData>;
+    /** Get extended album metadata. */
+    metadata(params: AlbumMetadataParams, options?: RequestOverrides): Promise<GetAlbumMetadataData>;
+}
+
+/** Parameters for {@link AnalysisResource.artistCompare}. */
+interface AnalysisArtistCompareParams {
+    /** Comma-separated artist IDs (2–10). */
+    ids: string | readonly string[];
+}
+/** Parameters for {@link AnalysisResource.audioFeatures}. */
+interface AnalysisAudioFeaturesParams {
+    /** Spotify track ID. */
+    id: string;
+}
+/** Parameters for {@link AnalysisResource.playlistAnalysis}. */
+interface AnalysisPlaylistAnalysisParams {
+    /** Spotify playlist ID. */
+    id: string;
+}
+/** Analysis endpoints. */
+declare class AnalysisResource extends Resource {
+    /** Compare artists side by side. */
+    artistCompare(params: AnalysisArtistCompareParams, options?: RequestOverrides): Promise<GetArtistCompareData>;
+    /** Get audio features for a track. */
+    audioFeatures(params: AnalysisAudioFeaturesParams, options?: RequestOverrides): Promise<unknown>;
+    /** Get analysis for a playlist. */
+    playlistAnalysis(params: AnalysisPlaylistAnalysisParams, options?: RequestOverrides): Promise<GetPlaylistAnalysisData>;
+}
+
+/** Parameters for {@link ArtistsResource.get}. */
+interface ArtistsGetParams {
+    /** Comma-separated artist IDs. */
+    ids: string | readonly string[];
+    /** Comma-separated providers to contrast against, e.g. `ytmusic,applemusic`. */
+    contrast?: string;
+}
+/** Parameters for {@link ArtistsResource.overview}. */
+interface ArtistsOverviewParams {
+    /** Spotify artist ID. */
+    id: string;
+    /** Comma-separated providers to contrast against, e.g. `ytmusic,applemusic`. */
+    contrast?: string;
+}
+/** Parameters for {@link ArtistsResource.discographyOverview}. */
+interface ArtistsDiscographyOverviewParams {
+    /** Spotify artist ID. */
+    id: string;
+}
+/** Parameters for {@link ArtistsResource.albums}. */
+interface ArtistsAlbumsParams {
+    /** Spotify artist ID. */
+    id: string;
+    offset?: number;
+    limit?: number;
+}
+/** Parameters for {@link ArtistsResource.singles}. */
+interface ArtistsSinglesParams {
+    /** Spotify artist ID. */
+    id: string;
+    offset?: number;
+    limit?: number;
+}
+/** Parameters for {@link ArtistsResource.appearsOn}. */
+interface ArtistsAppearsOnParams {
+    /** Spotify artist ID. */
+    id: string;
+}
+/** Parameters for {@link ArtistsResource.discoveredOn}. */
+interface ArtistsDiscoveredOnParams {
+    /** Spotify artist ID. */
+    id: string;
+}
+/** Parameters for {@link ArtistsResource.featuring}. */
+interface ArtistsFeaturingParams {
+    /** Spotify artist ID. */
+    id: string;
+}
+/** Parameters for {@link ArtistsResource.related}. */
+interface ArtistsRelatedParams {
+    /** Spotify artist ID. */
+    id: string;
+}
+/** Parameters for {@link ArtistsResource.topTracks}. */
+interface ArtistsTopTracksParams {
+    /** Spotify artist ID. */
+    id: string;
+    /** Market (country) code to localize results, e.g. `US`. */
+    market?: string;
+}
+/** Artist endpoints. */
+declare class ArtistsResource extends Resource {
+    /** Get one or more artists by ID. */
+    get(params: ArtistsGetParams, options?: RequestOverrides): Promise<GetArtistsData>;
+    /** Get an artist overview. */
+    overview(params: ArtistsOverviewParams, options?: RequestOverrides): Promise<GetArtistOverviewData>;
+    /** Get an artist's discography overview. */
+    discographyOverview(params: ArtistsDiscographyOverviewParams, options?: RequestOverrides): Promise<GetArtistDiscographyOverviewData>;
+    /** Get an artist's albums (paginated). */
+    albums(params: ArtistsAlbumsParams, options?: RequestOverrides): Promise<GetArtistAlbumsData>;
+    /** Get an artist's singles (paginated). */
+    singles(params: ArtistsSinglesParams, options?: RequestOverrides): Promise<GetArtistSinglesData>;
+    /** Get releases an artist appears on. */
+    appearsOn(params: ArtistsAppearsOnParams, options?: RequestOverrides): Promise<GetArtistAppearsOnData>;
+    /** Get playlists an artist was discovered on. */
+    discoveredOn(params: ArtistsDiscoveredOnParams, options?: RequestOverrides): Promise<GetArtistDiscoveredOnData>;
+    /** Get tracks featuring an artist. */
+    featuring(params: ArtistsFeaturingParams, options?: RequestOverrides): Promise<GetArtistFeaturingData>;
+    /** Get artists related to an artist. */
+    related(params: ArtistsRelatedParams, options?: RequestOverrides): Promise<GetArtistRelatedData>;
+    /** Get an artist's top tracks. */
+    topTracks(params: ArtistsTopTracksParams, options?: RequestOverrides): Promise<GetArtistTopTracksData>;
+}
+
+/** Parameters for {@link AudiobooksResource.get}. */
+interface AudiobooksGetParams {
+    /** Comma-separated Spotify audiobook IDs. */
+    ids: string | readonly string[];
+    /** An ISO 3166-1 alpha-2 country code to filter availability. */
+    market?: string;
+}
+/** Parameters for {@link AudiobooksResource.getById}. */
+interface AudiobooksGetByIdParams {
+    /** Spotify audiobook ID. */
+    id: string;
+    /** An ISO 3166-1 alpha-2 country code to filter availability. */
+    market?: string;
+}
+/** Parameters for {@link AudiobooksResource.chapters}. */
+interface AudiobooksChaptersParams {
+    /** Spotify audiobook ID. */
+    id: string;
+    /** The index of the first chapter to return. */
+    offset?: number;
+    /** The maximum number of chapters to return. */
+    limit?: number;
+}
+/** Audiobook endpoints. */
+declare class AudiobooksResource extends Resource {
+    /** Get one or more audiobooks by ID. */
+    get(params: AudiobooksGetParams, options?: RequestOverrides): Promise<GetAudiobooksData>;
+    /** Get a single audiobook by ID. */
+    getById(params: AudiobooksGetByIdParams, options?: RequestOverrides): Promise<unknown>;
+    /** Get an audiobook's chapters (paginated). */
+    chapters(params: AudiobooksChaptersParams, options?: RequestOverrides): Promise<unknown>;
+}
+
+/** Parameters for {@link BatchResource.albumMetadata}. */
+interface BatchAlbumMetadataParams {
+    /** Comma-separated album IDs (max 25). */
+    ids: string | readonly string[];
+}
+/** Parameters for {@link BatchResource.artistOverview}. */
+interface BatchArtistOverviewParams {
+    /** Comma-separated artist IDs (max 25). */
+    ids: string | readonly string[];
+}
+/** Parameters for {@link BatchResource.trackCredits}. */
+interface BatchTrackCreditsParams {
+    /** Comma-separated track IDs (max 25). */
+    ids: string | readonly string[];
+}
+/** Parameters for {@link BatchResource.trackLyrics}. */
+interface BatchTrackLyricsParams {
+    /** Comma-separated track IDs. */
+    ids: string | readonly string[];
+    /** Lyrics output format. Default `json`. */
+    format?: 'json' | 'lrc' | 'srt' | 'raw';
+}
+/** Parameters for {@link BatchResource.trackPopularity}. */
+interface BatchTrackPopularityParams {
+    /** Comma-separated track IDs. */
+    ids: string | readonly string[];
+}
+/** Batch endpoints — fetch metadata for many IDs in one call. */
+declare class BatchResource extends Resource {
+    /** Get extended album metadata for many albums at once. */
+    albumMetadata(params: BatchAlbumMetadataParams, options?: RequestOverrides): Promise<GetAlbumMetadataBatchData>;
+    /** Get artist overviews for many artists at once. */
+    artistOverview(params: BatchArtistOverviewParams, options?: RequestOverrides): Promise<GetArtistOverviewBatchData>;
+    /** Get credits for many tracks at once. */
+    trackCredits(params: BatchTrackCreditsParams, options?: RequestOverrides): Promise<GetTrackCreditsBatchData>;
+    /** Get synced lyrics for many tracks at once. */
+    trackLyrics(params: BatchTrackLyricsParams, options?: RequestOverrides): Promise<GetTrackLyricsBatchData>;
+    /** Get popularity scores for many tracks at once. */
+    trackPopularity(params: BatchTrackPopularityParams, options?: RequestOverrides): Promise<GetTrackPopularityBatchData>;
+}
+
+/** Parameters for {@link BrowseResource.categories}. */
+interface BrowseCategoriesParams {
+    /** ISO country code (e.g. `US`). */
+    country?: string;
+    /** Locale (e.g. `en_US`). */
+    locale?: string;
+    limit?: number;
+    offset?: number;
+}
+/** Parameters for {@link BrowseResource.category}. */
+interface BrowseCategoryParams {
+    /** Spotify category ID. */
+    id: string;
+    /** ISO country code (e.g. `US`). */
+    country?: string;
+    /** Locale (e.g. `en_US`). */
+    locale?: string;
+}
+/** Parameters for {@link BrowseResource.featuredPlaylists}. */
+interface BrowseFeaturedPlaylistsParams {
+    /** ISO country code (e.g. `US`). */
+    country?: string;
+    /** Locale (e.g. `en_US`). */
+    locale?: string;
+    limit?: number;
+    offset?: number;
+}
+/** Parameters for {@link BrowseResource.newReleases}. */
+interface BrowseNewReleasesParams {
+    /** ISO country code (e.g. `US`). */
+    country?: string;
+    limit?: number;
+    offset?: number;
+}
+/** Parameters for {@link BrowseResource.recommendations}. */
+interface BrowseRecommendationsParams {
+    /** Comma-separated seed track IDs. */
+    seed_tracks?: string | readonly string[];
+    /** Comma-separated seed artist IDs. */
+    seed_artists?: string | readonly string[];
+    /** Comma-separated seed genres. */
+    seed_genres?: string;
+    limit?: number;
+}
+/** Browse endpoints. */
+declare class BrowseResource extends Resource {
+    /** List browse categories. */
+    categories(params?: BrowseCategoriesParams, options?: RequestOverrides): Promise<GetBrowseCategoriesData>;
+    /** Get a single browse category by ID. */
+    category(params: BrowseCategoryParams, options?: RequestOverrides): Promise<GetBrowseCategoriesIdData>;
+    /** Get featured playlists. */
+    featuredPlaylists(params?: BrowseFeaturedPlaylistsParams, options?: RequestOverrides): Promise<GetBrowseFeaturedPlaylistsData>;
+    /** Get new album releases. */
+    newReleases(params?: BrowseNewReleasesParams, options?: RequestOverrides): Promise<GetBrowseNewReleasesData>;
+    /** Get track recommendations from seed tracks, artists, and/or genres. */
+    recommendations(params?: BrowseRecommendationsParams, options?: RequestOverrides): Promise<GetBrowseRecommendationsData>;
+}
+
+/** Parameters for {@link CacheResource.invalidate}. */
+interface CacheInvalidateParams {
+    /** Exact cache key to invalidate. */
+    key?: string;
+    /** Glob/prefix pattern matching multiple cache keys to invalidate. */
+    pattern?: string;
+}
+/** Cache administration endpoints. */
+declare class CacheResource extends Resource {
+    /** Get cache statistics (hits, misses, size, etc.). */
+    stats(query?: QueryParams$1, options?: RequestOverrides): Promise<GetCacheStatsData>;
+    /** Invalidate cached entries by exact key or by matching pattern. */
+    invalidate(params: CacheInvalidateParams, options?: RequestOverrides): Promise<unknown>;
+}
+
+/** Parameters for {@link ChartsResource.top200Tracks}. */
+interface ChartsTop200TracksParams {
+    /** Chart period, e.g. `daily` or `weekly`. Default `daily`. */
+    period?: string;
+    /** Country code or `global`. Default `global`. */
+    country?: string;
+    /** Chart date (`YYYY-MM-DD`). Defaults to the latest available. */
+    date?: string;
+}
+/** Parameters for {@link ChartsResource.topArtists}. */
+interface ChartsTopArtistsParams {
+    /** Chart period, e.g. `daily` or `weekly`. Default `daily`. */
+    period?: string;
+    /** Country code or `global`. Default `global`. */
+    country?: string;
+}
+/** Parameters for {@link ChartsResource.topAlbums}. */
+interface ChartsTopAlbumsParams {
+    /** Chart period, e.g. `daily` or `weekly`. Default `daily`. */
+    period?: string;
+    /** Country code or `global`. Default `global`. */
+    country?: string;
+}
+/** Parameters for {@link ChartsResource.viralTracks}. */
+interface ChartsViralTracksParams {
+    /** Country code or `global`. Default `global`. */
+    country?: string;
+}
+/** Spotify Charts endpoints. */
+declare class ChartsResource extends Resource {
+    /** Top 20 artists by monthly listeners. */
+    topByMonthlyListeners(query?: QueryParams$1, options?: RequestOverrides): Promise<GetTop20ByMonthlyListenersData>;
+    /** Top 200 tracks chart. */
+    top200Tracks(params: ChartsTop200TracksParams, options?: RequestOverrides): Promise<GetTop200TracksData>;
+    /** Top artists chart. */
+    topArtists(params: ChartsTopArtistsParams, options?: RequestOverrides): Promise<GetTopArtistsData>;
+    /** Top albums chart. */
+    topAlbums(params: ChartsTopAlbumsParams, options?: RequestOverrides): Promise<GetTopAlbumsData>;
+    /** Viral tracks chart. */
+    viralTracks(params: ChartsViralTracksParams, options?: RequestOverrides): Promise<GetViralTracksData>;
+    /** Top 20 artists by followers. */
+    topByFollowers(query?: QueryParams$1, options?: RequestOverrides): Promise<GetTop20ByFollowersData>;
+}
+
+/** Parameters for {@link ConcertsResource.locations}. */
+interface ConcertsLocationsParams {
+    /** City, venue, or place name. */
+    query: string;
+}
+/** Parameters for {@link ConcertsResource.feed}. */
+interface ConcertsFeedParams {
+    /** Spotify geohash (from `/partner/concert-locations`). */
+    geoHash: string;
+    /** Geoname ID (from `/partner/concert-locations`). */
+    geonameId: string;
+    /** Start of date range (YYYY-MM-DD). */
+    from?: string;
+    /** End of date range (YYYY-MM-DD). */
+    to?: string;
+    radiusInKm?: number;
+    /** Comma-separated Spotify concept URIs (e.g. `spotify:concept:rock,spotify:concept:pop`). */
+    conceptUris?: string;
+    /** Pass back the `paginationKey` from a prior response. */
+    paginationKey?: string;
+    /** Enrich each concert with full concert details in parallel. */
+    details?: boolean;
+    /** Max concerts to enrich per request (max 50). */
+    detailsLimit?: number;
+    /** Return a flat, normalized concert shape instead of raw GraphQL. */
+    parsed?: boolean;
+}
+/** Parameters for {@link ConcertsResource.get}. */
+interface ConcertsGetParams {
+    /** Concert ID, `spotify:concert:URI`, or `open.spotify.com/concert/<id>` URL. */
+    id: string;
+    /** Return a flat, normalized concert shape instead of raw GraphQL. */
+    parsed?: boolean;
+    /** Set `false` to query as anonymous user (omits `me.profile` block). */
+    authenticated?: boolean;
+}
+/** Parameters for {@link ConcertsResource.byArtist}. */
+interface ConcertsByArtistParams {
+    /** Artist ID, URI, or open.spotify.com URL. */
+    id: string;
+    /** Geohash for nearby-concert prioritization. `0` = global. */
+    geoHash?: string;
+    includeNearby?: boolean;
+    /** Enrich each concert with full concert details in parallel. */
+    details?: boolean;
+    /** Max concerts to enrich per request (max 50). */
+    detailsLimit?: number;
+    /** Return a flat, normalized concert shape instead of raw GraphQL. */
+    parsed?: boolean;
+}
+/** Parameters for {@link ConcertsResource.searchArtists}. */
+interface ConcertsSearchArtistsParams {
+    /** Artist name to search. */
+    query: string;
+    geoHash?: string;
+    includeNearby?: boolean;
+    /** Number of artist matches to return concerts for. */
+    limit?: number;
+    /** Enrich each concert with full concert details in parallel. */
+    details?: boolean;
+    /** Max concerts to enrich per request (max 50). */
+    detailsLimit?: number;
+    /** Return a flat, normalized concert shape instead of raw GraphQL. */
+    parsed?: boolean;
+}
+/** Concert endpoints. */
+declare class ConcertsResource extends Resource {
+    /** Search concert locations by city, venue, or place name. */
+    locations(params: ConcertsLocationsParams, options?: RequestOverrides): Promise<GetPartnerConcertLocationsData>;
+    /** Get the concert feed for a location. */
+    feed(params: ConcertsFeedParams, options?: RequestOverrides): Promise<unknown>;
+    /** Get details for a single concert. */
+    get(params: ConcertsGetParams, options?: RequestOverrides): Promise<GetPartnerConcertData>;
+    /** Get an artist's upcoming concerts. */
+    byArtist(params: ConcertsByArtistParams, options?: RequestOverrides): Promise<GetPartnerArtistConcertsData>;
+    /** Search concerts by artist name. */
+    searchArtists(params: ConcertsSearchArtistsParams, options?: RequestOverrides): Promise<GetPartnerSearchConcertArtistsData>;
+}
+
+/** Credentials / cookie-pool status endpoints. */
+declare class CredentialsResource extends Resource {
+    /** Get the current credentials status. */
+    status(query?: QueryParams$1, options?: RequestOverrides): Promise<GetCredentialsStatusData>;
+    /** Get the Redis-backed cookie pool status. */
+    redisCookies(query?: QueryParams$1, options?: RequestOverrides): Promise<GetCookiesRedisData>;
+}
+
+/** Parameters for {@link DownloadsResource.track}. */
+interface DownloadsTrackParams {
+    /** Track query — a Spotify track URL/ID or a free-text search string. */
+    q: string;
+}
+/** Parameters for {@link DownloadsResource.soundcloud}. */
+interface DownloadsSoundcloudParams {
+    /** Track query — a SoundCloud track URL or a free-text search string. */
+    q: string;
+}
+/** Track download endpoints. */
+declare class DownloadsResource extends Resource {
+    /** Download a track. */
+    track(params: DownloadsTrackParams, options?: RequestOverrides): Promise<unknown>;
+    /** Download a track from SoundCloud. */
+    soundcloud(params: DownloadsSoundcloudParams, options?: RequestOverrides): Promise<unknown>;
+}
+
+/** Parameters for {@link EpisodesResource.get}. */
+interface EpisodesGetParams {
+    /** Comma-separated Spotify episode IDs. */
+    ids: string | readonly string[];
+    /** ISO 3166-1 alpha-2 market code. */
+    market?: string;
+}
+/** Parameters for {@link EpisodesResource.byId}. */
+interface EpisodesByIdParams {
+    /** Spotify episode ID. */
+    id: string;
+    /** ISO 3166-1 alpha-2 market code. */
+    market?: string;
+}
+/** Episode endpoints. */
+declare class EpisodesResource extends Resource {
+    /** Get one or more episodes by ID. */
+    get(params: EpisodesGetParams, options?: RequestOverrides): Promise<GetEpisodesData>;
+    /** Get a single episode by ID. */
+    byId(params: EpisodesByIdParams, options?: RequestOverrides): Promise<unknown>;
+}
+
+/** Health, readiness and diagnostics endpoints. */
+declare class HealthResource extends Resource {
+    /** Lightweight liveness probe. */
+    ping(query?: QueryParams$1, options?: RequestOverrides): Promise<GetPingData>;
+    /** Overall cluster health summary. */
+    get(query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Health of the individual instance serving the request. */
+    instance(query?: QueryParams$1, options?: RequestOverrides): Promise<GetHealthInstanceData>;
+    /** Cluster-wide health overview. */
+    cluster(query?: QueryParams$1, options?: RequestOverrides): Promise<GetHealthClusterData>;
+    /** Strict cluster health check (fails unless every instance is healthy). */
+    clusterStrict(query?: QueryParams$1, options?: RequestOverrides): Promise<GetHealthClusterStrictData>;
+    /** Health and statistics for the proxy pool. */
+    proxies(query?: QueryParams$1, options?: RequestOverrides): Promise<GetHealthProxiesData>;
+    /** Clear accumulated proxy statistics. */
+    clearProxies(body?: unknown, query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Clear accumulated error counters. */
+    clearErrors(body?: unknown, query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+}
+
+/** Parameters for {@link LookupsResource.isrc}. */
+interface LookupsIsrcParams {
+    /** International Standard Recording Code identifying the track. */
+    isrc: string;
+}
+/** Parameters for {@link LookupsResource.upc}. */
+interface LookupsUpcParams {
+    /** Universal Product Code identifying the album. */
+    upc: string;
+}
+/** Identifier lookup endpoints (ISRC / UPC). */
+declare class LookupsResource extends Resource {
+    /** Lookup a track by its ISRC. */
+    isrc(params: LookupsIsrcParams, options?: RequestOverrides): Promise<GetIsrcLookupData>;
+    /** Lookup an album by its UPC. */
+    upc(params: LookupsUpcParams, options?: RequestOverrides): Promise<GetUpcLookupData>;
+}
+
+/** Markets endpoints. */
+declare class MarketsResource extends Resource {
+    /** List the markets (countries) where Spotify is available. */
+    get(query?: QueryParams$1, options?: RequestOverrides): Promise<GetMarketsData>;
+}
+
+/** Parameters for {@link PartnerResource.playlist}. */
+interface PartnerPlaylistParams {
+    /** 22-character Spotify playlist ID. */
+    id: string;
+    offset?: number;
+    limit?: number;
+}
+/** Parameters for {@link PartnerResource.track}. */
+interface PartnerTrackParams {
+    /** Spotify track ID. */
+    id: string;
+}
+/** Parameters for {@link PartnerResource.trackCount}. */
+interface PartnerTrackCountParams {
+    /** Spotify track ID. */
+    spotify_track_id?: string;
+    /** ISRC to look the track up by. */
+    isrc?: string;
+}
+/** Parameters for {@link PartnerResource.album}. */
+interface PartnerAlbumParams {
+    /** Spotify album ID. */
+    id: string;
+    /** Locale, e.g. `intl-es`. */
+    locale?: string;
+    offset?: number;
+    limit?: number;
+}
+/** Parameters for {@link PartnerResource.artistOverview}. */
+interface PartnerArtistOverviewParams {
+    /** Spotify artist ID. */
+    id: string;
+    /** Locale, e.g. `en`. */
+    locale?: string;
+    /** Include prerelease content. */
+    includePrerelease?: boolean;
+}
+/** Parameters for {@link PartnerResource.artistDiscography}. */
+interface PartnerArtistDiscographyParams {
+    /** Spotify artist ID. */
+    id: string;
+    offset?: number;
+    limit?: number;
+}
+/** Spotify Partner (internal GraphQL) endpoints. */
+declare class PartnerResource extends Resource {
+    /** Get partner playlist data (paginated). */
+    playlist(params: PartnerPlaylistParams, options?: RequestOverrides): Promise<GetPartnerPlaylistData>;
+    /** Get partner track data. */
+    track(params: PartnerTrackParams, options?: RequestOverrides): Promise<GetPartnerTrackData>;
+    /** Get a track's play count by Spotify ID or ISRC. */
+    trackCount(params: PartnerTrackCountParams, options?: RequestOverrides): Promise<GetPartnerTrackCountData>;
+    /** Get partner album data (paginated). */
+    album(params: PartnerAlbumParams, options?: RequestOverrides): Promise<GetPartnerAlbumData>;
+    /** Get partner artist overview. */
+    artistOverview(params: PartnerArtistOverviewParams, options?: RequestOverrides): Promise<GetPartnerArtistOverviewData>;
+    /** Get partner artist discography (paginated). */
+    artistDiscography(params: PartnerArtistDiscographyParams, options?: RequestOverrides): Promise<GetPartnerArtistDiscographyData>;
+}
+
+/** Parameters for {@link PlaylistsResource.get}. */
+interface PlaylistsGetParams {
+    /** Spotify playlist ID. */
+    id: string;
+}
+/** Parameters for {@link PlaylistsResource.tracks}. */
+interface PlaylistsTracksParams {
+    /** Spotify playlist ID. */
+    id: string;
+    offset?: number;
+    limit?: number;
+}
+/** Parameters for {@link PlaylistsResource.fromSeed}. */
+interface PlaylistsFromSeedParams {
+    /** Spotify URI to seed the generated playlist from. */
+    uri: string;
+}
+/** Playlist endpoints. */
+declare class PlaylistsResource extends Resource {
+    /** Get a playlist by ID. */
+    get(params: PlaylistsGetParams, options?: RequestOverrides): Promise<GetPlaylistData>;
+    /** Get a playlist's tracks (paginated). */
+    tracks(params: PlaylistsTracksParams, options?: RequestOverrides): Promise<GetPlaylistTracksData>;
+    /** Generate a playlist from a seed URI. */
+    fromSeed(params: PlaylistsFromSeedParams, options?: RequestOverrides): Promise<GetSeedToPlaylistData>;
+}
+
+/** Parameters for {@link SearchResource.search}. */
+interface SearchParams {
+    /** Search query. */
+    q: string;
+    /** Search type: `multi`, `tracks`, `albums`, `artists`, `playlists`, etc. Default `multi`. */
+    type?: string;
+    offset?: number;
+    limit?: number;
+    numberOfTopResults?: number;
+    /** Comma-separated providers to contrast against, e.g. `ytmusic,applemusic`. */
+    contrast?: string;
+}
+/** Parameters for {@link SearchResource.topResults}. */
+interface SearchTopResultsParams {
+    q: string;
+    numberOfTopResults?: number;
+    contrast?: string;
+}
+/** Parameters for {@link SearchResource.lyrics}. */
+interface SearchLyricsParams {
+    q: string;
+    /** Lyrics output format. */
+    format?: 'json' | 'lrc' | 'srt' | 'raw';
+}
+/** Parameters for {@link SearchResource.suggestions}. */
+interface SearchSuggestionsParams {
+    q: string;
+    offset?: number;
+    limit?: number;
+    numberOfTopResults?: number;
+    includeAuthors?: boolean;
+    debug?: boolean;
+    timeout?: number;
+    contrast?: string;
+}
+/** Parameters for {@link SearchResource.multiMarket}. */
+interface SearchMultiMarketParams {
+    q: string;
+    type?: string;
+    markets?: string;
+    limit?: number;
+}
+/** Search endpoints. */
+declare class SearchResource extends Resource {
+    /** Search Spotify across one or more types. */
+    search(params: SearchParams, options?: RequestOverrides): Promise<GetSearchData>;
+    /** Search returning only the top results. */
+    topResults(params: SearchTopResultsParams, options?: RequestOverrides): Promise<GetSearchTopResultsData>;
+    /** Search and return synced lyrics for the best match. */
+    lyrics(params: SearchLyricsParams, options?: RequestOverrides): Promise<GetSearchLyricsData>;
+    /** Search suggestions / autocomplete. */
+    suggestions(params: SearchSuggestionsParams, options?: RequestOverrides): Promise<GetSearchSuggestionsData>;
+    /** Search across multiple markets at once. */
+    multiMarket(params: SearchMultiMarketParams, options?: RequestOverrides): Promise<unknown>;
+}
+
+/** Parameters for {@link ShowsResource.get}. */
+interface ShowsGetParams {
+    /** Comma-separated Spotify show IDs. */
+    ids: string | readonly string[];
+    /** ISO market code. */
+    market?: string;
+}
+/** Parameters for {@link ShowsResource.getById}. */
+interface ShowsGetByIdParams {
+    /** Spotify show ID. */
+    id: string;
+    /** ISO market code. */
+    market?: string;
+}
+/** Parameters for {@link ShowsResource.episodes}. */
+interface ShowsEpisodesParams {
+    /** Spotify show ID. */
+    id: string;
+    offset?: number;
+    limit?: number;
+}
+/** Show (podcast) endpoints. */
+declare class ShowsResource extends Resource {
+    /** Get one or more shows by ID. */
+    get(params: ShowsGetParams, options?: RequestOverrides): Promise<GetShowsData>;
+    /** Get a single show by ID. */
+    getById(params: ShowsGetByIdParams, options?: RequestOverrides): Promise<GetShowsIdData>;
+    /** Get a show's episodes (paginated). */
+    episodes(params: ShowsEpisodesParams, options?: RequestOverrides): Promise<unknown>;
+}
+
+/** Parameters for {@link SnapshotsResource.list}. */
+interface SnapshotsListParams {
+    /** Spotify playlist ID. */
+    id: string;
+}
+/** Parameters for {@link SnapshotsResource.create}. */
+interface SnapshotsCreateParams {
+    /** Spotify playlist ID to snapshot. */
+    id?: string;
+    /** Webhook URL notified when the snapshot completes. */
+    webhook?: string;
+}
+/** Playlist snapshot endpoints. */
+declare class SnapshotsResource extends Resource {
+    /** List the snapshots taken for a playlist. */
+    list(params: SnapshotsListParams, options?: RequestOverrides): Promise<GetPlaylistSnapshotData>;
+    /** Create a new snapshot of a playlist. */
+    create(params: SnapshotsCreateParams, options?: RequestOverrides): Promise<GetPlaylistSnapshotData>;
+}
+
+/** Parameters for {@link TrackingResource.track}. */
+interface TrackingTrackParams {
+    /** Kind of Spotify entity to track. */
+    type: 'track' | 'album' | 'artist' | 'playlist';
+    /** Spotify ID of the entity to track. */
+    id: string;
+}
+/** Parameters for {@link TrackingResource.untrack}. */
+interface TrackingUntrackParams {
+    /** Kind of Spotify entity to untrack. */
+    type: string;
+    /** Spotify ID of the entity to untrack. */
+    id: string;
+}
+/** Parameters for {@link TrackingResource.items}. */
+interface TrackingItemsParams {
+    offset?: number;
+    limit?: number;
+}
+/** Parameters for {@link TrackingResource.item}. */
+interface TrackingItemParams {
+    /** Kind of Spotify entity. */
+    spotifyType: string;
+    /** Spotify ID of the tracked entity. */
+    spotifyId: string;
+}
+/** Parameters for {@link TrackingResource.logs}. */
+interface TrackingLogsParams {
+    offset?: number;
+    limit?: number;
+}
+/** Tracking endpoints. */
+declare class TrackingResource extends Resource {
+    /** Start tracking a Spotify item. */
+    track(params: TrackingTrackParams, options?: RequestOverrides): Promise<unknown>;
+    /** Stop tracking a Spotify item. */
+    untrack(params: TrackingUntrackParams, options?: RequestOverrides): Promise<unknown>;
+    /** List tracked items (paginated). */
+    items(params: TrackingItemsParams, options?: RequestOverrides): Promise<GetTrackingItemsData>;
+    /** Get the detail of a single tracked item. */
+    item(params: TrackingItemParams, options?: RequestOverrides): Promise<unknown>;
+    /** Get the tracking change log (paginated). */
+    logs(params: TrackingLogsParams, options?: RequestOverrides): Promise<GetTrackingLogsData>;
+    /** Get tracking statistics. */
+    stats(query?: QueryParams$1, options?: RequestOverrides): Promise<GetTrackingStatsData>;
+    /** Get tracking subsystem health. */
+    health(query?: QueryParams$1, options?: RequestOverrides): Promise<GetTrackingHealthData>;
+}
+
+/** Parameters for {@link TracksResource.get}. */
+interface TracksGetParams {
+    /** Comma-separated track IDs. */
+    ids: string | readonly string[];
+    /**
+     * Comma-separated list of streaming providers to contrast against.
+     * Appends a `_contrast` field to the response with cross-platform matching data.
+     * Available providers: `ytmusic`, `applemusic`, `amazonmusic`, `tencentmusic`, `pandora`, `gaana`.
+     */
+    contrast?: string;
+}
+/** Parameters for {@link TracksResource.credits}. */
+interface TracksCreditsParams {
+    /** Spotify track ID. */
+    id: string;
+}
+/** Parameters for {@link TracksResource.lyrics}. */
+interface TracksLyricsParams {
+    /** Spotify track ID. */
+    id: string;
+    /** Lyrics output format. Default `json`. */
+    format?: 'json' | 'lrc' | 'srt' | 'raw';
+    /** Whether to request the vocal-removal (instrumental) variant. Default `false`. */
+    vocalRemoval?: boolean;
+}
+/** Parameters for {@link TracksResource.recommendations}. */
+interface TracksRecommendationsParams {
+    /** Number of recommended tracks to return. */
+    limit?: number;
+    /** Comma-separated seed track IDs. */
+    seed_tracks?: string | readonly string[];
+    /** Comma-separated seed artist IDs. */
+    seed_artists?: string | readonly string[];
+    /** Comma-separated seed genres. */
+    seed_genres?: string;
+}
+/** Track endpoints. */
+declare class TracksResource extends Resource {
+    /** Get one or more tracks by ID. */
+    get(params: TracksGetParams, options?: RequestOverrides): Promise<GetTracksData>;
+    /** Get a track's credits (writers, producers, performers). */
+    credits(params: TracksCreditsParams, options?: RequestOverrides): Promise<GetTrackCreditsData>;
+    /** Get a track's lyrics. */
+    lyrics(params: TracksLyricsParams, options?: RequestOverrides): Promise<GetTrackLyricsData>;
+    /** Get track recommendations from seed tracks, artists and/or genres. */
+    recommendations(params: TracksRecommendationsParams, options?: RequestOverrides): Promise<GetRecommendationsData>;
+}
+
+/** Parameters for {@link UsersResource.profile}. */
+interface UsersProfileParams {
+    /** Spotify user ID. */
+    id: string;
+    /** Max number of playlists to include. Default `10`. */
+    playlistLimit?: number;
+    /** Max number of artists to include. Default `100`. */
+    artistLimit?: number;
+    /** Max number of episodes to include. Default `100`. */
+    episodeLimit?: number;
+}
+/** Parameters for {@link UsersResource.followers}. */
+interface UsersFollowersParams {
+    /** Spotify user ID. */
+    id: string;
+}
+/** User endpoints. */
+declare class UsersResource extends Resource {
+    /** Get a public user profile, including their playlists, artists and episodes. */
+    profile(params: UsersProfileParams, options?: RequestOverrides): Promise<GetUserProfileData>;
+    /** Get a user's followers. */
+    followers(params: UsersFollowersParams, options?: RequestOverrides): Promise<GetUserFollowersData>;
+}
+
+/** Parameters for {@link WebhooksResource.register}. */
+interface WebhooksRegisterParams {
+    /** Destination URL that delivery payloads are POSTed to. */
+    url?: string;
+    /** Event names to subscribe this webhook to. */
+    events?: string[];
+}
+/** Parameters for {@link WebhooksResource.delete}. */
+interface WebhooksDeleteParams {
+    /** Webhook ID. */
+    id: string;
+}
+/** Parameters for {@link WebhooksResource.test}. */
+interface WebhooksTestParams {
+    /** Webhook ID. */
+    id: string;
+}
+/** Parameters for {@link WebhooksResource.deliveries}. */
+interface WebhooksDeliveriesParams {
+    /** Webhook ID. */
+    id: string;
+}
+/** Webhook management endpoints. */
+declare class WebhooksResource extends Resource {
+    /** List registered webhooks. */
+    get(query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Register a new webhook. */
+    register(params: WebhooksRegisterParams, options?: RequestOverrides): Promise<unknown>;
+    /** Get aggregate webhook delivery statistics. */
+    stats(query?: QueryParams$1, options?: RequestOverrides): Promise<unknown>;
+    /** Delete a webhook by ID. */
+    delete(params: WebhooksDeleteParams, options?: RequestOverrides): Promise<unknown>;
+    /** Trigger a test delivery for a webhook. */
+    test(params: WebhooksTestParams, options?: RequestOverrides): Promise<unknown>;
+    /** Get the delivery log for a webhook. */
+    deliveries(params: WebhooksDeliveriesParams, options?: RequestOverrides): Promise<unknown>;
+}
+
+/**
+ * The Spotify Data API client. Every endpoint is reachable through a typed
+ * resource namespace, e.g. `client.search.search({ q: 'daft punk' })`.
+ */
+declare class SpotifyApiClient extends SpotifyHttpClient {
+    readonly ai: AiResource;
+    readonly albums: AlbumsResource;
+    readonly analysis: AnalysisResource;
+    readonly artists: ArtistsResource;
+    readonly audiobooks: AudiobooksResource;
+    readonly batch: BatchResource;
+    readonly browse: BrowseResource;
+    readonly cache: CacheResource;
+    readonly charts: ChartsResource;
+    readonly concerts: ConcertsResource;
+    readonly credentials: CredentialsResource;
+    readonly downloads: DownloadsResource;
+    readonly episodes: EpisodesResource;
+    readonly health: HealthResource;
+    readonly lookups: LookupsResource;
+    readonly markets: MarketsResource;
+    readonly partner: PartnerResource;
+    readonly playlists: PlaylistsResource;
+    readonly search: SearchResource;
+    readonly shows: ShowsResource;
+    readonly snapshots: SnapshotsResource;
+    readonly tracking: TrackingResource;
+    readonly tracks: TracksResource;
+    readonly users: UsersResource;
+    readonly webhooks: WebhooksResource;
+    constructor(config: ClientConfig);
+}
+/** Convenience factory equivalent to `new SpotifyApiClient(config)`. */
+declare function createClient(config: ClientConfig): SpotifyApiClient;
+
+/** Options used to construct a {@link SpotifyApiError}. */
+interface SpotifyApiErrorInit {
+    message: string;
+    /** HTTP status code, when the failure came from a response. */
+    status?: number;
+    /** Machine-readable code: upstream `error` field, or `TIMEOUT`/`NETWORK`/`ABORTED`/`CONFIG`. */
+    code?: string;
+    /** The request URL that failed. */
+    url?: string;
+    /** Parsed response body (or raw text), when available. */
+    body?: unknown;
+    /** Underlying error, if any. */
+    cause?: unknown;
+}
+/**
+ * Every failure thrown by the client is a `SpotifyApiError`, giving uniform access
+ * to `status`, `code`, `url` and the parsed `body`.
+ */
+declare class SpotifyApiError extends Error {
+    readonly status?: number;
+    readonly code?: string;
+    readonly url?: string;
+    readonly body?: unknown;
+    constructor(init: SpotifyApiErrorInit);
+    /** True when the server returned HTTP 429. */
+    get isRateLimit(): boolean;
+    /** True for HTTP 5xx responses. */
+    get isServerError(): boolean;
+    /** True when the request timed out client-side. */
+    get isTimeout(): boolean;
+}
+
+/**
+ * Spotify ID normalization helpers.
+ *
+ * Every endpoint that takes an `id` / `ids` accepts a bare Spotify ID, a URI
+ * (`spotify:artist:…`), or an open.spotify.com URL — these helpers reduce any of
+ * those to the bare ID. Non-Spotify values (category slugs, webhook UUIDs, etc.)
+ * pass through unchanged, so normalization is always safe to apply.
+ */
+/** Reduce a Spotify ID / URI / URL to its bare ID. Unknown formats pass through. */
+declare function normalizeId(input: string | number): string;
+/** Accept a comma-separated string or an array of IDs/URIs/URLs → comma-joined bare IDs. */
+declare function normalizeIds(input: string | number | ReadonlyArray<string | number>): string;
+
+/**
+ * Pagination helpers for the many `offset`/`limit` endpoints.
+ *
+ * Because each endpoint nests its items differently, you supply a `getItems`
+ * function that extracts the current page's array. Iteration stops when a page
+ * returns fewer items than `limit` (or when `maxItems` is reached).
+ */
+interface PaginateOptions<T> {
+    /** Extract the array of items from a page (default: the page itself if it is an array). */
+    getItems?: (page: T) => ReadonlyArray<unknown>;
+    /** Starting offset. Default `0`. */
+    offset?: number;
+    /** Page size. Default `50`. */
+    limit?: number;
+    /** Stop after collecting this many items. */
+    maxItems?: number;
+    /** Hard cap on page requests (safety). Default `100`. */
+    maxPages?: number;
+}
+/** A page fetcher: given `{ offset, limit }`, return that page. */
+type PageFetcher<T> = (params: {
+    offset: number;
+    limit: number;
+}) => Promise<T>;
+/**
+ * Async-iterate pages of a paginated endpoint.
+ *
+ * @example
+ * for await (const page of paginate((p) => spotify.artists.albums({ id, ...p }), {
+ *   getItems: (p) => p?.data?.artist?.discography?.albums?.items ?? [],
+ * })) {
+ *   // handle page
+ * }
+ */
+declare function paginate<T>(fetcher: PageFetcher<T>, options?: PaginateOptions<T>): AsyncGenerator<T>;
+/** Collect all items across pages into a single flat array (bounded by `maxItems`/`maxPages`). */
+declare function collect<T, I = unknown>(fetcher: PageFetcher<T>, options?: PaginateOptions<T>): Promise<I[]>;
+
+export { type AccessExplanation, type AccessInfo, type AddedAt, AiResource, AlbumAlbumType, type AlbumCopyright, type AlbumExternalids, type AlbumMetadata, type AlbumMetadataParams, type AlbumMoreAlbumsByArtist, type AlbumOfTrackClass, type AlbumOfTrackDate, type AlbumOfTrackPlayability, type AlbumOfTrackTracks, type AlbumSharingInfo, type AlbumTracksParams, type AlbumUnion, type AlbumUnionMoreAlbumsByArtist, type AlbumUnionVisualIdentity, type AlbumsClass, type AlbumsGetParams, type AlbumsPagingInfo, AlbumsResource, type AlbumsV2, type AllItem, type AmbitiousData, type AmbitiousDiscography, type AmbitiousItem, type AnalysisArtistCompareParams, type AnalysisAudioFeaturesParams, type AnalysisPlaylistAnalysisParams, AnalysisResource, type ArtistElement, type ArtistGoods, type ArtistMetadata, type ArtistStats, type ArtistUnionRelatedContent, ArtistUnionTypename, type ArtistUnionVisualIdentity, type ArtistsAlbumsParams, type ArtistsAppearsOnParams, type ArtistsDiscographyOverviewParams, type ArtistsDiscoveredOnParams, type ArtistsFeaturingParams, type ArtistsGetParams, type ArtistsOverviewParams, type ArtistsRelatedParams, ArtistsResource, type ArtistsSinglesParams, type ArtistsTopTracksParams, type Attribute, type AudioAssociations, AudioAssociationsTypename, type AudioFeatures, type AudioPreviews, type AudiobooksChaptersParams, type AudiobooksGetByIdParams, type AudiobooksGetParams, AudiobooksResource, type AvatarImage, type AvatarImageElement, type BackgroundImageClass, type Badge, type BatchAlbumMetadataParams, type BatchArtistOverviewParams, BatchResource, type BatchTrackCreditsParams, type BatchTrackLyricsParams, type BatchTrackPopularityParams, type BiographyElement, BiographyType, type BraggadociousData, type BraggadociousItem, type BrowseCategoriesParams, type BrowseCategoryParams, type BrowseFeaturedPlaylistsParams, type BrowseNewReleasesParams, type BrowseRecommendationsParams, BrowseResource, type CacheInvalidateParams, CacheResource, type Categories, type ChartEntryData, ChartsResource, type ChartsTop200TracksParams, type ChartsTopAlbumsParams, type ChartsTopArtistsParams, type ChartsViralTracksParams, type ChipOrder, type ChipOrderItem, type ClientConfig, type Color, type ColorDark, type Comparison, type CompilationsClass, type CompilationsItem, type Concert, type ConcertLocations, type ConcertLocationsItem, type ConcertsByArtistParams, type ConcertsFeedParams, type ConcertsGetParams, type ConcertsLocationsParams, type ConcertsPagingInfo, ConcertsResource, type ConcertsSearchArtistsParams, type Content, type ContentItem, type ContentPagingInfo, type ContentRating, type Contrast, type CoverArt, type CoverArtElement, CredentialsResource, type CunningData, type CunningDiscography, type CunningItem, type CurrentUserCapabilities, DEFAULT_RETRIES, DEFAULT_RETRY_DELAY_MS, DEFAULT_TIMEOUT_MS, DEFAULT_USER_AGENT, type Data1, type Data2, type Data3, type Data4, type DataAlbumOfTrack, type DataArtist, type DataVisuals, type Dev, type Diff, type DiscoveredOn, type DiscoveredOnItem, type DiscoveredOnV2Item, type Discs, type DiscsItem, DownloadsResource, type DownloadsSoundcloudParams, type DownloadsTrackParams, type EncoreBaseSetTextColor, type Endpoint, EntryStatus, type EpisodesByIdParams, type EpisodesGetParams, EpisodesResource, type ErrorEnvelope, type Events, type EventsConcerts, type ExternalLinks, type ExternalLinksItem, type ExternalUrls, type ExtractedColorSet, type Featured, type FeaturedData, type FetchLike, type File, type FirstArtist, type FirstArtistItem, type FluffyAlbum, type FluffyAlbums, type FluffyAppearsOn, type FluffyAssociationsV3, type FluffyData, type FluffyDate, type FluffyDiscography, type FluffyExamples, type FluffyExtractedColors, type FluffyGoods, type FluffyItem, type FluffyItemsV2, type FluffyMerch, type FluffyOwnerV2, type FluffyPinnedItem, type FluffyPodcastV2, type FluffyPopularReleasesAlbums, type FluffyProfile, type FluffyRelatedContent, type FluffyReleases, type FluffyRelinkingInformation, type FluffyTopResultsV2, type FluffyTopTracks, type FluffyTrack, type FluffyTracks, FluffyType, FluffyTypename, type FluffyVisualIdentity, type FluffyVisuals, type FollowerRatio, type Followers, Format, type FriskyData, type FriskyItem, type GatedEntityRelation, type Genres, type GenresItem, type GetAlbumMetadataBatchData, type GetAlbumMetadataBatchDataResult, type GetAlbumMetadataData, type GetAlbumMetadataDataAlbum, type GetAlbumMetadataDataClass, type GetAlbumTracksData, type GetAlbumTracksDataAlbum, type GetAlbumsData, type GetAlbumsDataAlbum, type GetArtistAlbumsData, type GetArtistAlbumsDataArtist, type GetArtistAppearsOnData, type GetArtistAppearsOnDataArtist, type GetArtistCompareData, type GetArtistCompareDataArtist, type GetArtistData, type GetArtistDiscographyOverviewData, type GetArtistDiscoveredOnData, type GetArtistFeaturingData, type GetArtistOverviewBatchData, type GetArtistOverviewBatchDataResult, type GetArtistOverviewData, type GetArtistOverviewDataArtistUnion, type GetArtistRelatedData, type GetArtistSinglesData, type GetArtistSinglesDataArtistUnion, type GetArtistTopTracksData, type GetArtistsData, type GetArtistsDataArtist, type GetAudiobooksData, type GetBrowseCategoriesData, type GetBrowseCategoriesIdData, type GetBrowseCategoriesidData, type GetBrowseFeaturedPlaylistsData, type GetBrowseFeaturedPlaylistsDataPlaylists, type GetBrowseNewReleasesData, type GetBrowseNewReleasesDataAlbums, type GetBrowseRecommendationsData, type GetCacheStatsData, type GetCookiesRedisData, type GetCookiesRedisDataStats, type GetCookiesRedisDataUsage, type GetCredentialsStatusData, type GetCredentialsStatusDataUsage, type GetEpisodesData, type GetHealthClusterData, type GetHealthClusterDataInstance, type GetHealthClusterStrictData, type GetHealthInstanceData, type GetHealthProxiesData, type GetHealthProxiesDataStats, type GetIsrcLookupData, type GetMarketsData, type GetPartnerAlbumData, type GetPartnerArtistConcertsData, type GetPartnerArtistConcertsDataArtistUnion, type GetPartnerArtistConcertsDataConcerts, type GetPartnerArtistDiscographyData, type GetPartnerArtistDiscographyDataArtistUnion, type GetPartnerArtistOverviewData, type GetPartnerArtistOverviewDataArtistUnion, type GetPartnerConcertData, type GetPartnerConcertLocationsData, type GetPartnerPlaylistData, type GetPartnerSearchConcertArtistsData, type GetPartnerSearchConcertArtistsDataArtist, type GetPartnerTrackCountData, type GetPartnerTrackData, type GetPingData, type GetPlaylistAnalysisData, type GetPlaylistAnalysisDataDuration, type GetPlaylistData, GetPlaylistDataType, type GetPlaylistSnapshotData, type GetPlaylistTracksData, type GetPlaylistTracksDataItem, type GetRecommendationsData, type GetRecommendationsDataTrack, type GetSDatum, type GetSearchData, type GetSearchDataArtists, type GetSearchDataEpisodes, type GetSearchDataPlaylists, type GetSearchDataTrack, type GetSearchLyricsData, type GetSearchLyricsDataTrack, type GetSearchSuggestionsData, type GetSearchSuggestionsDataSearchV2, type GetSearchTopResultsData, type GetSearchTopResultsDataSearchV2, type GetSeedToPlaylistData, type GetShowsData, type GetShowsIdData, type GetShowsIdDataEpisodes, type GetShowsidData, type GetTop200TracksData, type GetTop200TracksDatum, type GetTop20ByFollowersData, type GetTop20ByFollowersDatum, type GetTop20ByMonthlyListenersData, type GetTop20ByMonthlyListenersDatum, type GetTopAlbumsData, type GetTopArtistsData, type GetTrackCreditsBatchData, type GetTrackCreditsBatchDataResult, type GetTrackCreditsData, type GetTrackLyricsBatchData, type GetTrackLyricsBatchDataResult, type GetTrackLyricsData, type GetTrackPopularityBatchData, type GetTrackPopularityBatchDataResult, type GetTrackingHealthData, type GetTrackingHealthDataStats, type GetTrackingItemsData, type GetTrackingLogsData, type GetTrackingStatsData, type GetTracksData, type GetUpcLookupData, type GetUserFollowersData, type GetUserProfileData, type GetViralTracksData, type HeaderImage, type HeaderImageClass, type HeaderImageExtractedColors, HealthResource, type HilariousData, type HilariousDiscography, type HilariousItem, type HilariousTrack, type Icon, type Id, type IdList, type ImageData, type ImageExtractedColors, type ImagesClass, type IndecentData, type IndecentDiscography, type IndecentItem, type IndecentTrack, type IndigoData, type IndigoDiscography, type IndigoItem, type IndigoReleases, type IndigoTrack, InstanceName, type Item1, type Item10, type Item11, type Item12, type Item13, type Item14, type Item15, type Item2, type Item3, type Item4, type Item5, type Item6, type Item7, type Item8, type Item9, type ItemArtists, type ItemClass, type ItemElement, type ItemExternalids, type ItemImages, type ItemItemV2, type ItemRelatedContent, ItemV2Typename, type ItemVisuals, type Items, type ItemsItem, ItemsV2Typename, Label, type LabelElement, LabelEnum, Language, type LastRequest, type LastRequestsTracking, type LastRequestsTrackingInstance, type LatestCopyright, type LatestElement, type LatestPlayability, LatestType, type Line, type LinkedTrack, type LookupsIsrcParams, LookupsResource, type LookupsUpcParams, type MagentaData, type MagentaItem, Market, MarketsResource, type MediaItem, MediaType, type Members, type MembersItem, type Metadata, type Metrics, type MischievousData, type MischievousItem, type Nearby, type OAuth, type OauthTokenStatus, type OnPlatformReputationTrait, type Overview, type OverviewData, type Owner, OwnerEnum, OwnerType, type OwnerV2, PROVIDERS, type PageFetcher, type PaginateOptions, type PartnerAlbumParams, type PartnerArtistDiscographyParams, type PartnerArtistOverviewParams, type PartnerPlaylistParams, PartnerResource, type PartnerTrackCountParams, type PartnerTrackParams, type PinnedItemItemV2, type PlayabilityClass, type PlayedState, type Playlist, type PlaylistV2, type PlaylistsFromSeedParams, type PlaylistsGetParams, PlaylistsResource, type PlaylistsTracksParams, type PlaylistsV2, type PlaylistsV2Item, PodcastV2Typename, type Podcasts, type PodcastsItem, type PopularReleases, type PopularReleasesAlbums, Precision, type Previews, PrimaryColor, type ProfileElement, type ProfilePlaylists, type Provider, type PublicPlaylist, type PurpleAlbum, type PurpleAlbums, type PurpleAppearsOn, type PurpleAssociationsV3, type PurpleData, type PurpleDate, type PurpleDiscography, type PurpleExamples, type PurpleExternalids, type PurpleExtractedColors, type PurpleGoods, type PurpleImages, type PurpleItem, type PurpleItemsV2, type PurpleLatest, PurpleMediaType, type PurpleMerch, type PurpleOwnerV2, type PurplePinnedItem, type PurplePodcastV2, type PurplePopularReleasesAlbums, type PurpleProfile, PurpleReason, type PurpleRelatedContent, type PurpleReleases, type PurpleRelinkingInformation, type PurpleRestrictions, type PurpleSharingInfo, type PurpleTopResultsV2, type PurpleTopTracks, type PurpleTrack, type PurpleTracks, PurpleType, PurpleTypename, type PurpleVisualIdentity, type PurpleVisuals, type QueryParams$1 as QueryParams, type QueryValue, type RankingMetric, RankingMetricType, type Redis, type RedisKeys, type RelatedArtists, type RelatedArtistsItem, type RelatedEntity, type RelatedEntityData, RelatedEntityTypename, type RelatedMusicVideosClass, type RelatedMusicVideosItem, type ReleaseDateClass, ReleaseDatePrecision, type ReleasesClass, type Request, type RequestOptions, type RequestOverrides, type ResolvedConfig, RestrictionsReason, type RetryInfo, type RoleCredit, type RoleCreditArtist, type Rotation, type SearchLyricsParams, type SearchMultiMarketParams, type SearchParams, SearchResource, type SearchSuggestionsParams, type SearchTests, type SearchTopResultsParams, type Seed, type ShowsEpisodesParams, type ShowsGetByIdParams, type ShowsGetParams, ShowsResource, type SignifierClass, type Singles, type SixteenByNineCoverImage, type Snapshot, type SnapshotTrack, type SnapshotsCreateParams, type SnapshotsListParams, SnapshotsResource, type Source, SpotifyApiClient, SpotifyApiError, type SpotifyApiErrorInit, SpotifyHttpClient, type SquareCoverImageClass, SquareCoverImageTypename, type StateClass, StateEnum, Status, type StatusCodeDistribution, type StickyData, type StickyDiscography, type StickyItem, type StickyReleases, type StickyTrack, StickyTypename, Subrole, type SuccessEnvelope, type Summary, type TentacledData, type TentacledDate, type TentacledDiscography, type TentacledItem, type TentacledPinnedItem, type TentacledProfile, type TentacledReleases, type TentacledTrack, TentacledTypename, type TentacledVisuals, type ThumbnailImage, type ThumbnailImageClass, type TopCities, type TopCitiesItem, type TopResults, type TopResultsItem, type TopTrack, type Topics, type TopicsItem, type TrackAlbumOfTrack, type TrackArtist, type TrackClass, type TrackData, type TrackDurationClass, type TrackMetadata, TrackType, type TrackUnion, type TrackUnionAlbumOfTrack, type TrackUnionAssociationsV3, type TrackingItemParams, type TrackingItemsParams, type TrackingLogsParams, TrackingResource, type TrackingTrackParams, type TrackingUntrackParams, type TracksCreditsParams, type TracksGetParams, type TracksLyricsParams, type TracksRecommendationsParams, TracksResource, type TracksTrack, type TracksV2, type TracksV2Item, Uri, type UserData, type UserLocationClass, type Users, type UsersFollowersParams, type UsersItem, type UsersProfileParams, UsersResource, type V2, type Verification, type Video, type VideoPreviewThumbnail, type VideoThumbnail, type WatchFeedEntrypoint, type WebhooksDeleteParams, type WebhooksDeliveriesParams, type WebhooksRegisterParams, WebhooksResource, type WebhooksTestParams, buildPath, collect, createClient, normalizeId, normalizeIds, paginate, resolveConfig };