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

package/dist/types/query/registry.d.ts

@@ -0,0 +1,74 @@
+import type { CatalogActivity } from "../../types/resources/catalog/activity.js";
+import type { CatalogAlbum } from "../../types/resources/catalog/album.js";
+import type { CatalogArtist } from "../../types/resources/catalog/artist.js";
+import type { CatalogConcert } from "../../types/resources/catalog/concert.js";
+import type { CatalogCreditArtist } from "../../types/resources/catalog/creditArtist.js";
+import type { CatalogAppleCurator, CatalogCurator } from "../../types/resources/catalog/curator.js";
+import type { CatalogGenre } from "../../types/resources/catalog/genre.js";
+import type { CatalogLyrics } from "../../types/resources/catalog/lyrics.js";
+import type { CatalogMusicVideo } from "../../types/resources/catalog/musicVideo.js";
+import type { CatalogPlaylist } from "../../types/resources/catalog/playlist.js";
+import type { CatalogRecordLabel } from "../../types/resources/catalog/recordLabel.js";
+import type { CatalogRoleCategory } from "../../types/resources/catalog/roleCategory.js";
+import type { CatalogSong } from "../../types/resources/catalog/song.js";
+import type { CatalogStation } from "../../types/resources/catalog/station.js";
+import type { CatalogStationGenre } from "../../types/resources/catalog/stationGenre.js";
+import type { CatalogSyllableLyrics } from "../../types/resources/catalog/syllableLyrics.js";
+import type { CatalogVenue } from "../../types/resources/catalog/venue.js";
+import type { LibraryAlbum } from "../../types/resources/library/album.js";
+import type { LibraryArtist } from "../../types/resources/library/artist.js";
+import type { LibraryMusicVideo } from "../../types/resources/library/musicVideo.js";
+import type { LibraryPlaylist } from "../../types/resources/library/playlist.js";
+import type { LibraryPlaylistFolder } from "../../types/resources/library/playlistFolder.js";
+import type { LibrarySong } from "../../types/resources/library/song.js";
+import type { MusicSummary } from "../../types/resources/me/musicSummary.js";
+import type { PersonalSocialProfile, SocialProfile } from "../../types/resources/me/profile.js";
+import type { Rating } from "../../types/resources/me/rating.js";
+import type { Recommendation } from "../../types/resources/me/recommendation.js";
+import type { AlbumPeriodSummary } from "../../types/resources/me/summaries/albumPeriodSummary.js";
+import type { ArtistPeriodSummary } from "../../types/resources/me/summaries/artistPeriodSummary.js";
+import type { GenrePeriodSummary } from "../../types/resources/me/summaries/genrePeriodSummary.js";
+import type { MonthlySongPeriodSummary } from "../../types/resources/me/summaries/monthlySongPeriodSummary.js";
+import type { PlaylistPeriodSummary } from "../../types/resources/me/summaries/playlistPeriodSummary.js";
+import type { SongPeriodSummary } from "../../types/resources/me/summaries/songPeriodSummary.js";
+import type { StationPeriodSummary } from "../../types/resources/me/summaries/stationPeriodSummary.js";
+import type { Storefront } from "../../types/resources/other/storefront.js";
+export type Registry = {
+    activities: CatalogActivity;
+    albums: CatalogAlbum;
+    "apple-curators": CatalogAppleCurator;
+    artists: CatalogArtist;
+    concerts: CatalogConcert;
+    "credit-artists": CatalogCreditArtist;
+    curators: CatalogCurator;
+    genres: CatalogGenre;
+    lyrics: CatalogLyrics;
+    "music-videos": CatalogMusicVideo;
+    playlists: CatalogPlaylist;
+    "record-labels": CatalogRecordLabel;
+    "role-categories": CatalogRoleCategory;
+    songs: CatalogSong;
+    stations: CatalogStation;
+    "station-genres": CatalogStationGenre;
+    "syllable-lyrics": CatalogSyllableLyrics;
+    venues: CatalogVenue;
+    "library-albums": LibraryAlbum;
+    "library-artists": LibraryArtist;
+    "library-music-videos": LibraryMusicVideo;
+    "library-playlist-folders": LibraryPlaylistFolder;
+    "library-playlists": LibraryPlaylist;
+    "library-songs": LibrarySong;
+    "personal-recommendation": Recommendation;
+    ratings: Rating;
+    "personal-social-profiles": PersonalSocialProfile;
+    storefronts: Storefront;
+    "music-summaries": MusicSummary;
+    "album-period-summaries": AlbumPeriodSummary;
+    "genre-period-summaries": GenrePeriodSummary;
+    "monthly-song-period-summaries": MonthlySongPeriodSummary;
+    "playlist-period-summaries": PlaylistPeriodSummary;
+    "song-period-summaries": SongPeriodSummary;
+    "station-period-summaries": StationPeriodSummary;
+    "artist-period-summaries": ArtistPeriodSummary;
+    "social-profiles": SocialProfile;
+};

