@keystrokehq/spotify 0.0.1

package/dist/library.mjs

@@ -0,0 +1,225 @@
+import { spotifyBooleanListSchema, spotifyIdSchema, spotifyMarketSchema, spotifyMutationSuccessSchema, spotifySavedAlbumPageSchema, spotifySavedAudiobookPageSchema, spotifySavedEpisodePageSchema, spotifySavedShowPageSchema, spotifySavedTrackPageSchema } from "./schemas.mjs";
+import { createSpotifyClient } from "./client.mjs";
+import { t as spotifyOperation } from "./factory-tZba6Hij.mjs";
+import { z } from "zod";
+
+//#region src/library.ts
+const offsetPaginationInputSchema = z.object({
+	limit: z.number().int().positive().max(50).optional(),
+	offset: z.number().int().nonnegative().optional()
+});
+const marketOffsetPaginationInputSchema = offsetPaginationInputSchema.extend({ market: spotifyMarketSchema.optional() });
+const savedItemIdsInputSchema = z.object({ ids: z.array(spotifyIdSchema).min(1).max(50) });
+const listSavedAlbums = spotifyOperation({
+	id: "list_saved_albums",
+	name: "List Saved Albums",
+	description: "List albums saved in the connected Spotify account library.",
+	input: marketOffsetPaginationInputSchema,
+	output: spotifySavedAlbumPageSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.listSavedAlbums(input);
+	}
+});
+const saveAlbums = spotifyOperation({
+	id: "save_albums",
+	name: "Save Albums",
+	description: "Save albums to the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.saveAlbums(input.ids);
+	}
+});
+const removeSavedAlbums = spotifyOperation({
+	id: "remove_saved_albums",
+	name: "Remove Saved Albums",
+	description: "Remove saved albums from the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.removeSavedAlbums(input.ids);
+	}
+});
+const checkSavedAlbums = spotifyOperation({
+	id: "check_saved_albums",
+	name: "Check Saved Albums",
+	description: "Check whether albums are saved in the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyBooleanListSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.checkSavedAlbums(input.ids);
+	}
+});
+const listSavedTracks = spotifyOperation({
+	id: "list_saved_tracks",
+	name: "List Saved Tracks",
+	description: "List tracks saved in the connected Spotify account library.",
+	input: marketOffsetPaginationInputSchema,
+	output: spotifySavedTrackPageSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.listSavedTracks(input);
+	}
+});
+const saveTracks = spotifyOperation({
+	id: "save_tracks",
+	name: "Save Tracks",
+	description: "Save tracks to the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.saveTracks(input.ids);
+	}
+});
+const removeSavedTracks = spotifyOperation({
+	id: "remove_saved_tracks",
+	name: "Remove Saved Tracks",
+	description: "Remove saved tracks from the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.removeSavedTracks(input.ids);
+	}
+});
+const checkSavedTracks = spotifyOperation({
+	id: "check_saved_tracks",
+	name: "Check Saved Tracks",
+	description: "Check whether tracks are saved in the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyBooleanListSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.checkSavedTracks(input.ids);
+	}
+});
+const listSavedShows = spotifyOperation({
+	id: "list_saved_shows",
+	name: "List Saved Shows",
+	description: "List shows saved in the connected Spotify account library.",
+	input: offsetPaginationInputSchema,
+	output: spotifySavedShowPageSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.listSavedShows(input);
+	}
+});
+const saveShows = spotifyOperation({
+	id: "save_shows",
+	name: "Save Shows",
+	description: "Save shows to the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.saveShows(input.ids);
+	}
+});
+const removeSavedShows = spotifyOperation({
+	id: "remove_saved_shows",
+	name: "Remove Saved Shows",
+	description: "Remove saved shows from the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.removeSavedShows(input.ids);
+	}
+});
+const checkSavedShows = spotifyOperation({
+	id: "check_saved_shows",
+	name: "Check Saved Shows",
+	description: "Check whether shows are saved in the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyBooleanListSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.checkSavedShows(input.ids);
+	}
+});
+const listSavedEpisodes = spotifyOperation({
+	id: "list_saved_episodes",
+	name: "List Saved Episodes",
+	description: "List episodes saved in the connected Spotify account library.",
+	input: marketOffsetPaginationInputSchema,
+	output: spotifySavedEpisodePageSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.listSavedEpisodes(input);
+	}
+});
+const saveEpisodes = spotifyOperation({
+	id: "save_episodes",
+	name: "Save Episodes",
+	description: "Save episodes to the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.saveEpisodes(input.ids);
+	}
+});
+const removeSavedEpisodes = spotifyOperation({
+	id: "remove_saved_episodes",
+	name: "Remove Saved Episodes",
+	description: "Remove saved episodes from the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.removeSavedEpisodes(input.ids);
+	}
+});
+const checkSavedEpisodes = spotifyOperation({
+	id: "check_saved_episodes",
+	name: "Check Saved Episodes",
+	description: "Check whether episodes are saved in the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyBooleanListSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.checkSavedEpisodes(input.ids);
+	}
+});
+const listSavedAudiobooks = spotifyOperation({
+	id: "list_saved_audiobooks",
+	name: "List Saved Audiobooks",
+	description: "List audiobooks saved in the connected Spotify account library.",
+	input: offsetPaginationInputSchema,
+	output: spotifySavedAudiobookPageSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.listSavedAudiobooks(input);
+	}
+});
+const saveAudiobooks = spotifyOperation({
+	id: "save_audiobooks",
+	name: "Save Audiobooks",
+	description: "Save audiobooks to the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.saveAudiobooks(input.ids);
+	}
+});
+const removeSavedAudiobooks = spotifyOperation({
+	id: "remove_saved_audiobooks",
+	name: "Remove Saved Audiobooks",
+	description: "Remove saved audiobooks from the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.removeSavedAudiobooks(input.ids);
+	}
+});
+const checkSavedAudiobooks = spotifyOperation({
+	id: "check_saved_audiobooks",
+	name: "Check Saved Audiobooks",
+	description: "Check whether audiobooks are saved in the connected Spotify account library.",
+	input: savedItemIdsInputSchema,
+	output: spotifyBooleanListSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).library.checkSavedAudiobooks(input.ids);
+	}
+});
+
+//#endregion
+export { checkSavedAlbums, checkSavedAudiobooks, checkSavedEpisodes, checkSavedShows, checkSavedTracks, listSavedAlbums, listSavedAudiobooks, listSavedEpisodes, listSavedShows, listSavedTracks, removeSavedAlbums, removeSavedAudiobooks, removeSavedEpisodes, removeSavedShows, removeSavedTracks, saveAlbums, saveAudiobooks, saveEpisodes, saveShows, saveTracks };

