@keystrokehq/spotify 0.0.1

package/dist/client.mjs

@@ -0,0 +1,758 @@
+import { SpotifyApiError, classifySpotifyApiError } from "./errors.mjs";
+import { createSpotifyCursorPageSchema, spotifyAlbumPageSchema, spotifyAlbumSchema, spotifyAlbumSummarySchema, spotifyArtistPageSchema, spotifyArtistSchema, spotifyAudioAnalysisSchema, spotifyAudioFeaturesSchema, spotifyAudiobookSchema, spotifyBooleanListSchema, spotifyCategoryPageSchema, spotifyCategorySchema, spotifyChapterPageSchema, spotifyChapterSchema, spotifyDeviceSchema, spotifyEpisodePageSchema, spotifyEpisodeSchema, spotifyMarketSchema, spotifyMutationSuccessSchema, spotifyPlaybackStateSchema, spotifyPlaylistImageSchema, spotifyPlaylistItemPageSchema, spotifyPlaylistItemSchema, spotifyPlaylistPageSchema, spotifyPlaylistSchema, spotifyQueueSchema, spotifyRecentlyPlayedItemSchema, spotifyRecentlyPlayedPageSchema, spotifyRecommendationsSchema, spotifySavedAlbumItemSchema, spotifySavedAlbumPageSchema, spotifySavedAudiobookItemSchema, spotifySavedAudiobookPageSchema, spotifySavedEpisodeItemSchema, spotifySavedEpisodePageSchema, spotifySavedShowItemSchema, spotifySavedShowPageSchema, spotifySavedTrackItemSchema, spotifySavedTrackPageSchema, spotifySearchResultSchema, spotifyShowSchema, spotifySnapshotResponseSchema, spotifyTrackPageSchema, spotifyTrackSchema, spotifyUserSchema } from "./schemas.mjs";
+import { z } from "zod";
+
+//#region src/client.ts
+const DEFAULT_BASE_URL = "https://api.spotify.com/v1";
+const DEFAULT_MAX_RETRIES = 2;
+const topTracksResponseSchema = z.object({ tracks: z.array(spotifyTrackSchema) });
+const severalArtistsResponseSchema = z.object({ artists: z.array(spotifyArtistSchema) });
+const severalAlbumsResponseSchema = z.object({ albums: z.array(spotifyAlbumSchema) });
+const severalTracksResponseSchema = z.object({ tracks: z.array(spotifyTrackSchema) });
+const severalShowsResponseSchema = z.object({ shows: z.array(spotifyShowSchema) });
+const severalEpisodesResponseSchema = z.object({ episodes: z.array(spotifyEpisodeSchema) });
+const severalAudiobooksResponseSchema = z.object({ audiobooks: z.array(spotifyAudiobookSchema) });
+const severalChaptersResponseSchema = z.object({ chapters: z.array(spotifyChapterSchema) });
+const nullablePlaybackStateSchema = spotifyPlaybackStateSchema.nullable();
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function camelCaseKey(value) {
+	return value.replace(/_([a-z])/gu, (_, letter) => letter.toUpperCase());
+}
+function snakeCaseKey(value) {
+	return value.replace(/[A-Z]/gu, (letter) => `_${letter.toLowerCase()}`);
+}
+function camelizeSpotifyJson(value) {
+	if (Array.isArray(value)) return value.map(camelizeSpotifyJson);
+	if (!isRecord(value)) return value;
+	const result = {};
+	for (const [key, nestedValue] of Object.entries(value)) result[camelCaseKey(key)] = camelizeSpotifyJson(nestedValue);
+	return result;
+}
+function snakeizeSpotifyJson(value) {
+	if (Array.isArray(value)) return value.map(snakeizeSpotifyJson);
+	if (!isRecord(value)) return value;
+	const result = {};
+	for (const [key, nestedValue] of Object.entries(value)) result[snakeCaseKey(key)] = snakeizeSpotifyJson(nestedValue);
+	return result;
+}
+function appendQueryParams(url, query) {
+	if (!query) return;
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) {
+			if (value.length === 0) continue;
+			url.searchParams.set(key, value.map((entry) => String(entry)).filter((entry) => entry.length > 0).join(","));
+			continue;
+		}
+		url.searchParams.set(key, String(value));
+	}
+}
+function toUrl(baseUrl, path) {
+	return new URL(path.replace(/^\//u, ""), `${baseUrl.replace(/\/$/u, "")}/`);
+}
+function parseRetryAfter(headers) {
+	const raw = headers.get("retry-after");
+	if (!raw) return;
+	const seconds = Number(raw);
+	return Number.isFinite(seconds) ? seconds : void 0;
+}
+function getRequestId(headers) {
+	return headers.get("x-request-id") ?? headers.get("spotify-trace-id") ?? headers.get("x-spotify-request-id") ?? void 0;
+}
+function extractErrorMessage(body, statusText) {
+	if (!isRecord(body)) return { message: statusText || "Spotify API request failed" };
+	const apiError = body.error;
+	if (isRecord(apiError) && typeof apiError.message === "string") return {
+		message: apiError.message,
+		code: typeof apiError.code === "string" ? apiError.code : void 0
+	};
+	if (typeof body.error === "string") return {
+		message: typeof body.errorDescription === "string" ? body.errorDescription : body.error || statusText,
+		code: body.error
+	};
+	return { message: statusText || "Spotify API request failed" };
+}
+function extractPageToken(url) {
+	if (!url) return;
+	try {
+		const parsed = new URL(url);
+		return parsed.searchParams.get("offset") ?? parsed.searchParams.get("after") ?? parsed.searchParams.get("before") ?? url;
+	} catch {
+		return url;
+	}
+}
+function normalizeOffsetPage(value, itemKey, responseSchema) {
+	if (!isRecord(value)) return value;
+	const itemsValue = value[itemKey];
+	const parsedItems = responseSchema.parse(itemsValue);
+	return {
+		href: typeof value.href === "string" ? value.href : void 0,
+		items: parsedItems,
+		limit: typeof value.limit === "number" ? value.limit : 0,
+		nextPageToken: extractPageToken(typeof value.next === "string" ? value.next : void 0),
+		offset: typeof value.offset === "number" ? value.offset : 0,
+		previousPageToken: extractPageToken(typeof value.previous === "string" ? value.previous : void 0),
+		total: typeof value.total === "number" ? value.total : void 0
+	};
+}
+function normalizeCursorPage(value, itemKey, responseSchema) {
+	if (!isRecord(value)) return value;
+	const itemsValue = value[itemKey];
+	const parsedItems = responseSchema.parse(itemsValue);
+	const cursors = isRecord(value.cursors) ? value.cursors : void 0;
+	return {
+		href: typeof value.href === "string" ? value.href : void 0,
+		items: parsedItems,
+		limit: typeof value.limit === "number" ? value.limit : 0,
+		nextPageToken: extractPageToken(typeof value.next === "string" ? value.next : void 0) ?? (typeof cursors?.after === "string" ? cursors.after : void 0),
+		previousPageToken: extractPageToken(typeof value.previous === "string" ? value.previous : void 0) ?? (typeof cursors?.before === "string" ? cursors.before : void 0),
+		total: typeof value.total === "number" ? value.total : void 0,
+		cursors: {
+			...typeof cursors?.after === "string" ? { after: cursors.after } : {},
+			...typeof cursors?.before === "string" ? { before: cursors.before } : {}
+		}
+	};
+}
+function normalizeEmptySuccess() {
+	return { success: true };
+}
+function normalizeEmptyBodyToNull(value) {
+	return value === "" ? null : value;
+}
+function toSnakeCaseBody(body) {
+	return JSON.stringify(snakeizeSpotifyJson(body));
+}
+function defaultSleep(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+function encodeId(value) {
+	return encodeURIComponent(value);
+}
+function createSpotifyClient(credentials, config = {}) {
+	const fetchImpl = config.fetch ?? fetch;
+	const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+	const maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+	const sleep = config.sleep ?? defaultSleep;
+	async function request(options) {
+		const url = toUrl(baseUrl, options.path);
+		appendQueryParams(url, options.query);
+		const method = options.method ?? "GET";
+		const requestHeaders = new Headers({
+			Authorization: `Bearer ${credentials.SPOTIFY_ACCESS_TOKEN}`,
+			Accept: "application/json",
+			...options.headers
+		});
+		let requestBody;
+		if (options.body !== void 0) {
+			if (!requestHeaders.has("Content-Type")) requestHeaders.set("Content-Type", "application/json");
+			if (typeof options.body === "string") requestBody = options.body;
+			else requestBody = toSnakeCaseBody(options.body);
+		}
+		for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+			const response = await fetchImpl(url, {
+				method,
+				headers: requestHeaders,
+				body: requestBody
+			});
+			const camelizedBody = camelizeSpotifyJson((response.headers.get("content-type") ?? "").includes("application/json") ? await response.json() : await response.text());
+			const retryAfterSeconds = parseRetryAfter(response.headers);
+			const requestId = getRequestId(response.headers);
+			if (!response.ok) {
+				const { message, code } = extractErrorMessage(camelizedBody, response.statusText);
+				const error = classifySpotifyApiError({
+					status: response.status,
+					message,
+					code,
+					requestId,
+					retryAfterSeconds
+				});
+				if (error.retryable && attempt < maxRetries) {
+					await sleep((retryAfterSeconds ?? attempt + 1) * 1e3);
+					continue;
+				}
+				throw error;
+			}
+			const mapped = options.mapResponse ? options.mapResponse(camelizedBody) : camelizedBody;
+			const parsed = options.responseSchema.safeParse(mapped);
+			if (!parsed.success) throw new SpotifyApiError({
+				kind: "validation",
+				message: parsed.error.issues.map((issue) => issue.message).join("; "),
+				requestId,
+				retryable: false
+			});
+			return parsed.data;
+		}
+		throw new SpotifyApiError({
+			kind: "rate_limit",
+			message: "Spotify API request exhausted retry budget",
+			retryable: true
+		});
+	}
+	function getOffsetPage(path, query, itemKey, itemListSchema, pageSchema) {
+		return request({
+			path,
+			query,
+			responseSchema: pageSchema,
+			mapResponse: (value) => normalizeOffsetPage(value, itemKey, itemListSchema)
+		});
+	}
+	function getCursorPage(path, query, itemKey, itemListSchema, pageSchema) {
+		return request({
+			path,
+			query,
+			responseSchema: pageSchema,
+			mapResponse: (value) => normalizeCursorPage(value, itemKey, itemListSchema)
+		});
+	}
+	return {
+		albums: {
+			getAlbum: (id, market) => request({
+				path: `/albums/${encodeId(id)}`,
+				query: { market },
+				responseSchema: spotifyAlbumSchema
+			}),
+			getAlbumTracks: (id, query) => getOffsetPage(`/albums/${encodeId(id)}/tracks`, query, "items", z.array(spotifyTrackSchema), spotifyTrackPageSchema),
+			getSeveralAlbums: (ids, market) => request({
+				path: "/albums",
+				query: {
+					ids,
+					market
+				},
+				responseSchema: severalAlbumsResponseSchema,
+				mapResponse: (value) => isRecord(value) ? value : { albums: [] }
+			}),
+			getNewReleases: (query) => request({
+				path: "/browse/new-releases",
+				query,
+				responseSchema: spotifyAlbumPageSchema,
+				mapResponse: (value) => {
+					if (!isRecord(value)) return value;
+					return normalizeOffsetPage(value.albums, "items", z.array(spotifyAlbumSummarySchema));
+				}
+			})
+		},
+		artists: {
+			getArtist: (id) => request({
+				path: `/artists/${encodeId(id)}`,
+				responseSchema: spotifyArtistSchema
+			}),
+			getArtistAlbums: (id, query) => getOffsetPage(`/artists/${encodeId(id)}/albums`, query, "items", z.array(spotifyAlbumSummarySchema), spotifyAlbumPageSchema),
+			getArtistTopTracks: (id, market) => request({
+				path: `/artists/${encodeId(id)}/top-tracks`,
+				query: { market },
+				responseSchema: topTracksResponseSchema,
+				mapResponse: (value) => isRecord(value) ? value : { tracks: [] }
+			}),
+			getArtistRelatedArtists: (id) => request({
+				path: `/artists/${encodeId(id)}/related-artists`,
+				responseSchema: severalArtistsResponseSchema,
+				mapResponse: (value) => isRecord(value) ? value : { artists: [] }
+			}),
+			getSeveralArtists: (ids) => request({
+				path: "/artists",
+				query: { ids },
+				responseSchema: severalArtistsResponseSchema,
+				mapResponse: (value) => isRecord(value) ? value : { artists: [] }
+			})
+		},
+		tracks: {
+			getTrack: (id, market) => request({
+				path: `/tracks/${encodeId(id)}`,
+				query: { market },
+				responseSchema: spotifyTrackSchema
+			}),
+			getSeveralTracks: (ids, market) => request({
+				path: "/tracks",
+				query: {
+					ids,
+					market
+				},
+				responseSchema: severalTracksResponseSchema,
+				mapResponse: (value) => isRecord(value) ? value : { tracks: [] }
+			})
+		},
+		audioFeatures: {
+			getAudioFeatures: (id) => request({
+				path: `/audio-features/${encodeId(id)}`,
+				responseSchema: spotifyAudioFeaturesSchema
+			}),
+			getSeveralAudioFeatures: (ids) => request({
+				path: "/audio-features",
+				query: { ids },
+				responseSchema: z.object({ audioFeatures: z.array(spotifyAudioFeaturesSchema.nullable()) })
+			})
+		},
+		audioAnalysis: { getAudioAnalysis: (id) => request({
+			path: `/audio-analysis/${encodeId(id)}`,
+			responseSchema: spotifyAudioAnalysisSchema
+		}) },
+		recommendations: { getRecommendations: (query) => request({
+			path: "/recommendations",
+			query,
+			responseSchema: spotifyRecommendationsSchema
+		}) },
+		shows: {
+			getShow: (id, market) => request({
+				path: `/shows/${encodeId(id)}`,
+				query: { market },
+				responseSchema: spotifyShowSchema
+			}),
+			getSeveralShows: (ids, market) => request({
+				path: "/shows",
+				query: {
+					ids,
+					market
+				},
+				responseSchema: severalShowsResponseSchema,
+				mapResponse: (value) => isRecord(value) ? value : { shows: [] }
+			}),
+			getShowEpisodes: (id, query) => getOffsetPage(`/shows/${encodeId(id)}/episodes`, query, "items", z.array(spotifyEpisodeSchema), spotifyEpisodePageSchema)
+		},
+		episodes: {
+			getEpisode: (id, market) => request({
+				path: `/episodes/${encodeId(id)}`,
+				query: { market },
+				responseSchema: spotifyEpisodeSchema
+			}),
+			getSeveralEpisodes: (ids, market) => request({
+				path: "/episodes",
+				query: {
+					ids,
+					market
+				},
+				responseSchema: severalEpisodesResponseSchema,
+				mapResponse: (value) => isRecord(value) ? value : { episodes: [] }
+			})
+		},
+		audiobooks: {
+			getAudiobook: (id, market) => request({
+				path: `/audiobooks/${encodeId(id)}`,
+				query: { market },
+				responseSchema: spotifyAudiobookSchema
+			}),
+			getSeveralAudiobooks: (ids, market) => request({
+				path: "/audiobooks",
+				query: {
+					ids,
+					market
+				},
+				responseSchema: severalAudiobooksResponseSchema,
+				mapResponse: (value) => isRecord(value) ? value : { audiobooks: [] }
+			}),
+			getAudiobookChapters: (id, query) => getOffsetPage(`/audiobooks/${encodeId(id)}/chapters`, query, "items", z.array(spotifyChapterSchema), spotifyChapterPageSchema)
+		},
+		chapters: {
+			getChapter: (id, market) => request({
+				path: `/chapters/${encodeId(id)}`,
+				query: { market },
+				responseSchema: spotifyChapterSchema
+			}),
+			getSeveralChapters: (ids, market) => request({
+				path: "/chapters",
+				query: {
+					ids,
+					market
+				},
+				responseSchema: severalChaptersResponseSchema,
+				mapResponse: (value) => isRecord(value) ? value : { chapters: [] }
+			})
+		},
+		discovery: {
+			search: (query) => request({
+				path: "/search",
+				query,
+				responseSchema: spotifySearchResultSchema
+			}),
+			getAvailableMarkets: () => request({
+				path: "/markets",
+				responseSchema: z.object({ markets: z.array(spotifyMarketSchema) })
+			}),
+			getAvailableGenreSeeds: () => request({
+				path: "/recommendations/available-genre-seeds",
+				responseSchema: z.object({ genres: z.array(z.string().min(1)) })
+			}),
+			getBrowseCategories: (query) => request({
+				path: "/browse/categories",
+				query,
+				responseSchema: spotifyCategoryPageSchema,
+				mapResponse: (value) => {
+					if (!isRecord(value)) return value;
+					return normalizeOffsetPage(value.categories, "items", z.array(spotifyCategorySchema));
+				}
+			}),
+			getBrowseCategory: (id, query) => request({
+				path: `/browse/categories/${encodeId(id)}`,
+				query,
+				responseSchema: spotifyCategorySchema
+			}),
+			getCategoryPlaylists: (id, query) => request({
+				path: `/browse/categories/${encodeId(id)}/playlists`,
+				query,
+				responseSchema: spotifyPlaylistPageSchema,
+				mapResponse: (value) => {
+					if (!isRecord(value)) return value;
+					return normalizeOffsetPage(value.playlists, "items", z.array(spotifyPlaylistSchema));
+				}
+			}),
+			getFeaturedPlaylists: (query) => request({
+				path: "/browse/featured-playlists",
+				query,
+				responseSchema: spotifyPlaylistPageSchema,
+				mapResponse: (value) => {
+					if (!isRecord(value)) return value;
+					return normalizeOffsetPage(value.playlists, "items", z.array(spotifyPlaylistSchema));
+				}
+			})
+		},
+		playlists: {
+			createPlaylist: (body) => request({
+				method: "POST",
+				path: "/me/playlists",
+				body,
+				responseSchema: spotifyPlaylistSchema
+			}),
+			getPlaylist: (id, query) => request({
+				path: `/playlists/${encodeId(id)}`,
+				query,
+				responseSchema: spotifyPlaylistSchema
+			}),
+			updatePlaylistDetails: (id, body) => request({
+				method: "PUT",
+				path: `/playlists/${encodeId(id)}`,
+				body,
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			getPlaylistItems: (id, query) => getOffsetPage(`/playlists/${encodeId(id)}/tracks`, query, "items", z.array(spotifyPlaylistItemSchema), spotifyPlaylistItemPageSchema),
+			getPlaylistCoverImage: (id) => request({
+				path: `/playlists/${encodeId(id)}/images`,
+				responseSchema: z.object({ images: z.array(spotifyPlaylistImageSchema) }),
+				mapResponse: (value) => ({ images: value })
+			}),
+			addItemsToPlaylist: (id, body) => request({
+				method: "POST",
+				path: `/playlists/${encodeId(id)}/tracks`,
+				body,
+				responseSchema: spotifySnapshotResponseSchema
+			}),
+			reorderPlaylistItems: (id, body) => request({
+				method: "PUT",
+				path: `/playlists/${encodeId(id)}/tracks`,
+				body,
+				responseSchema: spotifySnapshotResponseSchema
+			}),
+			replacePlaylistItems: (id, body) => request({
+				method: "PUT",
+				path: `/playlists/${encodeId(id)}/tracks`,
+				body,
+				responseSchema: spotifySnapshotResponseSchema
+			}),
+			removeItemsFromPlaylist: (id, body) => request({
+				method: "DELETE",
+				path: `/playlists/${encodeId(id)}/tracks`,
+				body,
+				responseSchema: spotifySnapshotResponseSchema
+			}),
+			listMyPlaylists: (query) => getOffsetPage("/me/playlists", query, "items", z.array(spotifyPlaylistSchema), spotifyPlaylistPageSchema),
+			listUserPlaylists: (userId, query) => getOffsetPage(`/users/${encodeId(userId)}/playlists`, query, "items", z.array(spotifyPlaylistSchema), spotifyPlaylistPageSchema),
+			followPlaylist: (id, body) => request({
+				method: "PUT",
+				path: `/playlists/${encodeId(id)}/followers`,
+				body,
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			unfollowPlaylist: (id) => request({
+				method: "DELETE",
+				path: `/playlists/${encodeId(id)}/followers`,
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			checkUsersFollowPlaylist: (id, ids) => request({
+				path: `/playlists/${encodeId(id)}/followers/contains`,
+				query: { ids },
+				responseSchema: spotifyBooleanListSchema
+			}),
+			uploadPlaylistCoverImage: (id, imageBase64) => request({
+				method: "PUT",
+				path: `/playlists/${encodeId(id)}/images`,
+				body: imageBase64,
+				headers: { "Content-Type": "image/jpeg" },
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			})
+		},
+		users: {
+			getMe: () => request({
+				path: "/me",
+				responseSchema: spotifyUserSchema
+			}),
+			getUser: (userId) => request({
+				path: `/users/${encodeId(userId)}`,
+				responseSchema: spotifyUserSchema
+			}),
+			getMyTopArtists: (query) => getOffsetPage("/me/top/artists", query, "items", z.array(spotifyArtistSchema), spotifyArtistPageSchema),
+			getMyTopTracks: (query) => getOffsetPage("/me/top/tracks", query, "items", z.array(spotifyTrackSchema), spotifyTrackPageSchema)
+		},
+		follow: {
+			getFollowedArtists: (query) => request({
+				path: "/me/following",
+				query: {
+					...query,
+					type: "artist"
+				},
+				responseSchema: createSpotifyCursorPageSchema(spotifyArtistSchema),
+				mapResponse: (value) => {
+					if (!isRecord(value)) return value;
+					return normalizeCursorPage(value.artists, "items", z.array(spotifyArtistSchema));
+				}
+			}),
+			followArtistsOrUsers: (type, ids) => request({
+				method: "PUT",
+				path: "/me/following",
+				query: {
+					type,
+					ids
+				},
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			unfollowArtistsOrUsers: (type, ids) => request({
+				method: "DELETE",
+				path: "/me/following",
+				query: {
+					type,
+					ids
+				},
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			checkFollowingArtistsOrUsers: (type, ids) => request({
+				path: "/me/following/contains",
+				query: {
+					type,
+					ids
+				},
+				responseSchema: spotifyBooleanListSchema
+			})
+		},
+		player: {
+			getPlaybackState: (market) => request({
+				path: "/me/player",
+				query: { market },
+				responseSchema: nullablePlaybackStateSchema,
+				mapResponse: normalizeEmptyBodyToNull
+			}),
+			transferPlayback: (body) => request({
+				method: "PUT",
+				path: "/me/player",
+				body,
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			getAvailableDevices: () => request({
+				path: "/me/player/devices",
+				responseSchema: z.object({ devices: z.array(spotifyDeviceSchema) })
+			}),
+			getCurrentlyPlaying: (query) => request({
+				path: "/me/player/currently-playing",
+				query,
+				responseSchema: nullablePlaybackStateSchema,
+				mapResponse: normalizeEmptyBodyToNull
+			}),
+			startOrResumePlayback: (body, deviceId) => request({
+				method: "PUT",
+				path: "/me/player/play",
+				query: { device_id: deviceId },
+				body,
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			pausePlayback: (deviceId) => request({
+				method: "PUT",
+				path: "/me/player/pause",
+				query: { device_id: deviceId },
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			skipToNext: (deviceId) => request({
+				method: "POST",
+				path: "/me/player/next",
+				query: { device_id: deviceId },
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			skipToPrevious: (deviceId) => request({
+				method: "POST",
+				path: "/me/player/previous",
+				query: { device_id: deviceId },
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			seekToPosition: (positionMs, deviceId) => request({
+				method: "PUT",
+				path: "/me/player/seek",
+				query: {
+					position_ms: positionMs,
+					device_id: deviceId
+				},
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			setRepeatMode: (state, deviceId) => request({
+				method: "PUT",
+				path: "/me/player/repeat",
+				query: {
+					state,
+					device_id: deviceId
+				},
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			setPlaybackVolume: (volumePercent, deviceId) => request({
+				method: "PUT",
+				path: "/me/player/volume",
+				query: {
+					volume_percent: volumePercent,
+					device_id: deviceId
+				},
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			setShuffleMode: (state, deviceId) => request({
+				method: "PUT",
+				path: "/me/player/shuffle",
+				query: {
+					state,
+					device_id: deviceId
+				},
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			getRecentlyPlayed: (query) => getCursorPage("/me/player/recently-played", query, "items", z.array(spotifyRecentlyPlayedItemSchema), spotifyRecentlyPlayedPageSchema),
+			addToQueue: (uri, deviceId) => request({
+				method: "POST",
+				path: "/me/player/queue",
+				query: {
+					uri,
+					device_id: deviceId
+				},
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			getQueue: () => request({
+				path: "/me/player/queue",
+				responseSchema: spotifyQueueSchema
+			})
+		},
+		library: {
+			listSavedAlbums: (query) => getOffsetPage("/me/albums", query, "items", z.array(spotifySavedAlbumItemSchema), spotifySavedAlbumPageSchema),
+			saveAlbums: (ids) => request({
+				method: "PUT",
+				path: "/me/albums",
+				query: { ids },
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			removeSavedAlbums: (ids) => request({
+				method: "DELETE",
+				path: "/me/albums",
+				query: { ids },
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			checkSavedAlbums: (ids) => request({
+				path: "/me/albums/contains",
+				query: { ids },
+				responseSchema: spotifyBooleanListSchema
+			}),
+			listSavedTracks: (query) => getOffsetPage("/me/tracks", query, "items", z.array(spotifySavedTrackItemSchema), spotifySavedTrackPageSchema),
+			saveTracks: (ids) => request({
+				method: "PUT",
+				path: "/me/tracks",
+				query: { ids },
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			removeSavedTracks: (ids) => request({
+				method: "DELETE",
+				path: "/me/tracks",
+				query: { ids },
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			checkSavedTracks: (ids) => request({
+				path: "/me/tracks/contains",
+				query: { ids },
+				responseSchema: spotifyBooleanListSchema
+			}),
+			listSavedShows: (query) => getOffsetPage("/me/shows", query, "items", z.array(spotifySavedShowItemSchema), spotifySavedShowPageSchema),
+			saveShows: (ids) => request({
+				method: "PUT",
+				path: "/me/shows",
+				query: { ids },
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			removeSavedShows: (ids) => request({
+				method: "DELETE",
+				path: "/me/shows",
+				query: { ids },
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			checkSavedShows: (ids) => request({
+				path: "/me/shows/contains",
+				query: { ids },
+				responseSchema: spotifyBooleanListSchema
+			}),
+			listSavedEpisodes: (query) => getOffsetPage("/me/episodes", query, "items", z.array(spotifySavedEpisodeItemSchema), spotifySavedEpisodePageSchema),
+			saveEpisodes: (ids) => request({
+				method: "PUT",
+				path: "/me/episodes",
+				query: { ids },
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			removeSavedEpisodes: (ids) => request({
+				method: "DELETE",
+				path: "/me/episodes",
+				query: { ids },
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			checkSavedEpisodes: (ids) => request({
+				path: "/me/episodes/contains",
+				query: { ids },
+				responseSchema: spotifyBooleanListSchema
+			}),
+			listSavedAudiobooks: (query) => getOffsetPage("/me/audiobooks", query, "items", z.array(spotifySavedAudiobookItemSchema), spotifySavedAudiobookPageSchema),
+			saveAudiobooks: (ids) => request({
+				method: "PUT",
+				path: "/me/audiobooks",
+				query: { ids },
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			removeSavedAudiobooks: (ids) => request({
+				method: "DELETE",
+				path: "/me/audiobooks",
+				query: { ids },
+				responseSchema: spotifyMutationSuccessSchema,
+				mapResponse: normalizeEmptySuccess
+			}),
+			checkSavedAudiobooks: (ids) => request({
+				path: "/me/audiobooks/contains",
+				query: { ids },
+				responseSchema: spotifyBooleanListSchema
+			})
+		}
+	};
+}
+
+//#endregion
+export { createSpotifyClient };