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

package/dist/clients/me/musicSummary.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: "music-summaries";
+type TResource = Registry[typeof type];
+export declare class MusicSummaryClient extends ResourceClient<typeof type, TResource> {
+    protected readonly type = "music-summaries";
+    getLatestReplay<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes>): Promise<ResourceResponse<import("../../types/public.js").MusicSummary, TScopes>>;
+}
+export {};

package/dist/clients/me/musicSummary.js

@@ -0,0 +1,14 @@
+import { ResourceClient } from "../../clients/resource.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+const type = "music-summaries";
+export class MusicSummaryClient extends ResourceClient {
+    type = "music-summaries";
+    async getLatestReplay(opts = {}) {
+        const query = new RequestQueryBuilder().params(opts).setStringArray("filter[year]", "latest");
+        const result = await this.http.request(`${this.path}/${this.type}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+}

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

@@ -0,0 +1,15 @@
+import { BaseResourceClient } from "../../clients/resource.js";
+import type { DefaultParams, LimitParam, PaginationParams } from "../../types/params.js";
+import type { ResourceOf } from "../../types/query/helpers.js";
+import type { RelationshipNames, TypeOf } from "../../types/query/resource.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { RelationshipItem, ResourceScopes, ScopedResourceIterator } from "../../types/query/scopes.js";
+import type { RatingResources } from "../../types/resources/me/rating.js";
+type TResource = ResourceOf<"ratings">;
+export declare class RatingsClient extends BaseResourceClient {
+    get<const TScopes extends ResourceScopes = {}>(id: string, type: TypeOf<RatingResources>, opts?: DefaultParams<TScopes>): Promise<ResourceResponse<import("../../types/resources/me/rating.js").Rating, TScopes>>;
+    getMany<const TScopes extends ResourceScopes = {}>(ids: string[], type: TypeOf<RatingResources>, opts?: DefaultParams<TScopes>): Promise<ResourceResponse<import("../../types/resources/me/rating.js").Rating, TScopes>>;
+    getRelationship<TRelationship extends RelationshipNames<TResource>, const TScopes extends ResourceScopes = {}>(id: string, type: TypeOf<RatingResources>, relationship: TRelationship, opts?: DefaultParams<TScopes> & PaginationParams): Promise<ResourceResponse<RelationshipItem<import("../../types/resources/me/rating.js").Rating, TRelationship>, TScopes>>;
+    iterateRelationship<TRelationship extends RelationshipNames<TResource>, const TScopes extends ResourceScopes = {}>(id: string, type: TypeOf<RatingResources>, relationship: TRelationship, opts?: DefaultParams<TScopes> & LimitParam): ScopedResourceIterator<RelationshipItem<TResource, TRelationship>, TScopes>;
+}
+export {};

package/dist/clients/me/ratings.js

@@ -0,0 +1,34 @@
+import { BaseResourceClient } from "../../clients/resource.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+export class RatingsClient extends BaseResourceClient {
+    async get(id, type, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/ratings/${type}/${id}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    async getMany(ids, type, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts).setStringArray("ids", ids);
+        const result = await this.http.request(`${this.path}/ratings/${type}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    async getRelationship(id, type, relationship, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/ratings/${type}/${id}/${relationship}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    iterateRelationship(id, type, relationship, opts = {}) {
+        return this.iterate((offset) => this.getRelationship(id, type, relationship, {
+            ...opts,
+            offset,
+        }));
+    }
+}

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

@@ -0,0 +1,17 @@
+import { BaseResourceClient } from "../../clients/resource.js";
+import type { DefaultParams, LimitParam, PaginationParams } from "../../types/params.js";
+import type { ResourceOf } from "../../types/query/helpers.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { ResourceScopes, ScopedResourceIterator } from "../../types/query/scopes.js";
+type RecentlyPlayedResource = ResourceOf<"albums" | "library-albums" | "playlists" | "library-playlists" | "stations">;
+type RecentlyPlayedTrackResource = ResourceOf<"songs" | "library-songs" | "music-videos" | "library-music-videos">;
+type RecentlyPlayedStationResource = ResourceOf<"stations">;
+export declare class RecentClient extends BaseResourceClient {
+    getRecentlyPlayed<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & PaginationParams): Promise<ResourceResponse<RecentlyPlayedResource, TScopes>>;
+    getRecentlyPlayedTracks<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & PaginationParams): Promise<ResourceResponse<RecentlyPlayedTrackResource, TScopes>>;
+    getRecentlyPlayedStations<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & PaginationParams): Promise<ResourceResponse<import("../../types/public.js").CatalogStation, TScopes>>;
+    iterateRecentlyPlayed<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & LimitParam): ScopedResourceIterator<RecentlyPlayedResource, TScopes>;
+    iterateRecentlyPlayedTracks<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & LimitParam): ScopedResourceIterator<RecentlyPlayedTrackResource, TScopes>;
+    iterateRecentlyPlayedStations<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & LimitParam): ScopedResourceIterator<RecentlyPlayedStationResource, TScopes>;
+}
+export {};

