@gigapay-dev/contracts 1.8.6 → 2.0.0

package/commands/orders/endpoints.ts

@@ -1,51 +0,0 @@
-import z from "zod";
-import { OrderReadResponseSchema } from "./read";
-import { EndpointContract } from "../../types";
-import { OrderCreateRequestSchema, OrderCreateResponseSchema } from "./create";
-import { OrdersListQuerySchema } from "./query";
-
-export const OrderEndpoints = {
-	create: {
-		method: "POST",
-		path: "/orders",
-		request: OrderCreateRequestSchema,
-		response: OrderCreateResponseSchema,
-	},
-	list: {
-		method: "GET",
-		path: "/orders",
-		request: OrdersListQuerySchema,
-		response: z.array(OrderReadResponseSchema),
-	},
-	getById: {
-		method: "GET",
-		path: "/orders/:id",
-		request: z.object({
-			id: z.coerce.number().positive(),
-		}),
-		response: OrderReadResponseSchema,
-	},
-	getUserOrders: {
-		method: "GET",
-		path: "/orders/user",
-		request: OrdersListQuerySchema,
-		response: z.array(OrderReadResponseSchema),
-	},
-	getUserOrderById: {
-		method: "GET",
-		path: "/orders/user/:userId/:orderId",
-		request: z.object({
-			userId: z.coerce.number().positive(),
-			orderId: z.coerce.number().positive(),
-		}),
-		response: OrderReadResponseSchema,
-	},
-} satisfies Record<string, EndpointContract>;
-
-export type OrderEndpointKey = keyof typeof OrderEndpoints;
-
-export type GetOrderRequest<K extends OrderEndpointKey> =
-	z.infer<typeof OrderEndpoints[K]["request"]>;
-
-export type GetOrderResponse<K extends OrderEndpointKey> =
-	z.infer<typeof OrderEndpoints[K]["response"]>;

package/commands/orders/enums.ts

@@ -1,25 +0,0 @@
-import z from "zod";
-
-export const OrderType = z.enum(["MAIN", "WEBAPP"]);
-export type OrderType = z.infer<typeof OrderType>;
-
-export const OrderStatus = z.enum([
-	"PENDING",
-	"AWAITING_PAYMENT",
-	"PAID",
-	"PROCESSING",
-	"SUCCESS",
-	"FAILED",
-	"REFUNDED",
-	"CANCELLED",
-]);
-export type OrderStatus = z.infer<typeof OrderStatus>;
-
-export const OrderItemStatus = z.enum([
-	"PENDING",
-	"PROCESSING",
-	"DELIVERED",
-	"FAILED",
-	"REFUNDED",
-]);
-export type OrderItemStatus = z.infer<typeof OrderItemStatus>;

package/commands/orders/index.ts

@@ -1,6 +0,0 @@
-export * from "./enums";
-export * from "./create";
-export * from "./update";
-export * from "./read";
-export * from "./query";
-export * from "./endpoints";

package/commands/orders/query.ts

@@ -1,46 +0,0 @@
-import z from "zod";
-import { PaginationQuery } from "../pagination";
-import { OrderStatus } from "./enums";
-
-/** Фильтр по периоду (базовая схема без refinements для merge) */
-const OrdersPeriodBase = z.object({
-	/** Предустановленный период: day, week, month, year, custom */
-	period: z.enum(["day", "week", "month", "year", "custom"]).optional(),
-	/** Начало периода (ISO datetime, обязателен при period=custom) */
-	start: z.string().datetime().optional(),
-	/** Конец периода (ISO datetime, обязателен при period=custom) */
-	end: z.string().datetime().optional(),
-});
-
-/** Фильтр по периоду с валидацией custom-диапазона */
-export const OrdersPeriodSchema = OrdersPeriodBase
-	.refine(v => v.period !== "custom" || (v.start && v.end), {
-		message: "start/end обязательны при period=custom",
-	})
-	.refine(v => v.period !== "custom" || new Date(v.start!) < new Date(v.end!), {
-		message: "start должен быть раньше end",
-	});
-
-/** Фильтры списка заказов */
-export const OrdersFiltersSchema = z.object({
-	/** Фильтр по email покупателя (частичное совпадение) */
-	email: z.string().optional(),
-	/** Фильтр по статусу заказа */
-	status: OrderStatus.optional(),
-});
-
-/** Сортировка списка заказов */
-export const OrdersSortSchema = z.object({
-	/** Поле для сортировки: createdAt, updatedAt, total, subtotal */
-	sortBy: z.enum(["createdAt", "updatedAt", "total", "subtotal"]).default("createdAt"),
-	/** Направление сортировки */
-	sortDir: z.enum(["asc", "desc"]).default("desc"),
-});
-
-/** Объединённая схема запроса списка заказов */
-export const OrdersListQuerySchema = PaginationQuery
-	.merge(OrdersFiltersSchema)
-	.merge(OrdersSortSchema)
-	.merge(OrdersPeriodBase);
-
-export type OrdersListQuery = z.infer<typeof OrdersListQuerySchema>;

