@keystrokehq/spotify 0.0.16 → 0.1.2

package/dist/upload-playlist-cover-image.operation-CnyIlv11.mjs

@@ -1,4247 +0,0 @@
-import { n as spotifyCredentialSet } from "./spotify.credential-set-CS3lCW-x.mjs";
-import { A as spotifyRecentlyPlayedItemSchema, B as spotifyAudiobookSchema, C as spotifyPlaylistImageSchema, E as spotifyDeviceSchema, F as spotifySavedTrackItemSchema, H as spotifyChapterSchema, I as spotifyAlbumSchema, J as spotifyUserSchema, L as spotifyAlbumSummarySchema, M as spotifySavedAudiobookItemSchema, N as spotifySavedEpisodeItemSchema, O as spotifyPlaybackStateSchema, P as spotifySavedShowItemSchema, R as spotifyArtistSchema, S as spotifyTrackPageSchema, T as spotifyPlaylistSchema, U as spotifyEpisodeSchema, W as spotifyShowSchema, Y as createSpotifyCursorPageSchema, Z as spotifyBooleanListSchema, _ as spotifySavedEpisodePageSchema, at as spotifyMutationSuccessSchema, b as spotifySearchResultSchema, c as spotifyChapterPageSchema, d as spotifyPlaylistPageSchema, dt as spotifyUriSchema, f as spotifyRecentlyPlayedPageSchema, g as spotifySavedAudiobookPageSchema, h as spotifySavedAlbumPageSchema, i as spotifyAudioFeaturesSchema, it as spotifyMarketSchema, j as spotifySavedAlbumItemSchema, k as spotifyQueueSchema, l as spotifyEpisodePageSchema, lt as spotifySnapshotResponseSchema, m as spotifyRecommendationsSchema, n as spotifyArtistPageSchema, nt as spotifyIdSchema, o as spotifyCategoryPageSchema, q as spotifyTrackSchema, r as spotifyAudioAnalysisSchema, s as spotifyCategorySchema, t as spotifyAlbumPageSchema, u as spotifyPlaylistItemPageSchema, ut as spotifyTimestampSchema, v as spotifySavedShowPageSchema, w as spotifyPlaylistItemSchema, y as spotifySavedTrackPageSchema } from "./browse-BaBol4IR.mjs";
-import { Operation } from "@keystrokehq/core";
-import { z } from "zod";
-
-//#region src/utils/errors.ts
-var SpotifyApiError = class extends Error {
-	kind;
-	status;
-	code;
-	requestId;
-	retryAfterSeconds;
-	retryable;
-	details;
-	constructor(options) {
-		super(options.message);
-		this.name = "SpotifyApiError";
-		this.kind = options.kind;
-		this.status = options.status;
-		this.code = options.code;
-		this.requestId = options.requestId;
-		this.retryAfterSeconds = options.retryAfterSeconds;
-		this.retryable = options.retryable ?? isRetryableStatus(options.status);
-		this.details = options.details;
-	}
-};
-function isRetryableStatus(status) {
-	if (status === void 0) return false;
-	return status === 429 || status >= 500;
-}
-function classifySpotifyApiError(input) {
-	const normalizedMessage = input.message.toLowerCase();
-	const normalizedCode = input.code?.toLowerCase();
-	if (input.status === 429) return new SpotifyApiError({
-		kind: "rate_limit",
-		message: input.message,
-		status: input.status,
-		code: input.code,
-		requestId: input.requestId,
-		retryAfterSeconds: input.retryAfterSeconds,
-		retryable: true,
-		details: input.details
-	});
-	if (input.status === 401 || normalizedCode === "invalid_token" || normalizedMessage.includes("invalid access token") || normalizedMessage.includes("authentication")) return new SpotifyApiError({
-		kind: "auth",
-		message: input.message,
-		status: input.status,
-		code: input.code,
-		requestId: input.requestId,
-		retryAfterSeconds: input.retryAfterSeconds,
-		retryable: false,
-		details: input.details
-	});
-	if (input.status === 403 && (normalizedCode === "premium_required" || normalizedMessage.includes("premium required"))) return new SpotifyApiError({
-		kind: "premium_required",
-		message: input.message,
-		status: input.status,
-		code: input.code ?? "PREMIUM_REQUIRED",
-		requestId: input.requestId,
-		retryAfterSeconds: input.retryAfterSeconds,
-		retryable: false,
-		details: input.details
-	});
-	if (input.status === 404 && (normalizedMessage.includes("deprecated") || normalizedMessage.includes("not available to your app") || normalizedMessage.includes("restricted"))) return new SpotifyApiError({
-		kind: "deprecated",
-		message: input.message,
-		status: input.status,
-		code: input.code,
-		requestId: input.requestId,
-		retryAfterSeconds: input.retryAfterSeconds,
-		retryable: false,
-		details: input.details
-	});
-	return new SpotifyApiError({
-		kind: "http",
-		message: input.message,
-		status: input.status,
-		code: input.code,
-		requestId: input.requestId,
-		retryAfterSeconds: input.retryAfterSeconds,
-		details: input.details
-	});
-}
-
-//#endregion
-//#region src/utils/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$2 = z.object({ artists: z.array(spotifyArtistSchema) });
-const severalAlbumsResponseSchema$1 = z.object({ albums: z.array(spotifyAlbumSchema) });
-const severalTracksResponseSchema$1 = 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$1,
-				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$2,
-				mapResponse: (value) => isRecord(value) ? value : { artists: [] }
-			}),
-			getSeveralArtists: (ids) => request({
-				path: "/artists",
-				query: { ids },
-				responseSchema: severalArtistsResponseSchema$2,
-				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$1,
-				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
-//#region src/operations/add-items-to-playlist.operation.ts
-const playlistPaginationInputSchema$13 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const playlistIdInputSchema$13 = z.object({ playlistId: spotifyIdSchema });
-const playlistAdditionalTypeSchema$13 = z.enum(["track", "episode"]);
-z.object({
-	name: z.string().trim().min(1),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistInputSchema$13 = playlistIdInputSchema$13.extend({
-	market: spotifyMarketSchema.optional(),
-	fields: z.string().trim().min(1).optional(),
-	additionalTypes: z.array(playlistAdditionalTypeSchema$13).min(1).optional()
-});
-playlistIdInputSchema$13.extend({
-	name: z.string().trim().min(1).optional(),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-getPlaylistInputSchema$13.extend({
-	limit: z.number().int().positive().max(100).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const addItemsToPlaylistInputSchema = playlistIdInputSchema$13.extend({
-	uris: z.array(spotifyUriSchema).min(1).max(100),
-	position: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$13.extend({
-	mode: z.literal("reorder"),
-	rangeStart: z.number().int().nonnegative(),
-	insertBefore: z.number().int().nonnegative(),
-	rangeLength: z.number().int().positive().optional(),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistIdInputSchema$13.extend({
-	mode: z.literal("replace"),
-	uris: z.array(spotifyUriSchema).min(1).max(100)
-});
-const playlistTrackRemovalSchema$13 = z.object({
-	uri: spotifyUriSchema,
-	positions: z.array(z.number().int().nonnegative()).min(1).optional()
-});
-playlistIdInputSchema$13.extend({
-	tracks: z.array(playlistTrackRemovalSchema$13).min(1).max(100),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistPaginationInputSchema$13.extend({ userId: spotifyIdSchema });
-playlistIdInputSchema$13.extend({ public: z.boolean().optional() });
-playlistIdInputSchema$13.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
-playlistIdInputSchema$13.extend({ imageBase64: z.string().trim().min(1) });
-z.object({ images: z.array(spotifyPlaylistImageSchema) });
-const addItemsToPlaylistOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.add-items-to-playlist",
-	name: "Add Items To Playlist",
-	description: "Add tracks or episodes to a Spotify playlist.",
-	input: addItemsToPlaylistInputSchema,
-	output: spotifySnapshotResponseSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).playlists.addItemsToPlaylist(input.playlistId, {
-			uris: input.uris,
-			position: input.position
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/add-to-queue.operation.ts
-z.object({});
-const playbackTypesSchema$14 = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema$14 = spotifyIdSchema.optional();
-z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema$14
-});
-z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema$14 = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-z.object({
-	deviceId: deviceIdSchema$14,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema$14.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema$14 = z.object({ deviceId: deviceIdSchema$14 });
-withOptionalDeviceIdSchema$14.extend({ positionMs: z.number().int().nonnegative() });
-withOptionalDeviceIdSchema$14.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-withOptionalDeviceIdSchema$14.extend({ volumePercent: z.number().int().min(0).max(100) });
-withOptionalDeviceIdSchema$14.extend({ state: z.boolean() });
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-const addToQueueInputSchema = withOptionalDeviceIdSchema$14.extend({ uri: spotifyUriSchema });
-z.object({ devices: z.array(spotifyDeviceSchema) });
-const addToQueueOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.add-to-queue",
-	name: "Add To Queue",
-	description: "Add a track or episode to the Spotify playback queue.",
-	input: addToQueueInputSchema,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).player.addToQueue(input.uri, input.deviceId);
-	}
-});
-
-//#endregion
-//#region src/operations/check-saved-albums.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema$14 = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const checkSavedAlbumsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.check-saved-albums",
-	name: "Check Saved Albums",
-	description: "Check whether albums are saved in the connected Spotify account library.",
-	input: savedItemIdsInputSchema$14,
-	output: spotifyBooleanListSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.checkSavedAlbums(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/check-saved-audiobooks.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema$13 = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const checkSavedAudiobooksOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.check-saved-audiobooks",
-	name: "Check Saved Audiobooks",
-	description: "Check whether audiobooks are saved in the connected Spotify account library.",
-	input: savedItemIdsInputSchema$13,
-	output: spotifyBooleanListSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.checkSavedAudiobooks(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/check-saved-episodes.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema$12 = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const checkSavedEpisodesOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.check-saved-episodes",
-	name: "Check Saved Episodes",
-	description: "Check whether episodes are saved in the connected Spotify account library.",
-	input: savedItemIdsInputSchema$12,
-	output: spotifyBooleanListSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.checkSavedEpisodes(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/check-saved-shows.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema$11 = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const checkSavedShowsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.check-saved-shows",
-	name: "Check Saved Shows",
-	description: "Check whether shows are saved in the connected Spotify account library.",
-	input: savedItemIdsInputSchema$11,
-	output: spotifyBooleanListSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.checkSavedShows(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/check-saved-tracks.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema$10 = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const checkSavedTracksOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.check-saved-tracks",
-	name: "Check Saved Tracks",
-	description: "Check whether tracks are saved in the connected Spotify account library.",
-	input: savedItemIdsInputSchema$10,
-	output: spotifyBooleanListSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.checkSavedTracks(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/check-spotify-following-artists-or-users.operation.ts
-const followTypeSchema$3 = z.enum(["artist", "user"]);
-const followIdsSchema$3 = z.array(spotifyIdSchema).min(1).max(50);
-createSpotifyCursorPageSchema(spotifyArtistSchema);
-z.object({
-	after: z.string().min(1).optional(),
-	limit: z.number().int().min(1).max(50).optional()
-});
-const followMutationInputSchema$2 = z.object({
-	type: followTypeSchema$3,
-	ids: followIdsSchema$3
-});
-const checkFollowingArtistsOrUsersOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.check-spotify-following-artists-or-users",
-	name: "Check Following Spotify Artists Or Users",
-	description: "Check whether the current Spotify user follows the given artists or users.",
-	input: followMutationInputSchema$2,
-	output: spotifyBooleanListSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).follow.checkFollowingArtistsOrUsers(input.type, input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/check-users-follow-playlist.operation.ts
-const playlistPaginationInputSchema$12 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const playlistIdInputSchema$12 = z.object({ playlistId: spotifyIdSchema });
-const playlistAdditionalTypeSchema$12 = z.enum(["track", "episode"]);
-z.object({
-	name: z.string().trim().min(1),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistInputSchema$12 = playlistIdInputSchema$12.extend({
-	market: spotifyMarketSchema.optional(),
-	fields: z.string().trim().min(1).optional(),
-	additionalTypes: z.array(playlistAdditionalTypeSchema$12).min(1).optional()
-});
-playlistIdInputSchema$12.extend({
-	name: z.string().trim().min(1).optional(),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-getPlaylistInputSchema$12.extend({
-	limit: z.number().int().positive().max(100).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$12.extend({
-	uris: z.array(spotifyUriSchema).min(1).max(100),
-	position: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$12.extend({
-	mode: z.literal("reorder"),
-	rangeStart: z.number().int().nonnegative(),
-	insertBefore: z.number().int().nonnegative(),
-	rangeLength: z.number().int().positive().optional(),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistIdInputSchema$12.extend({
-	mode: z.literal("replace"),
-	uris: z.array(spotifyUriSchema).min(1).max(100)
-});
-const playlistTrackRemovalSchema$12 = z.object({
-	uri: spotifyUriSchema,
-	positions: z.array(z.number().int().nonnegative()).min(1).optional()
-});
-playlistIdInputSchema$12.extend({
-	tracks: z.array(playlistTrackRemovalSchema$12).min(1).max(100),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistPaginationInputSchema$12.extend({ userId: spotifyIdSchema });
-playlistIdInputSchema$12.extend({ public: z.boolean().optional() });
-const checkUsersFollowPlaylistInputSchema = playlistIdInputSchema$12.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
-playlistIdInputSchema$12.extend({ imageBase64: z.string().trim().min(1) });
-z.object({ images: z.array(spotifyPlaylistImageSchema) });
-const checkUsersFollowPlaylistOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.check-users-follow-playlist",
-	name: "Check Users Follow Playlist",
-	description: "Check whether specific Spotify users follow a playlist.",
-	input: checkUsersFollowPlaylistInputSchema,
-	output: spotifyBooleanListSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).playlists.checkUsersFollowPlaylist(input.playlistId, input.userIds);
-	}
-});
-
-//#endregion
-//#region src/operations/create-playlist.operation.ts
-const playlistPaginationInputSchema$11 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const playlistIdInputSchema$11 = z.object({ playlistId: spotifyIdSchema });
-const playlistAdditionalTypeSchema$11 = z.enum(["track", "episode"]);
-const createPlaylistInputSchema = z.object({
-	name: z.string().trim().min(1),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistInputSchema$11 = playlistIdInputSchema$11.extend({
-	market: spotifyMarketSchema.optional(),
-	fields: z.string().trim().min(1).optional(),
-	additionalTypes: z.array(playlistAdditionalTypeSchema$11).min(1).optional()
-});
-playlistIdInputSchema$11.extend({
-	name: z.string().trim().min(1).optional(),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-getPlaylistInputSchema$11.extend({
-	limit: z.number().int().positive().max(100).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$11.extend({
-	uris: z.array(spotifyUriSchema).min(1).max(100),
-	position: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$11.extend({
-	mode: z.literal("reorder"),
-	rangeStart: z.number().int().nonnegative(),
-	insertBefore: z.number().int().nonnegative(),
-	rangeLength: z.number().int().positive().optional(),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistIdInputSchema$11.extend({
-	mode: z.literal("replace"),
-	uris: z.array(spotifyUriSchema).min(1).max(100)
-});
-const playlistTrackRemovalSchema$11 = z.object({
-	uri: spotifyUriSchema,
-	positions: z.array(z.number().int().nonnegative()).min(1).optional()
-});
-playlistIdInputSchema$11.extend({
-	tracks: z.array(playlistTrackRemovalSchema$11).min(1).max(100),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistPaginationInputSchema$11.extend({ userId: spotifyIdSchema });
-playlistIdInputSchema$11.extend({ public: z.boolean().optional() });
-playlistIdInputSchema$11.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
-playlistIdInputSchema$11.extend({ imageBase64: z.string().trim().min(1) });
-z.object({ images: z.array(spotifyPlaylistImageSchema) });
-const createPlaylistOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.create-playlist",
-	name: "Create Playlist",
-	description: "Create a Spotify playlist for the connected account.",
-	input: createPlaylistInputSchema,
-	output: spotifyPlaylistSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).playlists.createPlaylist(input);
-	}
-});
-
-//#endregion
-//#region src/operations/follow-playlist.operation.ts
-const playlistPaginationInputSchema$10 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const playlistIdInputSchema$10 = z.object({ playlistId: spotifyIdSchema });
-const playlistAdditionalTypeSchema$10 = z.enum(["track", "episode"]);
-z.object({
-	name: z.string().trim().min(1),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistInputSchema$10 = playlistIdInputSchema$10.extend({
-	market: spotifyMarketSchema.optional(),
-	fields: z.string().trim().min(1).optional(),
-	additionalTypes: z.array(playlistAdditionalTypeSchema$10).min(1).optional()
-});
-playlistIdInputSchema$10.extend({
-	name: z.string().trim().min(1).optional(),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-getPlaylistInputSchema$10.extend({
-	limit: z.number().int().positive().max(100).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$10.extend({
-	uris: z.array(spotifyUriSchema).min(1).max(100),
-	position: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$10.extend({
-	mode: z.literal("reorder"),
-	rangeStart: z.number().int().nonnegative(),
-	insertBefore: z.number().int().nonnegative(),
-	rangeLength: z.number().int().positive().optional(),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistIdInputSchema$10.extend({
-	mode: z.literal("replace"),
-	uris: z.array(spotifyUriSchema).min(1).max(100)
-});
-const playlistTrackRemovalSchema$10 = z.object({
-	uri: spotifyUriSchema,
-	positions: z.array(z.number().int().nonnegative()).min(1).optional()
-});
-playlistIdInputSchema$10.extend({
-	tracks: z.array(playlistTrackRemovalSchema$10).min(1).max(100),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistPaginationInputSchema$10.extend({ userId: spotifyIdSchema });
-const followPlaylistInputSchema = playlistIdInputSchema$10.extend({ public: z.boolean().optional() });
-playlistIdInputSchema$10.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
-playlistIdInputSchema$10.extend({ imageBase64: z.string().trim().min(1) });
-z.object({ images: z.array(spotifyPlaylistImageSchema) });
-const followPlaylistOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.follow-playlist",
-	name: "Follow Playlist",
-	description: "Follow a Spotify playlist for the connected account.",
-	input: followPlaylistInputSchema,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).playlists.followPlaylist(input.playlistId, { public: input.public });
-	}
-});
-
-//#endregion
-//#region src/operations/follow-spotify-artists-or-users.operation.ts
-const followTypeSchema$2 = z.enum(["artist", "user"]);
-const followIdsSchema$2 = z.array(spotifyIdSchema).min(1).max(50);
-createSpotifyCursorPageSchema(spotifyArtistSchema);
-z.object({
-	after: z.string().min(1).optional(),
-	limit: z.number().int().min(1).max(50).optional()
-});
-const followMutationInputSchema$1 = z.object({
-	type: followTypeSchema$2,
-	ids: followIdsSchema$2
-});
-const followArtistsOrUsersOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.follow-spotify-artists-or-users",
-	name: "Follow Spotify Artists Or Users",
-	description: "Follow Spotify artists or users for the current account.",
-	needsApproval: true,
-	input: followMutationInputSchema$1,
-	output: spotifyMutationSuccessSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).follow.followArtistsOrUsers(input.type, input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/get-available-devices.operation.ts
-const emptyInputSchema$2 = z.object({});
-const playbackTypesSchema$13 = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema$13 = spotifyIdSchema.optional();
-z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema$13
-});
-z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema$13 = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-z.object({
-	deviceId: deviceIdSchema$13,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema$13.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema$13 = z.object({ deviceId: deviceIdSchema$13 });
-withOptionalDeviceIdSchema$13.extend({ positionMs: z.number().int().nonnegative() });
-withOptionalDeviceIdSchema$13.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-withOptionalDeviceIdSchema$13.extend({ volumePercent: z.number().int().min(0).max(100) });
-withOptionalDeviceIdSchema$13.extend({ state: z.boolean() });
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-withOptionalDeviceIdSchema$13.extend({ uri: spotifyUriSchema });
-const availableDevicesResponseSchema = z.object({ devices: z.array(spotifyDeviceSchema) });
-const getAvailableDevicesOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-available-devices",
-	name: "Get Available Devices",
-	description: "List Spotify devices available for playback.",
-	input: emptyInputSchema$2,
-	output: availableDevicesResponseSchema,
-	run: async (_input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).player.getAvailableDevices();
-	}
-});
-
-//#endregion
-//#region src/operations/get-currently-playing.operation.ts
-z.object({});
-const playbackTypesSchema$12 = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema$12 = spotifyIdSchema.optional();
-const currentlyPlayingInputSchema = z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema$12
-});
-z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema$12 = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-z.object({
-	deviceId: deviceIdSchema$12,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema$12.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema$12 = z.object({ deviceId: deviceIdSchema$12 });
-withOptionalDeviceIdSchema$12.extend({ positionMs: z.number().int().nonnegative() });
-withOptionalDeviceIdSchema$12.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-withOptionalDeviceIdSchema$12.extend({ volumePercent: z.number().int().min(0).max(100) });
-withOptionalDeviceIdSchema$12.extend({ state: z.boolean() });
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-withOptionalDeviceIdSchema$12.extend({ uri: spotifyUriSchema });
-z.object({ devices: z.array(spotifyDeviceSchema) });
-const getCurrentlyPlayingOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-currently-playing",
-	name: "Get Currently Playing",
-	description: "Fetch the currently playing Spotify track or episode, if any.",
-	input: currentlyPlayingInputSchema,
-	output: spotifyPlaybackStateSchema.nullable(),
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).player.getCurrentlyPlaying({
-			market: input.market,
-			additional_types: input.additionalTypes
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-playback-state.operation.ts
-z.object({});
-const playbackTypesSchema$11 = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema$11 = spotifyIdSchema.optional();
-z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema$11
-});
-z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema$11 = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-z.object({
-	deviceId: deviceIdSchema$11,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema$11.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema$11 = z.object({ deviceId: deviceIdSchema$11 });
-withOptionalDeviceIdSchema$11.extend({ positionMs: z.number().int().nonnegative() });
-withOptionalDeviceIdSchema$11.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-withOptionalDeviceIdSchema$11.extend({ volumePercent: z.number().int().min(0).max(100) });
-withOptionalDeviceIdSchema$11.extend({ state: z.boolean() });
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-withOptionalDeviceIdSchema$11.extend({ uri: spotifyUriSchema });
-z.object({ devices: z.array(spotifyDeviceSchema) });
-const getPlaybackStateOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-playback-state",
-	name: "Get Playback State",
-	description: "Fetch the current Spotify playback state for the connected account.",
-	input: z.object({ market: spotifyMarketSchema.optional() }),
-	output: spotifyPlaybackStateSchema.nullable(),
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).player.getPlaybackState(input.market);
-	}
-});
-
-//#endregion
-//#region src/operations/get-playlist.operation.ts
-const playlistPaginationInputSchema$9 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const playlistIdInputSchema$9 = z.object({ playlistId: spotifyIdSchema });
-const playlistAdditionalTypeSchema$9 = z.enum(["track", "episode"]);
-z.object({
-	name: z.string().trim().min(1),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistInputSchema$9 = playlistIdInputSchema$9.extend({
-	market: spotifyMarketSchema.optional(),
-	fields: z.string().trim().min(1).optional(),
-	additionalTypes: z.array(playlistAdditionalTypeSchema$9).min(1).optional()
-});
-playlistIdInputSchema$9.extend({
-	name: z.string().trim().min(1).optional(),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-getPlaylistInputSchema$9.extend({
-	limit: z.number().int().positive().max(100).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$9.extend({
-	uris: z.array(spotifyUriSchema).min(1).max(100),
-	position: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$9.extend({
-	mode: z.literal("reorder"),
-	rangeStart: z.number().int().nonnegative(),
-	insertBefore: z.number().int().nonnegative(),
-	rangeLength: z.number().int().positive().optional(),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistIdInputSchema$9.extend({
-	mode: z.literal("replace"),
-	uris: z.array(spotifyUriSchema).min(1).max(100)
-});
-const playlistTrackRemovalSchema$9 = z.object({
-	uri: spotifyUriSchema,
-	positions: z.array(z.number().int().nonnegative()).min(1).optional()
-});
-playlistIdInputSchema$9.extend({
-	tracks: z.array(playlistTrackRemovalSchema$9).min(1).max(100),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistPaginationInputSchema$9.extend({ userId: spotifyIdSchema });
-playlistIdInputSchema$9.extend({ public: z.boolean().optional() });
-playlistIdInputSchema$9.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
-playlistIdInputSchema$9.extend({ imageBase64: z.string().trim().min(1) });
-z.object({ images: z.array(spotifyPlaylistImageSchema) });
-const getPlaylistOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-playlist",
-	name: "Get Playlist",
-	description: "Fetch a Spotify playlist by ID.",
-	input: getPlaylistInputSchema$9,
-	output: spotifyPlaylistSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).playlists.getPlaylist(input.playlistId, {
-			market: input.market,
-			fields: input.fields,
-			additional_types: input.additionalTypes
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-playlist-cover-image.operation.ts
-const playlistPaginationInputSchema$8 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const playlistIdInputSchema$8 = z.object({ playlistId: spotifyIdSchema });
-const playlistAdditionalTypeSchema$8 = z.enum(["track", "episode"]);
-z.object({
-	name: z.string().trim().min(1),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistInputSchema$8 = playlistIdInputSchema$8.extend({
-	market: spotifyMarketSchema.optional(),
-	fields: z.string().trim().min(1).optional(),
-	additionalTypes: z.array(playlistAdditionalTypeSchema$8).min(1).optional()
-});
-playlistIdInputSchema$8.extend({
-	name: z.string().trim().min(1).optional(),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-getPlaylistInputSchema$8.extend({
-	limit: z.number().int().positive().max(100).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$8.extend({
-	uris: z.array(spotifyUriSchema).min(1).max(100),
-	position: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$8.extend({
-	mode: z.literal("reorder"),
-	rangeStart: z.number().int().nonnegative(),
-	insertBefore: z.number().int().nonnegative(),
-	rangeLength: z.number().int().positive().optional(),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistIdInputSchema$8.extend({
-	mode: z.literal("replace"),
-	uris: z.array(spotifyUriSchema).min(1).max(100)
-});
-const playlistTrackRemovalSchema$8 = z.object({
-	uri: spotifyUriSchema,
-	positions: z.array(z.number().int().nonnegative()).min(1).optional()
-});
-playlistIdInputSchema$8.extend({
-	tracks: z.array(playlistTrackRemovalSchema$8).min(1).max(100),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistPaginationInputSchema$8.extend({ userId: spotifyIdSchema });
-playlistIdInputSchema$8.extend({ public: z.boolean().optional() });
-playlistIdInputSchema$8.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
-playlistIdInputSchema$8.extend({ imageBase64: z.string().trim().min(1) });
-const playlistCoverImageResponseSchema = z.object({ images: z.array(spotifyPlaylistImageSchema) });
-const getPlaylistCoverImageOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-playlist-cover-image",
-	name: "Get Playlist Cover Image",
-	description: "Fetch cover images for a Spotify playlist.",
-	input: playlistIdInputSchema$8,
-	output: playlistCoverImageResponseSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).playlists.getPlaylistCoverImage(input.playlistId);
-	}
-});
-
-//#endregion
-//#region src/operations/get-playlist-items.operation.ts
-const playlistPaginationInputSchema$7 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const playlistIdInputSchema$7 = z.object({ playlistId: spotifyIdSchema });
-const playlistAdditionalTypeSchema$7 = z.enum(["track", "episode"]);
-z.object({
-	name: z.string().trim().min(1),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistInputSchema$7 = playlistIdInputSchema$7.extend({
-	market: spotifyMarketSchema.optional(),
-	fields: z.string().trim().min(1).optional(),
-	additionalTypes: z.array(playlistAdditionalTypeSchema$7).min(1).optional()
-});
-playlistIdInputSchema$7.extend({
-	name: z.string().trim().min(1).optional(),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistItemsInputSchema = getPlaylistInputSchema$7.extend({
-	limit: z.number().int().positive().max(100).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$7.extend({
-	uris: z.array(spotifyUriSchema).min(1).max(100),
-	position: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$7.extend({
-	mode: z.literal("reorder"),
-	rangeStart: z.number().int().nonnegative(),
-	insertBefore: z.number().int().nonnegative(),
-	rangeLength: z.number().int().positive().optional(),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistIdInputSchema$7.extend({
-	mode: z.literal("replace"),
-	uris: z.array(spotifyUriSchema).min(1).max(100)
-});
-const playlistTrackRemovalSchema$7 = z.object({
-	uri: spotifyUriSchema,
-	positions: z.array(z.number().int().nonnegative()).min(1).optional()
-});
-playlistIdInputSchema$7.extend({
-	tracks: z.array(playlistTrackRemovalSchema$7).min(1).max(100),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistPaginationInputSchema$7.extend({ userId: spotifyIdSchema });
-playlistIdInputSchema$7.extend({ public: z.boolean().optional() });
-playlistIdInputSchema$7.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
-playlistIdInputSchema$7.extend({ imageBase64: z.string().trim().min(1) });
-z.object({ images: z.array(spotifyPlaylistImageSchema) });
-const getPlaylistItemsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-playlist-items",
-	name: "Get Playlist Items",
-	description: "List tracks and episodes in a Spotify playlist.",
-	input: getPlaylistItemsInputSchema,
-	output: spotifyPlaylistItemPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).playlists.getPlaylistItems(input.playlistId, {
-			market: input.market,
-			fields: input.fields,
-			limit: input.limit,
-			offset: input.offset,
-			additional_types: input.additionalTypes
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-queue.operation.ts
-const emptyInputSchema$1 = z.object({});
-const playbackTypesSchema$10 = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema$10 = spotifyIdSchema.optional();
-z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema$10
-});
-z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema$10 = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-z.object({
-	deviceId: deviceIdSchema$10,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema$10.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema$10 = z.object({ deviceId: deviceIdSchema$10 });
-withOptionalDeviceIdSchema$10.extend({ positionMs: z.number().int().nonnegative() });
-withOptionalDeviceIdSchema$10.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-withOptionalDeviceIdSchema$10.extend({ volumePercent: z.number().int().min(0).max(100) });
-withOptionalDeviceIdSchema$10.extend({ state: z.boolean() });
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-withOptionalDeviceIdSchema$10.extend({ uri: spotifyUriSchema });
-z.object({ devices: z.array(spotifyDeviceSchema) });
-const getQueueOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-queue",
-	name: "Get Queue",
-	description: "Fetch the current Spotify playback queue.",
-	input: emptyInputSchema$1,
-	output: spotifyQueueSchema,
-	run: async (_input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).player.getQueue();
-	}
-});
-
-//#endregion
-//#region src/operations/get-recently-played.operation.ts
-z.object({});
-const playbackTypesSchema$9 = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema$9 = spotifyIdSchema.optional();
-z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema$9
-});
-z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema$9 = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-z.object({
-	deviceId: deviceIdSchema$9,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema$9.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema$9 = z.object({ deviceId: deviceIdSchema$9 });
-withOptionalDeviceIdSchema$9.extend({ positionMs: z.number().int().nonnegative() });
-withOptionalDeviceIdSchema$9.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-withOptionalDeviceIdSchema$9.extend({ volumePercent: z.number().int().min(0).max(100) });
-withOptionalDeviceIdSchema$9.extend({ state: z.boolean() });
-const getRecentlyPlayedInputSchema = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-withOptionalDeviceIdSchema$9.extend({ uri: spotifyUriSchema });
-z.object({ devices: z.array(spotifyDeviceSchema) });
-const getRecentlyPlayedOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-recently-played",
-	name: "Get Recently Played",
-	description: "List recently played Spotify tracks for the connected account.",
-	input: getRecentlyPlayedInputSchema,
-	output: spotifyRecentlyPlayedPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).player.getRecentlyPlayed(input);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-album.operation.ts
-z.array(spotifyIdSchema).min(1).max(20);
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-z.object({ albums: z.array(spotifyAlbumSchema) });
-const getAlbumOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-album",
-	name: "Get Spotify Album",
-	description: "Fetch a Spotify album by its ID.",
-	input: z.object({
-		id: spotifyIdSchema,
-		market: spotifyMarketSchema.optional()
-	}),
-	output: spotifyAlbumSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).albums.getAlbum(input.id, input.market);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-album-tracks.operation.ts
-z.array(spotifyIdSchema).min(1).max(20);
-const pagingSchema$2 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-z.object({ albums: z.array(spotifyAlbumSchema) });
-const getAlbumTracksOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-album-tracks",
-	name: "Get Spotify Album Tracks",
-	description: "List tracks for a Spotify album.",
-	input: pagingSchema$2.extend({
-		id: spotifyIdSchema,
-		market: spotifyMarketSchema.optional()
-	}),
-	output: spotifyTrackPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).albums.getAlbumTracks(input.id, {
-			market: input.market,
-			limit: input.limit,
-			offset: input.offset
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-artist.operation.ts
-z.array(spotifyIdSchema).min(1).max(50);
-z.enum([
-	"album",
-	"single",
-	"appears_on",
-	"compilation"
-]);
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-z.object({ artists: z.array(spotifyArtistSchema) });
-z.object({ tracks: z.array(spotifyTrackSchema) });
-const getArtistOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-artist",
-	name: "Get Spotify Artist",
-	description: "Fetch a Spotify artist by its ID.",
-	input: z.object({ id: spotifyIdSchema }),
-	output: spotifyArtistSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).artists.getArtist(input.id);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-artist-albums.operation.ts
-z.array(spotifyIdSchema).min(1).max(50);
-const artistAlbumGroupSchema = z.enum([
-	"album",
-	"single",
-	"appears_on",
-	"compilation"
-]);
-const pagingSchema$1 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-z.object({ artists: z.array(spotifyArtistSchema) });
-z.object({ tracks: z.array(spotifyTrackSchema) });
-const getArtistAlbumsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-artist-albums",
-	name: "Get Spotify Artist Albums",
-	description: "List albums released by a Spotify artist.",
-	input: pagingSchema$1.extend({
-		id: spotifyIdSchema,
-		includeGroups: z.array(artistAlbumGroupSchema).min(1).optional(),
-		market: spotifyMarketSchema.optional()
-	}),
-	output: spotifyAlbumPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).artists.getArtistAlbums(input.id, {
-			include_groups: input.includeGroups,
-			market: input.market,
-			limit: input.limit,
-			offset: input.offset
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-artist-related-artists.operation.ts
-z.array(spotifyIdSchema).min(1).max(50);
-z.enum([
-	"album",
-	"single",
-	"appears_on",
-	"compilation"
-]);
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const severalArtistsResponseSchema$1 = z.object({ artists: z.array(spotifyArtistSchema) });
-z.object({ tracks: z.array(spotifyTrackSchema) });
-const getArtistRelatedArtistsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-artist-related-artists",
-	name: "Get Spotify Artist Related Artists",
-	description: "Fetch artists related to a Spotify artist. Deprecated upstream by Spotify.",
-	input: z.object({ id: spotifyIdSchema }),
-	output: severalArtistsResponseSchema$1,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).artists.getArtistRelatedArtists(input.id);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-artist-top-tracks.operation.ts
-z.array(spotifyIdSchema).min(1).max(50);
-z.enum([
-	"album",
-	"single",
-	"appears_on",
-	"compilation"
-]);
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-z.object({ artists: z.array(spotifyArtistSchema) });
-const artistTopTracksResponseSchema = z.object({ tracks: z.array(spotifyTrackSchema) });
-const getArtistTopTracksOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-artist-top-tracks",
-	name: "Get Spotify Artist Top Tracks",
-	description: "Fetch the top tracks for a Spotify artist in a market.",
-	input: z.object({
-		id: spotifyIdSchema,
-		market: spotifyMarketSchema
-	}),
-	output: artistTopTracksResponseSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).artists.getArtistTopTracks(input.id, input.market);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-audio-analysis.operation.ts
-const getAudioAnalysisOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-audio-analysis",
-	name: "Get Spotify Audio Analysis",
-	description: "Fetch the detailed Spotify audio analysis for a track.",
-	input: z.object({ id: spotifyIdSchema }),
-	output: spotifyAudioAnalysisSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).audioAnalysis.getAudioAnalysis(input.id);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-audio-features.operation.ts
-z.array(spotifyIdSchema).min(1).max(100);
-z.object({ audioFeatures: z.array(spotifyAudioFeaturesSchema.nullable()) });
-const getAudioFeaturesOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-audio-features",
-	name: "Get Spotify Audio Features",
-	description: "Fetch Spotify audio features for a track.",
-	input: z.object({ id: spotifyIdSchema }),
-	output: spotifyAudioFeaturesSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).audioFeatures.getAudioFeatures(input.id);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-audiobook.operation.ts
-const audiobookIdsSchema$2 = z.array(spotifyIdSchema).min(1).max(50);
-const audiobookLookupInputSchema = z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional()
-});
-z.object({
-	ids: audiobookIdsSchema$2,
-	market: spotifyMarketSchema.optional()
-});
-z.object({ audiobooks: z.array(spotifyAudiobookSchema) });
-z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional(),
-	limit: z.number().int().min(1).max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const getAudiobookOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-audiobook",
-	name: "Get Spotify Audiobook",
-	description: "Fetch a single Spotify audiobook by ID.",
-	input: audiobookLookupInputSchema,
-	output: spotifyAudiobookSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).audiobooks.getAudiobook(input.id, input.market);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-audiobook-chapters.operation.ts
-const audiobookIdsSchema$1 = z.array(spotifyIdSchema).min(1).max(50);
-z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional()
-});
-z.object({
-	ids: audiobookIdsSchema$1,
-	market: spotifyMarketSchema.optional()
-});
-z.object({ audiobooks: z.array(spotifyAudiobookSchema) });
-const audiobookChaptersInputSchema = z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional(),
-	limit: z.number().int().min(1).max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const getAudiobookChaptersOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-audiobook-chapters",
-	name: "Get Spotify Audiobook Chapters",
-	description: "List chapters for a Spotify audiobook.",
-	input: audiobookChaptersInputSchema,
-	output: spotifyChapterPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).audiobooks.getAudiobookChapters(input.id, {
-			market: input.market,
-			limit: input.limit,
-			offset: input.offset
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-available-genre-seeds.operation.ts
-const availableGenreSeedsResponseSchema = z.object({ genres: z.array(z.string().min(1)) });
-const getAvailableGenreSeedsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-available-genre-seeds",
-	name: "Get Spotify Available Genre Seeds",
-	description: "List Spotify recommendation genre seeds. This endpoint is deprecated upstream by Spotify.",
-	input: z.object({}),
-	output: availableGenreSeedsResponseSchema,
-	run: async (_input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).discovery.getAvailableGenreSeeds();
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-available-markets.operation.ts
-const availableMarketsResponseSchema = z.object({ markets: z.array(spotifyMarketSchema) });
-const getAvailableMarketsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-available-markets",
-	name: "Get Spotify Available Markets",
-	description: "List the markets currently supported by Spotify.",
-	input: z.object({}),
-	output: availableMarketsResponseSchema,
-	run: async (_input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).discovery.getAvailableMarkets();
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-browse-categories.operation.ts
-z.string().min(1);
-const categoryPagingSchema$1 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const getBrowseCategoriesOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-browse-categories",
-	name: "Get Spotify Browse Categories",
-	description: "List Spotify browse categories.",
-	input: categoryPagingSchema$1.extend({
-		country: spotifyMarketSchema.optional(),
-		locale: z.string().min(1).optional()
-	}),
-	output: spotifyCategoryPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).discovery.getBrowseCategories({
-			country: input.country,
-			locale: input.locale,
-			limit: input.limit,
-			offset: input.offset
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-browse-category.operation.ts
-const browseCategoryIdSchema$1 = z.string().min(1);
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const getBrowseCategoryOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-browse-category",
-	name: "Get Spotify Browse Category",
-	description: "Fetch a single Spotify browse category.",
-	input: z.object({
-		id: browseCategoryIdSchema$1,
-		country: spotifyMarketSchema.optional(),
-		locale: z.string().min(1).optional()
-	}),
-	output: spotifyCategorySchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).discovery.getBrowseCategory(input.id, {
-			country: input.country,
-			locale: input.locale
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-category-playlists.operation.ts
-const browseCategoryIdSchema = z.string().min(1);
-const categoryPagingSchema = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const getCategoryPlaylistsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-category-playlists",
-	name: "Get Spotify Category Playlists",
-	description: "List playlists for a Spotify browse category. This endpoint is deprecated upstream by Spotify.",
-	input: categoryPagingSchema.extend({
-		id: browseCategoryIdSchema,
-		country: spotifyMarketSchema.optional()
-	}),
-	output: spotifyPlaylistPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).discovery.getCategoryPlaylists(input.id, {
-			country: input.country,
-			limit: input.limit,
-			offset: input.offset
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-chapter.operation.ts
-const chapterIdsSchema$1 = z.array(spotifyIdSchema).min(1).max(50);
-const chapterLookupInputSchema = z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional()
-});
-z.object({
-	ids: chapterIdsSchema$1,
-	market: spotifyMarketSchema.optional()
-});
-z.object({ chapters: z.array(spotifyChapterSchema) });
-const getChapterOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-chapter",
-	name: "Get Spotify Chapter",
-	description: "Fetch a single Spotify chapter by ID.",
-	input: chapterLookupInputSchema,
-	output: spotifyChapterSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).chapters.getChapter(input.id, input.market);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-episode.operation.ts
-const severalEpisodeIdsSchema$1 = z.array(spotifyIdSchema).min(1).max(50);
-const episodeLookupInputSchema = z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional()
-});
-z.object({
-	ids: severalEpisodeIdsSchema$1,
-	market: spotifyMarketSchema.optional()
-});
-z.object({ episodes: z.array(spotifyEpisodeSchema) });
-const getEpisodeOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-episode",
-	name: "Get Spotify Episode",
-	description: "Fetch a single Spotify episode by ID.",
-	input: episodeLookupInputSchema,
-	output: spotifyEpisodeSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).episodes.getEpisode(input.id, input.market);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-featured-playlists.operation.ts
-const getFeaturedPlaylistsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-featured-playlists",
-	name: "Get Spotify Featured Playlists",
-	description: "List featured Spotify playlists for a market. This endpoint is deprecated upstream by Spotify.",
-	input: z.object({
-		country: spotifyMarketSchema.optional(),
-		locale: z.string().min(1).optional(),
-		timestamp: spotifyTimestampSchema.optional(),
-		limit: z.number().int().positive().max(50).optional(),
-		offset: z.number().int().nonnegative().optional()
-	}),
-	output: spotifyPlaylistPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).discovery.getFeaturedPlaylists({
-			country: input.country,
-			locale: input.locale,
-			timestamp: input.timestamp,
-			limit: input.limit,
-			offset: input.offset
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-followed-artists.operation.ts
-const followTypeSchema$1 = z.enum(["artist", "user"]);
-const followIdsSchema$1 = z.array(spotifyIdSchema).min(1).max(50);
-const followedArtistsPageSchema = createSpotifyCursorPageSchema(spotifyArtistSchema);
-const followedArtistsInputSchema = z.object({
-	after: z.string().min(1).optional(),
-	limit: z.number().int().min(1).max(50).optional()
-});
-z.object({
-	type: followTypeSchema$1,
-	ids: followIdsSchema$1
-});
-const getFollowedArtistsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-followed-artists",
-	name: "Get Followed Spotify Artists",
-	description: "List the artists followed by the current Spotify user.",
-	input: followedArtistsInputSchema,
-	output: followedArtistsPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).follow.getFollowedArtists({
-			after: input.after,
-			limit: input.limit
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-me.operation.ts
-const emptyInputSchema = z.object({});
-const topItemTimeRangeSchema$2 = z.enum([
-	"short_term",
-	"medium_term",
-	"long_term"
-]);
-z.object({
-	timeRange: topItemTimeRangeSchema$2.optional(),
-	limit: z.number().int().min(1).max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const getMeOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-me",
-	name: "Get Spotify Me",
-	description: "Fetch the current Spotify user profile.",
-	input: emptyInputSchema,
-	output: spotifyUserSchema,
-	run: async (_input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).users.getMe();
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-my-top-artists.operation.ts
-z.object({});
-const topItemTimeRangeSchema$1 = z.enum([
-	"short_term",
-	"medium_term",
-	"long_term"
-]);
-const topItemsInputSchema$1 = z.object({
-	timeRange: topItemTimeRangeSchema$1.optional(),
-	limit: z.number().int().min(1).max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const getMyTopArtistsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-my-top-artists",
-	name: "Get My Top Spotify Artists",
-	description: "List the current user's top Spotify artists.",
-	input: topItemsInputSchema$1,
-	output: spotifyArtistPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).users.getMyTopArtists({
-			time_range: input.timeRange,
-			limit: input.limit,
-			offset: input.offset
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-my-top-tracks.operation.ts
-z.object({});
-const topItemTimeRangeSchema = z.enum([
-	"short_term",
-	"medium_term",
-	"long_term"
-]);
-const topItemsInputSchema = z.object({
-	timeRange: topItemTimeRangeSchema.optional(),
-	limit: z.number().int().min(1).max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const getMyTopTracksOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-my-top-tracks",
-	name: "Get My Top Spotify Tracks",
-	description: "List the current user's top Spotify tracks.",
-	input: topItemsInputSchema,
-	output: spotifyTrackPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).users.getMyTopTracks({
-			time_range: input.timeRange,
-			limit: input.limit,
-			offset: input.offset
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-new-releases.operation.ts
-z.array(spotifyIdSchema).min(1).max(20);
-const pagingSchema = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-z.object({ albums: z.array(spotifyAlbumSchema) });
-const getNewReleasesOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-new-releases",
-	name: "Get Spotify New Releases",
-	description: "List Spotify new-release albums for a market.",
-	input: pagingSchema.extend({ country: spotifyMarketSchema.optional() }),
-	output: spotifyAlbumPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).albums.getNewReleases({
-			country: input.country,
-			limit: input.limit,
-			offset: input.offset
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-recommendations.operation.ts
-const recommendationNumberSchema = z.number().min(0).max(1);
-const recommendationKeySchema = z.number().int().min(0).max(11);
-const recommendationModeSchema = z.number().int().min(0).max(1);
-const recommendationPopularitySchema = z.number().int().min(0).max(100);
-const recommendationTempoSchema = z.number().nonnegative();
-const recommendationDurationSchema = z.number().int().nonnegative();
-const recommendationTimeSignatureSchema = z.number().int().positive();
-const recommendationSeedIdListSchema = z.array(spotifyIdSchema).max(5).optional();
-const recommendationSeedGenreListSchema = z.array(z.string().min(1)).max(5).optional();
-const recommendationInputSchema = z.object({
-	seedArtists: recommendationSeedIdListSchema,
-	seedGenres: recommendationSeedGenreListSchema,
-	seedTracks: recommendationSeedIdListSchema,
-	market: spotifyMarketSchema.optional(),
-	limit: z.number().int().positive().max(100).optional(),
-	minAcousticness: recommendationNumberSchema.optional(),
-	maxAcousticness: recommendationNumberSchema.optional(),
-	targetAcousticness: recommendationNumberSchema.optional(),
-	minDanceability: recommendationNumberSchema.optional(),
-	maxDanceability: recommendationNumberSchema.optional(),
-	targetDanceability: recommendationNumberSchema.optional(),
-	minDurationMs: recommendationDurationSchema.optional(),
-	maxDurationMs: recommendationDurationSchema.optional(),
-	targetDurationMs: recommendationDurationSchema.optional(),
-	minEnergy: recommendationNumberSchema.optional(),
-	maxEnergy: recommendationNumberSchema.optional(),
-	targetEnergy: recommendationNumberSchema.optional(),
-	minInstrumentalness: recommendationNumberSchema.optional(),
-	maxInstrumentalness: recommendationNumberSchema.optional(),
-	targetInstrumentalness: recommendationNumberSchema.optional(),
-	minKey: recommendationKeySchema.optional(),
-	maxKey: recommendationKeySchema.optional(),
-	targetKey: recommendationKeySchema.optional(),
-	minLiveness: recommendationNumberSchema.optional(),
-	maxLiveness: recommendationNumberSchema.optional(),
-	targetLiveness: recommendationNumberSchema.optional(),
-	minLoudness: z.number().optional(),
-	maxLoudness: z.number().optional(),
-	targetLoudness: z.number().optional(),
-	minMode: recommendationModeSchema.optional(),
-	maxMode: recommendationModeSchema.optional(),
-	targetMode: recommendationModeSchema.optional(),
-	minPopularity: recommendationPopularitySchema.optional(),
-	maxPopularity: recommendationPopularitySchema.optional(),
-	targetPopularity: recommendationPopularitySchema.optional(),
-	minSpeechiness: recommendationNumberSchema.optional(),
-	maxSpeechiness: recommendationNumberSchema.optional(),
-	targetSpeechiness: recommendationNumberSchema.optional(),
-	minTempo: recommendationTempoSchema.optional(),
-	maxTempo: recommendationTempoSchema.optional(),
-	targetTempo: recommendationTempoSchema.optional(),
-	minTimeSignature: recommendationTimeSignatureSchema.optional(),
-	maxTimeSignature: recommendationTimeSignatureSchema.optional(),
-	targetTimeSignature: recommendationTimeSignatureSchema.optional(),
-	minValence: recommendationNumberSchema.optional(),
-	maxValence: recommendationNumberSchema.optional(),
-	targetValence: recommendationNumberSchema.optional()
-}).superRefine((input, ctx) => {
-	const seedCount = (input.seedArtists?.length ?? 0) + (input.seedGenres?.length ?? 0) + (input.seedTracks?.length ?? 0);
-	if (seedCount === 0) ctx.addIssue({
-		code: z.ZodIssueCode.custom,
-		message: "At least one recommendation seed is required.",
-		path: ["seedArtists"]
-	});
-	if (seedCount > 5) ctx.addIssue({
-		code: z.ZodIssueCode.custom,
-		message: "Spotify recommendations support at most 5 combined seeds.",
-		path: ["seedArtists"]
-	});
-});
-const getRecommendationsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-recommendations",
-	name: "Get Spotify Recommendations",
-	description: "Generate Spotify track recommendations from seeds and tunable audio targets.",
-	input: recommendationInputSchema,
-	output: spotifyRecommendationsSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).recommendations.getRecommendations({
-			seed_artists: input.seedArtists,
-			seed_genres: input.seedGenres,
-			seed_tracks: input.seedTracks,
-			market: input.market,
-			limit: input.limit,
-			min_acousticness: input.minAcousticness,
-			max_acousticness: input.maxAcousticness,
-			target_acousticness: input.targetAcousticness,
-			min_danceability: input.minDanceability,
-			max_danceability: input.maxDanceability,
-			target_danceability: input.targetDanceability,
-			min_duration_ms: input.minDurationMs,
-			max_duration_ms: input.maxDurationMs,
-			target_duration_ms: input.targetDurationMs,
-			min_energy: input.minEnergy,
-			max_energy: input.maxEnergy,
-			target_energy: input.targetEnergy,
-			min_instrumentalness: input.minInstrumentalness,
-			max_instrumentalness: input.maxInstrumentalness,
-			target_instrumentalness: input.targetInstrumentalness,
-			min_key: input.minKey,
-			max_key: input.maxKey,
-			target_key: input.targetKey,
-			min_liveness: input.minLiveness,
-			max_liveness: input.maxLiveness,
-			target_liveness: input.targetLiveness,
-			min_loudness: input.minLoudness,
-			max_loudness: input.maxLoudness,
-			target_loudness: input.targetLoudness,
-			min_mode: input.minMode,
-			max_mode: input.maxMode,
-			target_mode: input.targetMode,
-			min_popularity: input.minPopularity,
-			max_popularity: input.maxPopularity,
-			target_popularity: input.targetPopularity,
-			min_speechiness: input.minSpeechiness,
-			max_speechiness: input.maxSpeechiness,
-			target_speechiness: input.targetSpeechiness,
-			min_tempo: input.minTempo,
-			max_tempo: input.maxTempo,
-			target_tempo: input.targetTempo,
-			min_time_signature: input.minTimeSignature,
-			max_time_signature: input.maxTimeSignature,
-			target_time_signature: input.targetTimeSignature,
-			min_valence: input.minValence,
-			max_valence: input.maxValence,
-			target_valence: input.targetValence
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-several-albums.operation.ts
-const albumIdListSchema = z.array(spotifyIdSchema).min(1).max(20);
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const severalAlbumsResponseSchema = z.object({ albums: z.array(spotifyAlbumSchema) });
-const getSeveralAlbumsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-several-albums",
-	name: "Get Several Spotify Albums",
-	description: "Fetch multiple Spotify albums in one request.",
-	input: z.object({
-		ids: albumIdListSchema,
-		market: spotifyMarketSchema.optional()
-	}),
-	output: severalAlbumsResponseSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).albums.getSeveralAlbums(input.ids, input.market);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-several-artists.operation.ts
-const artistIdListSchema = z.array(spotifyIdSchema).min(1).max(50);
-z.enum([
-	"album",
-	"single",
-	"appears_on",
-	"compilation"
-]);
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const severalArtistsResponseSchema = z.object({ artists: z.array(spotifyArtistSchema) });
-z.object({ tracks: z.array(spotifyTrackSchema) });
-const getSeveralArtistsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-several-artists",
-	name: "Get Several Spotify Artists",
-	description: "Fetch multiple Spotify artists in one request.",
-	input: z.object({ ids: artistIdListSchema }),
-	output: severalArtistsResponseSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).artists.getSeveralArtists(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-several-audio-features.operation.ts
-const trackIdListSchema$1 = z.array(spotifyIdSchema).min(1).max(100);
-const severalAudioFeaturesResponseSchema = z.object({ audioFeatures: z.array(spotifyAudioFeaturesSchema.nullable()) });
-const getSeveralAudioFeaturesOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-several-audio-features",
-	name: "Get Several Spotify Audio Features",
-	description: "Fetch Spotify audio features for multiple tracks.",
-	input: z.object({ ids: trackIdListSchema$1 }),
-	output: severalAudioFeaturesResponseSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).audioFeatures.getSeveralAudioFeatures(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-several-audiobooks.operation.ts
-const audiobookIdsSchema = z.array(spotifyIdSchema).min(1).max(50);
-z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional()
-});
-const severalAudiobooksInputSchema = z.object({
-	ids: audiobookIdsSchema,
-	market: spotifyMarketSchema.optional()
-});
-const severalAudiobooksOutputSchema = z.object({ audiobooks: z.array(spotifyAudiobookSchema) });
-z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional(),
-	limit: z.number().int().min(1).max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const getSeveralAudiobooksOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-several-audiobooks",
-	name: "Get Several Spotify Audiobooks",
-	description: "Fetch multiple Spotify audiobooks in a single request.",
-	input: severalAudiobooksInputSchema,
-	output: severalAudiobooksOutputSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).audiobooks.getSeveralAudiobooks(input.ids, input.market);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-several-chapters.operation.ts
-const chapterIdsSchema = z.array(spotifyIdSchema).min(1).max(50);
-z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional()
-});
-const severalChaptersInputSchema = z.object({
-	ids: chapterIdsSchema,
-	market: spotifyMarketSchema.optional()
-});
-const severalChaptersOutputSchema = z.object({ chapters: z.array(spotifyChapterSchema) });
-const getSeveralChaptersOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-several-chapters",
-	name: "Get Several Spotify Chapters",
-	description: "Fetch multiple Spotify chapters in a single request.",
-	input: severalChaptersInputSchema,
-	output: severalChaptersOutputSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).chapters.getSeveralChapters(input.ids, input.market);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-several-episodes.operation.ts
-const severalEpisodeIdsSchema = z.array(spotifyIdSchema).min(1).max(50);
-z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional()
-});
-const severalEpisodesInputSchema = z.object({
-	ids: severalEpisodeIdsSchema,
-	market: spotifyMarketSchema.optional()
-});
-const severalEpisodesOutputSchema = z.object({ episodes: z.array(spotifyEpisodeSchema) });
-const getSeveralEpisodesOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-several-episodes",
-	name: "Get Several Spotify Episodes",
-	description: "Fetch multiple Spotify episodes in a single request.",
-	input: severalEpisodesInputSchema,
-	output: severalEpisodesOutputSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).episodes.getSeveralEpisodes(input.ids, input.market);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-several-shows.operation.ts
-const spotifyManyIdsSchema$2 = z.array(spotifyIdSchema).min(1).max(50);
-z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional()
-});
-const severalShowsInputSchema = z.object({
-	ids: spotifyManyIdsSchema$2,
-	market: spotifyMarketSchema.optional()
-});
-const severalShowsOutputSchema = z.object({ shows: z.array(spotifyShowSchema) });
-z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional(),
-	limit: z.number().int().min(1).max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const getSeveralShowsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-several-shows",
-	name: "Get Several Spotify Shows",
-	description: "Fetch multiple Spotify shows in a single request.",
-	input: severalShowsInputSchema,
-	output: severalShowsOutputSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).shows.getSeveralShows(input.ids, input.market);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-several-tracks.operation.ts
-const trackIdListSchema = z.array(spotifyIdSchema).min(1).max(50);
-const severalTracksResponseSchema = z.object({ tracks: z.array(spotifyTrackSchema) });
-const getSeveralTracksOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-several-tracks",
-	name: "Get Several Spotify Tracks",
-	description: "Fetch multiple Spotify tracks in one request.",
-	input: z.object({
-		ids: trackIdListSchema,
-		market: spotifyMarketSchema.optional()
-	}),
-	output: severalTracksResponseSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).tracks.getSeveralTracks(input.ids, input.market);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-show.operation.ts
-const spotifyManyIdsSchema$1 = z.array(spotifyIdSchema).min(1).max(50);
-const showLookupInputSchema = z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional()
-});
-z.object({
-	ids: spotifyManyIdsSchema$1,
-	market: spotifyMarketSchema.optional()
-});
-z.object({ shows: z.array(spotifyShowSchema) });
-z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional(),
-	limit: z.number().int().min(1).max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const getShowOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-show",
-	name: "Get Spotify Show",
-	description: "Fetch a single Spotify show by ID.",
-	input: showLookupInputSchema,
-	output: spotifyShowSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).shows.getShow(input.id, input.market);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-show-episodes.operation.ts
-const spotifyManyIdsSchema = z.array(spotifyIdSchema).min(1).max(50);
-z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional()
-});
-z.object({
-	ids: spotifyManyIdsSchema,
-	market: spotifyMarketSchema.optional()
-});
-z.object({ shows: z.array(spotifyShowSchema) });
-const showEpisodesInputSchema = z.object({
-	id: spotifyIdSchema,
-	market: spotifyMarketSchema.optional(),
-	limit: z.number().int().min(1).max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const getShowEpisodesOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-show-episodes",
-	name: "Get Spotify Show Episodes",
-	description: "List episodes for a Spotify show.",
-	input: showEpisodesInputSchema,
-	output: spotifyEpisodePageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).shows.getShowEpisodes(input.id, {
-			market: input.market,
-			limit: input.limit,
-			offset: input.offset
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-track.operation.ts
-z.array(spotifyIdSchema).min(1).max(50);
-z.object({ tracks: z.array(spotifyTrackSchema) });
-const getTrackOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-track",
-	name: "Get Spotify Track",
-	description: "Fetch a Spotify track by its ID.",
-	input: z.object({
-		id: spotifyIdSchema,
-		market: spotifyMarketSchema.optional()
-	}),
-	output: spotifyTrackSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).tracks.getTrack(input.id, input.market);
-	}
-});
-
-//#endregion
-//#region src/operations/get-spotify-user.operation.ts
-const userLookupInputSchema = z.object({ id: spotifyIdSchema });
-const getUserOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.get-spotify-user",
-	name: "Get Spotify User",
-	description: "Fetch a Spotify user profile by user ID.",
-	input: userLookupInputSchema,
-	output: spotifyUserSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).users.getUser(input.id);
-	}
-});
-
-//#endregion
-//#region src/operations/list-my-playlists.operation.ts
-const playlistPaginationInputSchema$6 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const playlistIdInputSchema$6 = z.object({ playlistId: spotifyIdSchema });
-const playlistAdditionalTypeSchema$6 = z.enum(["track", "episode"]);
-z.object({
-	name: z.string().trim().min(1),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistInputSchema$6 = playlistIdInputSchema$6.extend({
-	market: spotifyMarketSchema.optional(),
-	fields: z.string().trim().min(1).optional(),
-	additionalTypes: z.array(playlistAdditionalTypeSchema$6).min(1).optional()
-});
-playlistIdInputSchema$6.extend({
-	name: z.string().trim().min(1).optional(),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-getPlaylistInputSchema$6.extend({
-	limit: z.number().int().positive().max(100).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$6.extend({
-	uris: z.array(spotifyUriSchema).min(1).max(100),
-	position: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$6.extend({
-	mode: z.literal("reorder"),
-	rangeStart: z.number().int().nonnegative(),
-	insertBefore: z.number().int().nonnegative(),
-	rangeLength: z.number().int().positive().optional(),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistIdInputSchema$6.extend({
-	mode: z.literal("replace"),
-	uris: z.array(spotifyUriSchema).min(1).max(100)
-});
-const playlistTrackRemovalSchema$6 = z.object({
-	uri: spotifyUriSchema,
-	positions: z.array(z.number().int().nonnegative()).min(1).optional()
-});
-playlistIdInputSchema$6.extend({
-	tracks: z.array(playlistTrackRemovalSchema$6).min(1).max(100),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistPaginationInputSchema$6.extend({ userId: spotifyIdSchema });
-playlistIdInputSchema$6.extend({ public: z.boolean().optional() });
-playlistIdInputSchema$6.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
-playlistIdInputSchema$6.extend({ imageBase64: z.string().trim().min(1) });
-z.object({ images: z.array(spotifyPlaylistImageSchema) });
-const listMyPlaylistsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.list-my-playlists",
-	name: "List My Playlists",
-	description: "List Spotify playlists owned or followed by the connected account.",
-	input: playlistPaginationInputSchema$6,
-	output: spotifyPlaylistPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).playlists.listMyPlaylists(input);
-	}
-});
-
-//#endregion
-//#region src/operations/list-saved-albums.operation.ts
-const marketOffsetPaginationInputSchema$2 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const listSavedAlbumsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.list-saved-albums",
-	name: "List Saved Albums",
-	description: "List albums saved in the connected Spotify account library.",
-	input: marketOffsetPaginationInputSchema$2,
-	output: spotifySavedAlbumPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.listSavedAlbums(input);
-	}
-});
-
-//#endregion
-//#region src/operations/list-saved-audiobooks.operation.ts
-const offsetPaginationInputSchema$1 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-offsetPaginationInputSchema$1.extend({ market: spotifyMarketSchema.optional() });
-z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const listSavedAudiobooksOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.list-saved-audiobooks",
-	name: "List Saved Audiobooks",
-	description: "List audiobooks saved in the connected Spotify account library.",
-	input: offsetPaginationInputSchema$1,
-	output: spotifySavedAudiobookPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.listSavedAudiobooks(input);
-	}
-});
-
-//#endregion
-//#region src/operations/list-saved-episodes.operation.ts
-const marketOffsetPaginationInputSchema$1 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const listSavedEpisodesOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.list-saved-episodes",
-	name: "List Saved Episodes",
-	description: "List episodes saved in the connected Spotify account library.",
-	input: marketOffsetPaginationInputSchema$1,
-	output: spotifySavedEpisodePageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.listSavedEpisodes(input);
-	}
-});
-
-//#endregion
-//#region src/operations/list-saved-shows.operation.ts
-const offsetPaginationInputSchema = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-offsetPaginationInputSchema.extend({ market: spotifyMarketSchema.optional() });
-z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const listSavedShowsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.list-saved-shows",
-	name: "List Saved Shows",
-	description: "List shows saved in the connected Spotify account library.",
-	input: offsetPaginationInputSchema,
-	output: spotifySavedShowPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.listSavedShows(input);
-	}
-});
-
-//#endregion
-//#region src/operations/list-saved-tracks.operation.ts
-const marketOffsetPaginationInputSchema = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const listSavedTracksOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.list-saved-tracks",
-	name: "List Saved Tracks",
-	description: "List tracks saved in the connected Spotify account library.",
-	input: marketOffsetPaginationInputSchema,
-	output: spotifySavedTrackPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.listSavedTracks(input);
-	}
-});
-
-//#endregion
-//#region src/operations/list-user-playlists.operation.ts
-const playlistPaginationInputSchema$5 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const playlistIdInputSchema$5 = z.object({ playlistId: spotifyIdSchema });
-const playlistAdditionalTypeSchema$5 = z.enum(["track", "episode"]);
-z.object({
-	name: z.string().trim().min(1),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistInputSchema$5 = playlistIdInputSchema$5.extend({
-	market: spotifyMarketSchema.optional(),
-	fields: z.string().trim().min(1).optional(),
-	additionalTypes: z.array(playlistAdditionalTypeSchema$5).min(1).optional()
-});
-playlistIdInputSchema$5.extend({
-	name: z.string().trim().min(1).optional(),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-getPlaylistInputSchema$5.extend({
-	limit: z.number().int().positive().max(100).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$5.extend({
-	uris: z.array(spotifyUriSchema).min(1).max(100),
-	position: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$5.extend({
-	mode: z.literal("reorder"),
-	rangeStart: z.number().int().nonnegative(),
-	insertBefore: z.number().int().nonnegative(),
-	rangeLength: z.number().int().positive().optional(),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistIdInputSchema$5.extend({
-	mode: z.literal("replace"),
-	uris: z.array(spotifyUriSchema).min(1).max(100)
-});
-const playlistTrackRemovalSchema$5 = z.object({
-	uri: spotifyUriSchema,
-	positions: z.array(z.number().int().nonnegative()).min(1).optional()
-});
-playlistIdInputSchema$5.extend({
-	tracks: z.array(playlistTrackRemovalSchema$5).min(1).max(100),
-	snapshotId: z.string().trim().min(1).optional()
-});
-const listUserPlaylistsInputSchema = playlistPaginationInputSchema$5.extend({ userId: spotifyIdSchema });
-playlistIdInputSchema$5.extend({ public: z.boolean().optional() });
-playlistIdInputSchema$5.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
-playlistIdInputSchema$5.extend({ imageBase64: z.string().trim().min(1) });
-z.object({ images: z.array(spotifyPlaylistImageSchema) });
-const listUserPlaylistsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.list-user-playlists",
-	name: "List User Playlists",
-	description: "List public Spotify playlists for a given user.",
-	input: listUserPlaylistsInputSchema,
-	output: spotifyPlaylistPageSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).playlists.listUserPlaylists(input.userId, {
-			limit: input.limit,
-			offset: input.offset
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/pause-playback.operation.ts
-z.object({});
-const playbackTypesSchema$8 = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema$8 = spotifyIdSchema.optional();
-z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema$8
-});
-z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema$8 = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-z.object({
-	deviceId: deviceIdSchema$8,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema$8.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema$8 = z.object({ deviceId: deviceIdSchema$8 });
-withOptionalDeviceIdSchema$8.extend({ positionMs: z.number().int().nonnegative() });
-withOptionalDeviceIdSchema$8.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-withOptionalDeviceIdSchema$8.extend({ volumePercent: z.number().int().min(0).max(100) });
-withOptionalDeviceIdSchema$8.extend({ state: z.boolean() });
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-withOptionalDeviceIdSchema$8.extend({ uri: spotifyUriSchema });
-z.object({ devices: z.array(spotifyDeviceSchema) });
-const pausePlaybackOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.pause-playback",
-	name: "Pause Playback",
-	description: "Pause Spotify playback on the current or selected device.",
-	input: withOptionalDeviceIdSchema$8,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).player.pausePlayback(input.deviceId);
-	}
-});
-
-//#endregion
-//#region src/operations/remove-items-from-playlist.operation.ts
-const playlistPaginationInputSchema$4 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const playlistIdInputSchema$4 = z.object({ playlistId: spotifyIdSchema });
-const playlistAdditionalTypeSchema$4 = z.enum(["track", "episode"]);
-z.object({
-	name: z.string().trim().min(1),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistInputSchema$4 = playlistIdInputSchema$4.extend({
-	market: spotifyMarketSchema.optional(),
-	fields: z.string().trim().min(1).optional(),
-	additionalTypes: z.array(playlistAdditionalTypeSchema$4).min(1).optional()
-});
-playlistIdInputSchema$4.extend({
-	name: z.string().trim().min(1).optional(),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-getPlaylistInputSchema$4.extend({
-	limit: z.number().int().positive().max(100).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$4.extend({
-	uris: z.array(spotifyUriSchema).min(1).max(100),
-	position: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$4.extend({
-	mode: z.literal("reorder"),
-	rangeStart: z.number().int().nonnegative(),
-	insertBefore: z.number().int().nonnegative(),
-	rangeLength: z.number().int().positive().optional(),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistIdInputSchema$4.extend({
-	mode: z.literal("replace"),
-	uris: z.array(spotifyUriSchema).min(1).max(100)
-});
-const playlistTrackRemovalSchema$4 = z.object({
-	uri: spotifyUriSchema,
-	positions: z.array(z.number().int().nonnegative()).min(1).optional()
-});
-const removeItemsFromPlaylistInputSchema = playlistIdInputSchema$4.extend({
-	tracks: z.array(playlistTrackRemovalSchema$4).min(1).max(100),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistPaginationInputSchema$4.extend({ userId: spotifyIdSchema });
-playlistIdInputSchema$4.extend({ public: z.boolean().optional() });
-playlistIdInputSchema$4.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
-playlistIdInputSchema$4.extend({ imageBase64: z.string().trim().min(1) });
-z.object({ images: z.array(spotifyPlaylistImageSchema) });
-const removeItemsFromPlaylistOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.remove-items-from-playlist",
-	name: "Remove Items From Playlist",
-	description: "Remove specific tracks or episodes from a Spotify playlist.",
-	input: removeItemsFromPlaylistInputSchema,
-	output: spotifySnapshotResponseSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).playlists.removeItemsFromPlaylist(input.playlistId, {
-			tracks: input.tracks,
-			snapshotId: input.snapshotId
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/remove-saved-albums.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema$9 = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const removeSavedAlbumsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.remove-saved-albums",
-	name: "Remove Saved Albums",
-	description: "Remove saved albums from the connected Spotify account library.",
-	input: savedItemIdsInputSchema$9,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.removeSavedAlbums(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/remove-saved-audiobooks.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema$8 = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const removeSavedAudiobooksOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.remove-saved-audiobooks",
-	name: "Remove Saved Audiobooks",
-	description: "Remove saved audiobooks from the connected Spotify account library.",
-	input: savedItemIdsInputSchema$8,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.removeSavedAudiobooks(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/remove-saved-episodes.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema$7 = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const removeSavedEpisodesOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.remove-saved-episodes",
-	name: "Remove Saved Episodes",
-	description: "Remove saved episodes from the connected Spotify account library.",
-	input: savedItemIdsInputSchema$7,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.removeSavedEpisodes(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/remove-saved-shows.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema$6 = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const removeSavedShowsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.remove-saved-shows",
-	name: "Remove Saved Shows",
-	description: "Remove saved shows from the connected Spotify account library.",
-	input: savedItemIdsInputSchema$6,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.removeSavedShows(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/remove-saved-tracks.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema$5 = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const removeSavedTracksOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.remove-saved-tracks",
-	name: "Remove Saved Tracks",
-	description: "Remove saved tracks from the connected Spotify account library.",
-	input: savedItemIdsInputSchema$5,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.removeSavedTracks(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/reorder-or-replace-playlist-items.operation.ts
-const playlistPaginationInputSchema$3 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const playlistIdInputSchema$3 = z.object({ playlistId: spotifyIdSchema });
-const playlistAdditionalTypeSchema$3 = z.enum(["track", "episode"]);
-z.object({
-	name: z.string().trim().min(1),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistInputSchema$3 = playlistIdInputSchema$3.extend({
-	market: spotifyMarketSchema.optional(),
-	fields: z.string().trim().min(1).optional(),
-	additionalTypes: z.array(playlistAdditionalTypeSchema$3).min(1).optional()
-});
-playlistIdInputSchema$3.extend({
-	name: z.string().trim().min(1).optional(),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-getPlaylistInputSchema$3.extend({
-	limit: z.number().int().positive().max(100).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$3.extend({
-	uris: z.array(spotifyUriSchema).min(1).max(100),
-	position: z.number().int().nonnegative().optional()
-});
-const reorderPlaylistItemsInputSchema = playlistIdInputSchema$3.extend({
-	mode: z.literal("reorder"),
-	rangeStart: z.number().int().nonnegative(),
-	insertBefore: z.number().int().nonnegative(),
-	rangeLength: z.number().int().positive().optional(),
-	snapshotId: z.string().trim().min(1).optional()
-});
-const replacePlaylistItemsInputSchema = playlistIdInputSchema$3.extend({
-	mode: z.literal("replace"),
-	uris: z.array(spotifyUriSchema).min(1).max(100)
-});
-const playlistTrackRemovalSchema$3 = z.object({
-	uri: spotifyUriSchema,
-	positions: z.array(z.number().int().nonnegative()).min(1).optional()
-});
-playlistIdInputSchema$3.extend({
-	tracks: z.array(playlistTrackRemovalSchema$3).min(1).max(100),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistPaginationInputSchema$3.extend({ userId: spotifyIdSchema });
-playlistIdInputSchema$3.extend({ public: z.boolean().optional() });
-playlistIdInputSchema$3.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
-playlistIdInputSchema$3.extend({ imageBase64: z.string().trim().min(1) });
-z.object({ images: z.array(spotifyPlaylistImageSchema) });
-const reorderOrReplacePlaylistItemsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.reorder-or-replace-playlist-items",
-	name: "Reorder Or Replace Playlist Items",
-	description: "Reorder existing playlist items or replace the full playlist contents.",
-	input: z.discriminatedUnion("mode", [reorderPlaylistItemsInputSchema, replacePlaylistItemsInputSchema]),
-	output: spotifySnapshotResponseSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		const client = createSpotifyClient(credentials);
-		if (input.mode === "reorder") return client.playlists.reorderPlaylistItems(input.playlistId, {
-			rangeStart: input.rangeStart,
-			insertBefore: input.insertBefore,
-			rangeLength: input.rangeLength,
-			snapshotId: input.snapshotId
-		});
-		return client.playlists.replacePlaylistItems(input.playlistId, { uris: input.uris });
-	}
-});
-
-//#endregion
-//#region src/operations/save-albums.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema$4 = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const saveAlbumsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.save-albums",
-	name: "Save Albums",
-	description: "Save albums to the connected Spotify account library.",
-	input: savedItemIdsInputSchema$4,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.saveAlbums(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/save-audiobooks.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema$3 = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const saveAudiobooksOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.save-audiobooks",
-	name: "Save Audiobooks",
-	description: "Save audiobooks to the connected Spotify account library.",
-	input: savedItemIdsInputSchema$3,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.saveAudiobooks(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/save-episodes.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema$2 = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const saveEpisodesOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.save-episodes",
-	name: "Save Episodes",
-	description: "Save episodes to the connected Spotify account library.",
-	input: savedItemIdsInputSchema$2,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.saveEpisodes(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/save-shows.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema$1 = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const saveShowsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.save-shows",
-	name: "Save Shows",
-	description: "Save shows to the connected Spotify account library.",
-	input: savedItemIdsInputSchema$1,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.saveShows(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/save-tracks.operation.ts
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-}).extend({ market: spotifyMarketSchema.optional() });
-const savedItemIdsInputSchema = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
-const saveTracksOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.save-tracks",
-	name: "Save Tracks",
-	description: "Save tracks to the connected Spotify account library.",
-	input: savedItemIdsInputSchema,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).library.saveTracks(input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/search-spotify-catalog.operation.ts
-const spotifySearchTypeSchema = z.enum([
-	"album",
-	"artist",
-	"playlist",
-	"track",
-	"show",
-	"episode",
-	"audiobook"
-]);
-const searchOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.search-spotify-catalog",
-	name: "Search Spotify Catalog",
-	description: "Search the Spotify catalog across one or more resource types.",
-	input: z.object({
-		query: z.string().min(1),
-		types: z.array(spotifySearchTypeSchema).min(1),
-		market: spotifyMarketSchema.optional(),
-		limit: z.number().int().positive().max(50).optional(),
-		offset: z.number().int().nonnegative().optional(),
-		includeExternalAudio: z.boolean().optional()
-	}),
-	output: spotifySearchResultSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).discovery.search({
-			q: input.query,
-			type: input.types,
-			market: input.market,
-			limit: input.limit,
-			offset: input.offset,
-			include_external: input.includeExternalAudio ? "audio" : void 0
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/seek-to-position.operation.ts
-z.object({});
-const playbackTypesSchema$7 = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema$7 = spotifyIdSchema.optional();
-z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema$7
-});
-z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema$7 = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-z.object({
-	deviceId: deviceIdSchema$7,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema$7.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema$7 = z.object({ deviceId: deviceIdSchema$7 });
-const seekToPositionInputSchema = withOptionalDeviceIdSchema$7.extend({ positionMs: z.number().int().nonnegative() });
-withOptionalDeviceIdSchema$7.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-withOptionalDeviceIdSchema$7.extend({ volumePercent: z.number().int().min(0).max(100) });
-withOptionalDeviceIdSchema$7.extend({ state: z.boolean() });
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-withOptionalDeviceIdSchema$7.extend({ uri: spotifyUriSchema });
-z.object({ devices: z.array(spotifyDeviceSchema) });
-const seekToPositionOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.seek-to-position",
-	name: "Seek To Position",
-	description: "Seek the currently playing Spotify item to a new playback position.",
-	input: seekToPositionInputSchema,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).player.seekToPosition(input.positionMs, input.deviceId);
-	}
-});
-
-//#endregion
-//#region src/operations/set-playback-volume.operation.ts
-z.object({});
-const playbackTypesSchema$6 = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema$6 = spotifyIdSchema.optional();
-z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema$6
-});
-z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema$6 = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-z.object({
-	deviceId: deviceIdSchema$6,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema$6.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema$6 = z.object({ deviceId: deviceIdSchema$6 });
-withOptionalDeviceIdSchema$6.extend({ positionMs: z.number().int().nonnegative() });
-withOptionalDeviceIdSchema$6.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-const playbackVolumeInputSchema = withOptionalDeviceIdSchema$6.extend({ volumePercent: z.number().int().min(0).max(100) });
-withOptionalDeviceIdSchema$6.extend({ state: z.boolean() });
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-withOptionalDeviceIdSchema$6.extend({ uri: spotifyUriSchema });
-z.object({ devices: z.array(spotifyDeviceSchema) });
-const setPlaybackVolumeOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.set-playback-volume",
-	name: "Set Playback Volume",
-	description: "Set Spotify playback volume on the current or selected device.",
-	input: playbackVolumeInputSchema,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).player.setPlaybackVolume(input.volumePercent, input.deviceId);
-	}
-});
-
-//#endregion
-//#region src/operations/set-repeat-mode.operation.ts
-z.object({});
-const playbackTypesSchema$5 = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema$5 = spotifyIdSchema.optional();
-z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema$5
-});
-z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema$5 = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-z.object({
-	deviceId: deviceIdSchema$5,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema$5.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema$5 = z.object({ deviceId: deviceIdSchema$5 });
-withOptionalDeviceIdSchema$5.extend({ positionMs: z.number().int().nonnegative() });
-const repeatModeInputSchema = withOptionalDeviceIdSchema$5.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-withOptionalDeviceIdSchema$5.extend({ volumePercent: z.number().int().min(0).max(100) });
-withOptionalDeviceIdSchema$5.extend({ state: z.boolean() });
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-withOptionalDeviceIdSchema$5.extend({ uri: spotifyUriSchema });
-z.object({ devices: z.array(spotifyDeviceSchema) });
-const setRepeatModeOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.set-repeat-mode",
-	name: "Set Repeat Mode",
-	description: "Set Spotify repeat mode for the current or selected device.",
-	input: repeatModeInputSchema,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).player.setRepeatMode(input.state, input.deviceId);
-	}
-});
-
-//#endregion
-//#region src/operations/set-shuffle-mode.operation.ts
-z.object({});
-const playbackTypesSchema$4 = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema$4 = spotifyIdSchema.optional();
-z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema$4
-});
-z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema$4 = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-z.object({
-	deviceId: deviceIdSchema$4,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema$4.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema$4 = z.object({ deviceId: deviceIdSchema$4 });
-withOptionalDeviceIdSchema$4.extend({ positionMs: z.number().int().nonnegative() });
-withOptionalDeviceIdSchema$4.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-withOptionalDeviceIdSchema$4.extend({ volumePercent: z.number().int().min(0).max(100) });
-const shuffleModeInputSchema = withOptionalDeviceIdSchema$4.extend({ state: z.boolean() });
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-withOptionalDeviceIdSchema$4.extend({ uri: spotifyUriSchema });
-z.object({ devices: z.array(spotifyDeviceSchema) });
-const setShuffleModeOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.set-shuffle-mode",
-	name: "Set Shuffle Mode",
-	description: "Enable or disable Spotify shuffle mode.",
-	input: shuffleModeInputSchema,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).player.setShuffleMode(input.state, input.deviceId);
-	}
-});
-
-//#endregion
-//#region src/operations/skip-to-next.operation.ts
-z.object({});
-const playbackTypesSchema$3 = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema$3 = spotifyIdSchema.optional();
-z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema$3
-});
-z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema$3 = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-z.object({
-	deviceId: deviceIdSchema$3,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema$3.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema$3 = z.object({ deviceId: deviceIdSchema$3 });
-withOptionalDeviceIdSchema$3.extend({ positionMs: z.number().int().nonnegative() });
-withOptionalDeviceIdSchema$3.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-withOptionalDeviceIdSchema$3.extend({ volumePercent: z.number().int().min(0).max(100) });
-withOptionalDeviceIdSchema$3.extend({ state: z.boolean() });
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-withOptionalDeviceIdSchema$3.extend({ uri: spotifyUriSchema });
-z.object({ devices: z.array(spotifyDeviceSchema) });
-const skipToNextOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.skip-to-next",
-	name: "Skip To Next",
-	description: "Skip to the next Spotify item in the active queue.",
-	input: withOptionalDeviceIdSchema$3,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).player.skipToNext(input.deviceId);
-	}
-});
-
-//#endregion
-//#region src/operations/skip-to-previous.operation.ts
-z.object({});
-const playbackTypesSchema$2 = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema$2 = spotifyIdSchema.optional();
-z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema$2
-});
-z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema$2 = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-z.object({
-	deviceId: deviceIdSchema$2,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema$2.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema$2 = z.object({ deviceId: deviceIdSchema$2 });
-withOptionalDeviceIdSchema$2.extend({ positionMs: z.number().int().nonnegative() });
-withOptionalDeviceIdSchema$2.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-withOptionalDeviceIdSchema$2.extend({ volumePercent: z.number().int().min(0).max(100) });
-withOptionalDeviceIdSchema$2.extend({ state: z.boolean() });
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-withOptionalDeviceIdSchema$2.extend({ uri: spotifyUriSchema });
-z.object({ devices: z.array(spotifyDeviceSchema) });
-const skipToPreviousOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.skip-to-previous",
-	name: "Skip To Previous",
-	description: "Skip to the previous Spotify item in the active queue.",
-	input: withOptionalDeviceIdSchema$2,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).player.skipToPrevious(input.deviceId);
-	}
-});
-
-//#endregion
-//#region src/operations/start-or-resume-playback.operation.ts
-z.object({});
-const playbackTypesSchema$1 = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema$1 = spotifyIdSchema.optional();
-z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema$1
-});
-z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema$1 = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-const startOrResumePlaybackInputSchema = z.object({
-	deviceId: deviceIdSchema$1,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema$1.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema$1 = z.object({ deviceId: deviceIdSchema$1 });
-withOptionalDeviceIdSchema$1.extend({ positionMs: z.number().int().nonnegative() });
-withOptionalDeviceIdSchema$1.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-withOptionalDeviceIdSchema$1.extend({ volumePercent: z.number().int().min(0).max(100) });
-withOptionalDeviceIdSchema$1.extend({ state: z.boolean() });
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-withOptionalDeviceIdSchema$1.extend({ uri: spotifyUriSchema });
-z.object({ devices: z.array(spotifyDeviceSchema) });
-function hasPlaybackBody(input) {
-	return input.contextUri !== void 0 || input.uris !== void 0 || input.offset !== void 0 || input.positionMs !== void 0;
-}
-const startOrResumePlaybackOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.start-or-resume-playback",
-	name: "Start Or Resume Playback",
-	description: "Start or resume Spotify playback on an active or selected device.",
-	input: startOrResumePlaybackInputSchema,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		const client = createSpotifyClient(credentials);
-		const body = hasPlaybackBody(input) ? {
-			contextUri: input.contextUri,
-			uris: input.uris,
-			offset: input.offset,
-			positionMs: input.positionMs
-		} : void 0;
-		return client.player.startOrResumePlayback(body, input.deviceId);
-	}
-});
-
-//#endregion
-//#region src/operations/transfer-playback.operation.ts
-z.object({});
-const playbackTypesSchema = z.array(z.enum(["track", "episode"])).min(1).optional();
-const deviceIdSchema = spotifyIdSchema.optional();
-z.object({
-	market: spotifyMarketSchema.optional(),
-	additionalTypes: playbackTypesSchema
-});
-const transferPlaybackInputSchema = z.object({
-	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
-	play: z.boolean().optional()
-});
-const playbackOffsetSchema = z.object({
-	position: z.number().int().nonnegative().optional(),
-	uri: spotifyUriSchema.optional()
-}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
-z.object({
-	deviceId: deviceIdSchema,
-	contextUri: spotifyUriSchema.optional(),
-	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
-	offset: playbackOffsetSchema.optional(),
-	positionMs: z.number().int().nonnegative().optional()
-});
-const withOptionalDeviceIdSchema = z.object({ deviceId: deviceIdSchema });
-withOptionalDeviceIdSchema.extend({ positionMs: z.number().int().nonnegative() });
-withOptionalDeviceIdSchema.extend({ state: z.enum([
-	"track",
-	"context",
-	"off"
-]) });
-withOptionalDeviceIdSchema.extend({ volumePercent: z.number().int().min(0).max(100) });
-withOptionalDeviceIdSchema.extend({ state: z.boolean() });
-z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	after: z.number().int().nonnegative().optional(),
-	before: z.number().int().nonnegative().optional()
-}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
-withOptionalDeviceIdSchema.extend({ uri: spotifyUriSchema });
-z.object({ devices: z.array(spotifyDeviceSchema) });
-const transferPlaybackOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.transfer-playback",
-	name: "Transfer Playback",
-	description: "Transfer Spotify playback to another available device.",
-	input: transferPlaybackInputSchema,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).player.transferPlayback(input);
-	}
-});
-
-//#endregion
-//#region src/operations/unfollow-playlist.operation.ts
-const playlistPaginationInputSchema$2 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const playlistIdInputSchema$2 = z.object({ playlistId: spotifyIdSchema });
-const playlistAdditionalTypeSchema$2 = z.enum(["track", "episode"]);
-z.object({
-	name: z.string().trim().min(1),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistInputSchema$2 = playlistIdInputSchema$2.extend({
-	market: spotifyMarketSchema.optional(),
-	fields: z.string().trim().min(1).optional(),
-	additionalTypes: z.array(playlistAdditionalTypeSchema$2).min(1).optional()
-});
-playlistIdInputSchema$2.extend({
-	name: z.string().trim().min(1).optional(),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-getPlaylistInputSchema$2.extend({
-	limit: z.number().int().positive().max(100).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$2.extend({
-	uris: z.array(spotifyUriSchema).min(1).max(100),
-	position: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$2.extend({
-	mode: z.literal("reorder"),
-	rangeStart: z.number().int().nonnegative(),
-	insertBefore: z.number().int().nonnegative(),
-	rangeLength: z.number().int().positive().optional(),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistIdInputSchema$2.extend({
-	mode: z.literal("replace"),
-	uris: z.array(spotifyUriSchema).min(1).max(100)
-});
-const playlistTrackRemovalSchema$2 = z.object({
-	uri: spotifyUriSchema,
-	positions: z.array(z.number().int().nonnegative()).min(1).optional()
-});
-playlistIdInputSchema$2.extend({
-	tracks: z.array(playlistTrackRemovalSchema$2).min(1).max(100),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistPaginationInputSchema$2.extend({ userId: spotifyIdSchema });
-playlistIdInputSchema$2.extend({ public: z.boolean().optional() });
-playlistIdInputSchema$2.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
-playlistIdInputSchema$2.extend({ imageBase64: z.string().trim().min(1) });
-z.object({ images: z.array(spotifyPlaylistImageSchema) });
-const unfollowPlaylistOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.unfollow-playlist",
-	name: "Unfollow Playlist",
-	description: "Unfollow a Spotify playlist for the connected account.",
-	input: playlistIdInputSchema$2,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).playlists.unfollowPlaylist(input.playlistId);
-	}
-});
-
-//#endregion
-//#region src/operations/unfollow-spotify-artists-or-users.operation.ts
-const followTypeSchema = z.enum(["artist", "user"]);
-const followIdsSchema = z.array(spotifyIdSchema).min(1).max(50);
-createSpotifyCursorPageSchema(spotifyArtistSchema);
-z.object({
-	after: z.string().min(1).optional(),
-	limit: z.number().int().min(1).max(50).optional()
-});
-const followMutationInputSchema = z.object({
-	type: followTypeSchema,
-	ids: followIdsSchema
-});
-const unfollowArtistsOrUsersOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.unfollow-spotify-artists-or-users",
-	name: "Unfollow Spotify Artists Or Users",
-	description: "Unfollow Spotify artists or users for the current account.",
-	needsApproval: true,
-	input: followMutationInputSchema,
-	output: spotifyMutationSuccessSchema,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).follow.unfollowArtistsOrUsers(input.type, input.ids);
-	}
-});
-
-//#endregion
-//#region src/operations/update-playlist-details.operation.ts
-const playlistPaginationInputSchema$1 = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const playlistIdInputSchema$1 = z.object({ playlistId: spotifyIdSchema });
-const playlistAdditionalTypeSchema$1 = z.enum(["track", "episode"]);
-z.object({
-	name: z.string().trim().min(1),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistInputSchema$1 = playlistIdInputSchema$1.extend({
-	market: spotifyMarketSchema.optional(),
-	fields: z.string().trim().min(1).optional(),
-	additionalTypes: z.array(playlistAdditionalTypeSchema$1).min(1).optional()
-});
-const updatePlaylistDetailsInputSchema = playlistIdInputSchema$1.extend({
-	name: z.string().trim().min(1).optional(),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-getPlaylistInputSchema$1.extend({
-	limit: z.number().int().positive().max(100).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$1.extend({
-	uris: z.array(spotifyUriSchema).min(1).max(100),
-	position: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema$1.extend({
-	mode: z.literal("reorder"),
-	rangeStart: z.number().int().nonnegative(),
-	insertBefore: z.number().int().nonnegative(),
-	rangeLength: z.number().int().positive().optional(),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistIdInputSchema$1.extend({
-	mode: z.literal("replace"),
-	uris: z.array(spotifyUriSchema).min(1).max(100)
-});
-const playlistTrackRemovalSchema$1 = z.object({
-	uri: spotifyUriSchema,
-	positions: z.array(z.number().int().nonnegative()).min(1).optional()
-});
-playlistIdInputSchema$1.extend({
-	tracks: z.array(playlistTrackRemovalSchema$1).min(1).max(100),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistPaginationInputSchema$1.extend({ userId: spotifyIdSchema });
-playlistIdInputSchema$1.extend({ public: z.boolean().optional() });
-playlistIdInputSchema$1.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
-playlistIdInputSchema$1.extend({ imageBase64: z.string().trim().min(1) });
-z.object({ images: z.array(spotifyPlaylistImageSchema) });
-const updatePlaylistDetailsOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.update-playlist-details",
-	name: "Update Playlist Details",
-	description: "Update a Spotify playlist name, privacy, collaboration, or description.",
-	input: updatePlaylistDetailsInputSchema,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).playlists.updatePlaylistDetails(input.playlistId, {
-			name: input.name,
-			public: input.public,
-			collaborative: input.collaborative,
-			description: input.description
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/upload-playlist-cover-image.operation.ts
-const playlistPaginationInputSchema = z.object({
-	limit: z.number().int().positive().max(50).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-const playlistIdInputSchema = z.object({ playlistId: spotifyIdSchema });
-const playlistAdditionalTypeSchema = z.enum(["track", "episode"]);
-z.object({
-	name: z.string().trim().min(1),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-const getPlaylistInputSchema = playlistIdInputSchema.extend({
-	market: spotifyMarketSchema.optional(),
-	fields: z.string().trim().min(1).optional(),
-	additionalTypes: z.array(playlistAdditionalTypeSchema).min(1).optional()
-});
-playlistIdInputSchema.extend({
-	name: z.string().trim().min(1).optional(),
-	public: z.boolean().optional(),
-	collaborative: z.boolean().optional(),
-	description: z.string().optional()
-});
-getPlaylistInputSchema.extend({
-	limit: z.number().int().positive().max(100).optional(),
-	offset: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema.extend({
-	uris: z.array(spotifyUriSchema).min(1).max(100),
-	position: z.number().int().nonnegative().optional()
-});
-playlistIdInputSchema.extend({
-	mode: z.literal("reorder"),
-	rangeStart: z.number().int().nonnegative(),
-	insertBefore: z.number().int().nonnegative(),
-	rangeLength: z.number().int().positive().optional(),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistIdInputSchema.extend({
-	mode: z.literal("replace"),
-	uris: z.array(spotifyUriSchema).min(1).max(100)
-});
-const playlistTrackRemovalSchema = z.object({
-	uri: spotifyUriSchema,
-	positions: z.array(z.number().int().nonnegative()).min(1).optional()
-});
-playlistIdInputSchema.extend({
-	tracks: z.array(playlistTrackRemovalSchema).min(1).max(100),
-	snapshotId: z.string().trim().min(1).optional()
-});
-playlistPaginationInputSchema.extend({ userId: spotifyIdSchema });
-playlistIdInputSchema.extend({ public: z.boolean().optional() });
-playlistIdInputSchema.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
-const uploadPlaylistCoverImageInputSchema = playlistIdInputSchema.extend({ imageBase64: z.string().trim().min(1) });
-z.object({ images: z.array(spotifyPlaylistImageSchema) });
-const uploadPlaylistCoverImageOperation = new Operation({
-	credentialSets: [spotifyCredentialSet],
-	id: "spotify.upload-playlist-cover-image",
-	name: "Upload Playlist Cover Image",
-	description: "Replace the cover image for a Spotify playlist.",
-	input: uploadPlaylistCoverImageInputSchema,
-	output: spotifyMutationSuccessSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const credentials = context.credentials.spotify;
-		return createSpotifyClient(credentials).playlists.uploadPlaylistCoverImage(input.playlistId, input.imageBase64);
-	}
-});
-
-//#endregion
-export { getEpisodeOperation as $, listSavedEpisodesOperation as A, checkSavedShowsOperation as At, getSeveralEpisodesOperation as B, removeSavedAudiobooksOperation as C, getAvailableDevicesOperation as Ct, listUserPlaylistsOperation as D, checkUsersFollowPlaylistOperation as Dt, pausePlaybackOperation as E, createPlaylistOperation as Et, getTrackOperation as F, addItemsToPlaylistOperation as Ft, getSeveralAlbumsOperation as G, getSeveralAudiobooksOperation as H, getShowEpisodesOperation as I, getMyTopTracksOperation as J, getRecommendationsOperation as K, getShowOperation as L, listSavedAlbumsOperation as M, checkSavedAudiobooksOperation as Mt, listMyPlaylistsOperation as N, checkSavedAlbumsOperation as Nt, listSavedTracksOperation as O, checkFollowingArtistsOrUsersOperation as Ot, getUserOperation as P, addToQueueOperation as Pt, getFeaturedPlaylistsOperation as Q, getSeveralTracksOperation as R, removeSavedEpisodesOperation as S, getCurrentlyPlayingOperation as St, removeItemsFromPlaylistOperation as T, followPlaylistOperation as Tt, getSeveralAudioFeaturesOperation as U, getSeveralChaptersOperation as V, getSeveralArtistsOperation as W, getMeOperation as X, getMyTopArtistsOperation as Y, getFollowedArtistsOperation as Z, saveAudiobooksOperation as _, getQueueOperation as _t, transferPlaybackOperation as a, getAvailableGenreSeedsOperation as at, removeSavedTracksOperation as b, getPlaylistOperation as bt, skipToNextOperation as c, getAudioFeaturesOperation as ct, setPlaybackVolumeOperation as d, getArtistRelatedArtistsOperation as dt, getChapterOperation as et, seekToPositionOperation as f, getArtistAlbumsOperation as ft, saveEpisodesOperation as g, getRecentlyPlayedOperation as gt, saveShowsOperation as h, getAlbumOperation as ht, unfollowPlaylistOperation as i, getAvailableMarketsOperation as it, listSavedAudiobooksOperation as j, checkSavedEpisodesOperation as jt, listSavedShowsOperation as k, checkSavedTracksOperation as kt, setShuffleModeOperation as l, getAudioAnalysisOperation as lt, saveTracksOperation as m, getAlbumTracksOperation as mt, updatePlaylistDetailsOperation as n, getBrowseCategoryOperation as nt, startOrResumePlaybackOperation as o, getAudiobookChaptersOperation as ot, searchOperation as p, getArtistOperation as pt, getNewReleasesOperation as q, unfollowArtistsOrUsersOperation as r, getBrowseCategoriesOperation as rt, skipToPreviousOperation as s, getAudiobookOperation as st, uploadPlaylistCoverImageOperation as t, getCategoryPlaylistsOperation as tt, setRepeatModeOperation as u, getArtistTopTracksOperation as ut, saveAlbumsOperation as v, getPlaylistItemsOperation as vt, removeSavedAlbumsOperation as w, followArtistsOrUsersOperation as wt, removeSavedShowsOperation as x, getPlaybackStateOperation as xt, reorderOrReplacePlaylistItemsOperation as y, getPlaylistCoverImageOperation as yt, getSeveralShowsOperation as z };