package/dist/types/query/resource.d.ts

@@ -0,0 +1,29 @@
+import type { Registry } from "../../types/query/registry.js";
+export interface Collection<TData> {
+    href?: string;
+    next?: string;
+    data: TData[];
+    meta?: Record<string, unknown>;
+}
+export interface ResourceRef<TType extends keyof Registry = keyof Registry> {
+    id: string;
+    type: TType;
+    href?: string;
+}
+export interface Resource<TType extends keyof Registry, TAttributes extends object = {}, TExtendables extends object = {}, TRelationships extends Record<string, AnyResource> = {}, TViews extends Record<string, AnyResource> = {}> extends ResourceRef<TType> {
+    attributes?: TAttributes;
+    extendables?: TExtendables;
+    relationships?: TRelationships;
+    views?: TViews;
+}
+export type AnyResource = Resource<keyof Registry>;
+export type TypeOf<TResource extends AnyResource> = TResource["type"];
+export type AttributesOf<TResource extends AnyResource> = NonNullable<TResource["attributes"]>;
+export type ExtendablesOf<TResource extends AnyResource> = NonNullable<TResource["extendables"]>;
+export type RelationshipsOf<TResource extends AnyResource> = NonNullable<TResource["relationships"]>;
+export type ViewsOf<TResource extends AnyResource> = NonNullable<TResource["views"]>;
+export type AttributeNames<TResource extends AnyResource> = Extract<keyof AttributesOf<TResource>, string>;
+export type ExtendableNames<TResource extends AnyResource> = Extract<keyof ExtendablesOf<TResource>, string>;
+export type RelationshipNames<TResource extends AnyResource> = Extract<keyof RelationshipsOf<TResource>, string>;
+export type ViewNames<TResource extends AnyResource> = Extract<keyof ViewsOf<TResource>, string>;
+export type ResourceLink<TResource extends AnyResource> = ResourceRef<TypeOf<TResource>>;

package/dist/types/query/response.d.ts

@@ -0,0 +1,3 @@
+import type { AnyResource, Collection } from "../../types/query/resource.js";
+import type { ResourceScopes, ScopedResource } from "../../types/query/scopes.js";
+export type ResourceResponse<TRoot extends AnyResource, TScopes extends ResourceScopes = {}> = Collection<ScopedResource<TRoot, TScopes>>;

package/dist/types/query/results.d.ts