package/commands/orders/read.ts

@@ -1,83 +0,0 @@
-import { z } from "zod";
-import { OrderType, OrderStatus, OrderItemStatus } from "./enums";
-
-/** Элемент заказа в ответе */
-export const OrderItemResponseSchema = z.object({
-	/** ID элемента заказа */
-	id: z.number(),
-	/** ID товара */
-	productId: z.number(),
-	/** ID варианта товара */
-	variantId: z.number(),
-	/** Количество */
-	quantity: z.number(),
-	/** Цена на момент покупки (строка, Decimal) */
-	price: z.string(),
-	/** Игровой логин для доставки */
-	gameUsername: z.string().nullable(),
-	/** Тип игрового логина */
-	gameUsernameType: z.string().nullable(),
-	/** Выданный ключ (если автоматическая доставка) */
-	deliveredKey: z.string().nullable(),
-	/** Дата доставки */
-	deliveredAt: z.coerce.date().nullable(),
-	/** Статус элемента заказа */
-	status: OrderItemStatus,
-	/** Название товара */
-	productTitle: z.string().optional(),
-	/** Название варианта */
-	variantName: z.string().optional(),
-});
-
-/** Полная информация о заказе */
-export const OrderReadResponseSchema = z.object({
-	/** ID заказа */
-	id: z.coerce.number().positive(),
-	/** ID пользователя (null для гостевых заказов) */
-	userId: z.coerce.number().positive().nullable().optional(),
-	/** ID промокода */
-	promocodeId: z.coerce.number().nonnegative().nullable().optional(),
-	/** ID способа оплаты */
-	paymentMethodId: z.coerce.number().nonnegative().nullable().optional(),
-	/** Email покупателя */
-	email: z.string(),
-	/** Статус заказа */
-	status: OrderStatus,
-	/** Тип заказа */
-	type: OrderType,
-	/** Сумма товаров до скидки и комиссий (строка, Decimal) */
-	subtotal: z.string(),
-	/** Сумма скидки (строка, Decimal) */
-	discount: z.string(),
-	/** Комиссия эквайринга (строка, Decimal) */
-	commission: z.string(),
-	/** Комиссия сервиса (строка, Decimal) */
-	serviceCommission: z.string(),
-	/** Итого к оплате (строка, Decimal) */
-	total: z.string(),
-	/** IP-адрес покупателя */
-	ipAddress: z.string().nullable().optional(),
-	/** UTM-метка источника трафика */
-	utmSource: z.string().nullable(),
-	/** Тип дизайна формы оплаты */
-	designType: z.string().nullable(),
-	/** Название способа оплаты */
-	paymentMethodName: z.string().nullable(),
-	/** Значение промокода */
-	promocodeValue: z.string().nullable(),
-	/** Скидка промокода в процентах (строка, Decimal) */
-	promocodeDiscount: z.string().nullable(),
-	/** Процент комиссии сервиса (serviceComission + secretComission) */
-	serviceCommissionPercent: z.coerce.number().nonnegative().optional(),
-	/** Процент комиссии эквайринга */
-	acquiringCommissionPercent: z.coerce.number().nonnegative().optional(),
-	/** Элементы заказа */
-	items: z.array(OrderItemResponseSchema).optional(),
-	/** Дата создания */
-	createdAt: z.coerce.date().default(() => new Date()),
-	/** Дата обновления */
-	updatedAt: z.coerce.date().default(() => new Date()),
-});
-
-export type OrderItemResponse = z.infer<typeof OrderItemResponseSchema>;
-export type OrderReadResponse = z.infer<typeof OrderReadResponseSchema>;

