@soundx/services 1.0.0

package/dist/cjs/models.d.ts

@@ -0,0 +1,174 @@
+export interface ISuccessResponse<T> {
+    code: number;
+    message: string;
+    data: T;
+}
+export declare enum TrackType {
+    MUSIC = "MUSIC",
+    AUDIOBOOK = "AUDIOBOOK"
+}
+export interface IErrorResponse {
+    code: number;
+    message: string;
+}
+export interface ITableData<T> {
+    pageSize: number;
+    current: number;
+    list: T;
+    total: number;
+}
+export interface ILoadMoreData<T> {
+    pageSize: number;
+    loadCount: number;
+    list: T[];
+    total: number;
+    hasMore: boolean;
+}
+export interface RecommendedItem {
+    title: string;
+    id: string;
+    items: Album[];
+}
+export interface TimelineItem {
+    id: string;
+    time: number;
+    items: (Album | Track)[];
+}
+export interface Track {
+    id: number;
+    name: string;
+    path: string;
+    artist: string;
+    artistEntity: Artist;
+    album: string;
+    albumEntity: Album;
+    cover: string | null;
+    duration: number | null;
+    lyrics: string | null;
+    index: number | null;
+    type: TrackType;
+    createdAt: string | Date;
+    artistId?: number;
+    albumId?: number;
+    folderId?: number;
+    likedByUsers?: UserTrackLike[];
+    listenedByUsers?: UserTrackHistory[];
+    likedAsAudiobookByUsers?: UserAudiobookLike[];
+    listenedAsAudiobookByUsers?: UserAudiobookHistory[];
+    playlists?: Playlist[];
+    progress?: number;
+}
+export interface Album {
+    id: number;
+    name: string;
+    artist: string;
+    cover: string | null;
+    year: string | null;
+    type: TrackType;
+    likedByUsers?: UserAlbumLike[];
+    listenedByUsers?: UserAlbumHistory[];
+    progress?: number;
+    resumeTrackId?: number | null;
+    resumeProgress?: number | null;
+}
+export interface Artist {
+    id: number;
+    name: string;
+    avatar: string | null;
+    type: TrackType;
+    bg_cover?: string | null;
+    description?: string | null;
+}
+export interface UserTrackLike {
+    id: number;
+    userId: number;
+    trackId: number;
+    createdAt: string | Date;
+    user?: User;
+    track?: Track;
+}
+export interface UserTrackHistory {
+    id: number;
+    userId: number;
+    trackId: number;
+    listenedAt: string | Date;
+    user?: User;
+    track?: Track;
+}
+export interface UserAlbumLike {
+    id: number;
+    userId: number;
+    albumId: number;
+    createdAt: string | Date;
+    user?: User;
+    album?: Album;
+}
+export interface UserAlbumHistory {
+    id: number;
+    userId: number;
+    albumId: number;
+    listenedAt: string | Date;
+    user?: User;
+    album?: Album;
+}
+export interface UserAudiobookLike {
+    id: number;
+    userId: number;
+    trackId: number;
+    createdAt: string | Date;
+    user?: User;
+    track?: Track;
+}
+export interface UserAudiobookHistory {
+    id: number;
+    userId: number;
+    trackId: number;
+    listenedAt: string | Date;
+    progress: number;
+    user?: User;
+    track?: Track;
+}
+export interface User {
+    id: number;
+    username: string;
+    password?: string;
+    is_admin: boolean;
+    likedTracks?: UserTrackLike[];
+    listenedTracks?: UserTrackHistory[];
+    likedAlbums?: UserAlbumLike[];
+    listenedAlbums?: UserAlbumHistory[];
+    likedAudiobooks?: UserAudiobookLike[];
+    listenedAudiobooks?: UserAudiobookHistory[];
+    playlists?: Playlist[];
+}
+export interface Playlist {
+    id: number;
+    name: string;
+    type: TrackType;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+    userId: number;
+    user?: User;
+    tracks?: Track[];
+    _count?: {
+        tracks: number;
+    };
+}
+export interface Device {
+    id: number;
+    name: string;
+    userId: number;
+    isOnline: boolean;
+    lastSeen?: string | Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Folder {
+    id: number;
+    path: string;
+    name: string;
+    parentId: number | null;
+    type: TrackType;
+    children?: Folder[];
+    tracks?: Track[];
+}

package/dist/cjs/models.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TrackType = void 0;
+let TrackType = exports.TrackType = /*#__PURE__*/function (TrackType) {
+  TrackType["MUSIC"] = "MUSIC";
+  TrackType["AUDIOBOOK"] = "AUDIOBOOK";
+  return TrackType;
+}({}); // Prisma Models

package/dist/cjs/playlist.d.ts

@@ -0,0 +1,9 @@
+import type { ISuccessResponse, Playlist } from "./models";
+export declare const createPlaylist: (name: string, type: "MUSIC" | "AUDIOBOOK", userId: number) => Promise<ISuccessResponse<Playlist>>;
+export declare const getPlaylists: (type?: "MUSIC" | "AUDIOBOOK", userId?: number) => Promise<ISuccessResponse<Playlist[]>>;
+export declare const getPlaylistById: (id: number) => Promise<ISuccessResponse<Playlist>>;
+export declare const updatePlaylist: (id: number, name: string) => Promise<ISuccessResponse<Playlist>>;
+export declare const deletePlaylist: (id: number) => Promise<ISuccessResponse<boolean>>;
+export declare const addTrackToPlaylist: (playlistId: number, trackId: number) => Promise<ISuccessResponse<boolean>>;
+export declare const addTracksToPlaylist: (playlistId: number, trackIds: number[]) => Promise<ISuccessResponse<boolean>>;
+export declare const removeTrackFromPlaylist: (playlistId: number, trackId: number) => Promise<ISuccessResponse<boolean>>;

package/dist/cjs/playlist.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updatePlaylist = exports.removeTrackFromPlaylist = exports.getPlaylists = exports.getPlaylistById = exports.deletePlaylist = exports.createPlaylist = exports.addTracksToPlaylist = exports.addTrackToPlaylist = void 0;
+var _request = _interopRequireDefault(require("./request"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const createPlaylist = async (name, type, userId) => {
+  return await _request.default.post("/playlists", {
+    name,
+    type,
+    userId
+  });
+};
+exports.createPlaylist = createPlaylist;
+const getPlaylists = async (type, userId) => {
+  return await _request.default.get("/playlists", {
+    params: {
+      userId,
+      type
+    }
+  });
+};
+exports.getPlaylists = getPlaylists;
+const getPlaylistById = async id => {
+  return await _request.default.get(`/playlists/${id}`);
+};
+exports.getPlaylistById = getPlaylistById;
+const updatePlaylist = async (id, name) => {
+  return await _request.default.put(`/playlists/${id}`, {
+    name
+  });
+};
+exports.updatePlaylist = updatePlaylist;
+const deletePlaylist = async id => {
+  return await _request.default.delete(`/playlists/${id}`);
+};
+exports.deletePlaylist = deletePlaylist;
+const addTrackToPlaylist = async (playlistId, trackId) => {
+  return await _request.default.post(`/playlists/${playlistId}/tracks`, {
+    trackId
+  });
+};
+exports.addTrackToPlaylist = addTrackToPlaylist;
+const addTracksToPlaylist = async (playlistId, trackIds) => {
+  return await _request.default.post(`/playlists/${playlistId}/tracks/batch`, {
+    trackIds
+  });
+};
+exports.addTracksToPlaylist = addTracksToPlaylist;
+const removeTrackFromPlaylist = async (playlistId, trackId) => {
+  return await _request.default.delete(`/playlists/${playlistId}/tracks/${trackId}`);
+};
+exports.removeTrackFromPlaylist = removeTrackFromPlaylist;

package/dist/cjs/request.d.ts

@@ -0,0 +1,16 @@
+import type { AxiosInstance } from "axios";
+export declare const setRequestInstance: (instance: AxiosInstance) => void;
+export declare const getRequestInstance: () => AxiosInstance;
+export declare const request: {
+    get: <T = any, R = any, D = any>(url: string, config?: any) => Promise<R>;
+    delete: <T_1 = any, R_1 = any, D_1 = any>(url: string, config?: any) => Promise<R_1>;
+    head: <T_2 = any, R_2 = any, D_2 = any>(url: string, config?: any) => Promise<R_2>;
+    options: <T_3 = any, R_3 = any, D_3 = any>(url: string, config?: any) => Promise<R_3>;
+    post: <T_4 = any, R_4 = any, D_4 = any>(url: string, data?: D_4 | undefined, config?: any) => Promise<R_4>;
+    put: <T_5 = any, R_5 = any, D_5 = any>(url: string, data?: D_5 | undefined, config?: any) => Promise<R_5>;
+    patch: <T_6 = any, R_6 = any, D_6 = any>(url: string, data?: D_6 | undefined, config?: any) => Promise<R_6>;
+    postForm: <T_7 = any, R_7 = any, D_7 = any>(url: string, data?: D_7 | undefined, config?: any) => Promise<R_7>;
+    putForm: <T_8 = any, R_8 = any, D_8 = any>(url: string, data?: D_8 | undefined, config?: any) => Promise<R_8>;
+    patchForm: <T_9 = any, R_9 = any, D_9 = any>(url: string, data?: D_9 | undefined, config?: any) => Promise<R_9>;
+};
+export default request;

package/dist/cjs/request.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setRequestInstance = exports.request = exports.getRequestInstance = exports.default = void 0;
+let requestInstance = null;
+const setRequestInstance = instance => {
+  requestInstance = instance;
+};
+exports.setRequestInstance = setRequestInstance;
+const getRequestInstance = () => {
+  if (!requestInstance) {
+    throw new Error("Request instance not initialized. Please call setRequestInstance first.");
+  }
+  return requestInstance;
+};
+
+// Facade to match typical axios usage: request.get, request.post etc.
+exports.getRequestInstance = getRequestInstance;
+const request = exports.request = {
+  get: (url, config) => getRequestInstance().get(url, config),
+  delete: (url, config) => getRequestInstance().delete(url, config),
+  head: (url, config) => getRequestInstance().head(url, config),
+  options: (url, config) => getRequestInstance().options(url, config),
+  post: (url, data, config) => getRequestInstance().post(url, data, config),
+  put: (url, data, config) => getRequestInstance().put(url, data, config),
+  patch: (url, data, config) => getRequestInstance().patch(url, data, config),
+  postForm: (url, data, config) => getRequestInstance().postForm(url, data, config),
+  putForm: (url, data, config) => getRequestInstance().putForm(url, data, config),
+  patchForm: (url, data, config) => getRequestInstance().patchForm(url, data, config)
+};
+var _default = exports.default = request;

package/dist/cjs/search-record.d.ts

@@ -0,0 +1,8 @@
+import type { ISuccessResponse } from "./models";
+export declare const addSearchRecord: (keyword: string) => Promise<ISuccessResponse<any>>;
+export declare const getSearchHistory: () => Promise<ISuccessResponse<string[]>>;
+export declare const getHotSearches: () => Promise<ISuccessResponse<{
+    keyword: string;
+    count: number;
+}[]>>;
+export declare const clearSearchHistory: () => Promise<ISuccessResponse<any>>;

package/dist/cjs/search-record.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSearchHistory = exports.getHotSearches = exports.clearSearchHistory = exports.addSearchRecord = void 0;
+var _request = _interopRequireDefault(require("./request"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const addSearchRecord = keyword => {
+  return _request.default.post("/search-record", {
+    keyword
+  });
+};
+exports.addSearchRecord = addSearchRecord;
+const getSearchHistory = () => {
+  return _request.default.get("/search-record/history");
+};
+exports.getSearchHistory = getSearchHistory;
+const getHotSearches = () => {
+  return _request.default.get("/search-record/hot");
+};
+exports.getHotSearches = getHotSearches;
+const clearSearchHistory = () => {
+  return _request.default.delete("/search-record/history");
+};
+exports.clearSearchHistory = clearSearchHistory;

package/dist/cjs/search.d.ts

@@ -0,0 +1,10 @@
+import type { Album, Artist, ISuccessResponse, Track } from "./models";
+export interface SearchResults {
+    tracks: Track[];
+    artists: Artist[];
+    albums: Album[];
+}
+export declare const searchTracks: (keyword: string, type?: string, limit?: number) => Promise<ISuccessResponse<Track[]>>;
+export declare const searchArtists: (keyword: string, type?: string, limit?: number) => Promise<ISuccessResponse<Artist[]>>;
+export declare const searchAlbums: (keyword: string, type?: string, limit?: number) => Promise<ISuccessResponse<Album[]>>;
+export declare const searchAll: (keyword: string, type?: string) => Promise<SearchResults>;

package/dist/cjs/search.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.searchTracks = exports.searchArtists = exports.searchAll = exports.searchAlbums = void 0;
+var _request = _interopRequireDefault(require("./request"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const searchTracks = (keyword, type, limit = 10) => {
+  return _request.default.get("/track/search", {
+    params: {
+      keyword,
+      type,
+      limit
+    }
+  });
+};
+exports.searchTracks = searchTracks;
+const searchArtists = (keyword, type, limit = 10) => {
+  return _request.default.get("/artist/search", {
+    params: {
+      keyword,
+      type,
+      limit
+    }
+  });
+};
+exports.searchArtists = searchArtists;
+const searchAlbums = (keyword, type, limit = 10) => {
+  return _request.default.get("/album/search", {
+    params: {
+      keyword,
+      type,
+      limit
+    }
+  });
+};
+exports.searchAlbums = searchAlbums;
+const searchAll = async (keyword, type) => {
+  const [tracksRes, artistsRes, albumsRes] = await Promise.all([searchTracks(keyword, type, 5), searchArtists(keyword, type, 5), searchAlbums(keyword, type, 5)]);
+  return {
+    tracks: tracksRes.code === 200 ? tracksRes.data : [],
+    artists: artistsRes.code === 200 ? artistsRes.data : [],
+    albums: albumsRes.code === 200 ? albumsRes.data : []
+  };
+};
+exports.searchAll = searchAll;

package/dist/cjs/track.d.ts

@@ -0,0 +1,21 @@
+import type { ILoadMoreData, ISuccessResponse, ITableData, Track } from "./models";
+export declare const getTrackList: () => Promise<ISuccessResponse<Track[]>>;
+export declare const getTrackTableList: (params: {
+    pageSize: number;
+    current: number;
+}) => Promise<ISuccessResponse<ITableData<Track[]>>>;
+export declare const loadMoreTrack: (params: {
+    pageSize: number;
+    loadCount: number;
+}) => Promise<ISuccessResponse<ILoadMoreData<Track[]>>>;
+export declare const createTrack: (data: Omit<Track, "id">) => Promise<ISuccessResponse<Track>>;
+export declare const updateTrack: (id: number, data: Partial<Track>) => Promise<ISuccessResponse<Track>>;
+export declare const deleteTrack: (id: number, deleteAlbum?: boolean) => Promise<ISuccessResponse<boolean>>;
+export declare const getDeletionImpact: (id: number) => Promise<ISuccessResponse<{
+    isLastTrackInAlbum: boolean;
+    albumName: string | null;
+}>>;
+export declare const batchCreateTracks: (data: Omit<Track, "id">[]) => Promise<ISuccessResponse<boolean>>;
+export declare const batchDeleteTracks: (ids: number[]) => Promise<ISuccessResponse<boolean>>;
+export declare const getLatestTracks: (type?: string, random?: boolean, pageSize?: number) => Promise<ISuccessResponse<Track[]>>;
+export declare const getTracksByArtist: (artist: string) => Promise<ISuccessResponse<Track[]>>;

package/dist/cjs/track.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateTrack = exports.loadMoreTrack = exports.getTracksByArtist = exports.getTrackTableList = exports.getTrackList = exports.getLatestTracks = exports.getDeletionImpact = exports.deleteTrack = exports.createTrack = exports.batchDeleteTracks = exports.batchCreateTracks = void 0;
+var _request = _interopRequireDefault(require("./request"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const getTrackList = () => {
+  return _request.default.get("/track/list");
+};
+exports.getTrackList = getTrackList;
+const getTrackTableList = params => {
+  return _request.default.get("/table-list", {
+    params
+  });
+};
+exports.getTrackTableList = getTrackTableList;
+const loadMoreTrack = params => {
+  return _request.default.get("/load-more", {
+    params
+  });
+};
+exports.loadMoreTrack = loadMoreTrack;
+const createTrack = data => {
+  return _request.default.post("/track", data);
+};
+exports.createTrack = createTrack;
+const updateTrack = (id, data) => {
+  return _request.default.put(`/track/${id}`, data);
+};
+exports.updateTrack = updateTrack;
+const deleteTrack = (id, deleteAlbum = false) => {
+  return _request.default.delete(`/track/${id}`, {
+    params: {
+      deleteAlbum
+    }
+  });
+};
+exports.deleteTrack = deleteTrack;
+const getDeletionImpact = id => {
+  return _request.default.get(`/track/${id}/deletion-impact`);
+};
+exports.getDeletionImpact = getDeletionImpact;
+const batchCreateTracks = data => {
+  return _request.default.post("/track/batch-create", data);
+};
+exports.batchCreateTracks = batchCreateTracks;
+const batchDeleteTracks = ids => {
+  return _request.default.delete("/track/batch-delete", {
+    data: ids
+  });
+};
+exports.batchDeleteTracks = batchDeleteTracks;
+const getLatestTracks = (type, random, pageSize) => {
+  return _request.default.get("/track/latest", {
+    params: {
+      type,
+      random,
+      pageSize
+    }
+  });
+};
+exports.getLatestTracks = getLatestTracks;
+const getTracksByArtist = artist => {
+  return _request.default.get("/track/artist", {
+    params: {
+      artist
+    }
+  });
+};
+exports.getTracksByArtist = getTracksByArtist;

package/dist/cjs/user.d.ts

@@ -0,0 +1,13 @@
+import { type ILoadMoreData, type ISuccessResponse } from "./models";
+export declare const addToHistory: (trackId: number, userId: number, progress?: number, deviceName?: string, deviceId?: number, isSyncMode?: boolean) => Promise<ISuccessResponse<any>>;
+export declare const getLatestHistory: (userId: number) => Promise<ISuccessResponse<any>>;
+export declare const addAlbumToHistory: (albumId: number, userId: number) => Promise<ISuccessResponse<any>>;
+export declare const getAlbumHistory: (userId: number, loadCount: number, pageSize: number, type?: string) => Promise<ISuccessResponse<ILoadMoreData<any>>>;
+export declare const toggleLike: (trackId: number, userId: number) => Promise<ISuccessResponse<any>>;
+export declare const toggleUnLike: (trackId: number, userId: number) => Promise<ISuccessResponse<any>>;
+export declare const toggleAlbumLike: (albumId: number, userId: number) => Promise<ISuccessResponse<any>>;
+export declare const unlikeAlbum: (albumId: number, userId: number) => Promise<ISuccessResponse<any>>;
+export declare const getFavoriteAlbums: (userId: number, loadCount: number, pageSize: number, type?: string) => Promise<ISuccessResponse<ILoadMoreData<any>>>;
+export declare const getFavoriteTracks: (userId: number, loadCount: number, pageSize: number, type?: string) => Promise<ISuccessResponse<ILoadMoreData<any>>>;
+export declare const getTrackHistory: (userId: number, loadCount: number, pageSize: number, type?: string) => Promise<ISuccessResponse<ILoadMoreData<any>>>;
+export declare const getUserList: () => Promise<ISuccessResponse<any[]>>;

package/dist/cjs/user.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unlikeAlbum = exports.toggleUnLike = exports.toggleLike = exports.toggleAlbumLike = exports.getUserList = exports.getTrackHistory = exports.getLatestHistory = exports.getFavoriteTracks = exports.getFavoriteAlbums = exports.getAlbumHistory = exports.addToHistory = exports.addAlbumToHistory = void 0;
+var _request = _interopRequireDefault(require("./request"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const addToHistory = (trackId, userId, progress = 0, deviceName, deviceId, isSyncMode) => {
+  return _request.default.post("/user-track-histories", {
+    trackId,
+    userId,
+    progress,
+    deviceName,
+    deviceId,
+    isSyncMode
+  });
+};
+exports.addToHistory = addToHistory;
+const getLatestHistory = userId => {
+  return _request.default.get("/user-track-histories/latest", {
+    params: {
+      userId
+    }
+  });
+};
+exports.getLatestHistory = getLatestHistory;
+const addAlbumToHistory = (albumId, userId) => {
+  return _request.default.post("/user-album-histories", {
+    albumId,
+    userId
+  });
+};
+exports.addAlbumToHistory = addAlbumToHistory;
+const getAlbumHistory = (userId, loadCount, pageSize, type) => {
+  return _request.default.get("/user-album-histories/load-more", {
+    params: {
+      pageSize,
+      loadCount,
+      userId,
+      type
+    }
+  });
+};
+exports.getAlbumHistory = getAlbumHistory;
+const toggleLike = (trackId, userId) => {
+  return _request.default.post("/user-track-likes/create", {
+    trackId,
+    userId
+  });
+};
+exports.toggleLike = toggleLike;
+const toggleUnLike = (trackId, userId) => {
+  return _request.default.delete("/user-track-likes/unlike", {
+    params: {
+      trackId,
+      userId
+    }
+  });
+};
+exports.toggleUnLike = toggleUnLike;
+const toggleAlbumLike = (albumId, userId) => {
+  return _request.default.post("/user-album-likes", {
+    albumId,
+    userId
+  });
+};
+exports.toggleAlbumLike = toggleAlbumLike;
+const unlikeAlbum = (albumId, userId) => {
+  return _request.default.delete("/user-album-likes/unlike", {
+    params: {
+      albumId,
+      userId
+    }
+  });
+};
+exports.unlikeAlbum = unlikeAlbum;
+const getFavoriteAlbums = (userId, loadCount, pageSize, type) => {
+  return _request.default.get("/user-album-likes/load-more", {
+    params: {
+      pageSize,
+      loadCount,
+      userId,
+      type
+    }
+  });
+};
+exports.getFavoriteAlbums = getFavoriteAlbums;
+const getFavoriteTracks = (userId, loadCount, pageSize, type) => {
+  return _request.default.get("/user-track-likes/load-more", {
+    params: {
+      pageSize,
+      loadCount: loadCount,
+      userId,
+      lastId: loadCount,
+      type
+    }
+  });
+};
+exports.getFavoriteTracks = getFavoriteTracks;
+const getTrackHistory = (userId, loadCount, pageSize, type) => {
+  return _request.default.get("/user-track-histories/load-more", {
+    params: {
+      pageSize,
+      loadCount: loadCount,
+      userId,
+      type
+    }
+  });
+};
+exports.getTrackHistory = getTrackHistory;
+const getUserList = () => {
+  return _request.default.get("/user/list");
+};
+exports.getUserList = getUserList;

package/dist/cjs/userAudiobookHistory.d.ts

@@ -0,0 +1,6 @@
+import type { ISuccessResponse } from "./models";
+export declare const reportAudiobookProgress: (data: {
+    userId: number;
+    trackId: number;
+    progress: number;
+}) => Promise<ISuccessResponse<any>>;

package/dist/cjs/userAudiobookHistory.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.reportAudiobookProgress = void 0;
+var _request = _interopRequireDefault(require("./request"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const reportAudiobookProgress = data => {
+  return _request.default.post("/user-audiobook-histories", data);
+};
+exports.reportAudiobookProgress = reportAudiobookProgress;

package/dist/esm/album.d.ts

@@ -0,0 +1,25 @@
+import type { Album, ILoadMoreData, ISuccessResponse, ITableData } from "./models";
+export declare const getAlbumList: () => Promise<ISuccessResponse<Album[]>>;
+export declare const getAlbumTableList: (params: {
+    pageSize: number;
+    current: number;
+}) => Promise<ISuccessResponse<ITableData<Album[]>>>;
+export declare const loadMoreAlbum: (params: {
+    pageSize: number;
+    loadCount: number;
+    type?: string;
+}) => Promise<ISuccessResponse<ILoadMoreData<Album>>>;
+export declare const createAlbum: (data: Omit<Album, "id">) => Promise<ISuccessResponse<Album>>;
+export declare const updateAlbum: (id: number, data: Partial<Album>) => Promise<ISuccessResponse<Album>>;
+export declare const deleteAlbum: (id: number) => Promise<ISuccessResponse<boolean>>;
+export declare const batchCreateAlbums: (data: Omit<Album, "id">[]) => Promise<ISuccessResponse<boolean>>;
+export declare const batchDeleteAlbums: (ids: number[]) => Promise<ISuccessResponse<boolean>>;
+export declare const getRecommendedAlbums: (type?: string, random?: boolean, pageSize?: number) => Promise<ISuccessResponse<Album[]>>;
+export declare const getRecentAlbums: (type?: string, random?: boolean, pageSize?: number) => Promise<ISuccessResponse<Album[]>>;
+export declare const getAlbumById: (id: number) => Promise<ISuccessResponse<Album>>;
+export declare const getAlbumTracks: (id: number, pageSize: number, skip: number, sort?: "asc" | "desc", keyword?: string, userId?: number) => Promise<ISuccessResponse<{
+    list: any[];
+    total: number;
+}>>;
+export declare const getAlbumsByArtist: (artist: string) => Promise<ISuccessResponse<Album[]>>;
+export declare const getCollaborativeAlbumsByArtist: (artist: string) => Promise<ISuccessResponse<Album[]>>;