@@ -0,0 +1,45 @@
+import type { RequiredProps } from "../../types/query/helpers.js";
+import type { AnyResource } from "../../types/query/resource.js";
+import type { ResourceResponse } from "../../types/query/response.js";
+import type { ResourceScopes } from "../../types/query/scopes.js";
+export interface Result<TTypes extends Record<string, AnyResource> = {}, TWith extends Record<string, AnyResource> = {}, TMap extends Partial<Record<keyof TTypes | keyof TWith, string>> = {}> {
+    types: TTypes;
+    with: TWith;
+    map: TMap;
+}
+export type AnyResult = Result<{}, {}, {}>;
+export type TypesOf<TResult extends AnyResult> = NonNullable<TResult["types"]>;
+export type WithOf<TResult extends AnyResult> = NonNullable<TResult["with"]>;
+export type MapOf<TResult extends AnyResult> = NonNullable<TResult["map"]>;
+export type TypesNames<TResult extends AnyResult> = Extract<keyof TypesOf<TResult>, string>;
+export type WithNames<TResult extends AnyResult> = Extract<keyof WithOf<TResult>, string>;
+export type MapNames<TResult extends AnyResult> = Extract<keyof MapOf<TResult>, string>;
+export type TypesItem<TResult extends AnyResult, K extends TypesNames<TResult>> = Extract<TypesOf<TResult>[K], AnyResource>;
+export type WithItem<TResult extends AnyResult, K extends WithNames<TResult>> = Extract<WithOf<TResult>[K], AnyResource>;
+export type ResultShape<TResult extends AnyResult> = {
+    types: readonly [TypesNames<TResult>, ...TypesNames<TResult>[]];
+} & ([WithNames<TResult>] extends [never] ? {} : {
+    with?: readonly WithNames<TResult>[];
+});
+export declare const internalTypesSymbol: unique symbol;
+export declare const internalWithSymbol: unique symbol;
+type ArrayPropItem<TShape, K extends PropertyKey> = TShape extends {
+    [P in K]?: readonly (infer U)[];
+} ? U : never;
+type SelectedTypes<TResult extends AnyResult, TShape extends ResultShape<TResult>> = Extract<ArrayPropItem<TShape, "types">, TypesNames<TResult>>;
+type SelectedWith<TResult extends AnyResult, TShape extends ResultShape<TResult>> = Extract<ArrayPropItem<TShape, "with">, WithNames<TResult>>;
+type ShapedTypes<TResult extends AnyResult, TShape extends ResultShape<TResult>> = RequiredProps<TypesOf<TResult>, SelectedTypes<TResult, TShape>>;
+type ShapedWith<TResult extends AnyResult, TShape extends ResultShape<TResult>> = RequiredProps<WithOf<TResult>, SelectedWith<TResult, TShape>>;
+type ShapedCombined<TResult extends AnyResult, TShape extends ResultShape<TResult>> = ShapedTypes<TResult, TShape> & ShapedWith<TResult, TShape>;
+type ShapedResults<TResult extends AnyResult, TShape extends ResultShape<TResult>, TScopes extends ResourceScopes = {}> = {
+    [K in keyof ShapedCombined<TResult, TShape> as K extends keyof MapOf<TResult> ? Extract<MapOf<TResult>[K], string> : K]: ResourceResponse<Extract<ShapedCombined<TResult, TShape>[K], AnyResource>, TScopes>;
+};
+export type ShapedResult<TResult extends AnyResult, TShape extends ResultShape<TResult>, TScopes extends ResourceScopes = {}> = {
+    meta: Record<string, unknown>;
+    results: ShapedResults<TResult, TShape, TScopes>;
+    [internalTypesSymbol]?: ShapedTypes<TResult, TShape>;
+    [internalWithSymbol]?: ShapedWith<TResult, TShape>;
+};
+export type AnyShapedResult = ShapedResult<AnyResult, ResultShape<AnyResult>, ResourceScopes>;
+export type ResultsOf<TShaped extends AnyShapedResult> = TShaped["results"];
+export {};

package/dist/types/query/scopes.d.ts

