@darco2903/cdn-api 1.0.7-beta.0 → 1.0.7-beta.1

package/{src/client.ts → dist/client.js}

@@ -1,18 +1,15 @@
-export * from "./common.js";
-import io from "socket.io-client";
-import { initClient } from "@ts-rest/core";
-import contract from "./contract/index.js";
-import type { CdnClientSocket } from "./socket/index.js";
-
-export function createClient(origin: string) {
-    return initClient(contract, {
-        baseUrl: origin,
-        credentials: "include",
-    });
-}
-
-export function createSocket(origin: string): CdnClientSocket {
-    return io(origin, {
-        autoConnect: true,
-    });
-}
+export * from "./common.js";
+import io from "socket.io-client";
+import { initClient } from "@ts-rest/core";
+import contract from "./contract/index.js";
+export function createClient(origin) {
+    return initClient(contract, {
+        baseUrl: origin,
+        credentials: "include",
+    });
+}
+export function createSocket(origin) {
+    return io(origin, {
+        autoConnect: true,
+    });
+}

package/{src/common.ts → dist/common.d.ts}

@@ -1,4 +1,4 @@
-export { default as contract } from "./contract/index.js";
-export * from "./socket/index.js";
-export * from "./types/index.js";
-export * from "./consts.js";
+export { default as contract } from "./contract/index.js";
+export * from "./socket/index.js";
+export * from "./types/index.js";
+export * from "./consts.js";

package/dist/common.js

@@ -0,0 +1,4 @@
+export { default as contract } from "./contract/index.js";
+export * from "./socket/index.js";
+export * from "./types/index.js";
+export * from "./consts.js";

package/dist/consts.d.ts

@@ -0,0 +1,5 @@
+import type { Algorithm } from "jsonwebtoken";
+export declare const API_VERSION = "v2";
+export declare const API_PATH_PREFIX = "/api/v2";
+export declare const JWT_ALGORITHM: Algorithm;
+export declare const STORAGE_PUBLIC_ID_LENGTH = 8;

package/{src/consts.ts → dist/consts.js}

@@ -1,8 +1,4 @@
-import type { Algorithm } from "jsonwebtoken";
-
-export const API_VERSION = "v2";
-export const API_PATH_PREFIX = `/api/${API_VERSION}`;
-
-export const JWT_ALGORITHM: Algorithm = "ES256";
-
-export const STORAGE_PUBLIC_ID_LENGTH = 8;
+export const API_VERSION = "v2";
+export const API_PATH_PREFIX = `/api/${API_VERSION}`;
+export const JWT_ALGORITHM = "ES256";
+export const STORAGE_PUBLIC_ID_LENGTH = 8;

package/dist/contract/auth.d.ts

@@ -0,0 +1,35 @@
+import z from "zod";
+declare const _default: {
+    access: {
+        method: "GET";
+        path: "/auth/access";
+        headers: z.ZodObject<{
+            authorization: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            authorization?: string | undefined;
+        }, {
+            authorization?: string | undefined;
+        }>;
+        responses: {
+            200: z.ZodType<{
+                access: boolean;
+            }, z.ZodTypeDef, {
+                access: boolean;
+            }>;
+            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";
+                name: "APIError";
+                error: string;
+            }, {
+                code: "INTERNAL_SERVER_ERROR";
+                name: "APIError";
+                error: string;
+            }>;
+        };
+    };
+};
+export default _default;

package/{src/contract/auth.ts → dist/contract/auth.js}

