@keystrokehq/spotify 0.0.1

package/dist/playlists.mjs

@@ -0,0 +1,243 @@
+import { spotifyBooleanListSchema, spotifyIdSchema, spotifyMarketSchema, spotifyMutationSuccessSchema, spotifyPlaylistImageSchema, spotifyPlaylistItemPageSchema, spotifyPlaylistPageSchema, spotifyPlaylistSchema, spotifySnapshotResponseSchema, spotifyUriSchema } from "./schemas.mjs";
+import { createSpotifyClient } from "./client.mjs";
+import { t as spotifyOperation } from "./factory-tZba6Hij.mjs";
+import { z } from "zod";
+
+//#region src/playlists.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"]);
+const createPlaylistInputSchema = 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()
+});
+const updatePlaylistDetailsInputSchema = playlistIdInputSchema.extend({
+	name: z.string().trim().min(1).optional(),
+	public: z.boolean().optional(),
+	collaborative: z.boolean().optional(),
+	description: z.string().optional()
+});
+const getPlaylistItemsInputSchema = getPlaylistInputSchema.extend({
+	limit: z.number().int().positive().max(100).optional(),
+	offset: z.number().int().nonnegative().optional()
+});
+const addItemsToPlaylistInputSchema = playlistIdInputSchema.extend({
+	uris: z.array(spotifyUriSchema).min(1).max(100),
+	position: z.number().int().nonnegative().optional()
+});
+const reorderPlaylistItemsInputSchema = 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()
+});
+const replacePlaylistItemsInputSchema = 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()
+});
+const removeItemsFromPlaylistInputSchema = playlistIdInputSchema.extend({
+	tracks: z.array(playlistTrackRemovalSchema).min(1).max(100),
+	snapshotId: z.string().trim().min(1).optional()
+});
+const listUserPlaylistsInputSchema = playlistPaginationInputSchema.extend({ userId: spotifyIdSchema });
+const followPlaylistInputSchema = playlistIdInputSchema.extend({ public: z.boolean().optional() });
+const checkUsersFollowPlaylistInputSchema = playlistIdInputSchema.extend({ userIds: z.array(spotifyIdSchema).min(1).max(5) });
+const uploadPlaylistCoverImageInputSchema = playlistIdInputSchema.extend({ imageBase64: z.string().trim().min(1) });
+const playlistCoverImageResponseSchema = z.object({ images: z.array(spotifyPlaylistImageSchema) });
+const createPlaylist = spotifyOperation({
+	id: "create_playlist",
+	name: "Create Playlist",
+	description: "Create a Spotify playlist for the connected account.",
+	input: createPlaylistInputSchema,
+	output: spotifyPlaylistSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).playlists.createPlaylist(input);
+	}
+});
+const getPlaylist = spotifyOperation({
+	id: "get_playlist",
+	name: "Get Playlist",
+	description: "Fetch a Spotify playlist by ID.",
+	input: getPlaylistInputSchema,
+	output: spotifyPlaylistSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).playlists.getPlaylist(input.playlistId, {
+			market: input.market,
+			fields: input.fields,
+			additional_types: input.additionalTypes
+		});
+	}
+});
+const updatePlaylistDetails = spotifyOperation({
+	id: "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, credentials) => {
+		return createSpotifyClient(credentials).playlists.updatePlaylistDetails(input.playlistId, {
+			name: input.name,
+			public: input.public,
+			collaborative: input.collaborative,
+			description: input.description
+		});
+	}
+});
+const getPlaylistItems = spotifyOperation({
+	id: "get_playlist_items",
+	name: "Get Playlist Items",
+	description: "List tracks and episodes in a Spotify playlist.",
+	input: getPlaylistItemsInputSchema,
+	output: spotifyPlaylistItemPageSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).playlists.getPlaylistItems(input.playlistId, {
+			market: input.market,
+			fields: input.fields,
+			limit: input.limit,
+			offset: input.offset,
+			additional_types: input.additionalTypes
+		});
+	}
+});
+const getPlaylistCoverImage = spotifyOperation({
+	id: "get_playlist_cover_image",
+	name: "Get Playlist Cover Image",
+	description: "Fetch cover images for a Spotify playlist.",
+	input: playlistIdInputSchema,
+	output: playlistCoverImageResponseSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).playlists.getPlaylistCoverImage(input.playlistId);
+	}
+});
+const addItemsToPlaylist = spotifyOperation({
+	id: "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, credentials) => {
+		return createSpotifyClient(credentials).playlists.addItemsToPlaylist(input.playlistId, {
+			uris: input.uris,
+			position: input.position
+		});
+	}
+});
+const reorderOrReplacePlaylistItems = spotifyOperation({
+	id: "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, credentials) => {
+		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 });
+	}
+});
+const removeItemsFromPlaylist = spotifyOperation({
+	id: "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, credentials) => {
+		return createSpotifyClient(credentials).playlists.removeItemsFromPlaylist(input.playlistId, {
+			tracks: input.tracks,
+			snapshotId: input.snapshotId
+		});
+	}
+});
+const listMyPlaylists = spotifyOperation({
+	id: "list_my_playlists",
+	name: "List My Playlists",
+	description: "List Spotify playlists owned or followed by the connected account.",
+	input: playlistPaginationInputSchema,
+	output: spotifyPlaylistPageSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).playlists.listMyPlaylists(input);
+	}
+});
+const listUserPlaylists = spotifyOperation({
+	id: "list_user_playlists",
+	name: "List User Playlists",
+	description: "List public Spotify playlists for a given user.",
+	input: listUserPlaylistsInputSchema,
+	output: spotifyPlaylistPageSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).playlists.listUserPlaylists(input.userId, {
+			limit: input.limit,
+			offset: input.offset
+		});
+	}
+});
+const followPlaylist = spotifyOperation({
+	id: "follow_playlist",
+	name: "Follow Playlist",
+	description: "Follow a Spotify playlist for the connected account.",
+	input: followPlaylistInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).playlists.followPlaylist(input.playlistId, { public: input.public });
+	}
+});
+const unfollowPlaylist = spotifyOperation({
+	id: "unfollow_playlist",
+	name: "Unfollow Playlist",
+	description: "Unfollow a Spotify playlist for the connected account.",
+	input: playlistIdInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).playlists.unfollowPlaylist(input.playlistId);
+	}
+});
+const checkUsersFollowPlaylist = spotifyOperation({
+	id: "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, credentials) => {
+		return createSpotifyClient(credentials).playlists.checkUsersFollowPlaylist(input.playlistId, input.userIds);
+	}
+});
+const uploadPlaylistCoverImage = spotifyOperation({
+	id: "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, credentials) => {
+		return createSpotifyClient(credentials).playlists.uploadPlaylistCoverImage(input.playlistId, input.imageBase64);
+	}
+});
+
+//#endregion
+export { addItemsToPlaylist, checkUsersFollowPlaylist, createPlaylist, followPlaylist, getPlaylist, getPlaylistCoverImage, getPlaylistItems, listMyPlaylists, listUserPlaylists, removeItemsFromPlaylist, reorderOrReplacePlaylistItems, unfollowPlaylist, updatePlaylistDetails, uploadPlaylistCoverImage };