@@ -0,0 +1,77 @@
+import type { RequiredProps } from "../../types/query/helpers.js";
+import type { Registry } from "../../types/query/registry.js";
+import type { AnyResource, AttributeNames, AttributesOf, Collection, ExtendableNames, ExtendablesOf, RelationshipNames, RelationshipsOf, ResourceLink, TypeOf, ViewNames, ViewsOf } from "../../types/query/resource.js";
+export type RelationshipItem<TResource extends AnyResource, K extends RelationshipNames<TResource>> = Extract<RelationshipsOf<TResource>[K], AnyResource>;
+export type ViewItem<TResource extends AnyResource, K extends ViewNames<TResource>> = Extract<ViewsOf<TResource>[K], AnyResource>;
+type RelationshipMode = "include" | "relate";
+type RelationshipSelection = RelationshipMode | {
+    mode: RelationshipMode;
+    limit?: number;
+};
+type RelationshipSelections<TResource extends AnyResource> = Partial<Record<RelationshipNames<TResource>, RelationshipSelection>>;
+type ViewSelection = boolean | {
+    limit: number;
+};
+type ViewSelections<TResource extends AnyResource> = Partial<Record<ViewNames<TResource>, ViewSelection>>;
+type ResourceScope<TResource extends AnyResource> = {
+    fields?: readonly AttributeNames<TResource>[];
+    relationships?: RelationshipSelections<TResource>;
+} & ([ExtendableNames<TResource>] extends [never] ? {} : {
+    extend?: readonly ExtendableNames<TResource>[];
+}) & ([ViewNames<TResource>] extends [never] ? {} : {
+    /** Views are only returned when this resource is the root resource. */
+    views?: ViewSelections<TResource>;
+});
+export type ResourceScopes = Partial<{
+    [K in Extract<keyof Registry, string>]: ResourceScope<Registry[K]>;
+}>;
+export type ScopeFor<TResource extends AnyResource, TScopes extends ResourceScopes = {}> = TypeOf<TResource> extends keyof TScopes ? TScopes[TypeOf<TResource>] : {};
+type RelationshipSelectionValue<TResource extends AnyResource, PScope, K extends RelationshipNames<TResource>> = PScope extends {
+    relationships?: infer TRelationships;
+} ? K extends keyof TRelationships ? TRelationships[K] : never : never;
+type RelationshipSelectionMode<TResource extends AnyResource, PScope, K extends RelationshipNames<TResource>> = RelationshipSelectionValue<TResource, PScope, K> extends {
+    mode: infer TMode;
+} ? Extract<TMode, RelationshipMode> : Extract<RelationshipSelectionValue<TResource, PScope, K>, RelationshipMode>;
+type RelationshipKeysByMode<TResource extends AnyResource, PScope, TMode extends RelationshipMode> = {
+    [K in RelationshipNames<TResource>]: Extract<RelationshipSelectionMode<TResource, PScope, K>, TMode> extends never ? never : K;
+}[RelationshipNames<TResource>];
+export type SelectedRelationshipKeys<TResource extends AnyResource, PScope> = RelationshipKeysByMode<TResource, PScope, RelationshipMode>;
+export type IncludedRelationshipKeys<TResource extends AnyResource, PScope> = RelationshipKeysByMode<TResource, PScope, "include">;
+export type IncludedViewKeys<TResource extends AnyResource, PScope> = SelectedViewKeys<TResource, PScope>;
+export type SelectedViewKeys<TResource extends AnyResource, PScope> = PScope extends {
+    views?: infer TViews;
+} ? {
+    [K in ViewNames<TResource>]: K extends keyof TViews ? TViews[K] extends false | undefined ? never : K : never;
+}[ViewNames<TResource>] : never;
+type ArrayPropItem<PScope, K extends PropertyKey> = PScope extends {
+    [P in K]?: readonly (infer U)[];
+} ? U : never;
+type SelectedFields<TResource extends AnyResource, PScope> = [
+    Extract<ArrayPropItem<PScope, "fields">, AttributeNames<TResource>>
+] extends [never] ? AttributeNames<TResource> : Extract<ArrayPropItem<PScope, "fields">, AttributeNames<TResource>>;
+type SelectedExtendables<TResource extends AnyResource, PScope> = Extract<ArrayPropItem<PScope, "extend">, ExtendableNames<TResource>>;
+type ScopedRelationshipItem<TResource extends AnyResource, PScope, K extends RelationshipNames<TResource>> = (Extract<RelationshipSelectionMode<TResource, PScope, K>, "include"> extends never ? never : RelationshipItem<TResource, K>) | (Extract<RelationshipSelectionMode<TResource, PScope, K>, "relate"> extends never ? never : ResourceLink<RelationshipItem<TResource, K>>);
+type ScopedRelationships<TResource extends AnyResource, TScopes extends ResourceScopes = {}> = {
+    relationships?: {
+        [K in SelectedRelationshipKeys<TResource, ScopeFor<TResource, TScopes>>]: Collection<ScopedResource<ScopedRelationshipItem<TResource, ScopeFor<TResource, TScopes>, K>, TScopes>>;
+    };
+};
+type ScopedViews<TResource extends AnyResource, TScopes extends ResourceScopes = {}> = {
+    views?: {
+        [K in SelectedViewKeys<TResource, ScopeFor<TResource, TScopes>>]: Collection<ScopedResource<ViewItem<TResource, K>, TScopes>>;
+    };
+};
+type ScopedFields<TResource extends AnyResource, PScope> = Pick<AttributesOf<TResource>, SelectedFields<TResource, PScope>> & Pick<ExtendablesOf<TResource>, SelectedExtendables<TResource, PScope>>;
+type ScopedAttributes<TResource extends AnyResource, PScope> = RequiredProps<AttributesOf<TResource>, SelectedFields<TResource, PScope>>;
+type ScopedExtendables<TResource extends AnyResource, PScope> = RequiredProps<ExtendablesOf<TResource>, SelectedExtendables<TResource, PScope>>;
+export declare const internalAttributesSymbol: unique symbol;
+export declare const internalExtendablesSymbol: unique symbol;
+type ScopedResourceItem<TResource extends AnyResource, TScopes extends ResourceScopes = {}> = ResourceLink<TResource> & {
+    attributes?: ScopedFields<TResource, ScopeFor<TResource, TScopes>>;
+    [internalAttributesSymbol]?: ScopedAttributes<TResource, ScopeFor<TResource, TScopes>>;
+    [internalExtendablesSymbol]?: ScopedExtendables<TResource, ScopeFor<TResource, TScopes>>;
+} & ScopedRelationships<TResource, TScopes> & ScopedViews<TResource, TScopes>;
+export type ScopedResource<TResource extends AnyResource, TScopes extends ResourceScopes = {}> = TResource extends AnyResource ? ScopedResourceItem<TResource, TScopes> : never;
+export type ScopedResourceOf<TKey extends keyof Registry, TScopes extends ResourceScopes = {}> = ScopedResource<Registry[TKey], TScopes>;
+export type ScopedResourceIterator<TResource extends AnyResource, TScopes extends ResourceScopes = {}> = AsyncGenerator<ScopedResource<TResource, TScopes>, void, unknown>;
+export {};

