@keystrokehq/spotify 0.0.1

package/dist/tracks.d.mts

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

package/dist/tracks.mjs

@@ -0,0 +1,37 @@
+import { spotifyIdSchema, spotifyMarketSchema, spotifyTrackSchema } from "./schemas.mjs";
+import { createSpotifyClient } from "./client.mjs";
+import { t as spotifyOperation } from "./factory-tZba6Hij.mjs";
+import { z } from "zod";
+
+//#region src/tracks.ts
+const trackIdListSchema = z.array(spotifyIdSchema).min(1).max(50);
+const severalTracksResponseSchema = z.object({ tracks: z.array(spotifyTrackSchema) });
+const getTrack = spotifyOperation({
+	id: "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, credentials) => {
+		return createSpotifyClient(credentials).tracks.getTrack(input.id, input.market);
+	}
+});
+const getSeveralTracks = spotifyOperation({
+	id: "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, credentials) => {
+		return createSpotifyClient(credentials).tracks.getSeveralTracks(input.ids, input.market);
+	}
+});
+
+//#endregion
+export { getSeveralTracks, getTrack };

package/dist/triggers.d.mts

@@ -0,0 +1,45 @@
+import { n as spotify } from "./integration-DQ5Egd4f.mjs";
+import { spotifyNewDeviceAddedEventSchema, spotifyPlaylistItemsChangedEventSchema, spotifyRecentlyPlayedTrackAddedEventSchema, spotifySavedItemAddedEventSchema, spotifyUserPlaylistsChangedEventSchema } from "./events.mjs";
+import { z } from "zod";
+import { BoundTrigger } from "@keystrokehq/core";
+import { IntegrationTriggerBindingOptions } from "@keystrokehq/integration-authoring";
+import { PollingTriggerManifest } from "@keystrokehq/core/trigger";
+
+//#region src/triggers.d.ts
+type SpotifyCredentialSets = readonly [typeof spotify];
+type SpotifyPollingSchedule = number | `${number}s` | `${number}m` | `${number}h` | `${number}d` | `${number}w` | `${number}y`;
+type SpotifyPollingBoundTrigger<TEvent> = BoundTrigger<TEvent, SpotifyCredentialSets, PollingTriggerManifest, TEvent>;
+interface SpotifyPollingBindingOptions<TEvent> extends IntegrationTriggerBindingOptions<TEvent, TEvent> {
+  readonly schedule?: SpotifyPollingSchedule;
+}
+interface PlaylistItemsChangedOptions extends SpotifyPollingBindingOptions<z.infer<typeof spotifyPlaylistItemsChangedEventSchema>> {
+  readonly playlistId: string;
+  readonly market?: string;
+  readonly limit?: number;
+}
+interface UserPlaylistsChangedOptions extends SpotifyPollingBindingOptions<z.infer<typeof spotifyUserPlaylistsChangedEventSchema>> {
+  readonly limit?: number;
+  readonly offset?: number;
+}
+interface RecentlyPlayedTrackAddedOptions extends SpotifyPollingBindingOptions<z.infer<typeof spotifyRecentlyPlayedTrackAddedEventSchema>> {
+  readonly limit?: number;
+}
+interface SavedItemAddedOptions extends SpotifyPollingBindingOptions<z.infer<typeof spotifySavedItemAddedEventSchema>> {
+  readonly itemType: 'album' | 'track' | 'show' | 'episode' | 'audiobook';
+  readonly limit?: number;
+  readonly market?: string;
+}
+declare function newDeviceAdded(options?: SpotifyPollingBindingOptions<z.infer<typeof spotifyNewDeviceAddedEventSchema>>): SpotifyPollingBoundTrigger<z.infer<typeof spotifyNewDeviceAddedEventSchema>>;
+declare function playlistItemsChanged(options: PlaylistItemsChangedOptions): SpotifyPollingBoundTrigger<z.infer<typeof spotifyPlaylistItemsChangedEventSchema>>;
+declare function userPlaylistsChanged(options?: UserPlaylistsChangedOptions): SpotifyPollingBoundTrigger<z.infer<typeof spotifyUserPlaylistsChangedEventSchema>>;
+declare function recentlyPlayedTrackAdded(options?: RecentlyPlayedTrackAddedOptions): SpotifyPollingBoundTrigger<z.infer<typeof spotifyRecentlyPlayedTrackAddedEventSchema>>;
+declare function savedItemAdded(options: SavedItemAddedOptions): SpotifyPollingBoundTrigger<z.infer<typeof spotifySavedItemAddedEventSchema>>;
+declare const polling: Readonly<{
+  newDeviceAdded: typeof newDeviceAdded;
+  playlistItemsChanged: typeof playlistItemsChanged;
+  userPlaylistsChanged: typeof userPlaylistsChanged;
+  recentlyPlayedTrackAdded: typeof recentlyPlayedTrackAdded;
+  savedItemAdded: typeof savedItemAdded;
+}>;
+//#endregion
+export { newDeviceAdded, playlistItemsChanged, polling, recentlyPlayedTrackAdded, savedItemAdded, userPlaylistsChanged };