package/commands/orders/update.ts

@@ -1,16 +0,0 @@
-import { z } from "zod";
-import { OrderStatus } from "./enums";
-
-/** Запрос на обновление заказа (администратором) */
-export const OrderUpdateRequestSchema = z.object({
-	/** Новый статус заказа */
-	status: OrderStatus.optional(),
-	/** Email покупателя */
-	email: z.string().email().optional(),
-	/** ID способа оплаты */
-	paymentMethodId: z.coerce.number().positive().optional(),
-	/** ID промокода */
-	promocodeId: z.coerce.number().positive().optional(),
-});
-
-export type OrderUpdateRequest = z.infer<typeof OrderUpdateRequestSchema>;

package/commands/pagination.ts

@@ -1,8 +0,0 @@
-import z from "zod";
-
-export const PaginationQuery = z.object({
-    take: z.string().optional(),
-    skip: z.string().optional(),
-});
-
-export type PaginationQuery = z.infer<typeof PaginationQuery>;

package/commands/payment-methods/create.ts

@@ -1,19 +0,0 @@
-import z from "zod";
-
-export const PaymentMethodsCreateRequestSchema = z.object({
-    name: z.string(),
-    image: z.string(),
-    key: z.string(),
-    uniqueKey: z.string(),
-    isActive: z.boolean().default(true),
-    type: z.string(),
-    maxAmount: z.coerce.number().nonnegative(),
-    minAmount: z.coerce.number().nonnegative(),
-    comission: z.coerce.number().nonnegative(),
-    secretComission: z.coerce.number().nonnegative(),
-    serviceComission: z.coerce.number().nonnegative(),
-    cryptoToken: z.string().optional(),
-    cryptoTokenSecret: z.string().optional(),
-});
-
-export type PaymentMethodsCreateRequest = z.infer<typeof PaymentMethodsCreateRequestSchema>;

package/commands/payment-methods/endpoints.ts

@@ -1,67 +0,0 @@
-import z from "zod";
-import { CourseReadResponseSchema, PaymentMethodReadResponseSchema } from "./read";
-import { EndpointContract } from "../../types";
-import { PaymentMethodUpdateRequestSchema } from "./update";
-import { PaymentMethodsCreateRequestSchema } from "./create";
-
-export const PaymentMethodEndpoints = {
-    course: {
-        method: "GET",
-        path: "/course",
-        request: z.object({}),
-        response: CourseReadResponseSchema,
-    },
-    create: {
-        method: "POST",
-        path: "/payment-methods",
-        request: z.object({
-            data: PaymentMethodsCreateRequestSchema,
-        }),
-        response: PaymentMethodReadResponseSchema,
-    },
-    update: {
-        method: "PUT",
-        path: "/payment-methods/:id",
-        request: z.object({
-            id: z.coerce.number().positive(),
-            data: PaymentMethodUpdateRequestSchema,
-        }),
-        response: PaymentMethodReadResponseSchema,
-    },
-    list: {
-        method: "GET",
-        path: "/payment-methods",
-        request: z.object({}),
-        response: z.array(PaymentMethodReadResponseSchema),
-    },
-    listAdmin: {
-        method: "GET",
-        path: "/payment-methods/admin",
-        request: z.object({}),
-        response: z.array(PaymentMethodReadResponseSchema),
-    },
-    getById: {
-        method: "GET",
-        path: "/payment-methods/:id",
-        request: z.object({
-            id: z.coerce.number().positive(),
-        }),
-        response: PaymentMethodReadResponseSchema,
-    },
-    getByIdAdmin: {
-        method: "GET",
-        path: "/payment-methods/admin/:id",
-        request: z.object({
-            id: z.coerce.number().positive(),
-        }),
-        response: PaymentMethodReadResponseSchema,
-    },
-} satisfies Record<string, EndpointContract>;
-
-export type PaymentMethodEndpointKey = keyof typeof PaymentMethodEndpoints;
-
-export type GetPaymentMethodRequest<K extends PaymentMethodEndpointKey> =
-  z.infer<typeof PaymentMethodEndpoints[K]["request"]>;
-
-export type GetPaymentMethodResponse<K extends PaymentMethodEndpointKey> =
-  z.infer<typeof PaymentMethodEndpoints[K]["response"]>;

package/commands/payment-methods/index.ts