package/dist/markets.d.mts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/markets.d.ts
+declare const getAvailableMarkets: _keystrokehq_core0.Operation<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+  markets: z.ZodArray<z.ZodString>;
+}, 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 { getAvailableMarkets };

package/dist/markets.mjs

@@ -0,0 +1,20 @@
+import { spotifyMarketSchema } from "./schemas.mjs";
+import { createSpotifyClient } from "./client.mjs";
+import { t as spotifyOperation } from "./factory-tZba6Hij.mjs";
+import { z } from "zod";
+
+//#region src/markets.ts
+const availableMarketsResponseSchema = z.object({ markets: z.array(spotifyMarketSchema) });
+const getAvailableMarkets = spotifyOperation({
+	id: "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, credentials) => {
+		return createSpotifyClient(credentials).discovery.getAvailableMarkets();
+	}
+});
+
+//#endregion
+export { getAvailableMarkets };

package/dist/me.d.mts

@@ -0,0 +1,169 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/me.d.ts
+declare const getMe: _keystrokehq_core0.Operation<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+  displayName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  externalUrls: z.ZodOptional<z.ZodObject<{
+    spotify: z.ZodOptional<z.ZodURL>;
+  }, z.core.$strip>>;
+  followers: z.ZodOptional<z.ZodObject<{
+    href: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+    total: z.ZodNumber;
+  }, z.core.$strip>>;
+  href: z.ZodOptional<z.ZodURL>;
+  id: z.ZodString;
+  type: z.ZodLiteral<"user">;
+  uri: z.ZodOptional<z.ZodString>;
+  email: z.ZodOptional<z.ZodEmail>;
+  country: z.ZodOptional<z.ZodString>;
+  product: z.ZodOptional<z.ZodString>;
+  images: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    url: z.ZodURL;
+    height: z.ZodNullable<z.ZodNumber>;
+    width: z.ZodNullable<z.ZodNumber>;
+  }, 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>;
+declare const getMyTopArtists: _keystrokehq_core0.Operation<z.ZodObject<{
+  timeRange: z.ZodOptional<z.ZodEnum<{
+    short_term: "short_term";
+    medium_term: "medium_term";
+    long_term: "long_term";
+  }>>;
+  limit: z.ZodOptional<z.ZodNumber>;
+  offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  href: z.ZodOptional<z.ZodURL>;
+  items: 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>;
+    followers: z.ZodOptional<z.ZodObject<{
+      href: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+      total: z.ZodNumber;
+    }, z.core.$strip>>;
+    genres: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    images: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      url: z.ZodURL;
+      height: z.ZodNullable<z.ZodNumber>;
+      width: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    popularity: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  limit: z.ZodNumber;
+  nextPageToken: z.ZodOptional<z.ZodString>;
+  offset: z.ZodNumber;
+  previousPageToken: z.ZodOptional<z.ZodString>;
+  total: z.ZodOptional<z.ZodNumber>;
+}, 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>;
+declare const getMyTopTracks: _keystrokehq_core0.Operation<z.ZodObject<{
+  timeRange: z.ZodOptional<z.ZodEnum<{
+    short_term: "short_term";
+    medium_term: "medium_term";
+    long_term: "long_term";
+  }>>;
+  limit: z.ZodOptional<z.ZodNumber>;
+  offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  href: z.ZodOptional<z.ZodURL>;
+  items: 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>>;
+  limit: z.ZodNumber;
+  nextPageToken: z.ZodOptional<z.ZodString>;
+  offset: z.ZodNumber;
+  previousPageToken: z.ZodOptional<z.ZodString>;
+  total: z.ZodOptional<z.ZodNumber>;
+}, 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 { getMe, getMyTopArtists, getMyTopTracks };