@@ -1,22 +1,18 @@
-import { initContract } from "@ts-rest/core";
-import z from "zod";
-import { authHeaderSchema } from "@darco2903/auth-api/client";
-import { apiError, apiSuccess } from "../types.js";
-
-const c = initContract();
-
-export default c.router({
-    access: {
-        method: "GET",
-        path: "/auth/access",
-        headers: authHeaderSchema,
-        responses: {
-            200: apiSuccess(
-                z.object({
-                    access: z.boolean(),
-                })
-            ),
-            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
-        },
-    },
-});
+import { initContract } from "@ts-rest/core";
+import z from "zod";
+import { authHeaderSchema } from "@darco2903/auth-api/client";
+import { apiError, apiSuccess } from "../types.js";
+const c = initContract();
+export default c.router({
+    access: {
+        method: "GET",
+        path: "/auth/access",
+        headers: authHeaderSchema,
+        responses: {
+            200: apiSuccess(z.object({
+                access: z.boolean(),
+            })),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+});

package/dist/contract/endpoint.d.ts

@@ -0,0 +1,396 @@
+import z from "zod";
+declare const _default: {
+    create: {
+        body: z.ZodObject<{
+            storage_id: z.ZodString;
+            endpoint: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            endpoint: string;
+            storage_id: string;
+        }, {
+            endpoint: string;
+            storage_id: string;
+        }>;
+        method: "POST";
+        path: "/endpoint";
+        headers: z.ZodObject<{
+            authorization: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            authorization?: string | undefined;
+        }, {
+            authorization?: string | undefined;
+        }>;
+        responses: {
+            200: z.ZodType<null, z.ZodTypeDef, null>;
+            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">[];
+            }>;
+            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";
+                name: "APIError";
+                error: "Unauthorized";
+            }, {
+                code: "UNAUTHORIZED";
+                name: "APIError";
+                error: "Unauthorized";
+            }>;
+            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";
+                name: "APIError";
+                error: "Forbidden";
+            }, {
+                code: "FORBIDDEN";
+                name: "APIError";
+                error: "Forbidden";
+            }>;
+            404: z.ZodObject<{
+                code: z.ZodType<"NOT_FOUND", z.ZodTypeDef, "NOT_FOUND">;
+                error: z.ZodType<"Record not found", z.ZodTypeDef, "Record not found">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "NOT_FOUND";
+                name: "APIError";
+                error: "Record not found";
+            }, {
+                code: "NOT_FOUND";
+                name: "APIError";
+                error: "Record not found";
+            }>;
+            409: z.ZodObject<{
+                code: z.ZodType<"CONFLICT", z.ZodTypeDef, "CONFLICT">;
+                error: z.ZodType<"Endpoint already exists", z.ZodTypeDef, "Endpoint already exists">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "CONFLICT";
+                name: "APIError";
+                error: "Endpoint already exists";
+            }, {
+                code: "CONFLICT";
+                name: "APIError";
+                error: "Endpoint already exists";
+            }>;
+            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";
+                name: "APIError";
+                error: string;
+            }, {
+                code: "INTERNAL_SERVER_ERROR";
+                name: "APIError";
+                error: string;
+            }>;
+        };
+    };
+    delete: {
+        body: z.ZodObject<{
+            endpoint: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            endpoint: string;
+        }, {
+            endpoint: string;
+        }>;
+        method: "DELETE";
+        path: "/endpoint";
+        headers: z.ZodObject<{
+            authorization: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            authorization?: string | undefined;
+        }, {
+            authorization?: string | undefined;
+        }>;
+        responses: {
+            200: z.ZodType<null, z.ZodTypeDef, null>;
+            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">[];
+            }>;
+            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";
+                name: "APIError";
+                error: "Unauthorized";
+            }, {
+                code: "UNAUTHORIZED";
+                name: "APIError";
+                error: "Unauthorized";
+            }>;
+            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";
+                name: "APIError";
+                error: "Forbidden";
+            }, {
+                code: "FORBIDDEN";
+                name: "APIError";
+                error: "Forbidden";
+            }>;
+            404: z.ZodObject<{
+                code: z.ZodType<"NOT_FOUND", z.ZodTypeDef, "NOT_FOUND">;
+                error: z.ZodType<"Endpoint not found", z.ZodTypeDef, "Endpoint not found">;
+                name: z.ZodLiteral<"APIError">;
+            }, "strip", z.ZodTypeAny, {
+                code: "NOT_FOUND";
+                name: "APIError";
+                error: "Endpoint not found";
+            }, {
+                code: "NOT_FOUND";
+                name: "APIError";
+                error: "Endpoint not found";
+            }>;
+            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";
+                name: "APIError";
+                error: string;
+            }, {
+                code: "INTERNAL_SERVER_ERROR";
+                name: "APIError";
+                error: string;
+            }>;
+        };
+    };
+};
+export default _default;

package/{src/contract/endpoint.ts → dist/contract/endpoint.js}

@@ -1,53 +1,42 @@
-import { initContract, ZodErrorSchema } from "@ts-rest/core";
-import z from "zod";
-import { authHeaderSchema } from "@darco2903/auth-api/client";
-import { apiError, apiSuccess } from "../types.js";
-import { endpointPathSchema } from "../types/index.js";
-
-const c = initContract();
-
-export default c.router({
-    create: {
-        method: "POST",
-        path: "/endpoint",
-        headers: authHeaderSchema,
-        body: z.object({
-            storage_id: z.string().nonempty(),
-            endpoint: endpointPathSchema,
-        }),
-        responses: {
-            200: apiSuccess(z.null()),
-            400: ZodErrorSchema,
-            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
-            403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
-            404: apiError(
-                z.literal("NOT_FOUND"),
-                z.literal("Record not found")
-            ),
-            409: apiError(
-                z.literal("CONFLICT"),
-                z.literal("Endpoint already exists")
-            ),
-            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
-        },
-    },
-    delete: {
-        method: "DELETE",
-        path: "/endpoint",
-        headers: authHeaderSchema,
-        body: z.object({
-            endpoint: endpointPathSchema,
-        }),
-        responses: {
-            200: apiSuccess(z.null()),
-            400: ZodErrorSchema,
-            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
-            403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
-            404: apiError(
-                z.literal("NOT_FOUND"),
-                z.literal("Endpoint not found")
-            ),
-            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
-        },
-    },
-});
+import { initContract, ZodErrorSchema } from "@ts-rest/core";
+import z from "zod";
+import { authHeaderSchema } from "@darco2903/auth-api/client";
+import { apiError, apiSuccess } from "../types.js";
+import { endpointPathSchema } from "../types/index.js";
+const c = initContract();
+export default c.router({
+    create: {
+        method: "POST",
+        path: "/endpoint",
+        headers: authHeaderSchema,
+        body: z.object({
+            storage_id: z.string().nonempty(),
+            endpoint: endpointPathSchema,
+        }),
+        responses: {
+            200: apiSuccess(z.null()),
+            400: ZodErrorSchema,
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
+            404: apiError(z.literal("NOT_FOUND"), z.literal("Record not found")),
+            409: apiError(z.literal("CONFLICT"), z.literal("Endpoint already exists")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+    delete: {
+        method: "DELETE",
+        path: "/endpoint",
+        headers: authHeaderSchema,
+        body: z.object({
+            endpoint: endpointPathSchema,
+        }),
+        responses: {
+            200: apiSuccess(z.null()),
+            400: ZodErrorSchema,
+            401: apiError(z.literal("UNAUTHORIZED"), z.literal("Unauthorized")),
+            403: apiError(z.literal("FORBIDDEN"), z.literal("Forbidden")),
+            404: apiError(z.literal("NOT_FOUND"), z.literal("Endpoint not found")),
+            500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
+        },
+    },
+});