@@ -1,4 +0,0 @@
-export * from './read';
-export * from './create';
-export * from './update';
-export * from './endpoints';

package/commands/payment-methods/read.ts

@@ -1,30 +0,0 @@
-import { z } from "zod";
-
-export const CourseReadResponseSchema = z.object({
-    USD_RUB: z.string(),
-    RUB_KZT: z.string(),
-    USD_KZT: z.string(),
-    KZT_RUB: z.string(),
-});
-
-export const PaymentMethodReadResponseSchema = z.object({
-    id: z.coerce.number().positive(),
-    name: z.string(),
-    image: z.string(),
-    key: z.string(),
-    uniqueKey: z.string(),
-    isActive: z.boolean(),
-    type: z.string(),
-    maxAmount: z.coerce.number().nonnegative(),
-    minAmount: z.coerce.number().nonnegative(),
-    comission: z.coerce.number().nonnegative(),
-    secretComission: z.coerce.number().nonnegative().optional(),
-    serviceComission: z.coerce.number().nonnegative(),
-    cryptoToken: z.string().nullable(),
-    cryptoNetwork: z.string().nullable(),
-    updatedAt: z.coerce.date(),
-    createdAt: z.coerce.date(),
-});
-
-export type CourseReadResponse = z.infer<typeof CourseReadResponseSchema>;
-export type PaymentMethodReadResponse = z.infer<typeof PaymentMethodReadResponseSchema>;

package/commands/payment-methods/update.ts

@@ -1,19 +0,0 @@
-import { z } from "zod";
-
-export const PaymentMethodUpdateRequestSchema = z.object({
-    name: z.string().optional(),
-    image: z.string().optional(),
-    key: z.string().optional(),
-    uniqueKey: z.string().optional(),
-    isActive: z.boolean().optional(),
-    type: z.string().optional(),
-    maxAmount: z.coerce.number().nonnegative().optional(),
-    minAmount: z.coerce.number().nonnegative().optional(),
-    comission: z.coerce.number().nonnegative().optional(),
-    secretComission: z.coerce.number().nonnegative().optional(),
-    serviceComission: z.coerce.number().nonnegative().optional(),
-    cryptoToken: z.string().nullable().optional(),
-    cryptoTokenSecret: z.string().nullable().optional(),
-})
-
-export type PaymentMethodUpdateRequest = z.infer<typeof PaymentMethodUpdateRequestSchema>

package/commands/products/create.ts

