@saavn-labs/sdk 0.1.0

package/dist/saavn/operations/get-details/schema.ops.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { SaavnAlbumEntity, SaavnArtistEntity, SaavnPlaylistEntity, SaavnSongEntity, SaavnTopSearchesEntity, } from '../../entities';
+import { CSVString, NonEmptyString, PositiveString, } from '../../primitives/string';
+import { SaavnSortBySchema, SaavnSortOrderSchema, } from '../../primitives/enums';
+export const SaavnGetDetailsSchema = {
+    album: {
+        params: z.strictObject({
+            albumid: PositiveString,
+        }),
+        response: SaavnAlbumEntity,
+    },
+    artist: {
+        params: z.strictObject({
+            artistId: PositiveString,
+            n_song: PositiveString.optional(),
+            n_album: PositiveString.optional(),
+            category: SaavnSortBySchema.optional(),
+            sort_order: SaavnSortOrderSchema.optional(),
+        }),
+        response: SaavnArtistEntity,
+    },
+    playlist: {
+        params: z.strictObject({
+            listid: PositiveString,
+            p: PositiveString.optional(),
+            n: PositiveString.optional(),
+        }),
+        response: SaavnPlaylistEntity,
+    },
+    songs: {
+        params: z.strictObject({
+            pids: CSVString,
+        }),
+        response: z.looseObject({
+            songs: z.array(SaavnSongEntity),
+        }),
+    },
+    topAlbumsOfTheYear: {
+        params: z.strictObject({
+            album_year: PositiveString,
+            album_lang: NonEmptyString.optional(),
+        }),
+        response: z.array(SaavnAlbumEntity),
+    },
+    topSearches: {
+        params: z.strictObject({}),
+        response: z.array(SaavnTopSearchesEntity),
+    },
+};

package/dist/saavn/operations/get-reco/index.d.ts

@@ -0,0 +1,144 @@
+import { SaavnGetRecoSchema } from './schema.ops';
+export declare const SaavnGetReco: {
+    albums: {
+        call: string;
+        schema: {
+            readonly params: import("zod").ZodObject<{
+                albumid: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            readonly response: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                title: import("zod").ZodString;
+                subtitle: import("zod").ZodString;
+                type: import("zod").ZodLiteral<"album">;
+                image: import("zod").ZodString;
+                perma_url: import("zod").ZodString;
+                explicit_content: import("zod").ZodString;
+                header_desc: import("zod").ZodString;
+                language: import("zod").ZodString;
+                year: import("zod").ZodString;
+                play_count: import("zod").ZodString;
+            }, import("zod/v4/core").$loose>>;
+        };
+        mapper: (data: import("zod").infer<typeof SaavnGetRecoSchema.albums.response>) => {
+            id: string;
+            type: "album";
+            title: string;
+            subtitle: string;
+            description: string;
+            url: string;
+            images: import("../../..").Image[];
+            language: string;
+            year: number;
+            stats: {
+                playCount: number;
+            };
+            flags: {
+                isExplicit: boolean;
+            };
+        }[];
+    };
+    playlists: {
+        call: string;
+        schema: {
+            readonly params: import("zod").ZodObject<{
+                listid: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            readonly response: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                title: import("zod").ZodString;
+                subtitle: import("zod").ZodString;
+                type: import("zod").ZodLiteral<"playlist">;
+                image: import("zod").ZodString;
+                perma_url: import("zod").ZodString;
+                explicit_content: import("zod").ZodString;
+                more_info: import("zod").ZodObject<{
+                    firstname: import("zod").ZodString;
+                }, import("zod/v4/core").$loose>;
+            }, import("zod/v4/core").$loose>>;
+        };
+        mapper: (data: import("zod").infer<typeof SaavnGetRecoSchema.playlists.response>) => {
+            id: string;
+            type: "playlist";
+            title: string;
+            subtitle: string;
+            url: string;
+            images: import("../../..").Image[];
+            flags: {
+                isExplicit: boolean;
+            };
+            owner: {
+                name: string;
+            };
+        }[];
+    };
+    songs: {
+        call: string;
+        schema: {
+            readonly params: import("zod").ZodObject<{
+                pid: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            readonly response: import("zod").ZodArray<import("zod").ZodLazy<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                title: import("zod").ZodString;
+                subtitle: import("zod").ZodString;
+                type: import("zod").ZodLiteral<"song">;
+                perma_url: import("zod").ZodString;
+                image: import("zod").ZodString;
+                explicit_content: import("zod").ZodString;
+                header_desc: import("zod").ZodString;
+                language: import("zod").ZodString;
+                year: import("zod").ZodString;
+                play_count: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>;
+                more_info: import("zod").ZodObject<{
+                    music: import("zod").ZodString;
+                    album_id: import("zod").ZodString;
+                    album: import("zod").ZodString;
+                    label: import("zod").ZodString;
+                    label_id: import("zod").ZodNullable<import("zod").ZodString>;
+                    origin: import("zod").ZodString;
+                    is_dolby_content: import("zod").ZodBoolean;
+                    encrypted_media_url: import("zod").ZodString;
+                    encrypted_drm_media_url: import("zod").ZodString;
+                    album_url: import("zod").ZodString;
+                    duration: import("zod").ZodString;
+                    has_lyrics: import("zod").ZodString;
+                    lyrics_snippet: import("zod").ZodString;
+                    lyrics_id: import("zod").ZodOptional<import("zod").ZodString>;
+                    copyright_text: import("zod").ZodString;
+                    release_date: import("zod").ZodNullable<import("zod").ZodString>;
+                    label_url: import("zod").ZodOptional<import("zod").ZodString>;
+                    vcode: import("zod").ZodOptional<import("zod").ZodString>;
+                    vlink: import("zod").ZodOptional<import("zod").ZodString>;
+                    artistMap: import("zod").ZodLazy<import("zod").ZodObject<{
+                        primary_artists: import("zod").ZodArray<import("zod").ZodObject<{
+                            id: import("zod").ZodString;
+                            name: import("zod").ZodString;
+                            role: import("zod").ZodString;
+                            image: import("zod").ZodString;
+                            type: import("zod").ZodLiteral<"artist">;
+                            perma_url: import("zod").ZodString;
+                        }, import("zod/v4/core").$loose>>;
+                        featured_artists: import("zod").ZodArray<import("zod").ZodObject<{
+                            id: import("zod").ZodString;
+                            name: import("zod").ZodString;
+                            role: import("zod").ZodString;
+                            image: import("zod").ZodString;
+                            type: import("zod").ZodLiteral<"artist">;
+                            perma_url: import("zod").ZodString;
+                        }, import("zod/v4/core").$loose>>;
+                        artists: import("zod").ZodArray<import("zod").ZodObject<{
+                            id: import("zod").ZodString;
+                            name: import("zod").ZodString;
+                            role: import("zod").ZodString;
+                            image: import("zod").ZodString;
+                            type: import("zod").ZodLiteral<"artist">;
+                            perma_url: import("zod").ZodString;
+                        }, import("zod/v4/core").$loose>>;
+                    }, import("zod/v4/core").$loose>>;
+                }, import("zod/v4/core").$loose>;
+            }, import("zod/v4/core").$loose>>>;
+        };
+        mapper: (data: import("zod").infer<typeof SaavnGetRecoSchema.songs.response>) => import("../../../core/models").Song[];
+    };
+};

