npm - @darco2903/altv-web-api - Versions diffs - 2.1.0 → 2.3.0 - Mend

@darco2903/altv-web-api 2.1.0 → 2.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/client.d.ts +295 -0
package/dist/contract/index.d.ts +594 -0
package/dist/contract/room.d.ts +383 -0
package/dist/contract/room.js +57 -1
package/dist/contract/youtube.d.ts +213 -0
package/dist/contract/youtube.js +18 -2
package/dist/types/youtube.d.ts +17 -0
package/dist/types/youtube.js +6 -0
package/package.json +1 -1

package/dist/contract/room.d.ts CHANGED Viewed

@@ -1178,6 +1178,389 @@ declare const _default: {
             }>]>;
         };
     };
+    queuePlaylist: {
+        description: "Add a YouTube playlist to the queue of a room, as many tracks as fit. It plays right away if the room has nothing to play. A Mix only exists around a video, it needs videoId";
+        method: "POST";
+        body: z.ZodObject<{
+            playlistId: z.ZodString;
+            videoId: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            playlistId: string;
+            videoId?: string | undefined;
+        }, {
+            playlistId: string;
+            videoId?: string | undefined;
+        }>;
+        path: "/room/:roomId/queue/playlist";
+        responses: {
+            500: z.ZodObject<{
+                code: z.ZodType<"INTERNAL_SERVER_ERROR", z.ZodTypeDef, "INTERNAL_SERVER_ERROR">;
+                error: z.ZodType<string, z.ZodTypeDef, string>;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "INTERNAL_SERVER_ERROR";
+                error: string;
+                name: "APIError";
+            }, {
+                code: "INTERNAL_SERVER_ERROR";
+                error: string;
+                name: "APIError";
+            }>;
+            404: z.ZodUnion<[z.ZodObject<{
+                code: z.ZodType<"ROOM_NOT_FOUND", z.ZodTypeDef, "ROOM_NOT_FOUND">;
+                error: z.ZodType<"The requested room was not found", z.ZodTypeDef, "The requested room was not found">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "ROOM_NOT_FOUND";
+                error: "The requested room was not found";
+                name: "APIError";
+            }, {
+                code: "ROOM_NOT_FOUND";
+                error: "The requested room was not found";
+                name: "APIError";
+            }>, z.ZodObject<{
+                code: z.ZodType<"PLAYLIST_UNAVAILABLE", z.ZodTypeDef, "PLAYLIST_UNAVAILABLE">;
+                error: z.ZodType<"This playlist can't be read, it may be private", z.ZodTypeDef, "This playlist can't be read, it may be private">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "PLAYLIST_UNAVAILABLE";
+                error: "This playlist can't be read, it may be private";
+                name: "APIError";
+            }, {
+                code: "PLAYLIST_UNAVAILABLE";
+                error: "This playlist can't be read, it may be private";
+                name: "APIError";
+            }>]>;
+            409: z.ZodObject<{
+                code: z.ZodType<"QUEUE_FULL", z.ZodTypeDef, "QUEUE_FULL">;
+                error: z.ZodType<"The queue of this room is full", z.ZodTypeDef, "The queue of this room is full">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "QUEUE_FULL";
+                error: "The queue of this room is full";
+                name: "APIError";
+            }, {
+                code: "QUEUE_FULL";
+                error: "The queue of this room is full";
+                name: "APIError";
+            }>;
+            429: z.ZodObject<{
+                code: z.ZodType<"TOO_MANY_SEARCHES", z.ZodTypeDef, "TOO_MANY_SEARCHES">;
+                error: z.ZodType<"Too many searches are running", z.ZodTypeDef, "Too many searches are running">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "TOO_MANY_SEARCHES";
+                error: "Too many searches are running";
+                name: "APIError";
+            }, {
+                code: "TOO_MANY_SEARCHES";
+                error: "Too many searches are running";
+                name: "APIError";
+            }>;
+            401: z.ZodObject<{
+                code: z.ZodType<"UNAUTHORIZED", z.ZodTypeDef, "UNAUTHORIZED">;
+                error: z.ZodType<"Unauthorized", z.ZodTypeDef, "Unauthorized">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "UNAUTHORIZED";
+                error: "Unauthorized";
+                name: "APIError";
+            }, {
+                code: "UNAUTHORIZED";
+                error: "Unauthorized";
+                name: "APIError";
+            }>;
+            403: z.ZodObject<{
+                code: z.ZodType<"FORBIDDEN", z.ZodTypeDef, "FORBIDDEN">;
+                error: z.ZodType<"Forbidden", z.ZodTypeDef, "Forbidden">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "FORBIDDEN";
+                error: "Forbidden";
+                name: "APIError";
+            }, {
+                code: "FORBIDDEN";
+                error: "Forbidden";
+                name: "APIError";
+            }>;
+            200: z.ZodObject<{
+                added: z.ZodNumber;
+                /** Can't be played: live, too long or without a duration */
+                skipped: z.ZodNumber;
+                /** Tracks of the playlist. A Mix has no end: added + skipped, it never looks cut */
+                total: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                added: number;
+                skipped: number;
+                total: number;
+            }, {
+                added: number;
+                skipped: number;
+                total: number;
+            }>;
+            400: z.ZodUnion<[z.ZodObject<{
+                name: z.ZodLiteral<"ZodError">;
+                issues: z.ZodArray<z.ZodObject<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, "strip", z.ZodAny, z.objectOutputType<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, z.ZodAny, "strip">, z.objectInputType<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, z.ZodAny, "strip">>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                name: "ZodError";
+                issues: z.objectOutputType<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, z.ZodAny, "strip">[];
+            }, {
+                name: "ZodError";
+                issues: z.objectInputType<{
+                    path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+                    message: z.ZodOptional<z.ZodString>;
+                    code: z.ZodNativeEnum<{
+                        invalid_type: "invalid_type";
+                        invalid_literal: "invalid_literal";
+                        custom: "custom";
+                        invalid_union: "invalid_union";
+                        invalid_union_discriminator: "invalid_union_discriminator";
+                        invalid_enum_value: "invalid_enum_value";
+                        unrecognized_keys: "unrecognized_keys";
+                        invalid_arguments: "invalid_arguments";
+                        invalid_return_type: "invalid_return_type";
+                        invalid_date: "invalid_date";
+                        invalid_string: "invalid_string";
+                        too_small: "too_small";
+                        too_big: "too_big";
+                        invalid_intersection_types: "invalid_intersection_types";
+                        not_multiple_of: "not_multiple_of";
+                        not_finite: "not_finite";
+                    }>;
+                }, z.ZodAny, "strip">[];
+            }>, z.ZodObject<{
+                code: z.ZodType<"INVALID_VIDEO_ID", z.ZodTypeDef, "INVALID_VIDEO_ID">;
+                error: z.ZodType<"The provided video ID is invalid", z.ZodTypeDef, "The provided video ID is invalid">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "INVALID_VIDEO_ID";
+                error: "The provided video ID is invalid";
+                name: "APIError";
+            }, {
+                code: "INVALID_VIDEO_ID";
+                error: "The provided video ID is invalid";
+                name: "APIError";
+            }>, z.ZodObject<{
+                code: z.ZodType<"INVALID_PLAYLIST_ID", z.ZodTypeDef, "INVALID_PLAYLIST_ID">;
+                error: z.ZodType<"The provided playlist ID is invalid", z.ZodTypeDef, "The provided playlist ID is invalid">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "INVALID_PLAYLIST_ID";
+                error: "The provided playlist ID is invalid";
+                name: "APIError";
+            }, {
+                code: "INVALID_PLAYLIST_ID";
+                error: "The provided playlist ID is invalid";
+                name: "APIError";
+            }>]>;
+        };
+    };
+    queueClear: {
+        description: "Remove every track from the queue of a room";
+        method: "DELETE";
+        body: z.ZodUndefined;
+        path: "/room/:roomId/queue";
+        responses: {
+            500: z.ZodObject<{
+                code: z.ZodType<"INTERNAL_SERVER_ERROR", z.ZodTypeDef, "INTERNAL_SERVER_ERROR">;
+                error: z.ZodType<string, z.ZodTypeDef, string>;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "INTERNAL_SERVER_ERROR";
+                error: string;
+                name: "APIError";
+            }, {
+                code: "INTERNAL_SERVER_ERROR";
+                error: string;
+                name: "APIError";
+            }>;
+            404: z.ZodObject<{
+                code: z.ZodType<"ROOM_NOT_FOUND", z.ZodTypeDef, "ROOM_NOT_FOUND">;
+                error: z.ZodType<"The requested room was not found", z.ZodTypeDef, "The requested room was not found">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "ROOM_NOT_FOUND";
+                error: "The requested room was not found";
+                name: "APIError";
+            }, {
+                code: "ROOM_NOT_FOUND";
+                error: "The requested room was not found";
+                name: "APIError";
+            }>;
+            401: z.ZodObject<{
+                code: z.ZodType<"UNAUTHORIZED", z.ZodTypeDef, "UNAUTHORIZED">;
+                error: z.ZodType<"Unauthorized", z.ZodTypeDef, "Unauthorized">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "UNAUTHORIZED";
+                error: "Unauthorized";
+                name: "APIError";
+            }, {
+                code: "UNAUTHORIZED";
+                error: "Unauthorized";
+                name: "APIError";
+            }>;
+            403: z.ZodObject<{
+                code: z.ZodType<"FORBIDDEN", z.ZodTypeDef, "FORBIDDEN">;
+                error: z.ZodType<"Forbidden", z.ZodTypeDef, "Forbidden">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "FORBIDDEN";
+                error: "Forbidden";
+                name: "APIError";
+            }, {
+                code: "FORBIDDEN";
+                error: "Forbidden";
+                name: "APIError";
+            }>;
+            200: typeof import("@ts-rest/core").ContractNoBody;
+        };
+    };
+    queueShuffle: {
+        description: "Put the queue of a room in a new random order, listeners get it through the roomQueue socket event";
+        method: "POST";
+        body: z.ZodUndefined;
+        path: "/room/:roomId/queue/shuffle";
+        responses: {
+            500: z.ZodObject<{
+                code: z.ZodType<"INTERNAL_SERVER_ERROR", z.ZodTypeDef, "INTERNAL_SERVER_ERROR">;
+                error: z.ZodType<string, z.ZodTypeDef, string>;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "INTERNAL_SERVER_ERROR";
+                error: string;
+                name: "APIError";
+            }, {
+                code: "INTERNAL_SERVER_ERROR";
+                error: string;
+                name: "APIError";
+            }>;
+            404: z.ZodObject<{
+                code: z.ZodType<"ROOM_NOT_FOUND", z.ZodTypeDef, "ROOM_NOT_FOUND">;
+                error: z.ZodType<"The requested room was not found", z.ZodTypeDef, "The requested room was not found">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "ROOM_NOT_FOUND";
+                error: "The requested room was not found";
+                name: "APIError";
+            }, {
+                code: "ROOM_NOT_FOUND";
+                error: "The requested room was not found";
+                name: "APIError";
+            }>;
+            401: z.ZodObject<{
+                code: z.ZodType<"UNAUTHORIZED", z.ZodTypeDef, "UNAUTHORIZED">;
+                error: z.ZodType<"Unauthorized", z.ZodTypeDef, "Unauthorized">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "UNAUTHORIZED";
+                error: "Unauthorized";
+                name: "APIError";
+            }, {
+                code: "UNAUTHORIZED";
+                error: "Unauthorized";
+                name: "APIError";
+            }>;
+            403: z.ZodObject<{
+                code: z.ZodType<"FORBIDDEN", z.ZodTypeDef, "FORBIDDEN">;
+                error: z.ZodType<"Forbidden", z.ZodTypeDef, "Forbidden">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "FORBIDDEN";
+                error: "Forbidden";
+                name: "APIError";
+            }, {
+                code: "FORBIDDEN";
+                error: "Forbidden";
+                name: "APIError";
+            }>;
+            200: typeof import("@ts-rest/core").ContractNoBody;
+        };
+    };
     queueRemove: {
         description: "Remove a track from the queue of a room";
         method: "DELETE";

package/dist/contract/room.js CHANGED Viewed

@@ -13,6 +13,7 @@ const internalError = {
 const noTrack = apiError(z.literal("NO_TRACK"), z.literal("The room has no track"));
 const queueItemNotFound = apiError(z.literal("QUEUE_ITEM_NOT_FOUND"), z.literal("The queue doesn't have this track"));
 const invalidVideoId = apiError(z.literal("INVALID_VIDEO_ID"), z.literal("The provided video ID is invalid"));
+const queueFull = apiError(z.literal("QUEUE_FULL"), z.literal("The queue of this room is full"));
 export default c.router({
     create: {
         method: "POST",
@@ -107,7 +108,62 @@ export default c.router({
             400: z.union([ZodErrorSchema, invalidVideoId]),
             ...authResponses,
             ...notFound,
-            409: apiError(z.literal("QUEUE_FULL"), z.literal("The queue of this room is full")),
+            409: queueFull,
+            ...internalError,
+        },
+    },
+    queuePlaylist: {
+        method: "POST",
+        path: "/room/:roomId/queue/playlist",
+        description: "Add a YouTube playlist to the queue of a room, as many tracks as fit. It plays right away if the room has nothing to play. A Mix only exists around a video, it needs videoId",
+        body: z.object({
+            playlistId: z.string(),
+            videoId: z.string().optional(),
+        }),
+        responses: {
+            200: apiSuccess(z.object({
+                added: z.number(),
+                /** Can't be played: live, too long or without a duration */
+                skipped: z.number(),
+                /** Tracks of the playlist. A Mix has no end: added + skipped, it never looks cut */
+                total: z.number(),
+            })),
+            400: z.union([
+                ZodErrorSchema,
+                invalidVideoId,
+                apiError(z.literal("INVALID_PLAYLIST_ID"), z.literal("The provided playlist ID is invalid")),
+            ]),
+            ...authResponses,
+            404: z.union([
+                notFound[404],
+                apiError(z.literal("PLAYLIST_UNAVAILABLE"), z.literal("This playlist can't be read, it may be private")),
+            ]),
+            409: queueFull,
+            429: apiError(z.literal("TOO_MANY_SEARCHES"), z.literal("Too many searches are running")),
+            ...internalError,
+        },
+    },
+    queueClear: {
+        method: "DELETE",
+        path: "/room/:roomId/queue",
+        description: "Remove every track from the queue of a room",
+        body: z.undefined(),
+        responses: {
+            200: c.noBody(),
+            ...authResponses,
+            ...notFound,
+            ...internalError,
+        },
+    },
+    queueShuffle: {
+        method: "POST",
+        path: "/room/:roomId/queue/shuffle",
+        description: "Put the queue of a room in a new random order, listeners get it through the roomQueue socket event",
+        body: z.undefined(),
+        responses: {
+            200: c.noBody(),
+            ...authResponses,
+            ...notFound,
             ...internalError,
         },
     },