@@ -1,134 +0,0 @@
-import z from "zod";
-import { ProductType, DeliveryType, MediaType, SystemRequirementType } from "./enums";
-
-/** Запрос на создание продукта */
-export const ProductCreateRequestSchema = z.object({
-	/** URL-friendly идентификатор */
-	slug: z.string().min(1),
-	/** Название продукта */
-	title: z.string().min(1),
-	/** Оригинальное название (на языке оригинала) */
-	originalTitle: z.string().optional(),
-	/** Тип продукта */
-	type: ProductType,
-	/** ID категории */
-	categoryId: z.number().int().positive(),
-	/** ID родительского продукта (для DLC) */
-	parentProductId: z.number().int().positive().optional(),
-	/** Полное описание */
-	description: z.string().optional(),
-	/** Кастомное описание */
-	customDescription: z.string().optional(),
-	/** Краткое описание */
-	shortDescription: z.string().optional(),
-	/** URL обложки */
-	coverImageUrl: z.string().url().optional(),
-	/** Разработчик */
-	developer: z.string().optional(),
-	/** Издатель */
-	publisher: z.string().optional(),
-	/** Дата выхода (ISO datetime) */
-	releaseDate: z.string().datetime().optional(),
-	/** Steam App ID */
-	steamAppId: z.number().int().optional(),
-	/** Мультиплеер */
-	hasMultiplayer: z.boolean().default(false),
-	/** Кооператив */
-	hasCoop: z.boolean().default(false),
-	/** Одиночная игра */
-	hasSinglePlayer: z.boolean().default(true),
-	/** SEO: заголовок */
-	metaTitle: z.string().optional(),
-	/** SEO: описание */
-	metaDescription: z.string().optional(),
-	/** ID жанров для привязки */
-	genreIds: z.array(z.number().int().positive()).optional(),
-	/** ID тегов для привязки */
-	tagIds: z.array(z.number().int().positive()).optional(),
-	/** ID регионов для привязки */
-	regionIds: z.array(z.number().int().positive()).optional(),
-});
-
-export type ProductCreateRequest = z.infer<typeof ProductCreateRequestSchema>;
-
-/** Запрос на создание варианта продукта */
-export const VariantCreateRequestSchema = z.object({
-	/** Название варианта */
-	name: z.string().min(1),
-	/** Артикул */
-	sku: z.string().min(1),
-	/** Цена */
-	price: z.number().positive(),
-	/** Цена до скидки */
-	originalPrice: z.number().positive().optional(),
-	/** Себестоимость */
-	costPrice: z.number().positive().optional(),
-	/** Сумма пополнения (для TOPUP) */
-	topupAmount: z.number().positive().optional(),
-	/** Валюта */
-	currency: z.string().optional(),
-	/** Длительность подписки (дни) */
-	durationDays: z.number().int().positive().optional(),
-	/** Платформа (Steam, Epic Games, ...) */
-	platform: z.string().optional(),
-	/** Код региона */
-	regionCode: z.string().optional(),
-	/** Тип доставки */
-	deliveryType: DeliveryType.default("AUTOMATIC"),
-});
-
-export type VariantCreateRequest = z.infer<typeof VariantCreateRequestSchema>;
-
-/** Запрос на импорт ключей */
-export const KeysImportRequestSchema = z.object({
-	/** Массив ключей для импорта */
-	keys: z.array(z.string().min(1)).min(1),
-});
-
-export type KeysImportRequest = z.infer<typeof KeysImportRequestSchema>;
-
-/** Ответ на импорт ключей */
-export const KeysImportResponseSchema = z.object({
-	/** Количество импортированных ключей */
-	imported: z.number(),
-});
-
-export type KeysImportResponse = z.infer<typeof KeysImportResponseSchema>;
-
-/** Запрос на добавление медиа */
-export const MediaCreateRequestSchema = z.object({
-	/** Тип медиа */
-	type: MediaType,
-	/** URL медиа */
-	url: z.string().url(),
-	/** Alt-текст */
-	alt: z.string().optional(),
-	/** Порядок сортировки */
-	sortOrder: z.number().int().default(0),
-});
-
-export type MediaCreateRequest = z.infer<typeof MediaCreateRequestSchema>;
-
-/** Запрос на upsert системных требований */
-export const SystemRequirementsRequestSchema = z.object({
-	/** Тип: минимальные / рекомендуемые */
-	type: SystemRequirementType,
-	/** Операционная система */
-	os: z.string().optional(),
-	/** Процессор */
-	processor: z.string().optional(),
-	/** Оперативная память */
-	memory: z.string().optional(),
-	/** Видеокарта */
-	graphics: z.string().optional(),
-	/** Место на диске */
-	storage: z.string().optional(),
-	/** DirectX */
-	directx: z.string().optional(),
-	/** Сеть */
-	network: z.string().optional(),
-	/** Дополнительно */
-	additional: z.string().optional(),
-});
-
-export type SystemRequirementsRequest = z.infer<typeof SystemRequirementsRequestSchema>;

package/commands/products/endpoints.ts