package/dist/clients/me/recent.js

@@ -0,0 +1,37 @@
+import { BaseResourceClient } from "../../clients/resource.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+export class RecentClient extends BaseResourceClient {
+    async getRecentlyPlayed(opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/recent/played`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    async getRecentlyPlayedTracks(opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/recent/played/tracks`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    async getRecentlyPlayedStations(opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/recent/radio-stations`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    iterateRecentlyPlayed(opts = {}) {
+        return this.iterate((offset) => this.getRecentlyPlayed({ ...opts, offset }));
+    }
+    iterateRecentlyPlayedTracks(opts = {}) {
+        return this.iterate((offset) => this.getRecentlyPlayedTracks({ ...opts, offset }));
+    }
+    iterateRecentlyPlayedStations(opts = {}) {
+        return this.iterate((offset) => this.getRecentlyPlayedStations({ ...opts, offset }));
+    }
+}

package/dist/clients/me/recommendation.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: "personal-recommendation";
+type TResource = Registry[typeof type];
+export declare class RecommendationClient extends ResourceClient<typeof type, TResource> {
+    protected readonly type = "recommendations";
+    getDefault<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & PaginationParams): Promise<ResourceResponse<import("../../types/public.js").Recommendation, TScopes>>;
+}
+export {};

package/dist/clients/me/recommendation.js

@@ -0,0 +1,14 @@
+import { ResourceClient } from "../../clients/resource.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+const type = "personal-recommendation";
+export class RecommendationClient extends ResourceClient {
+    type = "recommendations";
+    async getDefault(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/me/station.d.ts

@@ -0,0 +1,10 @@
+import { BaseResourceClient } from "../../clients/resource.js";
+import type { DefaultParams, LimitParam } from "../../types/params.js";
+import type { ResourceOf } from "../../types/query/helpers.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { ResourceScopes } from "../../types/query/scopes.js";
+type StationTrackResource = ResourceOf<"songs" | "music-videos">;
+export declare class StationClient extends BaseResourceClient {
+    getNextTracks<const TScopes extends ResourceScopes = {}>(id: string, opts?: DefaultParams<TScopes> & LimitParam): Promise<ResourceResponse<StationTrackResource, TScopes>>;
+}
+export {};

package/dist/clients/me/station.js

@@ -0,0 +1,13 @@
+import { BaseResourceClient } from "../../clients/resource.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+export class StationClient extends BaseResourceClient {
+    async getNextTracks(id, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/stations/next-tracks/${id}`, {
+            config: opts.config,
+            method: "POST",
+            query,
+        });
+        return this.prepare(result);
+    }
+}

package/dist/clients/playback.d.ts

@@ -0,0 +1,9 @@
+import type { HttpClient } from "../core/http.js";
+import type { ConfigParm } from "../types/params.js";
+import type { PlayActivityEvent, PlayActivityResponse, PlaybackSong, PlaybackSongIds } from "../types/playback.js";
+export declare class PlaybackClient {
+    private readonly http;
+    constructor(http: HttpClient);
+    getSong(ids: PlaybackSongIds, opts?: ConfigParm): Promise<PlaybackSong>;
+    reportPlayActivity(events: PlayActivityEvent | PlayActivityEvent[], opts?: ConfigParm): Promise<PlayActivityResponse>;
+}

