@darco2903/altv-web-api 0.0.0-stage → 1.0.0-pre

package/dist/contract/mediaStream.js

@@ -0,0 +1,108 @@
+import { initContract, ZodErrorSchema } from "@ts-rest/core";
+import { z } from "zod";
+import { apiError, apiSuccess } from "../types.js";
+const c = initContract();
+export default c.router({
+    init: {
+        method: "POST",
+        path: "/media-stream/init",
+        description: "Initialize a new media stream from a YouTube video",
+        body: z.object({
+            videoId: z.string(),
+        }),
+        responses: {
+            200: apiSuccess(z.object({
+                streamId: z.string(),
+            })),
+            400: z.union([
+                ZodErrorSchema,
+                apiError(z.literal("INVALID_VIDEO_ID"), z.literal("The provided video ID is invalid")),
+            ]),
+            // 401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    get: {
+        method: "GET",
+        path: "/media-stream/get/:streamId",
+        description: "Get media stream info",
+        responses: {
+            200: apiSuccess(z.object({
+                streamId: z.string(),
+                startTime: z.number(),
+                duration: z.number(),
+                url: z.string(),
+                paused: z.boolean(),
+            })),
+            400: z.union([
+                ZodErrorSchema,
+                apiError(z.literal("INVALID_STREAM_ID"), z.literal("The provided stream ID is invalid")),
+            ]),
+            // 401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    play: {
+        method: "POST",
+        path: "/media-stream/play/:streamId",
+        description: "Play a media stream",
+        body: z.undefined(),
+        responses: {
+            200: apiSuccess(z.undefined()),
+            400: z.union([
+                ZodErrorSchema,
+                apiError(z.literal("INVALID_STREAM_ID"), z.literal("The provided stream ID is invalid")),
+            ]),
+            // 401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            404: apiError(z.literal("STREAM_NOT_FOUND"), z.literal("The requested stream was not found")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    pause: {
+        method: "POST",
+        path: "/media-stream/pause/:streamId",
+        description: "Pause a media stream",
+        body: z.undefined(),
+        responses: {
+            200: apiSuccess(z.undefined()),
+            400: z.union([
+                ZodErrorSchema,
+                apiError(z.literal("INVALID_STREAM_ID"), z.literal("The provided stream ID is invalid")),
+            ]),
+            // 401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            404: apiError(z.literal("STREAM_NOT_FOUND"), z.literal("The requested stream was not found")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    seek: {
+        method: "POST",
+        path: "/media-stream/seek/:streamId",
+        description: "Seek a media stream",
+        query: z.object({
+            time: z.coerce.number().min(0),
+        }),
+        body: z.undefined(),
+        responses: {
+            200: apiSuccess(z.undefined()),
+            400: z.union([
+                ZodErrorSchema,
+                apiError(z.literal("INVALID_STREAM_ID"), z.literal("The provided stream ID is invalid")),
+            ]),
+            // 401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            404: apiError(z.literal("STREAM_NOT_FOUND"), z.literal("The requested stream was not found")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    stream: {
+        method: "GET",
+        path: "/media-stream/stream/:streamId",
+        description: "Get media stream by stream ID",
+        responses: {
+            200: apiSuccess(z.any()),
+            400: apiError(z.literal("INVALID_VIDEO_ID"), z.literal("The provided video ID is invalid")),
+            // 401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            404: apiError(z.literal("STREAM_NOT_FOUND"), z.literal("The requested stream was not found")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+});

package/dist/contract/sync.d.ts

@@ -0,0 +1,157 @@
+import { z } from "zod";
+declare const _default: {
+    sync: {
+        description: "Synchronize time with the server";
+        method: "POST";
+        body: z.ZodObject<{
+            clientTime: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            clientTime: number;
+        }, {
+            clientTime: number;
+        }>;
+        path: "/sync";
+        responses: {
+            200: z.ZodObject<{
+                clientTime: z.ZodNumber;
+                serverTime: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                clientTime: number;
+                serverTime: number;
+            }, {
+                clientTime: number;
+                serverTime: number;
+            }>;
+            400: 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">[];
+            }>;
+        };
+    };
+    time: {
+        description: "Get the current server time";
+        method: "GET";
+        path: "/time";
+        responses: {
+            200: z.ZodObject<{
+                serverTime: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                serverTime: number;
+            }, {
+                serverTime: number;
+            }>;
+        };
+    };
+};
+export default _default;

package/dist/contract/sync.js

@@ -0,0 +1,31 @@
+import { initContract, ZodErrorSchema } from "@ts-rest/core";
+import { z } from "zod";
+import { apiSuccess } from "../types.js";
+const c = initContract();
+export default c.router({
+    sync: {
+        method: "POST",
+        path: "/sync",
+        description: "Synchronize time with the server",
+        body: z.object({
+            clientTime: z.number().int().nonnegative(),
+        }),
+        responses: {
+            200: apiSuccess(z.object({
+                clientTime: z.number().int().nonnegative(),
+                serverTime: z.number().int().nonnegative(),
+            })),
+            400: ZodErrorSchema,
+        },
+    },
+    time: {
+        method: "GET",
+        path: "/time",
+        description: "Get the current server time",
+        responses: {
+            200: apiSuccess(z.object({
+                serverTime: z.number().int().nonnegative(),
+            })),
+        },
+    },
+});

package/dist/contract/youtube.d.ts

@@ -0,0 +1,168 @@
+import { z } from "zod";
+declare const _default: {
+    getLink: {
+        query: z.ZodObject<{
+            quality: z.ZodOptional<z.ZodEnum<["highest", "highestaudio", "highestvideo", "lowest", "lowestaudio", "lowestvideo"]>>;
+            filter: z.ZodOptional<z.ZodEnum<["audio", "audioandvideo", "audioonly", "video", "videoandaudio", "videoonly"]>>;
+        }, "strip", z.ZodTypeAny, {
+            filter?: "audio" | "audioandvideo" | "audioonly" | "video" | "videoandaudio" | "videoonly" | undefined;
+            quality?: "highest" | "highestaudio" | "highestvideo" | "lowest" | "lowestaudio" | "lowestvideo" | undefined;
+        }, {
+            filter?: "audio" | "audioandvideo" | "audioonly" | "video" | "videoandaudio" | "videoonly" | undefined;
+            quality?: "highest" | "highestaudio" | "highestvideo" | "lowest" | "lowestaudio" | "lowestvideo" | undefined;
+        }>;
+        description: "Get direct audio link from a YouTube video URL";
+        method: "GET";
+        path: "/youtube/audio-link/:videoId";
+        responses: {
+            200: z.ZodObject<{
+                url: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                url: string;
+            }, {
+                url: string;
+            }>;
+            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";
+            }>]>;
+            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";
+            }>;
+        };
+    };
+};
+export default _default;

package/dist/contract/youtube.js

@@ -0,0 +1,27 @@
+import { initContract, ZodErrorSchema } from "@ts-rest/core";
+import { z } from "zod";
+import { apiError, apiSuccess } from "../types.js";
+import { youTubeFilterSchema, youTubeQualitySchema } from "../types/youtube.js";
+const c = initContract();
+export default c.router({
+    getLink: {
+        method: "GET",
+        path: "/youtube/audio-link/:videoId",
+        description: "Get direct audio link from a YouTube video URL",
+        query: z.object({
+            quality: youTubeQualitySchema.optional(),
+            filter: youTubeFilterSchema.optional(),
+        }),
+        responses: {
+            200: apiSuccess(z.object({
+                url: z.string().url(),
+            })),
+            400: z.union([
+                ZodErrorSchema,
+                apiError(z.literal("INVALID_VIDEO_ID"), z.literal("The provided video ID is invalid")),
+            ]),
+            // 401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./common.js";
+export * from "./client.js";
+export * from "./server.js";
+export * from "./socket/index.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./common.js";
+export * from "./client.js";
+export * from "./server.js";
+export * from "./socket/index.js";

package/dist/server.d.ts

@@ -0,0 +1 @@
+export * from "./common.js";

package/dist/server.js

@@ -0,0 +1,18 @@
+export * from "./common.js";
+// import type { JwtPayload } from "jsonwebtoken";
+// export async function JWTVerify(
+//     token: string,
+//     pubKey: string
+// ): Promise<JwtPayload | string | undefined> {
+//     if (typeof window !== "undefined") {
+//         throw new Error(
+//             "JWTverify should not be called in the browser context"
+//         );
+//     }
+//     return new Promise(async (resolve) => {
+//         const jwt = (await import("jsonwebtoken")).default;
+//         jwt.verify(token, pubKey, (err, decoded) => {
+//             resolve(err ? undefined : decoded);
+//         });
+//     });
+// }

package/dist/socket/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./mediaStream.js";
+export * from "./types.js";

package/dist/socket/index.js

@@ -0,0 +1,2 @@
+export * from "./mediaStream.js";
+export * from "./types.js";

package/dist/socket/mediaStream.d.ts

@@ -0,0 +1,9 @@
+export interface SocketClientToServerMediaStream {
+    mediaStreamListen: (streamId: string, callback: (success: boolean) => void) => void;
+    mediaStreamUnlisten: (streamId: string, callback: (success: boolean) => void) => void;
+}
+export interface SocketServerToClientMediaStream {
+    mediaStreamPlay: (streamId: string, startTime: number) => void;
+    mediaStreamPause: (streamId: string) => void;
+    mediaStreamSeek: (streamId: string, startTime: number) => void;
+}

package/dist/socket/mediaStream.js

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

package/dist/socket/types.d.ts

@@ -0,0 +1,5 @@
+import { SocketClientToServerMediaStream, SocketServerToClientMediaStream } from "./mediaStream.js";
+export interface ClientToServerEvents extends SocketClientToServerMediaStream {
+}
+export interface ServerToClientEvents extends SocketServerToClientMediaStream {
+}

package/dist/socket/types.js

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

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./youtube.js";

package/dist/types/index.js

@@ -0,0 +1 @@
+export * from "./youtube.js";

package/dist/types/youtube.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const youTubeQualitySchema: z.ZodEnum<["highest", "highestaudio", "highestvideo", "lowest", "lowestaudio", "lowestvideo"]>;
+export type YouTubeQuality = z.infer<typeof youTubeQualitySchema>;
+export declare const youTubeFilterSchema: z.ZodEnum<["audio", "audioandvideo", "audioonly", "video", "videoandaudio", "videoonly"]>;
+export type YouTubeFilter = z.infer<typeof youTubeFilterSchema>;

package/dist/types/youtube.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export const youTubeQualitySchema = z.enum([
+    "highest",
+    "highestaudio",
+    "highestvideo",
+    "lowest",
+    "lowestaudio",
+    "lowestvideo",
+]);
+export const youTubeFilterSchema = z.enum([
+    "audio",
+    "audioandvideo",
+    "audioonly",
+    "video",
+    "videoandaudio",
+    "videoonly",
+]);

package/dist/types.d.ts

@@ -0,0 +1,31 @@
+import { z, ZodType } from "zod";
+export declare const apiSuccess: <T>(schema: T) => T;
+export declare const apiError: <T, U>(code: ZodType<T>, error: ZodType<U>) => z.ZodObject<{
+    code: z.ZodType<T, z.ZodTypeDef, T>;
+    error: z.ZodType<U, z.ZodTypeDef, U>;
+    name: z.ZodLiteral<"APIError">;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    code: z.ZodType<T, z.ZodTypeDef, T>;
+    error: z.ZodType<U, z.ZodTypeDef, U>;
+    name: z.ZodLiteral<"APIError">;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<{
+    code: z.ZodType<T, z.ZodTypeDef, T>;
+    error: z.ZodType<U, z.ZodTypeDef, U>;
+    name: z.ZodLiteral<"APIError">;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>;
+export declare const apiErrorData: <T, U, V>(code: ZodType<T>, error: ZodType<U>, data: ZodType<V>) => z.ZodObject<{
+    code: z.ZodType<T, z.ZodTypeDef, T>;
+    error: z.ZodType<U, z.ZodTypeDef, U>;
+    name: z.ZodLiteral<"APIError">;
+    data: z.ZodType<V, z.ZodTypeDef, V>;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    code: z.ZodType<T, z.ZodTypeDef, T>;
+    error: z.ZodType<U, z.ZodTypeDef, U>;
+    name: z.ZodLiteral<"APIError">;
+    data: z.ZodType<V, z.ZodTypeDef, V>;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<{
+    code: z.ZodType<T, z.ZodTypeDef, T>;
+    error: z.ZodType<U, z.ZodTypeDef, U>;
+    name: z.ZodLiteral<"APIError">;
+    data: z.ZodType<V, z.ZodTypeDef, V>;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>;

package/dist/types.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+// export const apiSuccess = <T>(schema: ZodType<T>) => schema;
+export const apiSuccess = (schema) => schema;
+export const apiError = (code, error) => z.object({
+    code,
+    error,
+    name: z.literal("APIError"),
+});
+export const apiErrorData = (code, error, data) => z.object({
+    code,
+    error,
+    name: z.literal("APIError"),
+    data,
+});