package/dist/types/request.d.ts

@@ -0,0 +1,14 @@
+import type { RequestQueryBuilder } from "../helpers/requestQuery.js";
+import type { RequestConfig } from "../types/config.js";
+export interface OpfelMusigHttpRequest {
+    body?: BodyInit | null | ((tokens: HeaderConfig) => BodyInit | null);
+    config?: RequestConfig;
+    headers?: Record<string, string>;
+    method?: "GET" | "POST";
+    query?: RequestQueryBuilder;
+}
+export interface HeaderConfig {
+    developerToken?: string | null;
+    userToken?: string | null;
+    excludeOrigin?: boolean;
+}

package/dist/types/resources/catalog/activity.d.ts

@@ -0,0 +1,15 @@
+import type { Resource } from "../../../types/query/resource.js";
+import type { CatalogPlaylist } from "../../../types/resources/catalog/playlist.js";
+import type { Artwork, EditorialNote } from "../../../types/shared.js";
+interface CatalogActivityAttributes {
+    artwork: Artwork;
+    editorialNotes?: EditorialNote;
+    name: string;
+    url: string;
+}
+interface CatalogActivityExtend {
+}
+export type CatalogActivity = Resource<"activities", CatalogActivityAttributes, CatalogActivityExtend, {
+    playlists: CatalogPlaylist;
+}>;
+export {};

package/dist/types/resources/catalog/album.d.ts

@@ -0,0 +1,47 @@
+import type { Resource } from "../../../types/query/resource.js";
+import type { CatalogArtist } from "../../../types/resources/catalog/artist.js";
+import type { CatalogGenre } from "../../../types/resources/catalog/genre.js";
+import type { CatalogMusicVideo } from "../../../types/resources/catalog/musicVideo.js";
+import type { CatalogPlaylist } from "../../../types/resources/catalog/playlist.js";
+import type { CatalogRecordLabel } from "../../../types/resources/catalog/recordLabel.js";
+import type { CatalogSong } from "../../../types/resources/catalog/song.js";
+import type { CatalogStation } from "../../../types/resources/catalog/station.js";
+import type { LibraryAlbum } from "../../../types/resources/library/album.js";
+import type { BaseAlbumAttributes } from "../../../types/resources/shared/album.js";
+import type { AssetUrls, AudioVariants, EditorialArtwork, EditorialNote, EditorialVideo, RatingValue } from "../../../types/shared.js";
+interface CatalogAlbumAttributes extends BaseAlbumAttributes {
+    copyright?: string;
+    editorialNotes?: EditorialNote;
+    isMasteredForItunes: boolean;
+    isSingle: boolean;
+    isCompilation: boolean;
+    isComplete: boolean;
+    isPrerelease: boolean;
+    recordLabel?: string;
+    audioTraits?: AudioVariants[];
+    upc?: string;
+    url: string;
+}
+interface CatalogAlbumExtend {
+    artistUrl?: string;
+    editorialVideo?: EditorialVideo;
+    editorialArtwork?: EditorialArtwork;
+    personalRating?: RatingValue;
+    extendedAssetUrls?: AssetUrls;
+}
+export type CatalogAlbum = Resource<"albums", CatalogAlbumAttributes, CatalogAlbumExtend, {
+    artists: CatalogArtist;
+    genres: CatalogGenre;
+    library: LibraryAlbum;
+    "record-labels": CatalogRecordLabel;
+    tracks: CatalogSong | CatalogMusicVideo;
+}, {
+    "appears-on": CatalogPlaylist;
+    "audio-extras": CatalogStation;
+    "more-by-artist": CatalogAlbum;
+    "other-versions": CatalogAlbum;
+    "related-videos": CatalogMusicVideo;
+    "video-extras": CatalogMusicVideo;
+    "you-might-also-like": CatalogAlbum;
+}>;
+export {};