@@ -1,108 +0,0 @@
-import z from "zod";
-import { EndpointContract } from "../../types";
-import { ProductFilterSchema } from "./query";
-import { ProductCreateRequestSchema, VariantCreateRequestSchema, KeysImportRequestSchema, KeysImportResponseSchema, MediaCreateRequestSchema, SystemRequirementsRequestSchema } from "./create";
-import { ProductUpdateRequestSchema } from "./update";
-import { ProductCatalogResponseSchema, ProductDetailResponseSchema, CategoryResponseSchema, GenreResponseSchema, RegionResponseSchema, KeysCountResponseSchema } from "./read";
-
-export const ProductEndpoints = {
-	// === Публичные ===
-	catalog: {
-		method: "GET",
-		path: "/products",
-		request: ProductFilterSchema,
-		response: z.object({
-			items: z.array(ProductCatalogResponseSchema),
-			total: z.number(),
-			skip: z.number(),
-			take: z.number(),
-		}),
-	},
-	categories: {
-		method: "GET",
-		path: "/products/categories",
-		response: z.array(CategoryResponseSchema),
-	},
-	genres: {
-		method: "GET",
-		path: "/products/genres",
-		response: z.array(GenreResponseSchema),
-	},
-	regions: {
-		method: "GET",
-		path: "/products/regions",
-		response: z.array(RegionResponseSchema),
-	},
-	getBySlug: {
-		method: "GET",
-		path: "/products/:slug",
-		request: z.object({ slug: z.string() }),
-		response: ProductDetailResponseSchema,
-	},
-
-	// === Администрирование ===
-	create: {
-		method: "POST",
-		path: "/products/admin",
-		request: ProductCreateRequestSchema,
-		response: ProductDetailResponseSchema,
-	},
-	update: {
-		method: "PUT",
-		path: "/products/admin/:id",
-		request: ProductUpdateRequestSchema,
-		response: ProductDetailResponseSchema,
-	},
-	archive: {
-		method: "DELETE",
-		path: "/products/admin/:id",
-		response: z.object({ status: z.string() }),
-	},
-	createVariant: {
-		method: "POST",
-		path: "/products/admin/:productId/variants",
-		request: VariantCreateRequestSchema,
-	},
-	updateVariant: {
-		method: "PUT",
-		path: "/products/admin/variants/:variantId",
-		request: VariantCreateRequestSchema,
-	},
-	importKeys: {
-		method: "POST",
-		path: "/products/admin/variants/:variantId/keys",
-		request: KeysImportRequestSchema,
-		response: KeysImportResponseSchema,
-	},
-	getKeysCount: {
-		method: "GET",
-		path: "/products/admin/variants/:variantId/keys/count",
-		response: KeysCountResponseSchema,
-	},
-	addMedia: {
-		method: "POST",
-		path: "/products/admin/:productId/media",
-		request: MediaCreateRequestSchema,
-	},
-	removeMedia: {
-		method: "DELETE",
-		path: "/products/admin/media/:mediaId",
-	},
-	upsertSystemRequirements: {
-		method: "POST",
-		path: "/products/admin/:productId/system-requirements",
-		request: SystemRequirementsRequestSchema,
-	},
-} satisfies Record<string, EndpointContract>;
-
-export type ProductEndpointKey = keyof typeof ProductEndpoints;
-
-export type GetProductRequest<K extends ProductEndpointKey> =
-	typeof ProductEndpoints[K] extends { request: z.ZodTypeAny }
-		? z.infer<typeof ProductEndpoints[K]["request"]>
-		: never;
-
-export type GetProductResponse<K extends ProductEndpointKey> =
-	typeof ProductEndpoints[K] extends { response: z.ZodTypeAny }
-		? z.infer<typeof ProductEndpoints[K]["response"]>
-		: never;

package/commands/products/enums.ts

@@ -1,33 +0,0 @@
-import z from "zod";
-
-/** Тип продукта */
-export const ProductType = z.enum([
-	"GAME_KEY",
-	"GAME_GIFT",
-	"TOPUP",
-	"SUBSCRIPTION",
-	"IN_GAME_ITEM",
-	"DLC",
-	"CURRENCY",
-]);
-export type ProductType = z.infer<typeof ProductType>;
-
-/** Статус продукта */
-export const ProductStatus = z.enum(["DRAFT", "ACTIVE", "OUT_OF_STOCK", "ARCHIVED"]);
-export type ProductStatus = z.infer<typeof ProductStatus>;
-
-/** Тип доставки варианта */
-export const DeliveryType = z.enum(["AUTOMATIC", "MANUAL", "BOT"]);
-export type DeliveryType = z.infer<typeof DeliveryType>;
-
-/** Тип медиа-контента */
-export const MediaType = z.enum(["SCREENSHOT", "SLIDER", "VIDEO", "TRAILER"]);
-export type MediaType = z.infer<typeof MediaType>;
-
-/** Статус ключа */
-export const KeyStatus = z.enum(["AVAILABLE", "RESERVED", "SOLD"]);
-export type KeyStatus = z.infer<typeof KeyStatus>;
-
-/** Тип системных требований */
-export const SystemRequirementType = z.enum(["minimum", "recommended"]);
-export type SystemRequirementType = z.infer<typeof SystemRequirementType>;

package/commands/products/index.ts

@@ -1,6 +0,0 @@
-export * from "./enums";
-export * from "./create";
-export * from "./update";
-export * from "./read";
-export * from "./query";
-export * from "./endpoints";