package/dist/clients/playback.js

@@ -0,0 +1,68 @@
+const webPlaybackUrl = "https://play.music.apple.com/WebObjects/MZPlay.woa/wa/webPlayback";
+const playActivityUrl = "https://universal-activity-service.itunes.apple.com/play";
+export class PlaybackClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async getSong(ids, opts = {}) {
+        const catalogId = ids.catalogId?.trim();
+        const libraryId = ids.libraryId?.trim();
+        if (!catalogId && !libraryId) {
+            throw new Error("webPlayback requires a catalog or library ID.");
+        }
+        const response = await this.http.requestUrl(webPlaybackUrl, {
+            config: opts.config,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                ...(catalogId
+                    ? libraryId
+                        ? { subscriptionAdamId: catalogId }
+                        : { salableAdamId: catalogId }
+                    : {}),
+                ...(libraryId ? { universalLibraryId: libraryId } : {}),
+            }),
+        });
+        const song = response.songList?.[0];
+        if (!song) {
+            throw new Error(`webPlayback returned no songs${response.status === undefined ? "." : ` (status ${response.status}).`}`);
+        }
+        if (!song.assets?.length) {
+            throw new Error("webPlayback returned a song without assets.");
+        }
+        return song;
+    }
+    async reportPlayActivity(events, opts = {}) {
+        const data = Array.isArray(events) ? events : [events];
+        if (data.length === 0) {
+            throw new Error("Play activity reporting requires at least one event.");
+        }
+        return this.http.requestUrl(playActivityUrl, {
+            config: opts.config,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: ({ developerToken, userToken }) => {
+                if (!developerToken) {
+                    throw new Error("Play activity reporting requires a developer token.");
+                }
+                if (!userToken) {
+                    throw new Error("Play activity reporting requires a music user token.");
+                }
+                return JSON.stringify({
+                    client_id: "JSCLIENT",
+                    event_type: "JSPLAY",
+                    data: data.map((event) => ({
+                        ...event,
+                        "developer-token": developerToken,
+                        "user-token": userToken,
+                    })),
+                });
+            },
+        });
+    }
+}

package/dist/clients/resource.d.ts