package/dist/types/resources/catalog/artist.d.ts

@@ -0,0 +1,57 @@
+import type { Resource } from "../../../types/query/resource.js";
+import type { CatalogAlbum } from "../../../types/resources/catalog/album.js";
+import type { CatalogConcert } from "../../../types/resources/catalog/concert.js";
+import type { CatalogGenre } from "../../../types/resources/catalog/genre.js";
+import type { CatalogMusicVideo } from "../../../types/resources/catalog/musicVideo.js";
+import type { CatalogPlaylist } from "../../../types/resources/catalog/playlist.js";
+import type { CatalogSong } from "../../../types/resources/catalog/song.js";
+import type { CatalogStation } from "../../../types/resources/catalog/station.js";
+import type { BaseArtistAttributes } from "../../../types/resources/shared/artist.js";
+import type { Artwork, AssetUrls, EditorialArtwork, EditorialNote, EditorialVideo, RatingValue } from "../../../types/shared.js";
+interface ArtistHero {
+    url: string;
+}
+interface CatalogArtistAttributes extends BaseArtistAttributes {
+    artwork?: Artwork;
+    genreNames: string[];
+    url: string;
+    editorialNotes?: EditorialNote;
+}
+interface CatalogArtistExtend {
+    editorialVideo?: EditorialVideo;
+    editorialArtwork?: EditorialArtwork;
+    personalRating?: RatingValue;
+    artistBio?: string;
+    bornOrFormed?: string;
+    hero?: ArtistHero;
+    isGroup?: boolean;
+    origin?: string;
+    extendedAssetUrls?: AssetUrls;
+}
+export type CatalogArtist = Resource<"artists", CatalogArtistAttributes, CatalogArtistExtend, {
+    albums: CatalogAlbum;
+    bands: CatalogArtist;
+    "default-playable-content": CatalogStation;
+    genres: CatalogGenre;
+    "music-videos": CatalogMusicVideo;
+    persons: CatalogArtist;
+    playlists: CatalogPlaylist;
+    station: CatalogStation;
+}, {
+    "all-upcoming-concerts": CatalogConcert;
+    "appears-on-albums": CatalogAlbum;
+    "compilation-albums": CatalogAlbum;
+    "featured-albums": CatalogAlbum;
+    "featured-on-albums": CatalogAlbum;
+    "featured-release": CatalogAlbum;
+    "full-albums": CatalogAlbum;
+    "latest-release": CatalogAlbum;
+    "live-albums": CatalogAlbum;
+    "more-to-hear": CatalogStation;
+    "music-videos": CatalogMusicVideo;
+    playlists: CatalogPlaylist;
+    "similar-artists": CatalogArtist;
+    singles: CatalogAlbum;
+    "top-songs": CatalogSong;
+}>;
+export {};

package/dist/types/resources/catalog/concert.d.ts