package/dist/me.mjs

@@ -0,0 +1,58 @@
+import { spotifyArtistPageSchema, spotifyTrackPageSchema, spotifyUserSchema } from "./schemas.mjs";
+import { createSpotifyClient } from "./client.mjs";
+import { t as spotifyOperation } from "./factory-tZba6Hij.mjs";
+import { z } from "zod";
+
+//#region src/me.ts
+const emptyInputSchema = 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 getMe = spotifyOperation({
+	id: "get_spotify_me",
+	name: "Get Spotify Me",
+	description: "Fetch the current Spotify user profile.",
+	input: emptyInputSchema,
+	output: spotifyUserSchema,
+	run: async (_input, credentials) => {
+		return createSpotifyClient(credentials).users.getMe();
+	}
+});
+const getMyTopArtists = spotifyOperation({
+	id: "get_spotify_my_top_artists",
+	name: "Get My Top Spotify Artists",
+	description: "List the current user's top Spotify artists.",
+	input: topItemsInputSchema,
+	output: spotifyArtistPageSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).users.getMyTopArtists({
+			time_range: input.timeRange,
+			limit: input.limit,
+			offset: input.offset
+		});
+	}
+});
+const getMyTopTracks = spotifyOperation({
+	id: "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, credentials) => {
+		return createSpotifyClient(credentials).users.getMyTopTracks({
+			time_range: input.timeRange,
+			limit: input.limit,
+			offset: input.offset
+		});
+	}
+});
+
+//#endregion
+export { getMe, getMyTopArtists, getMyTopTracks };

package/dist/messaging.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/messaging.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/operations.d.mts

@@ -0,0 +1,6 @@
+import { AnyOperation } from "@keystrokehq/core/operation";
+
+//#region src/operations.d.ts
+declare const spotifyOperations: Readonly<Record<string, AnyOperation>>;
+//#endregion
+export { spotifyOperations };