package/dist/saavn/operations/get-reco/index.js

@@ -0,0 +1,19 @@
+import { SaavnGetRecoMapper } from './mapper.ops';
+import { SaavnGetRecoSchema } from './schema.ops';
+export const SaavnGetReco = {
+    albums: {
+        call: 'reco.getAlbumReco',
+        schema: SaavnGetRecoSchema.albums,
+        mapper: SaavnGetRecoMapper.albums,
+    },
+    playlists: {
+        call: 'reco.getPlaylistReco',
+        schema: SaavnGetRecoSchema.playlists,
+        mapper: SaavnGetRecoMapper.playlists,
+    },
+    songs: {
+        call: 'reco.getreco',
+        schema: SaavnGetRecoSchema.songs,
+        mapper: SaavnGetRecoMapper.songs,
+    },
+};

package/dist/saavn/operations/get-reco/mapper.ops.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { SaavnGetRecoSchema } from './schema.ops';
+export declare const SaavnGetRecoMapper: {
+    albums: (data: z.infer<typeof SaavnGetRecoSchema.albums.response>) => {
+        id: string;
+        type: "album";
+        title: string;
+        subtitle: string;
+        description: string;
+        url: string;
+        images: import("../../..").Image[];
+        language: string;
+        year: number;
+        stats: {
+            playCount: number;
+        };
+        flags: {
+            isExplicit: boolean;
+        };
+    }[];
+    playlists: (data: z.infer<typeof SaavnGetRecoSchema.playlists.response>) => {
+        id: string;
+        type: "playlist";
+        title: string;
+        subtitle: string;
+        url: string;
+        images: import("../../..").Image[];
+        flags: {
+            isExplicit: boolean;
+        };
+        owner: {
+            name: string;
+        };
+    }[];
+    songs: (data: z.infer<typeof SaavnGetRecoSchema.songs.response>) => import("../../../core/models").Song[];
+};

package/dist/saavn/operations/get-reco/mapper.ops.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { mapSong, parseImageUrls, mapArtist } from '../../common-mapper';
+import { SaavnGetRecoSchema } from './schema.ops';
+export const SaavnGetRecoMapper = {
+    albums: (data) => {
+        return data.map((album) => ({
+            id: album.id,
+            type: 'album',
+            title: album.title,
+            subtitle: album.subtitle,
+            description: album.header_desc,
+            url: album.perma_url,
+            images: parseImageUrls(album.image),
+            language: album.language,
+            year: parseInt(album.year, 10),
+            stats: {
+                playCount: parseInt(album.play_count, 10),
+            },
+            flags: {
+                isExplicit: album.explicit_content === '1',
+            },
+        }));
+    },
+    playlists: (data) => {
+        return data.map((playlist) => ({
+            id: playlist.id,
+            type: 'playlist',
+            title: playlist.title,
+            subtitle: playlist.subtitle,
+            url: playlist.perma_url,
+            images: parseImageUrls(playlist.image),
+            flags: {
+                isExplicit: playlist.explicit_content === '1',
+            },
+            owner: {
+                name: playlist.more_info?.firstname,
+            },
+        }));
+    },
+    songs: (data) => {
+        return data.map(mapSong);
+    },
+};