@@ -0,0 +1,32 @@
+import type { Resource } from "../../../types/query/resource.js";
+import type { CatalogArtist } from "../../../types/resources/catalog/artist.js";
+import type { CatalogPlaylist } from "../../../types/resources/catalog/playlist.js";
+import type { CatalogVenue } from "../../../types/resources/catalog/venue.js";
+interface ConcertProvider {
+    name: string;
+    url: string;
+}
+interface ConcertTicket {
+    provider: ConcertProvider;
+    vendor: string;
+    url: string;
+}
+interface CatalogConcertAttributes {
+    endISODateTime: string;
+    startISODateTime: string;
+    timezone: string;
+    url: string;
+}
+interface CatalogConcertExtend {
+    eventDataProviders?: ConcertProvider[];
+    ticketDataProvider?: ConcertProvider | ConcertProvider[];
+    tickets?: ConcertTicket[];
+}
+export type CatalogConcert = Resource<"concerts", CatalogConcertAttributes, CatalogConcertExtend, {
+    artists: CatalogArtist;
+    playlists: CatalogPlaylist;
+    venues: CatalogVenue;
+}, {
+    "more-upcoming-concerts": CatalogConcert;
+}>;
+export {};

package/dist/types/resources/catalog/creditArtist.d.ts

@@ -0,0 +1,11 @@
+import type { Resource } from "../../../types/query/resource.js";
+import type { Artwork } from "../../../types/shared.js";
+interface CatalogCreditArtistAttributes {
+    artwork?: Artwork;
+    name: string;
+    roleNames: string[];
+}
+interface CatalogCreditArtistExtend {
+}
+export type CatalogCreditArtist = Resource<"credit-artists", CatalogCreditArtistAttributes, CatalogCreditArtistExtend>;
+export {};

package/dist/types/resources/catalog/curator.d.ts

@@ -0,0 +1,27 @@
+import type { Resource } from "../../../types/query/resource.js";
+import type { CatalogPlaylist } from "../../../types/resources/catalog/playlist.js";
+import type { Artwork, EditorialNote } from "../../../types/shared.js";
+interface CatalogCuratorBaseAttributes {
+    artwork: Artwork;
+    editorialNotes?: EditorialNote;
+    name: string;
+    url: string;
+}
+interface CatalogCuratorAttributes extends CatalogCuratorBaseAttributes {
+}
+interface CatalogAppleCuratorAttributes extends CatalogCuratorBaseAttributes {
+    kind: "Curator" | "Genre" | "Show";
+    shortName?: string;
+    showHostName?: string;
+}
+interface CatalogCuratorExtend {
+}
+interface CatalogAppleCuratorExtend {
+}
+export type CatalogCurator = Resource<"curators", CatalogCuratorAttributes, CatalogCuratorExtend, {
+    playlists: CatalogPlaylist;
+}>;
+export type CatalogAppleCurator = Resource<"apple-curators", CatalogAppleCuratorAttributes, CatalogAppleCuratorExtend, {
+    playlists: CatalogPlaylist;
+}>;
+export {};

package/dist/types/resources/catalog/genre.d.ts

@@ -0,0 +1,11 @@
+import type { Resource } from "../../../types/query/resource.js";
+interface CatalogGenreAttributes {
+    chartLabel?: string;
+    name: string;
+    parentId?: string;
+    parentName?: string;
+}
+interface CatalogGenreExtend {
+}
+export type CatalogGenre = Resource<"genres", CatalogGenreAttributes, CatalogGenreExtend>;
+export {};

package/dist/types/resources/catalog/lyrics.d.ts

@@ -0,0 +1,8 @@
+import type { Resource } from "../../../types/query/resource.js";
+import type { BaseLyricsAttributes } from "../../../types/resources/shared/lyrics.js";
+interface CatalogLyricsAttributes extends BaseLyricsAttributes {
+}
+interface CatalogLyricsExtend {
+}
+export type CatalogLyrics = Resource<"lyrics", CatalogLyricsAttributes, CatalogLyricsExtend>;
+export {};

package/dist/types/resources/catalog/musicVideo.d.ts

