@darco2903/altv-web-api 2.1.0 → 2.2.0

package/dist/client.d.ts

@@ -823,6 +823,168 @@ export declare function createClient(origin: string): {
             body: unknown;
             headers: Headers;
         }>;
+        queuePlaylist: (args: {
+            params: {
+                roomId: string;
+            };
+            body: {
+                playlistId: string;
+                videoId?: string | undefined;
+            };
+            cache?: RequestCache | undefined;
+            extraHeaders?: Record<string, string | undefined> | undefined;
+            fetchOptions?: import("@ts-rest/core").FetchOptions | undefined;
+            overrideClientOptions?: Partial<import("@ts-rest/core").OverrideableClientArgs> | undefined;
+        }) => Promise<{
+            status: 500;
+            body: {
+                code: "INTERNAL_SERVER_ERROR";
+                error: string;
+                name: "APIError";
+            };
+            headers: Headers;
+        } | {
+            status: 401;
+            body: {
+                code: "UNAUTHORIZED";
+                error: "Unauthorized";
+                name: "APIError";
+            };
+            headers: Headers;
+        } | {
+            status: 403;
+            body: {
+                code: "FORBIDDEN";
+                error: "Forbidden";
+                name: "APIError";
+            };
+            headers: Headers;
+        } | {
+            status: 200;
+            body: {
+                added: number;
+                skipped: number;
+                total: number;
+            };
+            headers: Headers;
+        } | {
+            status: 400;
+            body: {
+                code: "INVALID_VIDEO_ID";
+                error: "The provided video ID is invalid";
+                name: "APIError";
+            } | {
+                name: "ZodError";
+                issues: import("zod").objectOutputType<{
+                    path: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, "many">;
+                    message: import("zod").ZodOptional<import("zod").ZodString>;
+                    code: import("zod").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";
+                    }>;
+                }, import("zod").ZodAny, "strip">[];
+            } | {
+                code: "INVALID_PLAYLIST_ID";
+                error: "The provided playlist ID is invalid";
+                name: "APIError";
+            };
+            headers: Headers;
+        } | {
+            status: 404;
+            body: {
+                code: "ROOM_NOT_FOUND";
+                error: "The requested room was not found";
+                name: "APIError";
+            } | {
+                code: "PLAYLIST_UNAVAILABLE";
+                error: "This playlist can't be read, it may be private";
+                name: "APIError";
+            };
+            headers: Headers;
+        } | {
+            status: 409;
+            body: {
+                code: "QUEUE_FULL";
+                error: "The queue of this room is full";
+                name: "APIError";
+            };
+            headers: Headers;
+        } | {
+            status: 429;
+            body: {
+                code: "TOO_MANY_SEARCHES";
+                error: "Too many searches are running";
+                name: "APIError";
+            };
+            headers: Headers;
+        } | {
+            status: 100 | 101 | 102 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308 | 402 | 405 | 406 | 407 | 408 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 428 | 431 | 451 | 501 | 502 | 503 | 504 | 505 | 507 | 511;
+            body: unknown;
+            headers: Headers;
+        }>;
+        queueClear: (args: {
+            params: {
+                roomId: string;
+            };
+            cache?: RequestCache | undefined;
+            extraHeaders?: Record<string, string | undefined> | undefined;
+            fetchOptions?: import("@ts-rest/core").FetchOptions | undefined;
+            overrideClientOptions?: Partial<import("@ts-rest/core").OverrideableClientArgs> | undefined;
+        }) => Promise<{
+            status: 500;
+            body: {
+                code: "INTERNAL_SERVER_ERROR";
+                error: string;
+                name: "APIError";
+            };
+            headers: Headers;
+        } | {
+            status: 401;
+            body: {
+                code: "UNAUTHORIZED";
+                error: "Unauthorized";
+                name: "APIError";
+            };
+            headers: Headers;
+        } | {
+            status: 403;
+            body: {
+                code: "FORBIDDEN";
+                error: "Forbidden";
+                name: "APIError";
+            };
+            headers: Headers;
+        } | {
+            status: 200;
+            body: undefined;
+            headers: Headers;
+        } | {
+            status: 404;
+            body: {
+                code: "ROOM_NOT_FOUND";
+                error: "The requested room was not found";
+                name: "APIError";
+            };
+            headers: Headers;
+        } | {
+            status: 400 | 100 | 409 | 429 | 101 | 102 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308 | 402 | 405 | 406 | 407 | 408 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 428 | 431 | 451 | 501 | 502 | 503 | 504 | 505 | 507 | 511;
+            body: unknown;
+            headers: Headers;
+        }>;
         queueRemove: (args: {
             params: {
                 roomId: string;

package/dist/contract/index.d.ts

@@ -1870,6 +1870,326 @@ 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: import("zod").ZodObject<{
+                playlistId: import("zod").ZodString;
+                videoId: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "strip", import("zod").ZodTypeAny, {
+                playlistId: string;
+                videoId?: string | undefined;
+            }, {
+                playlistId: string;
+                videoId?: string | undefined;
+            }>;
+            path: "/api/v2/room/:roomId/queue/playlist";
+            responses: {
+                500: import("zod").ZodObject<{
+                    code: import("zod").ZodType<"INTERNAL_SERVER_ERROR", import("zod").ZodTypeDef, "INTERNAL_SERVER_ERROR">;
+                    error: import("zod").ZodType<string, import("zod").ZodTypeDef, string>;
+                    name: import("zod").ZodLiteral<"APIError">;
+                }, "strip", import("zod").ZodTypeAny, {
+                    code: "INTERNAL_SERVER_ERROR";
+                    error: string;
+                    name: "APIError";
+                }, {
+                    code: "INTERNAL_SERVER_ERROR";
+                    error: string;
+                    name: "APIError";
+                }>;
+                404: import("zod").ZodUnion<[import("zod").ZodObject<{
+                    code: import("zod").ZodType<"ROOM_NOT_FOUND", import("zod").ZodTypeDef, "ROOM_NOT_FOUND">;
+                    error: import("zod").ZodType<"The requested room was not found", import("zod").ZodTypeDef, "The requested room was not found">;
+                    name: import("zod").ZodLiteral<"APIError">;
+                }, "strip", import("zod").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";
+                }>, import("zod").ZodObject<{
+                    code: import("zod").ZodType<"PLAYLIST_UNAVAILABLE", import("zod").ZodTypeDef, "PLAYLIST_UNAVAILABLE">;
+                    error: import("zod").ZodType<"This playlist can't be read, it may be private", import("zod").ZodTypeDef, "This playlist can't be read, it may be private">;
+                    name: import("zod").ZodLiteral<"APIError">;
+                }, "strip", import("zod").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: import("zod").ZodObject<{
+                    code: import("zod").ZodType<"QUEUE_FULL", import("zod").ZodTypeDef, "QUEUE_FULL">;
+                    error: import("zod").ZodType<"The queue of this room is full", import("zod").ZodTypeDef, "The queue of this room is full">;
+                    name: import("zod").ZodLiteral<"APIError">;
+                }, "strip", import("zod").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: import("zod").ZodObject<{
+                    code: import("zod").ZodType<"TOO_MANY_SEARCHES", import("zod").ZodTypeDef, "TOO_MANY_SEARCHES">;
+                    error: import("zod").ZodType<"Too many searches are running", import("zod").ZodTypeDef, "Too many searches are running">;
+                    name: import("zod").ZodLiteral<"APIError">;
+                }, "strip", import("zod").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: import("zod").ZodObject<{
+                    code: import("zod").ZodType<"UNAUTHORIZED", import("zod").ZodTypeDef, "UNAUTHORIZED">;
+                    error: import("zod").ZodType<"Unauthorized", import("zod").ZodTypeDef, "Unauthorized">;
+                    name: import("zod").ZodLiteral<"APIError">;
+                }, "strip", import("zod").ZodTypeAny, {
+                    code: "UNAUTHORIZED";
+                    error: "Unauthorized";
+                    name: "APIError";
+                }, {
+                    code: "UNAUTHORIZED";
+                    error: "Unauthorized";
+                    name: "APIError";
+                }>;
+                403: import("zod").ZodObject<{
+                    code: import("zod").ZodType<"FORBIDDEN", import("zod").ZodTypeDef, "FORBIDDEN">;
+                    error: import("zod").ZodType<"Forbidden", import("zod").ZodTypeDef, "Forbidden">;
+                    name: import("zod").ZodLiteral<"APIError">;
+                }, "strip", import("zod").ZodTypeAny, {
+                    code: "FORBIDDEN";
+                    error: "Forbidden";
+                    name: "APIError";
+                }, {
+                    code: "FORBIDDEN";
+                    error: "Forbidden";
+                    name: "APIError";
+                }>;
+                200: import("zod").ZodObject<{
+                    added: import("zod").ZodNumber;
+                    skipped: import("zod").ZodNumber;
+                    total: import("zod").ZodNumber;
+                }, "strip", import("zod").ZodTypeAny, {
+                    added: number;
+                    skipped: number;
+                    total: number;
+                }, {
+                    added: number;
+                    skipped: number;
+                    total: number;
+                }>;
+                400: import("zod").ZodUnion<[import("zod").ZodObject<{
+                    name: import("zod").ZodLiteral<"ZodError">;
+                    issues: import("zod").ZodArray<import("zod").ZodObject<{
+                        path: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, "many">;
+                        message: import("zod").ZodOptional<import("zod").ZodString>;
+                        code: import("zod").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", import("zod").ZodAny, import("zod").objectOutputType<{
+                        path: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, "many">;
+                        message: import("zod").ZodOptional<import("zod").ZodString>;
+                        code: import("zod").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";
+                        }>;
+                    }, import("zod").ZodAny, "strip">, import("zod").objectInputType<{
+                        path: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, "many">;
+                        message: import("zod").ZodOptional<import("zod").ZodString>;
+                        code: import("zod").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";
+                        }>;
+                    }, import("zod").ZodAny, "strip">>, "many">;
+                }, "strip", import("zod").ZodTypeAny, {
+                    name: "ZodError";
+                    issues: import("zod").objectOutputType<{
+                        path: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, "many">;
+                        message: import("zod").ZodOptional<import("zod").ZodString>;
+                        code: import("zod").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";
+                        }>;
+                    }, import("zod").ZodAny, "strip">[];
+                }, {
+                    name: "ZodError";
+                    issues: import("zod").objectInputType<{
+                        path: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, "many">;
+                        message: import("zod").ZodOptional<import("zod").ZodString>;
+                        code: import("zod").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";
+                        }>;
+                    }, import("zod").ZodAny, "strip">[];
+                }>, import("zod").ZodObject<{
+                    code: import("zod").ZodType<"INVALID_VIDEO_ID", import("zod").ZodTypeDef, "INVALID_VIDEO_ID">;
+                    error: import("zod").ZodType<"The provided video ID is invalid", import("zod").ZodTypeDef, "The provided video ID is invalid">;
+                    name: import("zod").ZodLiteral<"APIError">;
+                }, "strip", import("zod").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";
+                }>, import("zod").ZodObject<{
+                    code: import("zod").ZodType<"INVALID_PLAYLIST_ID", import("zod").ZodTypeDef, "INVALID_PLAYLIST_ID">;
+                    error: import("zod").ZodType<"The provided playlist ID is invalid", import("zod").ZodTypeDef, "The provided playlist ID is invalid">;
+                    name: import("zod").ZodLiteral<"APIError">;
+                }, "strip", import("zod").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: import("zod").ZodUndefined;
+            path: "/api/v2/room/:roomId/queue";
+            responses: {
+                500: import("zod").ZodObject<{
+                    code: import("zod").ZodType<"INTERNAL_SERVER_ERROR", import("zod").ZodTypeDef, "INTERNAL_SERVER_ERROR">;
+                    error: import("zod").ZodType<string, import("zod").ZodTypeDef, string>;
+                    name: import("zod").ZodLiteral<"APIError">;
+                }, "strip", import("zod").ZodTypeAny, {
+                    code: "INTERNAL_SERVER_ERROR";
+                    error: string;
+                    name: "APIError";
+                }, {
+                    code: "INTERNAL_SERVER_ERROR";
+                    error: string;
+                    name: "APIError";
+                }>;
+                404: import("zod").ZodObject<{
+                    code: import("zod").ZodType<"ROOM_NOT_FOUND", import("zod").ZodTypeDef, "ROOM_NOT_FOUND">;
+                    error: import("zod").ZodType<"The requested room was not found", import("zod").ZodTypeDef, "The requested room was not found">;
+                    name: import("zod").ZodLiteral<"APIError">;
+                }, "strip", import("zod").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: import("zod").ZodObject<{
+                    code: import("zod").ZodType<"UNAUTHORIZED", import("zod").ZodTypeDef, "UNAUTHORIZED">;
+                    error: import("zod").ZodType<"Unauthorized", import("zod").ZodTypeDef, "Unauthorized">;
+                    name: import("zod").ZodLiteral<"APIError">;
+                }, "strip", import("zod").ZodTypeAny, {
+                    code: "UNAUTHORIZED";
+                    error: "Unauthorized";
+                    name: "APIError";
+                }, {
+                    code: "UNAUTHORIZED";
+                    error: "Unauthorized";
+                    name: "APIError";
+                }>;
+                403: import("zod").ZodObject<{
+                    code: import("zod").ZodType<"FORBIDDEN", import("zod").ZodTypeDef, "FORBIDDEN">;
+                    error: import("zod").ZodType<"Forbidden", import("zod").ZodTypeDef, "Forbidden">;
+                    name: import("zod").ZodLiteral<"APIError">;
+                }, "strip", import("zod").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.d.ts

@@ -1178,6 +1178,328 @@ 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;
+        };
+    };
     queueRemove: {
         description: "Remove a track from the queue of a room";
         method: "DELETE";

package/dist/contract/room.js

@@ -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,50 @@ 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,
         },
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darco2903/altv-web-api",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "",
   "main": "./dist/index.js",
   "keywords": [],