@opfelmusig/lib 0.0.0-ci.0.sha-3e76884

package/README.md

@@ -0,0 +1,8 @@
+# Öpfelmusig
+
+Öpfelmusig is the literal Swiss German translation of "Apple Music"
+
+- Öpfel = Swiss German for German "Apfel" ("Apple")
+- Musig = Swiss German for German "Musik" ("Music")
+
+It will primarily be used privately for my own use cases, so I do not intend to make it production-ready (but it probably will be).

package/dist/clients/catalog/album.d.ts

@@ -0,0 +1,12 @@
+import { EquivalentClient } from "../../clients/shared/equivalent.js";
+import type { DefaultParams } from "../../types/params.js";
+import type { Registry } from "../../types/query/registry.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { ResourceScopes } from "../../types/query/scopes.js";
+declare const type: "albums";
+type TResource = Registry[typeof type];
+export declare class AlbumClient extends EquivalentClient<typeof type, TResource> {
+    protected readonly type: "albums";
+    getByUpc<const TScopes extends ResourceScopes = {}>(upc: string | string[], opts?: DefaultParams<TScopes>): Promise<ResourceResponse<import("../../types/public.js").CatalogAlbum, TScopes>>;
+}
+export {};

package/dist/clients/catalog/album.js

@@ -0,0 +1,14 @@
+import { EquivalentClient } from "../../clients/shared/equivalent.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+const type = "albums";
+export class AlbumClient extends EquivalentClient {
+    type = type;
+    async getByUpc(upc, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts).setStringArray("filter[upc]", upc);
+        const result = await this.http.request(`${this.path}/${this.type}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+}

package/dist/clients/catalog/genre.d.ts

@@ -0,0 +1,13 @@
+import { ResourceClient } from "../../clients/resource.js";
+import type { DefaultParams, LimitParam, PaginationParams } from "../../types/params.js";
+import type { Registry } from "../../types/query/registry.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { ResourceScopes, ScopedResourceIterator } from "../../types/query/scopes.js";
+declare const type: "genres";
+type TResource = Registry[typeof type];
+export declare class GenreClient extends ResourceClient<typeof type, TResource> {
+    protected readonly type: "genres";
+    getFromTopCharts<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & PaginationParams): Promise<ResourceResponse<import("../../types/public.js").CatalogGenre, TScopes>>;
+    iterateFromTopCharts<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & LimitParam): ScopedResourceIterator<TResource, TScopes>;
+}
+export {};

package/dist/clients/catalog/genre.js

@@ -0,0 +1,17 @@
+import { ResourceClient } from "../../clients/resource.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+const type = "genres";
+export class GenreClient extends ResourceClient {
+    type = type;
+    async getFromTopCharts(opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/${this.type}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    iterateFromTopCharts(opts = {}) {
+        return this.iterate((offset) => this.getFromTopCharts({ ...opts, offset }));
+    }
+}

package/dist/clients/catalog/index.d.ts

@@ -0,0 +1,71 @@
+import { AlbumClient } from "../../clients/catalog/album.js";
+import { GenreClient } from "../../clients/catalog/genre.js";
+import { MusicVideoClient } from "../../clients/catalog/musicVideo.js";
+import { PlaylistClient } from "../../clients/catalog/playlist.js";
+import { SongClient } from "../../clients/catalog/song.js";
+import { StationClient } from "../../clients/catalog/station.js";
+import { StationGenreClient } from "../../clients/catalog/stationGenre.js";
+import { BaseResourceClient } from "../../clients/resource.js";
+import type { HttpClient } from "../../core/http.js";
+import type { CatalogResources, CatalogResourceTypes } from "../../types/combined.js";
+import type { ResultParams, PaginationParams, ConfigParm, DefaultParams } from "../../types/params.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { ResultShape, ShapedResult } from "../../types/query/results.js";
+import type { ResourceScopes } from "../../types/query/scopes.js";
+import type { SearchCatalogResult } from "../../types/results/search.js";
+declare const ActivityClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").ResourceClient<"activities", import("../../types/public.js").CatalogActivity>;
+declare class ActivityClient extends ActivityClient_base {
+}
+declare const AppleCuratorClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").ResourceClient<"apple-curators", import("../../types/public.js").CatalogAppleCurator>;
+declare class AppleCuratorClient extends AppleCuratorClient_base {
+}
+declare const ArtistClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").ResourceClient<"artists", import("../../types/public.js").CatalogArtist>;
+declare class ArtistClient extends ArtistClient_base {
+}
+declare const ConcertClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").ResourceClient<"concerts", import("../../types/public.js").CatalogConcert>;
+declare class ConcertClient extends ConcertClient_base {
+}
+declare const CreditArtistClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").ResourceClient<"credit-artists", import("../../types/public.js").CatalogCreditArtist>;
+declare class CreditArtistClient extends CreditArtistClient_base {
+}
+declare const CuratorClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").ResourceClient<"curators", import("../../types/public.js").CatalogCurator>;
+declare class CuratorClient extends CuratorClient_base {
+}
+declare const LyricsClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").ResourceClient<"lyrics", import("../../types/public.js").CatalogLyrics>;
+declare class LyricsClient extends LyricsClient_base {
+}
+declare const RecordLabelClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").ResourceClient<"record-labels", import("../../types/public.js").CatalogRecordLabel>;
+declare class RecordLabelClient extends RecordLabelClient_base {
+}
+declare const RoleCategoryClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").ResourceClient<"role-categories", import("../../types/public.js").CatalogRoleCategory>;
+declare class RoleCategoryClient extends RoleCategoryClient_base {
+}
+declare const SyllableLyricsClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").ResourceClient<"syllable-lyrics", import("../../types/public.js").CatalogSyllableLyrics>;
+declare class SyllableLyricsClient extends SyllableLyricsClient_base {
+}
+export declare class CatalogClient extends BaseResourceClient {
+    protected http: HttpClient;
+    protected path: string;
+    activities: ActivityClient;
+    albums: AlbumClient;
+    appleCurators: AppleCuratorClient;
+    playlists: PlaylistClient;
+    artists: ArtistClient;
+    concerts: ConcertClient;
+    creditArtists: CreditArtistClient;
+    curators: CuratorClient;
+    genres: GenreClient;
+    lyrics: LyricsClient;
+    musicVideos: MusicVideoClient;
+    recordLabels: RecordLabelClient;
+    roleCategories: RoleCategoryClient;
+    songs: SongClient;
+    stations: StationClient;
+    stationGenres: StationGenreClient;
+    syllableLyrics: SyllableLyricsClient;
+    constructor(http: HttpClient, path: string);
+    search<const TTypes extends ResultShape<SearchCatalogResult>, const TScopes extends ResourceScopes = {}>(term: string, opts: ResultParams<SearchCatalogResult, TTypes, TScopes> & PaginationParams): Promise<ShapedResult<SearchCatalogResult, TTypes, TScopes>>;
+    searchHints(term: string, opts?: ConfigParm): Promise<string[]>;
+    getMany<const TScopes extends ResourceScopes = {}>(ids: Partial<Record<CatalogResourceTypes, string[]>>, opts?: DefaultParams<TScopes>): Promise<ResourceResponse<CatalogResources, TScopes>>;
+}
+export {};

package/dist/clients/catalog/index.js

@@ -0,0 +1,99 @@
+import { AlbumClient } from "../../clients/catalog/album.js";
+import { GenreClient } from "../../clients/catalog/genre.js";
+import { MusicVideoClient } from "../../clients/catalog/musicVideo.js";
+import { PlaylistClient } from "../../clients/catalog/playlist.js";
+import { SongClient } from "../../clients/catalog/song.js";
+import { StationClient } from "../../clients/catalog/station.js";
+import { StationGenreClient } from "../../clients/catalog/stationGenre.js";
+import { BaseResourceClient, createResourceClient } from "../../clients/resource.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+class ActivityClient extends createResourceClient("activities") {
+}
+class AppleCuratorClient extends createResourceClient("apple-curators") {
+}
+class ArtistClient extends createResourceClient("artists") {
+}
+class ConcertClient extends createResourceClient("concerts") {
+}
+class CreditArtistClient extends createResourceClient("credit-artists") {
+}
+class CuratorClient extends createResourceClient("curators") {
+}
+class LyricsClient extends createResourceClient("lyrics") {
+}
+class RecordLabelClient extends createResourceClient("record-labels") {
+}
+class RoleCategoryClient extends createResourceClient("role-categories") {
+}
+class SyllableLyricsClient extends createResourceClient("syllable-lyrics") {
+}
+export class CatalogClient extends BaseResourceClient {
+    http;
+    path;
+    activities;
+    albums;
+    appleCurators;
+    playlists;
+    artists;
+    concerts;
+    creditArtists;
+    curators;
+    genres;
+    lyrics;
+    musicVideos;
+    recordLabels;
+    roleCategories;
+    songs;
+    stations;
+    stationGenres;
+    syllableLyrics;
+    constructor(http, path) {
+        super(http, path);
+        this.http = http;
+        this.path = path;
+        this.activities = new ActivityClient(http, path);
+        this.albums = new AlbumClient(http, path);
+        this.appleCurators = new AppleCuratorClient(http, path);
+        this.playlists = new PlaylistClient(http, path);
+        this.artists = new ArtistClient(http, path);
+        this.concerts = new ConcertClient(http, path);
+        this.creditArtists = new CreditArtistClient(http, path);
+        this.curators = new CuratorClient(http, path);
+        this.genres = new GenreClient(http, path);
+        this.lyrics = new LyricsClient(http, path);
+        this.musicVideos = new MusicVideoClient(http, path);
+        this.recordLabels = new RecordLabelClient(http, path);
+        this.roleCategories = new RoleCategoryClient(http, path);
+        this.songs = new SongClient(http, path);
+        this.stations = new StationClient(http, path);
+        this.stationGenres = new StationGenreClient(http, path);
+        this.syllableLyrics = new SyllableLyricsClient(http, path);
+    }
+    async search(term, opts) {
+        const query = new RequestQueryBuilder().params(opts).setString("term", term);
+        const result = await this.http.request(`${this.path}/search`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepareResults(result);
+    }
+    async searchHints(term, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts).setString("term", term);
+        const result = await this.http.request(`${this.path}/search/hints`, {
+            config: opts.config,
+            query,
+        });
+        return result.results.terms;
+    }
+    async getMany(ids, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        for (const [key, value] of Object.entries(ids)) {
+            query.setStringArray("ids", value, key);
+        }
+        const result = await this.http.request(this.path, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+}

package/dist/clients/catalog/musicVideo.d.ts

@@ -0,0 +1,12 @@
+import { EquivalentClient } from "../../clients/shared/equivalent.js";
+import type { DefaultParams } from "../../types/params.js";
+import type { Registry } from "../../types/query/registry.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { ResourceScopes } from "../../types/query/scopes.js";
+declare const type: "music-videos";
+type TResource = Registry[typeof type];
+export declare class MusicVideoClient extends EquivalentClient<typeof type, TResource> {
+    protected readonly type: "music-videos";
+    getByIsrc<const TScopes extends ResourceScopes = {}>(isrc: string | string[], opts?: DefaultParams<TScopes>): Promise<ResourceResponse<import("../../types/public.js").CatalogMusicVideo, TScopes>>;
+}
+export {};

package/dist/clients/catalog/musicVideo.js

@@ -0,0 +1,14 @@
+import { EquivalentClient } from "../../clients/shared/equivalent.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+const type = "music-videos";
+export class MusicVideoClient extends EquivalentClient {
+    type = type;
+    async getByIsrc(isrc, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts).setStringArray("filter[isrc]", isrc);
+        const result = await this.http.request(`${this.path}/${this.type}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+}

package/dist/clients/catalog/playlist.d.ts

@@ -0,0 +1,12 @@
+import { ResourceClient } from "../../clients/resource.js";
+import type { DefaultParams } from "../../types/params.js";
+import type { Registry } from "../../types/query/registry.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { ResourceScopes } from "../../types/query/scopes.js";
+declare const type: "playlists";
+type TResource = Registry[typeof type];
+export declare class PlaylistClient extends ResourceClient<typeof type, TResource> {
+    protected readonly type: "playlists";
+    getByStorefrontChart<const TScopes extends ResourceScopes = {}>(chart: string | string[], opts?: DefaultParams<TScopes>): Promise<ResourceResponse<import("../../types/public.js").CatalogPlaylist, TScopes>>;
+}
+export {};

package/dist/clients/catalog/playlist.js

@@ -0,0 +1,16 @@
+import { ResourceClient } from "../../clients/resource.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+const type = "playlists";
+export class PlaylistClient extends ResourceClient {
+    type = type;
+    async getByStorefrontChart(chart, opts = {}) {
+        const query = new RequestQueryBuilder()
+            .params(opts)
+            .setStringArray("filter[storefront-chart]", chart);
+        const result = await this.http.request(`${this.path}/${this.type}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+}

package/dist/clients/catalog/song.d.ts

@@ -0,0 +1,12 @@
+import { EquivalentClient } from "../../clients/shared/equivalent.js";
+import type { DefaultParams } from "../../types/params.js";
+import type { Registry } from "../../types/query/registry.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { ResourceScopes } from "../../types/query/scopes.js";
+declare const type: "songs";
+type TResource = Registry[typeof type];
+export declare class SongClient extends EquivalentClient<typeof type, TResource> {
+    protected readonly type: "songs";
+    getByIsrc<const TScopes extends ResourceScopes = {}>(isrc: string | string[], opts?: DefaultParams<TScopes>): Promise<ResourceResponse<import("../../types/public.js").CatalogSong, TScopes>>;
+}
+export {};

package/dist/clients/catalog/song.js

@@ -0,0 +1,14 @@
+import { EquivalentClient } from "../../clients/shared/equivalent.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+const type = "songs";
+export class SongClient extends EquivalentClient {
+    type = type;
+    async getByIsrc(isrc, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts).setStringArray("filter[isrc]", isrc);
+        const result = await this.http.request(`${this.path}/${this.type}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+}

package/dist/clients/catalog/station.d.ts

@@ -0,0 +1,14 @@
+import { ResourceClient } from "../../clients/resource.js";
+import type { DefaultParams } from "../../types/params.js";
+import type { Registry } from "../../types/query/registry.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { ResourceScopes } from "../../types/query/scopes.js";
+declare const type: "stations";
+type TResource = Registry[typeof type];
+export declare class StationClient extends ResourceClient<typeof type, TResource> {
+    protected readonly type: "stations";
+    getFeaturedOnStorefront<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes>): Promise<ResourceResponse<import("../../types/public.js").CatalogStation, TScopes>>;
+    getPersonal<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes>): Promise<ResourceResponse<import("../../types/public.js").CatalogStation, TScopes>>;
+    getResourceStation<const TScopes extends ResourceScopes = {}>(resourceId: string, opts?: DefaultParams<TScopes>): Promise<ResourceResponse<import("../../types/public.js").CatalogStation, TScopes>>;
+}
+export {};

package/dist/clients/catalog/station.js

@@ -0,0 +1,34 @@
+import { ResourceClient } from "../../clients/resource.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+const type = "stations";
+export class StationClient extends ResourceClient {
+    type = type;
+    async getFeaturedOnStorefront(opts = {}) {
+        const query = new RequestQueryBuilder()
+            .params(opts)
+            .setStringArray("filter[featured]", "apple-music-live-radio");
+        const result = await this.http.request(`${this.path}/${this.type}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    async getPersonal(opts = {}) {
+        const query = new RequestQueryBuilder()
+            .params(opts)
+            .setStringArray("filter[identity]", "personal");
+        const result = await this.http.request(`${this.path}/${this.type}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    async getResourceStation(resourceId, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/${this.type}/ra.${resourceId}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+}

package/dist/clients/catalog/stationGenre.d.ts

@@ -0,0 +1,12 @@
+import { ResourceClient } from "../../clients/resource.js";
+import type { DefaultParams, PaginationParams } from "../../types/params.js";
+import type { Registry } from "../../types/query/registry.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { ResourceScopes } from "../../types/query/scopes.js";
+declare const type: "station-genres";
+type TResource = Registry[typeof type];
+export declare class StationGenreClient extends ResourceClient<typeof type, TResource> {
+    protected readonly type: "station-genres";
+    getAll<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & PaginationParams): Promise<ResourceResponse<import("../../types/public.js").CatalogStationGenre, TScopes>>;
+}
+export {};

package/dist/clients/catalog/stationGenre.js

@@ -0,0 +1,14 @@
+import { ResourceClient } from "../../clients/resource.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+const type = "station-genres";
+export class StationGenreClient extends ResourceClient {
+    type = type;
+    async getAll(opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/${this.type}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+}

package/dist/clients/library/index.d.ts

@@ -0,0 +1,39 @@
+import { LibraryPlaylistFolderClient } from "../../clients/library/playlistFolder.js";
+import { BaseResourceClient } from "../../clients/resource.js";
+import type { HttpClient } from "../../core/http.js";
+import type { LibraryResources, LibraryResourceTypes, PinnableResources, RecentlyAddedResources } from "../../types/combined.js";
+import type { DefaultParams, LimitParam, PaginationParams, ResultParams } from "../../types/params.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { ResultShape, ShapedResult } from "../../types/query/results.js";
+import type { ResourceScopes, ScopedResourceIterator } from "../../types/query/scopes.js";
+import type { SearchLibraryResult } from "../../types/results/search.js";
+declare const LibraryAlbumClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").LibraryResourceClient<"library-albums", import("../../types/public.js").LibraryAlbum>;
+declare class LibraryAlbumClient extends LibraryAlbumClient_base {
+}
+declare const LibraryArtistClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").LibraryResourceClient<"library-artists", import("../../types/public.js").LibraryArtist>;
+declare class LibraryArtistClient extends LibraryArtistClient_base {
+}
+declare const LibraryMusicVideoClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").LibraryResourceClient<"library-music-videos", import("../../types/public.js").LibraryMusicVideo>;
+declare class LibraryMusicVideoClient extends LibraryMusicVideoClient_base {
+}
+declare const LibraryPlaylistClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").LibraryResourceClient<"library-playlists", import("../../types/public.js").LibraryPlaylist>;
+declare class LibraryPlaylistClient extends LibraryPlaylistClient_base {
+}
+declare const LibrarySongClient_base: new (http: HttpClient, path: string) => import("../../clients/resource.js").LibraryResourceClient<"library-songs", import("../../types/public.js").LibrarySong>;
+declare class LibrarySongClient extends LibrarySongClient_base {
+}
+export declare class LibraryClient extends BaseResourceClient {
+    songs: LibrarySongClient;
+    albums: LibraryAlbumClient;
+    artists: LibraryArtistClient;
+    musicVideos: LibraryMusicVideoClient;
+    playlists: LibraryPlaylistClient;
+    playlistFolders: LibraryPlaylistFolderClient;
+    constructor(http: HttpClient, path: string);
+    getPins<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & LimitParam): Promise<ResourceResponse<PinnableResources, TScopes>>;
+    getRecentlyAdded<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & PaginationParams): Promise<ResourceResponse<RecentlyAddedResources, TScopes>>;
+    search<const TTypes extends ResultShape<SearchLibraryResult>, const TScopes extends ResourceScopes = {}>(term: string, opts: ResultParams<SearchLibraryResult, TTypes, TScopes> & PaginationParams): Promise<ShapedResult<SearchLibraryResult, TTypes, TScopes>>;
+    getMany<const TScopes extends ResourceScopes = {}>(ids: Partial<Record<LibraryResourceTypes, string[]>>, opts?: DefaultParams<TScopes>): Promise<ResourceResponse<LibraryResources, TScopes>>;
+    iterateRecentlyAdded<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & LimitParam): ScopedResourceIterator<RecentlyAddedResources, TScopes>;
+}
+export {};

package/dist/clients/library/index.js

@@ -0,0 +1,68 @@
+import { LibraryPlaylistFolderClient } from "../../clients/library/playlistFolder.js";
+import { BaseResourceClient, createLibraryResourceClient } from "../../clients/resource.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+class LibraryAlbumClient extends createLibraryResourceClient("albums") {
+}
+class LibraryArtistClient extends createLibraryResourceClient("artists") {
+}
+class LibraryMusicVideoClient extends createLibraryResourceClient("music-videos") {
+}
+class LibraryPlaylistClient extends createLibraryResourceClient("playlists") {
+}
+class LibrarySongClient extends createLibraryResourceClient("songs") {
+}
+export class LibraryClient extends BaseResourceClient {
+    songs;
+    albums;
+    artists;
+    musicVideos;
+    playlists;
+    playlistFolders;
+    constructor(http, path) {
+        super(http, path);
+        this.songs = new LibrarySongClient(http, path);
+        this.albums = new LibraryAlbumClient(http, path);
+        this.artists = new LibraryArtistClient(http, path);
+        this.musicVideos = new LibraryMusicVideoClient(http, path);
+        this.playlists = new LibraryPlaylistClient(http, path);
+        this.playlistFolders = new LibraryPlaylistFolderClient(http, path);
+    }
+    async getPins(opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/pins`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    async getRecentlyAdded(opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/recently-added`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    async search(term, opts) {
+        const query = new RequestQueryBuilder().params(opts).setString("term", term);
+        const result = await this.http.request(`${this.path}/search`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepareResults(result);
+    }
+    async getMany(ids, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        for (const [key, value] of Object.entries(ids)) {
+            query.setStringArray("ids", value, key);
+        }
+        const result = await this.http.request(this.path, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    iterateRecentlyAdded(opts = {}) {
+        return this.iterate((offset) => this.getRecentlyAdded({ ...opts, offset }));
+    }
+}

package/dist/clients/library/playlistFolder.d.ts

@@ -0,0 +1,12 @@
+import { ResourceClient } from "../../clients/resource.js";
+import type { DefaultParams } from "../../types/params.js";
+import type { Registry } from "../../types/query/registry.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { ResourceScopes } from "../../types/query/scopes.js";
+declare const type: "library-playlist-folders";
+type TResource = Registry[typeof type];
+export declare class LibraryPlaylistFolderClient extends ResourceClient<typeof type, TResource> {
+    protected readonly type = "playlist-folders";
+    getRoot<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes>): Promise<ResourceResponse<import("../../types/public.js").LibraryPlaylistFolder, TScopes>>;
+}
+export {};

package/dist/clients/library/playlistFolder.js

@@ -0,0 +1,16 @@
+import { ResourceClient } from "../../clients/resource.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+const type = "library-playlist-folders";
+export class LibraryPlaylistFolderClient extends ResourceClient {
+    type = "playlist-folders";
+    async getRoot(opts = {}) {
+        const query = new RequestQueryBuilder()
+            .params(opts)
+            .setStringArray("filter[identity]", "playlistsroot");
+        const result = await this.http.request(`${this.path}/${this.type}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+}

package/dist/clients/me/index.d.ts

@@ -0,0 +1,25 @@
+import { MusicSummaryClient } from "../../clients/me/musicSummary.js";
+import { RatingsClient } from "../../clients/me/ratings.js";
+import { RecentClient } from "../../clients/me/recent.js";
+import { RecommendationClient } from "../../clients/me/recommendation.js";
+import { StationClient } from "../../clients/me/station.js";
+import { BaseResourceClient } from "../../clients/resource.js";
+import type { HttpClient } from "../../core/http.js";
+import type { DefaultParams, LimitParam, PaginationParams } from "../../types/params.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { ResourceScopes, ScopedResourceIterator } from "../../types/query/scopes.js";
+import type { LibraryPlaylist } from "../../types/resources/library/playlist.js";
+import type { PersonalSocialProfile } from "../../types/resources/me/profile.js";
+import type { Storefront } from "../../types/resources/other/storefront.js";
+export declare class MeClient extends BaseResourceClient {
+    recommendations: RecommendationClient;
+    musicSummaries: MusicSummaryClient;
+    recent: RecentClient;
+    ratings: RatingsClient;
+    stations: StationClient;
+    constructor(http: HttpClient, path: string);
+    getStorefront<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes>): Promise<ResourceResponse<Storefront, TScopes>>;
+    getProfile<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes>): Promise<ResourceResponse<PersonalSocialProfile, TScopes>>;
+    getHeavyRotation<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & PaginationParams): Promise<ResourceResponse<LibraryPlaylist, TScopes>>;
+    iterateHeavyRotation<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & LimitParam): ScopedResourceIterator<LibraryPlaylist, TScopes>;
+}

package/dist/clients/me/index.js

@@ -0,0 +1,49 @@
+import { MusicSummaryClient } from "../../clients/me/musicSummary.js";
+import { RatingsClient } from "../../clients/me/ratings.js";
+import { RecentClient } from "../../clients/me/recent.js";
+import { RecommendationClient } from "../../clients/me/recommendation.js";
+import { StationClient } from "../../clients/me/station.js";
+import { BaseResourceClient } from "../../clients/resource.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+export class MeClient extends BaseResourceClient {
+    recommendations;
+    musicSummaries;
+    recent;
+    ratings;
+    stations;
+    constructor(http, path) {
+        super(http, path);
+        this.recommendations = new RecommendationClient(http, path);
+        this.musicSummaries = new MusicSummaryClient(http, path);
+        this.recent = new RecentClient(http, path);
+        this.ratings = new RatingsClient(http, path);
+        this.stations = new StationClient(http, path);
+    }
+    async getStorefront(opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/storefront`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    async getProfile(opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/social/profile`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    async getHeavyRotation(opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/history/heavy-rotation`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    iterateHeavyRotation(opts = {}) {
+        return this.iterate((offset) => this.getHeavyRotation({ ...opts, offset }));
+    }
+}