@@ -0,0 +1,34 @@
+import type { Resource } from "../../../types/query/resource.js";
+import type { CatalogAlbum } from "../../../types/resources/catalog/album.js";
+import type { CatalogArtist } from "../../../types/resources/catalog/artist.js";
+import type { CatalogGenre } from "../../../types/resources/catalog/genre.js";
+import type { CatalogSong } from "../../../types/resources/catalog/song.js";
+import type { LibraryMusicVideo } from "../../../types/resources/library/musicVideo.js";
+import type { BaseMusicVideoAttributes } from "../../../types/resources/shared/musicVideo.js";
+import type { EditorialNote, Preview, RatingValue } from "../../../types/shared.js";
+interface CatalogMusicVideoAttributes extends BaseMusicVideoAttributes {
+    editorialNotes?: EditorialNote;
+    has4K: boolean;
+    hasHDR: boolean;
+    isrc?: string;
+    previews: Preview[];
+    url: string;
+    videoSubType?: "preview";
+    workId?: string;
+    workName?: string;
+}
+interface CatalogMusicVideoExtend {
+    artistUrl?: string;
+    personalRating?: RatingValue;
+}
+export type CatalogMusicVideo = Resource<"music-videos", CatalogMusicVideoAttributes, CatalogMusicVideoExtend, {
+    albums: CatalogAlbum;
+    artists: CatalogArtist;
+    genres: CatalogGenre;
+    library: LibraryMusicVideo;
+    songs: CatalogSong;
+}, {
+    "more-by-artist": CatalogMusicVideo;
+    "more-in-genre": CatalogMusicVideo;
+}>;
+export {};

package/dist/types/resources/catalog/playlist.d.ts

@@ -0,0 +1,35 @@
+import type { Resource } from "../../../types/query/resource.js";
+import type { CatalogActivity } from "../../../types/resources/catalog/activity.js";
+import type { CatalogArtist } from "../../../types/resources/catalog/artist.js";
+import type { CatalogAppleCurator, CatalogCurator } from "../../../types/resources/catalog/curator.js";
+import type { CatalogMusicVideo } from "../../../types/resources/catalog/musicVideo.js";
+import type { CatalogSong } from "../../../types/resources/catalog/song.js";
+import type { LibraryPlaylist } from "../../../types/resources/library/playlist.js";
+import type { SocialProfile } from "../../../types/resources/me/profile.js";
+import type { BasePlaylistAttributes } from "../../../types/resources/shared/playlist.js";
+import type { EditorialArtwork, EditorialVideo, RatingValue } from "../../../types/shared.js";
+type CatalogPlaylistType = "editorial" | "external" | "personal-mix" | "replay" | "user-shared";
+interface CatalogPlaylistAttributes extends BasePlaylistAttributes {
+    curatorName: string;
+    curatorSocialHandle?: string;
+    isChart: boolean;
+    lastModifiedDate?: string;
+    playlistType: CatalogPlaylistType;
+    url: string;
+}
+interface CatalogPlaylistExtend {
+    personalRating?: RatingValue;
+    editorialVideo?: EditorialVideo;
+    editorialArtwork?: EditorialArtwork;
+    trackTypes?: ("music-videos" | "songs")[];
+    trackCount?: number;
+}
+export type CatalogPlaylist = Resource<"playlists", CatalogPlaylistAttributes, CatalogPlaylistExtend, {
+    curator: CatalogActivity | CatalogAppleCurator | CatalogCurator | SocialProfile;
+    library: LibraryPlaylist;
+    tracks: CatalogSong | CatalogMusicVideo;
+}, {
+    "featured-artists": CatalogArtist;
+    "more-by-curator": CatalogPlaylist;
+}>;
+export {};

package/dist/types/resources/catalog/recordLabel.d.ts

@@ -0,0 +1,16 @@
+import type { Resource } from "../../../types/query/resource.js";
+import type { CatalogAlbum } from "../../../types/resources/catalog/album.js";
+import type { Artwork, Description } from "../../../types/shared.js";
+interface CatalogRecordLabelAttributes {
+    artwork: Artwork;
+    description?: Description;
+    name: string;
+    url: string;
+}
+interface CatalogRecordLabelExtend {
+}
+export type CatalogRecordLabel = Resource<"record-labels", CatalogRecordLabelAttributes, CatalogRecordLabelExtend, {}, {
+    "latest-releases": CatalogAlbum;
+    "top-releases": CatalogAlbum;
+}>;
+export {};

package/dist/types/resources/catalog/roleCategory.d.ts

@@ -0,0 +1,12 @@
+import type { Resource } from "../../../types/query/resource.js";
+import type { CatalogCreditArtist } from "../../../types/resources/catalog/creditArtist.js";
+interface CatalogRoleCategoryAttributes {
+    kind: string;
+    title: string;
+}
+interface CatalogRoleCategoryExtend {
+}
+export type CatalogRoleCategory = Resource<"role-categories", CatalogRoleCategoryAttributes, CatalogRoleCategoryExtend, {
+    "credit-artists": CatalogCreditArtist;
+}>;
+export {};