@@ -0,0 +1,34 @@
+import type { HttpClient } from "../core/http.js";
+import type { DefaultParams, LimitParam, PaginationParams, SortParams } from "../types/params.js";
+import type { Registry } from "../types/query/registry.js";
+import type { AnyResource, RelationshipNames, ViewNames } from "../types/query/resource.js";
+import type { ResourceResponse } from "../types/query/response.js";
+import type { AnyResult, ResultShape, ShapedResult } from "../types/query/results.js";
+import type { RelationshipItem, ResourceScopes, ScopedResourceIterator, ViewItem } from "../types/query/scopes.js";
+type ResourceClientConstructor<TKey extends keyof Registry> = new (http: HttpClient, path: string) => ResourceClient<TKey>;
+type LibraryResourceClientConstructor<TKey extends keyof Registry> = new (http: HttpClient, path: string) => LibraryResourceClient<TKey>;
+export declare abstract class BaseResourceClient {
+    protected readonly http: HttpClient;
+    protected readonly path: string;
+    constructor(http: HttpClient, path: string);
+    protected prepare<TResource extends AnyResource, TScopes extends ResourceScopes = {}>(raw: ResourceResponse<TResource, TScopes>): ResourceResponse<TResource, TScopes>;
+    protected prepareResults<TResult extends AnyResult, TTypes extends ResultShape<TResult>, TScopes extends ResourceScopes = {}>(raw: ShapedResult<TResult, TTypes, TScopes>): ShapedResult<TResult, TTypes, TScopes>;
+    protected iterate<TResource extends AnyResource, const TScopes extends ResourceScopes = {}>(fetch: (offset: number) => Promise<ResourceResponse<TResource, TScopes>>): ScopedResourceIterator<TResource, TScopes>;
+}
+export declare abstract class ResourceClient<TKey extends keyof Registry, TResource extends Registry[TKey] = Registry[TKey]> extends BaseResourceClient {
+    protected readonly type: string;
+    constructor(http: HttpClient, path: string, type?: string);
+    get<const TScopes extends ResourceScopes = {}>(id: string, opts?: DefaultParams<TScopes>): Promise<ResourceResponse<TResource, TScopes>>;
+    getMany<const TScopes extends ResourceScopes = {}>(ids: string[], opts?: DefaultParams<TScopes>): Promise<ResourceResponse<TResource, TScopes>>;
+    getRelationship<TRelationship extends RelationshipNames<TResource>, const TScopes extends ResourceScopes = {}>(id: string, relationship: TRelationship, opts?: DefaultParams<TScopes> & PaginationParams): Promise<ResourceResponse<RelationshipItem<TResource, TRelationship>, TScopes>>;
+    getView<TView extends ViewNames<TResource>, const TScopes extends ResourceScopes = {}>(id: string, view: TView, opts?: DefaultParams<TScopes> & PaginationParams): Promise<ResourceResponse<ViewItem<TResource, TView>, TScopes>>;
+    iterateRelationship<TRelationship extends RelationshipNames<TResource>, const TScopes extends ResourceScopes = {}>(id: string, relationship: TRelationship, opts?: DefaultParams<TScopes> & LimitParam): ScopedResourceIterator<RelationshipItem<TResource, TRelationship>, TScopes>;
+    iterateView<TView extends ViewNames<TResource>, const TScopes extends ResourceScopes = {}>(id: string, view: TView, opts?: DefaultParams<TScopes> & LimitParam): ScopedResourceIterator<ViewItem<TResource, TView>, TScopes>;
+}
+export declare function createResourceClient<const TKey extends keyof Registry>(type: TKey): ResourceClientConstructor<TKey>;
+export declare abstract class LibraryResourceClient<TKey extends keyof Registry, TResource extends Registry[TKey] = Registry[TKey]> extends ResourceClient<TKey, TResource> {
+    getAll<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & PaginationParams & SortParams<"dateAdded" | "name">): Promise<ResourceResponse<TResource, TScopes>>;
+    iterateAll<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes> & LimitParam & SortParams<"dateAdded" | "name">): ScopedResourceIterator<TResource, TScopes>;
+}
+export declare function createLibraryResourceClient<const TKey extends keyof Registry>(type: string): LibraryResourceClientConstructor<TKey>;
+export {};

package/dist/clients/resource.js