package/dist/saavn/operations/get-reco/schema.ops.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+export declare const SaavnGetRecoSchema: {
+    readonly albums: {
+        readonly params: z.ZodObject<{
+            albumid: z.ZodString;
+        }, z.core.$strict>;
+        readonly response: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            subtitle: z.ZodString;
+            type: z.ZodLiteral<"album">;
+            image: z.ZodString;
+            perma_url: z.ZodString;
+            explicit_content: z.ZodString;
+            header_desc: z.ZodString;
+            language: z.ZodString;
+            year: z.ZodString;
+            play_count: z.ZodString;
+        }, z.core.$loose>>;
+    };
+    readonly playlists: {
+        readonly params: z.ZodObject<{
+            listid: z.ZodString;
+        }, z.core.$strict>;
+        readonly response: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            subtitle: z.ZodString;
+            type: z.ZodLiteral<"playlist">;
+            image: z.ZodString;
+            perma_url: z.ZodString;
+            explicit_content: z.ZodString;
+            more_info: z.ZodObject<{
+                firstname: z.ZodString;
+            }, z.core.$loose>;
+        }, z.core.$loose>>;
+    };
+    readonly songs: {
+        readonly params: z.ZodObject<{
+            pid: z.ZodString;
+        }, z.core.$strict>;
+        readonly response: z.ZodArray<z.ZodLazy<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            subtitle: z.ZodString;
+            type: z.ZodLiteral<"song">;
+            perma_url: z.ZodString;
+            image: z.ZodString;
+            explicit_content: z.ZodString;
+            header_desc: z.ZodString;
+            language: z.ZodString;
+            year: z.ZodString;
+            play_count: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            more_info: z.ZodObject<{
+                music: z.ZodString;
+                album_id: z.ZodString;
+                album: z.ZodString;
+                label: z.ZodString;
+                label_id: z.ZodNullable<z.ZodString>;
+                origin: z.ZodString;
+                is_dolby_content: z.ZodBoolean;
+                encrypted_media_url: z.ZodString;
+                encrypted_drm_media_url: z.ZodString;
+                album_url: z.ZodString;
+                duration: z.ZodString;
+                has_lyrics: z.ZodString;
+                lyrics_snippet: z.ZodString;
+                lyrics_id: z.ZodOptional<z.ZodString>;
+                copyright_text: z.ZodString;
+                release_date: z.ZodNullable<z.ZodString>;
+                label_url: z.ZodOptional<z.ZodString>;
+                vcode: z.ZodOptional<z.ZodString>;
+                vlink: z.ZodOptional<z.ZodString>;
+                artistMap: z.ZodLazy<z.ZodObject<{
+                    primary_artists: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        name: z.ZodString;
+                        role: z.ZodString;
+                        image: z.ZodString;
+                        type: z.ZodLiteral<"artist">;
+                        perma_url: z.ZodString;
+                    }, z.core.$loose>>;
+                    featured_artists: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        name: z.ZodString;
+                        role: z.ZodString;
+                        image: z.ZodString;
+                        type: z.ZodLiteral<"artist">;
+                        perma_url: z.ZodString;
+                    }, z.core.$loose>>;
+                    artists: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        name: z.ZodString;
+                        role: z.ZodString;
+                        image: z.ZodString;
+                        type: z.ZodLiteral<"artist">;
+                        perma_url: z.ZodString;
+                    }, z.core.$loose>>;
+                }, z.core.$loose>>;
+            }, z.core.$loose>;
+        }, z.core.$loose>>>;
+    };
+};

package/dist/saavn/operations/get-reco/schema.ops.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { NonEmptyString, PositiveString } from '../../primitives/string';
+import { SaavnAlbumBase, SaavnPlaylistBase } from '../../entities/base';
+import { SaavnSongEntity } from '../../entities';
+export const SaavnGetRecoSchema = {
+    albums: {
+        params: z.strictObject({
+            albumid: PositiveString,
+        }),
+        response: z.array(SaavnAlbumBase),
+    },
+    playlists: {
+        params: z.strictObject({
+            listid: PositiveString,
+        }),
+        response: z.array(SaavnPlaylistBase.extend({
+            more_info: z.looseObject({
+                firstname: z.string(),
+            }),
+        })),
+    },
+    songs: {
+        params: z.strictObject({
+            pid: NonEmptyString,
+        }),
+        response: z.array(z.lazy(() => SaavnSongEntity)),
+    },
+};