package/dist/triggers.mjs

@@ -0,0 +1,201 @@
+import { t as spotify } from "./integration-ykoImsCq.mjs";
+import { createSpotifyClient } from "./client.mjs";
+import { spotifyNewDeviceAddedEventSchema, spotifyPlaylistItemsChangedEventSchema, spotifyRecentlyPlayedTrackAddedEventSchema, spotifySavedItemAddedEventSchema, spotifyUserPlaylistsChangedEventSchema } from "./events.mjs";
+import { z } from "zod";
+import { createPollingTriggerBindingFactory } from "@keystrokehq/integration-authoring";
+
+//#region src/triggers.ts
+const nullableNewDeviceEventSchema = z.union([spotifyNewDeviceAddedEventSchema, z.null()]);
+const nullablePlaylistItemsChangedEventSchema = z.union([spotifyPlaylistItemsChangedEventSchema, z.null()]);
+const nullableUserPlaylistsChangedEventSchema = z.union([spotifyUserPlaylistsChangedEventSchema, z.null()]);
+const nullableRecentlyPlayedTrackAddedEventSchema = z.union([spotifyRecentlyPlayedTrackAddedEventSchema, z.null()]);
+const nullableSavedItemAddedEventSchema = z.union([spotifySavedItemAddedEventSchema, z.null()]);
+function newDeviceAdded(options) {
+	return createPollingTriggerBindingFactory({
+		defaultName: "Spotify New Device Added",
+		defaultDescription: "Poll available Spotify devices and emit the most recent device snapshot.",
+		schedule: options?.schedule ?? "5m",
+		credentialSets: [spotify],
+		response: nullableNewDeviceEventSchema,
+		poll: async (ctx) => {
+			const device = (await createSpotifyClient(ctx.credentials.spotify).player.getAvailableDevices()).devices[0];
+			return device ? {
+				eventId: `device:${device.id ?? device.name}`,
+				type: "device.added",
+				device
+			} : null;
+		},
+		mapPayload: (response) => response,
+		idempotencyKey: (response) => response?.eventId
+	})({
+		name: options?.name,
+		description: options?.description,
+		filter: options?.filter,
+		transform: options?.transform
+	});
+}
+function playlistItemsChanged(options) {
+	return createPollingTriggerBindingFactory({
+		defaultName: "Spotify Playlist Items Changed",
+		defaultDescription: "Poll playlist items and emit the most recent playlist entry.",
+		schedule: options.schedule ?? "5m",
+		credentialSets: [spotify],
+		response: nullablePlaylistItemsChangedEventSchema,
+		poll: async (ctx) => {
+			const item = (await createSpotifyClient(ctx.credentials.spotify).playlists.getPlaylistItems(options.playlistId, {
+				market: options.market,
+				limit: options.limit ?? 20
+			})).items[0];
+			const itemUri = item?.track?.uri ?? item?.track?.id;
+			return item && itemUri ? {
+				eventId: `${options.playlistId}:${item.addedAt ?? "unknown"}:${itemUri}:0`,
+				type: "playlist.item_added",
+				playlistId: options.playlistId,
+				snapshotId: item.addedAt ?? "unknown",
+				item
+			} : null;
+		},
+		mapPayload: (response) => response,
+		idempotencyKey: (response) => response?.eventId
+	})({
+		name: options.name,
+		description: options.description,
+		filter: options.filter,
+		transform: options.transform
+	});
+}
+function userPlaylistsChanged(options) {
+	return createPollingTriggerBindingFactory({
+		defaultName: "Spotify User Playlists Changed",
+		defaultDescription: "Poll the current user playlists and emit the most recent playlist snapshot.",
+		schedule: options?.schedule ?? "5m",
+		credentialSets: [spotify],
+		response: nullableUserPlaylistsChangedEventSchema,
+		poll: async (ctx) => {
+			const playlist = (await createSpotifyClient(ctx.credentials.spotify).playlists.listMyPlaylists({
+				limit: options?.limit ?? 20,
+				offset: options?.offset
+			})).items[0];
+			return playlist ? {
+				eventId: `${playlist.id}:${playlist.tracks?.total ?? 0}:details_changed`,
+				type: "playlist.details_changed",
+				playlist
+			} : null;
+		},
+		mapPayload: (response) => response,
+		idempotencyKey: (response) => response?.eventId
+	})({
+		name: options?.name,
+		description: options?.description,
+		filter: options?.filter,
+		transform: options?.transform
+	});
+}
+function recentlyPlayedTrackAdded(options) {
+	return createPollingTriggerBindingFactory({
+		defaultName: "Spotify Recently Played Track Added",
+		defaultDescription: "Poll recently played tracks and emit the most recent playback event.",
+		schedule: options?.schedule ?? "5m",
+		credentialSets: [spotify],
+		response: nullableRecentlyPlayedTrackAddedEventSchema,
+		poll: async (ctx) => {
+			const play = (await createSpotifyClient(ctx.credentials.spotify).player.getRecentlyPlayed({
+				limit: options?.limit ?? 1,
+				after: ctx.lastPolledAt ? Date.parse(ctx.lastPolledAt) : void 0
+			})).items[0];
+			return play ? {
+				eventId: `${play.playedAt}:${play.track.id}`,
+				type: "recently_played.track_added",
+				play
+			} : null;
+		},
+		mapPayload: (response) => response,
+		idempotencyKey: (response) => response?.eventId
+	})({
+		name: options?.name,
+		description: options?.description,
+		filter: options?.filter,
+		transform: options?.transform
+	});
+}
+function savedItemAdded(options) {
+	return createPollingTriggerBindingFactory({
+		defaultName: "Spotify Saved Item Added",
+		defaultDescription: "Poll the Spotify library and emit the most recent saved item for a resource type.",
+		schedule: options.schedule ?? "5m",
+		credentialSets: [spotify],
+		response: nullableSavedItemAddedEventSchema,
+		poll: async (ctx) => {
+			const client = createSpotifyClient(ctx.credentials.spotify);
+			if (options.itemType === "album") {
+				const item = (await client.library.listSavedAlbums({
+					limit: options.limit ?? 1,
+					market: options.market
+				})).items[0];
+				return item ? {
+					eventId: `album:${item.album.id}:${item.addedAt}`,
+					type: "library.saved_item_added",
+					itemType: "album",
+					item
+				} : null;
+			}
+			if (options.itemType === "track") {
+				const item = (await client.library.listSavedTracks({
+					limit: options.limit ?? 1,
+					market: options.market
+				})).items[0];
+				return item ? {
+					eventId: `track:${item.track.id}:${item.addedAt}`,
+					type: "library.saved_item_added",
+					itemType: "track",
+					item
+				} : null;
+			}
+			if (options.itemType === "show") {
+				const item = (await client.library.listSavedShows({ limit: options.limit ?? 1 })).items[0];
+				return item ? {
+					eventId: `show:${item.show.id}:${item.addedAt}`,
+					type: "library.saved_item_added",
+					itemType: "show",
+					item
+				} : null;
+			}
+			if (options.itemType === "episode") {
+				const item = (await client.library.listSavedEpisodes({
+					limit: options.limit ?? 1,
+					market: options.market
+				})).items[0];
+				return item ? {
+					eventId: `episode:${item.episode.id}:${item.addedAt}`,
+					type: "library.saved_item_added",
+					itemType: "episode",
+					item
+				} : null;
+			}
+			const item = (await client.library.listSavedAudiobooks({ limit: options.limit ?? 1 })).items[0];
+			return item ? {
+				eventId: `audiobook:${item.audiobook.id}:${item.addedAt}`,
+				type: "library.saved_item_added",
+				itemType: "audiobook",
+				item
+			} : null;
+		},
+		mapPayload: (response) => response,
+		idempotencyKey: (response) => response?.eventId
+	})({
+		name: options.name,
+		description: options.description,
+		filter: options.filter,
+		transform: options.transform
+	});
+}
+const polling = Object.freeze({
+	newDeviceAdded,
+	playlistItemsChanged,
+	userPlaylistsChanged,
+	recentlyPlayedTrackAdded,
+	savedItemAdded
+});
+
+//#endregion
+export { newDeviceAdded, playlistItemsChanged, polling, recentlyPlayedTrackAdded, savedItemAdded, userPlaylistsChanged };

package/dist/users.d.mts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/users.d.ts
+declare const getUser: _keystrokehq_core0.Operation<z.ZodObject<{
+  id: z.ZodString;
+}, 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>;
+//#endregion
+export { getUser };

package/dist/users.mjs

@@ -0,0 +1,20 @@
+import { spotifyIdSchema, spotifyUserSchema } from "./schemas.mjs";
+import { createSpotifyClient } from "./client.mjs";
+import { t as spotifyOperation } from "./factory-tZba6Hij.mjs";
+import { z } from "zod";
+
+//#region src/users.ts
+const userLookupInputSchema = z.object({ id: spotifyIdSchema });
+const getUser = spotifyOperation({
+	id: "get_spotify_user",
+	name: "Get Spotify User",
+	description: "Fetch a Spotify user profile by user ID.",
+	input: userLookupInputSchema,
+	output: spotifyUserSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).users.getUser(input.id);
+	}
+});
+
+//#endregion
+export { getUser };

package/dist/verification.d.mts

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

package/dist/verification.mjs

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