package/dist/recommendations.d.mts

@@ -0,0 +1,144 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/recommendations.d.ts
+declare const getRecommendations: _keystrokehq_core0.Operation<z.ZodObject<{
+  seedArtists: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  seedGenres: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  seedTracks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  market: z.ZodOptional<z.ZodString>;
+  limit: z.ZodOptional<z.ZodNumber>;
+  minAcousticness: z.ZodOptional<z.ZodNumber>;
+  maxAcousticness: z.ZodOptional<z.ZodNumber>;
+  targetAcousticness: z.ZodOptional<z.ZodNumber>;
+  minDanceability: z.ZodOptional<z.ZodNumber>;
+  maxDanceability: z.ZodOptional<z.ZodNumber>;
+  targetDanceability: z.ZodOptional<z.ZodNumber>;
+  minDurationMs: z.ZodOptional<z.ZodNumber>;
+  maxDurationMs: z.ZodOptional<z.ZodNumber>;
+  targetDurationMs: z.ZodOptional<z.ZodNumber>;
+  minEnergy: z.ZodOptional<z.ZodNumber>;
+  maxEnergy: z.ZodOptional<z.ZodNumber>;
+  targetEnergy: z.ZodOptional<z.ZodNumber>;
+  minInstrumentalness: z.ZodOptional<z.ZodNumber>;
+  maxInstrumentalness: z.ZodOptional<z.ZodNumber>;
+  targetInstrumentalness: z.ZodOptional<z.ZodNumber>;
+  minKey: z.ZodOptional<z.ZodNumber>;
+  maxKey: z.ZodOptional<z.ZodNumber>;
+  targetKey: z.ZodOptional<z.ZodNumber>;
+  minLiveness: z.ZodOptional<z.ZodNumber>;
+  maxLiveness: z.ZodOptional<z.ZodNumber>;
+  targetLiveness: z.ZodOptional<z.ZodNumber>;
+  minLoudness: z.ZodOptional<z.ZodNumber>;
+  maxLoudness: z.ZodOptional<z.ZodNumber>;
+  targetLoudness: z.ZodOptional<z.ZodNumber>;
+  minMode: z.ZodOptional<z.ZodNumber>;
+  maxMode: z.ZodOptional<z.ZodNumber>;
+  targetMode: z.ZodOptional<z.ZodNumber>;
+  minPopularity: z.ZodOptional<z.ZodNumber>;
+  maxPopularity: z.ZodOptional<z.ZodNumber>;
+  targetPopularity: z.ZodOptional<z.ZodNumber>;
+  minSpeechiness: z.ZodOptional<z.ZodNumber>;
+  maxSpeechiness: z.ZodOptional<z.ZodNumber>;
+  targetSpeechiness: z.ZodOptional<z.ZodNumber>;
+  minTempo: z.ZodOptional<z.ZodNumber>;
+  maxTempo: z.ZodOptional<z.ZodNumber>;
+  targetTempo: z.ZodOptional<z.ZodNumber>;
+  minTimeSignature: z.ZodOptional<z.ZodNumber>;
+  maxTimeSignature: z.ZodOptional<z.ZodNumber>;
+  targetTimeSignature: z.ZodOptional<z.ZodNumber>;
+  minValence: z.ZodOptional<z.ZodNumber>;
+  maxValence: z.ZodOptional<z.ZodNumber>;
+  targetValence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  seeds: z.ZodArray<z.ZodObject<{
+    afterFilteringSize: z.ZodOptional<z.ZodNumber>;
+    afterRelinkingSize: z.ZodOptional<z.ZodNumber>;
+    href: z.ZodOptional<z.ZodURL>;
+    id: z.ZodString;
+    initialPoolSize: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodString;
+  }, z.core.$strip>>;
+  tracks: z.ZodArray<z.ZodObject<{
+    album: z.ZodOptional<z.ZodObject<{
+      albumType: z.ZodOptional<z.ZodEnum<{
+        album: "album";
+        single: "single";
+        compilation: "compilation";
+      }>>;
+      artists: z.ZodArray<z.ZodObject<{
+        externalUrls: z.ZodOptional<z.ZodObject<{
+          spotify: z.ZodOptional<z.ZodURL>;
+        }, z.core.$strip>>;
+        href: z.ZodOptional<z.ZodURL>;
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodLiteral<"artist">;
+        uri: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      availableMarkets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      externalUrls: z.ZodOptional<z.ZodObject<{
+        spotify: z.ZodOptional<z.ZodURL>;
+      }, z.core.$strip>>;
+      href: z.ZodOptional<z.ZodURL>;
+      id: z.ZodString;
+      images: z.ZodArray<z.ZodObject<{
+        url: z.ZodURL;
+        height: z.ZodNullable<z.ZodNumber>;
+        width: z.ZodNullable<z.ZodNumber>;
+      }, z.core.$strip>>;
+      name: z.ZodString;
+      releaseDate: z.ZodOptional<z.ZodString>;
+      releaseDatePrecision: z.ZodOptional<z.ZodEnum<{
+        year: "year";
+        month: "month";
+        day: "day";
+      }>>;
+      totalTracks: z.ZodOptional<z.ZodNumber>;
+      type: z.ZodLiteral<"album">;
+      uri: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    artists: z.ZodArray<z.ZodObject<{
+      externalUrls: z.ZodOptional<z.ZodObject<{
+        spotify: z.ZodOptional<z.ZodURL>;
+      }, z.core.$strip>>;
+      href: z.ZodOptional<z.ZodURL>;
+      id: z.ZodString;
+      name: z.ZodString;
+      type: z.ZodLiteral<"artist">;
+      uri: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    availableMarkets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    discNumber: z.ZodOptional<z.ZodNumber>;
+    durationMs: z.ZodNumber;
+    explicit: z.ZodBoolean;
+    externalIds: z.ZodOptional<z.ZodObject<{
+      isrc: z.ZodOptional<z.ZodString>;
+      ean: z.ZodOptional<z.ZodString>;
+      upc: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    externalUrls: z.ZodOptional<z.ZodObject<{
+      spotify: z.ZodOptional<z.ZodURL>;
+    }, z.core.$strip>>;
+    href: z.ZodOptional<z.ZodURL>;
+    id: z.ZodString;
+    isLocal: z.ZodOptional<z.ZodBoolean>;
+    isPlayable: z.ZodOptional<z.ZodBoolean>;
+    name: z.ZodString;
+    popularity: z.ZodOptional<z.ZodNumber>;
+    previewUrl: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodNull]>>;
+    restrictions: z.ZodOptional<z.ZodObject<{
+      reason: z.ZodString;
+    }, z.core.$strip>>;
+    trackNumber: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"track">;
+    uri: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"spotify", z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { getRecommendations };

package/dist/recommendations.mjs

@@ -0,0 +1,137 @@
+import { spotifyIdSchema, spotifyMarketSchema, spotifyRecommendationsSchema } from "./schemas.mjs";
+import { createSpotifyClient } from "./client.mjs";
+import { t as spotifyOperation } from "./factory-tZba6Hij.mjs";
+import { z } from "zod";
+
+//#region src/recommendations.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 getRecommendations = spotifyOperation({
+	id: "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, credentials) => {
+		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
+export { getRecommendations };