@@ -0,0 +1,105 @@
+import { RequestQueryBuilder } from "../helpers/requestQuery.js";
+export class BaseResourceClient {
+    http;
+    path;
+    constructor(http, path) {
+        this.http = http;
+        this.path = path;
+    }
+    prepare(raw) {
+        return raw;
+    }
+    prepareResults(raw) {
+        return raw;
+    }
+    async *iterate(fetch) {
+        let page = await fetch(0);
+        while (true) {
+            yield* page.data;
+            if (!page.next)
+                break;
+            const offsetValue = new URL(page.next, "https://music.apple.com").searchParams.get("offset");
+            if (!offsetValue)
+                break;
+            const offset = Number(offsetValue);
+            if (Number.isNaN(offset))
+                break;
+            page = await fetch(offset);
+        }
+    }
+}
+export class ResourceClient extends BaseResourceClient {
+    type;
+    constructor(http, path, type = "") {
+        super(http, path);
+        this.type = type;
+    }
+    async get(id, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/${this.type}/${id}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    async getMany(ids, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts).setStringArray("ids", ids);
+        const result = await this.http.request(`${this.path}/${this.type}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    async getRelationship(id, relationship, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/${this.type}/${id}/${relationship}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    async getView(id, view, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts);
+        const result = await this.http.request(`${this.path}/${this.type}/${id}/view/${view}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    iterateRelationship(id, relationship, opts = {}) {
+        return this.iterate((offset) => this.getRelationship(id, relationship, {
+            ...opts,
+            offset,
+        }));
+    }
+    iterateView(id, view, opts = {}) {
+        return this.iterate((offset) => this.getView(id, view, { ...opts, offset }));
+    }
+}
+export function createResourceClient(type) {
+    return class extends ResourceClient {
+        constructor(http, path) {
+            super(http, path, type);
+        }
+    };
+}
+export class LibraryResourceClient extends ResourceClient {
+    async getAll(opts = {}) {
+        const query = new RequestQueryBuilder().params(opts).setString("sort", opts.sort);
+        const result = await this.http.request(`${this.path}/${this.type}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+    iterateAll(opts = {}) {
+        return this.iterate((offset) => this.getAll({ ...opts, offset }));
+    }
+}
+export function createLibraryResourceClient(type) {
+    return class extends LibraryResourceClient {
+        constructor(http, path) {
+            super(http, path, type);
+        }
+    };
+}

package/dist/clients/shared/equivalent.d.ts

@@ -0,0 +1,10 @@
+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";
+export declare abstract class EquivalentClient<TKey extends keyof Registry, TResource extends Registry[TKey] = Registry[TKey]> extends ResourceClient<TKey, TResource> {
+    getEquivalents<const TScopes extends ResourceScopes = {}>(ids: string | string[], opts?: DefaultParams<TScopes> & {
+        restrict?: ["explicit"];
+    }): Promise<ResourceResponse<TResource, TScopes>>;
+}

package/dist/clients/shared/equivalent.js

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

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

@@ -0,0 +1,7 @@
+import { BaseResourceClient } from "../../clients/resource.js";
+import { SocialProfileClient } from "../../clients/social/profile.js";
+import type { HttpClient } from "../../core/http.js";
+export declare class SocialClient extends BaseResourceClient {
+    profiles: SocialProfileClient;
+    constructor(http: HttpClient, path: string);
+}

package/dist/clients/social/index.js

@@ -0,0 +1,9 @@
+import { BaseResourceClient } from "../../clients/resource.js";
+import { SocialProfileClient } from "../../clients/social/profile.js";
+export class SocialClient extends BaseResourceClient {
+    profiles;
+    constructor(http, path) {
+        super(http, path);
+        this.profiles = new SocialProfileClient(http, path);
+    }
+}

package/dist/clients/social/profile.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: "social-profiles";
+type TResource = Registry[typeof type];
+export declare class SocialProfileClient extends ResourceClient<typeof type, TResource> {
+    protected readonly type: "social-profiles";
+    getByHandle<const TScopes extends ResourceScopes = {}>(handles: string | string[], opts?: DefaultParams<TScopes>): Promise<ResourceResponse<import("../../types/resources/me/profile.js").SocialProfile, TScopes>>;
+}
+export {};

package/dist/clients/social/profile.js

@@ -0,0 +1,14 @@
+import { ResourceClient } from "../../clients/resource.js";
+import { RequestQueryBuilder } from "../../helpers/requestQuery.js";
+const type = "social-profiles";
+export class SocialProfileClient extends ResourceClient {
+    type = type;
+    async getByHandle(handles, opts = {}) {
+        const query = new RequestQueryBuilder().params(opts).setStringArray("filter[handle]", handles);
+        const result = await this.http.request(`${this.path}/${this.type}`, {
+            config: opts.config,
+            query,
+        });
+        return this.prepare(result);
+    }
+}

package/dist/clients/storefront.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: "storefronts";
+type TResource = Registry[typeof type];
+export declare class StorefrontClient extends ResourceClient<typeof type, TResource> {
+    protected readonly type = "storefronts";
+    getAll<const TScopes extends ResourceScopes = {}>(opts?: DefaultParams<TScopes>): Promise<ResourceResponse<import("../types/public.js").Storefront, TScopes>>;
+}
+export {};

package/dist/clients/storefront.js

@@ -0,0 +1,14 @@
+import { ResourceClient } from "../clients/resource.js";
+import { RequestQueryBuilder } from "../helpers/requestQuery.js";
+const type = "storefronts";
+export class StorefrontClient extends ResourceClient {
+    type = "storefronts";
+    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/core/client.d.ts

@@ -0,0 +1,40 @@
+import { CatalogClient } from "../clients/catalog/index.js";
+import { LibraryClient } from "../clients/library/index.js";
+import { MeClient } from "../clients/me/index.js";
+import { PlaybackClient } from "../clients/playback.js";
+import { SocialClient } from "../clients/social/index.js";
+import { StorefrontClient } from "../clients/storefront.js";
+import { HttpClient } from "../core/http.js";
+import type { OpfelMusigConfig } from "../types/config.js";
+import type { ConfigParm } from "../types/params.js";
+export declare class OpfelMusigClient {
+    http: HttpClient;
+    catalog: CatalogClient;
+    library: LibraryClient;
+    storefront: StorefrontClient;
+    me: MeClient;
+    social: SocialClient;
+    playback: PlaybackClient;
+    private readonly apiVersion;
+    test(opts?: ConfigParm): Promise<void>;
+    /**
+     * Use the logged in users default `storefront` and `language`.
+     */
+    useUserDefault(opts?: ConfigParm): Promise<(Pick<import("../types/resources/other/storefront.js").StorefrontAttributes, keyof import("../types/resources/other/storefront.js").StorefrontAttributes> & Pick<{}, never>) | undefined>;
+    /**
+     * Set the language from a language tag like `de-CH`
+     */
+    setLanguageFromTag(language?: string): void;
+    /**
+     * For each key:
+     * - `T`: use the new value
+     * - `undefined`: use the old value
+     * - `null`: delete the value
+     */
+    edit: typeof this.http.edit;
+    get config(): {
+        storefront: string | undefined;
+        language: import("../types/config.js").LanguageConfig | undefined;
+    };
+    constructor(config?: OpfelMusigConfig);
+}

package/dist/core/client.js

@@ -0,0 +1,82 @@
+import { CatalogClient } from "../clients/catalog/index.js";
+import { LibraryClient } from "../clients/library/index.js";
+import { MeClient } from "../clients/me/index.js";
+import { PlaybackClient } from "../clients/playback.js";
+import { SocialClient } from "../clients/social/index.js";
+import { StorefrontClient } from "../clients/storefront.js";
+import { HttpClient } from "../core/http.js";
+import { lyricScriptFromLanguage } from "../helpers/language.js";
+export class OpfelMusigClient {
+    http;
+    catalog;
+    library;
+    storefront;
+    me;
+    social;
+    playback;
+    apiVersion = "v1";
+    async test(opts = {}) {
+        await this.http.request(`${this.apiVersion}/test`, {
+            config: opts.config,
+        });
+    }
+    /**
+     * Use the logged in users default `storefront` and `language`.
+     */
+    async useUserDefault(opts = {}) {
+        const storefront = await this.me.getStorefront({
+            config: opts.config,
+        });
+        const userDefaultStorefront = storefront.data[0];
+        if (!userDefaultStorefront)
+            throw new Error("Apple Music API returned no user storefront");
+        this.edit({
+            storefront: userDefaultStorefront.id,
+        });
+        const language = userDefaultStorefront.attributes?.defaultLanguageTag;
+        if (language) {
+            this.edit({
+                language: {
+                    default: language,
+                    lyrics: language,
+                    script: lyricScriptFromLanguage(language),
+                },
+            });
+        }
+        return userDefaultStorefront.attributes;
+    }
+    /**
+     * Set the language from a language tag like `de-CH`
+     */
+    setLanguageFromTag(language) {
+        if (language) {
+            this.edit({
+                language: {
+                    default: language,
+                    lyrics: language,
+                    script: lyricScriptFromLanguage(language),
+                },
+            });
+        }
+    }
+    /**
+     * For each key:
+     * - `T`: use the new value
+     * - `undefined`: use the old value
+     * - `null`: delete the value
+     */
+    edit;
+    get config() {
+        return this.http.conf;
+    }
+    constructor(config = {}) {
+        this.http = new HttpClient(config);
+        this.edit = this.http.edit;
+        this.catalog = new CatalogClient(this.http, `${this.apiVersion}/catalog/{{storefront}}`);
+        this.library = new LibraryClient(this.http, `${this.apiVersion}/me/library`);
+        this.me = new MeClient(this.http, `${this.apiVersion}/me`);
+        this.storefront = new StorefrontClient(this.http, this.apiVersion);
+        this.social = new SocialClient(this.http, `${this.apiVersion}/social/{{storefront}}`);
+        this.playback = new PlaybackClient(this.http);
+    }
+}