@zyacreatives/shared 2.5.54 → 2.5.55

package/src/schemas/product.ts

@@ -1,47 +1,127 @@
 import { z } from "@hono/zod-openapi";
+
 import {
   DISCOUNT_TYPES,
   PRICING_MODELS,
   PRODUCT_STATUS,
   WAGES_CURRENCY,
 } from "../constants";
+
 import { CreateFileInputSchema, FileEntitySchema } from "./file";
 
+/**
+ * --------------------------------
+ * SHARED
+ * --------------------------------
+ */
+
 export const ProductDiscountEntitySchema = z.object({
   discountType: z.enum(DISCOUNT_TYPES),
-  amount: z
-    .number()
-    .int("Amount must be a whole number")
-    .min(0, "Discount amount cannot be negative"),
+  amount: z.number().int().min(0),
   discountCode: z.string().optional(),
   active: z.boolean().default(true),
 });
 
+export type ProductDiscountEntity = z.infer<typeof ProductDiscountEntitySchema>;
+
 export const ProductLinkSchema = z.object({
   title: z.string().nullable(),
   url: z.string(),
 });
 
-const ProductCoreInputSchema = z.object({
-  id: z.cuid2().openapi({ description: "Client-generated ID for the product" }),
+export type ProductLink = z.infer<typeof ProductLinkSchema>;
+
+/**
+ * --------------------------------
+ * SHAPE
+ * --------------------------------
+ */
 
-  title: z.string().min(1, "Title is required").max(255),
-  description: z.string().min(1, "Description is required"),
+const ProductShape = z.object({
+  title: z.string().min(1).max(255),
+  description: z.string().min(1),
   keyFeatures: z.string(),
+
   status: z.enum(PRODUCT_STATUS).default("DRAFT"),
-  category: z.string().min(1, "Category is required"),
+
+  category: z.string().min(1),
   subcategory: z.string().optional(),
-  tags: z.array(z.string()).max(10, "Keep tags to a maximum of 10").default([]),
-  files: z.array(CreateFileInputSchema).default([]),
-  productLinks: z.array(ProductLinkSchema).default([]),
+
+  tags: z.array(z.string()).max(10).default([]),
 
   currency: z.enum(WAGES_CURRENCY),
   pricingModel: z.enum(PRICING_MODELS).default(PRICING_MODELS.FIXED),
-  price: z.number().int("Must be a whole number").min(0).optional(),
-  suggestedPrice: z.number().int("Must be in cents").min(0).optional(),
+  price: z.number().int().min(0).optional(),
+  suggestedPrice: z.number().int().min(0).optional(),
+
   discounts: z.array(ProductDiscountEntitySchema).max(3).default([]),
 });
 
+export type ProductShapeType = z.infer<typeof ProductShape>;
+
+const ProductComplianceShape = z.object({
+  supportEmail: z.email(),
+  supportPhone: z.string().optional(),
+
+  ownsRights: z.literal(true),
+  noHarmfulContent: z.literal(true),
+  providesSupport: z.boolean(),
+  agreesToTerms: z.literal(true),
+});
+
+export type ProductComplianceShapeType = z.infer<typeof ProductComplianceShape>;
+
+/**
+ * --------------------------------
+ * BASE ENTITY
+ * --------------------------------
+ */
+
+export const ProductEntitySchema = z
+  .object({
+    id: z.cuid2(),
+
+    sellerId: z.cuid2(),
+    sellerUsername: z.string(),
+    sellerName: z.string(),
+    sellerImageUrl: z.url().nullable().optional(),
+
+    ...ProductShape.shape,
+
+    subcategory: z.string().nullable().optional(),
+
+    files: z.array(FileEntitySchema).default([]),
+    productLinks: z.array(ProductLinkSchema).default([]),
+
+    ownsRights: z.boolean(),
+    noHarmfulContent: z.boolean(),
+    providesSupport: z.boolean(),
+    agreesToTerms: z.boolean(),
+
+    supportEmail: z.email().nullable().optional(),
+    supportPhone: z.string().nullable().optional(),
+
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+    deletedAt: z.iso.datetime().nullable().optional(),
+  })
+  .openapi("Product");
+
+export type ProductEntity = z.infer<typeof ProductEntitySchema>;
+
+/**
+ * --------------------------------
+ * INPUTS
+ * --------------------------------
+ */
+
+const ProductCoreInputSchema = ProductShape.extend({
+  id: z.cuid2(),
+
+  files: z.array(CreateFileInputSchema).default([]),
+  productLinks: z.array(ProductLinkSchema).default([]),
+});
+
 export const CreateProductInputSchema = ProductCoreInputSchema.superRefine(
   (data, ctx) => {
     if (
@@ -81,10 +161,11 @@ export const CreateProductInputSchema = ProductCoreInputSchema.superRefine(
     }
 
     const deliveryFiles = data.files.filter(
-      (f) => f.parentType === "PRODUCT_DELIVERY",
+      (file) => file.parentType === "PRODUCT_DELIVERY",
     );
+
     const coverImages = data.files.filter(
-      (f) => f.parentType === "PRODUCT_COVER",
+      (file) => file.parentType === "PRODUCT_COVER",
     );
 
     if (deliveryFiles.length === 0 && data.productLinks.length === 0) {
@@ -103,7 +184,8 @@ export const CreateProductInputSchema = ProductCoreInputSchema.superRefine(
         path: ["files"],
       });
     } else {
-      const thumbnails = coverImages.filter((img) => img.isThumbnail);
+      const thumbnails = coverImages.filter((image) => image.isThumbnail);
+
       if (thumbnails.length !== 1) {
         ctx.addIssue({
           code: "custom",
@@ -142,209 +224,190 @@ export const CreateProductInputSchema = ProductCoreInputSchema.superRefine(
   },
 );
 
-export const ProductServiceAndComplianceInputSchema = z.object({
-  id: z.cuid2().openapi({ description: "ID of the product" }),
-  supportEmail: z.email("A valid support email is required"),
-  supportPhone: z.string().optional(),
-  ownsRights: z.literal(
-    true,
-    '"You must confirm you own the rights to this product."',
-  ),
-  noHarmfulContent: z.literal(true, "You must confirm no harmful content."),
-  providesSupport: z.boolean(),
-  agreesToTerms: z.literal(true, "You must agree to the Terms."),
-});
+export type CreateProductInputEntity = z.infer<typeof CreateProductInputSchema>;
+
+export const ProductServiceAndComplianceInputSchema =
+  ProductComplianceShape.extend({
+    id: z.cuid2(),
+  }).openapi("ProductServiceAndComplianceInput");
+
+export type ProductServiceAndComplianceInputEntity = z.infer<
+  typeof ProductServiceAndComplianceInputSchema
+>;
 
 export const UpdateProductInputSchema = ProductCoreInputSchema.extend(
-  ProductServiceAndComplianceInputSchema.omit({ id: true }).shape,
+  ProductComplianceShape.shape,
 )
   .partial()
   .extend({
-    id: z.cuid2().openapi({ description: "ID of the product being updated" }),
+    id: z.cuid2(),
   });
 
-export const ProductEntitySchema = z
-  .object({
-    id: z.cuid2(),
-    sellerId: z.cuid2().openapi({ description: "ID of the creator/seller" }),
-    sellerUsername: z.string(),
-    sellerName: z.string(),
-    sellerImageUrl: z.url().optional().nullable(),
+export type UpdateProductInputEntity = z.infer<typeof UpdateProductInputSchema>;
 
-    title: z.string(),
-    description: z.string(),
-    keyFeatures: z.string(),
-    status: z.enum(PRODUCT_STATUS).default("DRAFT"),
-    category: z.string(),
-    subcategory: z.string().optional().nullable(),
-    tags: z.array(z.string()),
+export const SearchProductInputSchema = z.object({
+  queryString: z.string().max(200).optional(),
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(30),
+  tags: z.array(z.string()).optional(),
+  filters: z.array(z.string()).optional(),
+  category: z.string().optional(),
+  subcategory: z.string().optional(),
+});
 
-    files: z.array(FileEntitySchema).default([]),
-    productLinks: z.array(ProductLinkSchema).default([]),
+export type SearchProductInput = z.infer<typeof SearchProductInputSchema>;
 
-    pricingModel: z.enum(PRICING_MODELS),
-    currency: z.enum(WAGES_CURRENCY),
-    price: z.number().int().optional().nullable(),
-    suggestedPrice: z.number().int().optional().nullable(),
-    discounts: z.array(ProductDiscountEntitySchema).default([]),
+export const ProductDiscountCheckInputSchema = z.object({
+  discountCode: z.string(),
+  productId: z.cuid2(),
+});
 
-    ownsRights: z.boolean(),
-    noHarmfulContent: z.boolean(),
-    providesSupport: z.boolean(),
-    agreesToTerms: z.boolean(),
-    supportEmail: z.email().optional().nullable(),
-    supportPhone: z.string().optional().nullable(),
+export type ProductDiscountCheckInput = z.infer<
+  typeof ProductDiscountCheckInputSchema
+>;
 
-    createdAt: z.coerce.date(),
-    updatedAt: z.coerce.date(),
-    deletedAt: z.coerce.date().optional().nullable(),
-  })
-  .openapi({ title: "ProductEntity" });
+export const RevenueChartInputSchema = z.object({
+  startDate: z.string().optional(),
+  endDate: z.string().optional(),
+});
+
+export type RevenueChartInput = z.infer<typeof RevenueChartInputSchema>;
+
+/**
+ * --------------------------------
+ * SEARCH / MARKETPLACE
+ * --------------------------------
+ */
 
 export const ProductSearchDocumentSchema = z.object({
   id: z.cuid2(),
+
   sellerId: z.cuid2(),
   sellerUsername: z.string(),
   sellerName: z.string(),
-  status: z.enum(PRODUCT_STATUS),
   sellerImageUrl: z.url().nullable(),
+
+  status: z.enum(PRODUCT_STATUS),
+
   title: z.string(),
   category: z.string(),
   subcategory: z.string().nullable(),
   tags: z.array(z.string()),
+
   thumbnailImgUrl: z.url().nullable(),
+
   currency: z.enum(WAGES_CURRENCY),
   price: z.number().nullable(),
   suggestedPrice: z.number().nullable(),
-  createdAt: z.coerce.date(),
-  updatedAt: z.coerce.date(),
-  deletedAt: z.coerce.date().optional().nullable(),
-});
 
-export const SearchProductInputSchema = z.object({
-  queryString: z
-    .string()
-    .max(200, { message: "Search string cannot exceed 200 characters" })
-    .optional()
-    .openapi({ example: "typescript utility types" }),
-  cursor: z.string().optional().openapi({ example: "ckj1a2b3c0000cur" }),
-  limit: z.coerce.number().int().min(1).max(100).optional().default(30),
-  tags: z.array(z.string()).optional(),
-  filters: z.array(z.string()).optional(),
-  category: z.string().optional(),
-  subcategory: z.string().optional(),
+  createdAt: z.iso.datetime(),
+  updatedAt: z.iso.datetime(),
+  deletedAt: z.iso.datetime().nullable().optional(),
 });
 
-export const SearchProductOutputSchema = z.object({
-  products: z.array(ProductSearchDocumentSchema),
-  nextCursor: z.string().optional().nullable(),
+export type ProductSearchDocument = z.infer<typeof ProductSearchDocumentSchema>;
+
+export const MarketplaceProductEntitySchema = ProductEntitySchema.omit({
+  discounts: true,
 });
 
+export type MarketplaceProductEntity = z.infer<
+  typeof MarketplaceProductEntitySchema
+>;
+
 export const MarketplaceCategorySchema = z.object({
   name: z.string(),
   imgUrl: z.url(),
   subcategories: z.array(z.string()),
 });
 
+export type MarketplaceCategoryOutput = z.infer<
+  typeof MarketplaceCategorySchema
+>;
+
+/**
+ * --------------------------------
+ * OUTPUTS
+ * --------------------------------
+ */
+
+export const SearchProductOutputSchema = z.object({
+  products: z.array(ProductSearchDocumentSchema),
+  nextCursor: z.string().optional(),
+});
+
+export type SearchProductOutput = z.infer<typeof SearchProductOutputSchema>;
+
 export const GetMarketplaceInfoOutputSchema = z.object({
   categories: z.array(MarketplaceCategorySchema),
   whatsHot: z.array(ProductSearchDocumentSchema),
   communityFavourites: z.array(ProductSearchDocumentSchema),
 });
 
-export const MarketplaceProductEntitySchema = ProductEntitySchema.omit({
-  discounts: true,
-});
-
-export const ProductDiscountCheckInputSchema = z.object({
-  discountCode: z.string(),
-  productId: z.cuid2(),
-});
+export type GetMarketplaceInfoOutput = z.infer<
+  typeof GetMarketplaceInfoOutputSchema
+>;
 
 export const ProductDiscountCheckOutputSchema = z.object({
   exists: z.boolean(),
   discount: ProductDiscountEntitySchema.nullable(),
 });
 
+export type ProductDiscountCheckOutput = z.infer<
+  typeof ProductDiscountCheckOutputSchema
+>;
+
 export const ProductStatsOutputSchema = z.object({
   salesToday: z.number().int(),
   revenueToday: z.number().int(),
   totalProductRevenue: z.number().int(),
 });
 
+export type ProductStatsOutput = z.infer<typeof ProductStatsOutputSchema>;
+
 export const ProductTransactionItemSchema = z.object({
   id: z.string(),
   customerEmail: z.string().nullable(),
   orderId: z.string().nullable(),
   price: z.number().int(),
   status: z.string(),
-  date: z.coerce.date(),
+  date: z.iso.datetime(),
 });
 
+export type ProductTransactionItem = z.infer<
+  typeof ProductTransactionItemSchema
+>;
+
 export const ProductTransactionsOutputSchema = z.object({
   transactions: z.array(ProductTransactionItemSchema),
 });
 
+export type ProductTransactionsOutput = z.infer<
+  typeof ProductTransactionsOutputSchema
+>;
+
 export const RevenueChartPointSchema = z.object({
-  date: z.string().openapi({ example: "2023-11-25" }),
+  date: z.string(),
   revenue: z.number().int(),
 });
 
+export type RevenueChartPoint = z.infer<typeof RevenueChartPointSchema>;
+
 export const ProductRevenueChartOutputSchema = z.object({
   chartData: z.array(RevenueChartPointSchema),
 });
 
-export const RevenueChartInputSchema = z.object({
-  startDate: z.string().optional().openapi({ description: "YYYY-MM-DD" }),
-  endDate: z.string().optional().openapi({ description: "YYYY-MM-DD" }),
-});
+export type ProductRevenueChartOutput = z.infer<
+  typeof ProductRevenueChartOutputSchema
+>;
 
 export const SellerDashboardStatsOutputSchema = z.object({
   totalSales: z.number().int(),
-  totalViews: z.number().int(), 
+  totalViews: z.number().int(),
   totalProducts: z.number().int(),
   totalDrafts: z.number().int(),
 });
 
-export type SellerDashboardStatsOutput = z.infer<typeof SellerDashboardStatsOutputSchema>;
-
-export type ProductLink = z.infer<typeof ProductLinkSchema>;
-export type SearchProductInput = z.infer<typeof SearchProductInputSchema>;
-export type SearchProductOutput = z.infer<typeof SearchProductOutputSchema>;
-export type MarketplaceCategoryOutput = z.infer<
-  typeof MarketplaceCategorySchema
->;
-export type GetMarketplaceInfoOutput = z.infer<
-  typeof GetMarketplaceInfoOutputSchema
->;
-
-export type ProductDiscountEntity = z.infer<typeof ProductDiscountEntitySchema>;
-export type CreateProductInputEntity = z.infer<typeof CreateProductInputSchema>;
-export type ProductServiceAndComplianceInputEntity = z.infer<
-  typeof ProductServiceAndComplianceInputSchema
->;
-export type UpdateProductInputEntity = z.infer<typeof UpdateProductInputSchema>;
-export type ProductEntity = z.infer<typeof ProductEntitySchema>;
-export type ProductSearchDocument = z.infer<typeof ProductSearchDocumentSchema>;
-export type MarketplaceProductEntity = z.infer<
-  typeof MarketplaceProductEntitySchema
->;
-
-export type ProductDiscountCheckInput = z.infer<
-  typeof ProductDiscountCheckInputSchema
->;
-export type ProductDiscountCheckOutput = z.infer<
-  typeof ProductDiscountCheckOutputSchema
+export type SellerDashboardStatsOutput = z.infer<
+  typeof SellerDashboardStatsOutputSchema
 >;
-export type ProductStatsOutput = z.infer<typeof ProductStatsOutputSchema>;
-export type ProductTransactionItem = z.infer<
-  typeof ProductTransactionItemSchema
->;
-export type ProductTransactionsOutput = z.infer<
-  typeof ProductTransactionsOutputSchema
->;
-export type RevenueChartPoint = z.infer<typeof RevenueChartPointSchema>;
-export type ProductRevenueChartOutput = z.infer<
-  typeof ProductRevenueChartOutputSchema
->;
-export type RevenueChartInput = z.infer<typeof RevenueChartInputSchema>;

package/src/schemas/project.ts

@@ -8,7 +8,6 @@ import {
 } from "../constants";
 import { CommentEntitySchema } from "./comment";
 import { BookmarkEntitySchema } from "./bookmark";
-import { ViewEntitySchema } from "./view";
 import { MinimalUserSchema } from "./user";
 import { ActivitySchema } from "./activity";
 import { FileEntitySchema } from "./file";
@@ -76,6 +75,13 @@ export const ProjectSocialGraphEntitySchema = z
   })
   .openapi("ProjectSocialGraphEntity");
 
+export type ProjectSocialGraphEntity = z.infer<
+  typeof ProjectSocialGraphEntitySchema
+>;
+export type PostSocialGraphEntity = z.infer<
+  typeof ProjectSocialGraphEntitySchema
+>;
+
 export const CreateProjectInputSchema = z
   .object({
     id: z.cuid2().optional(),
@@ -302,14 +308,6 @@ export type GetProjectWithLikesOutput = z.infer<
   typeof GetProjectWithLikesOutputSchema
 >;
 
-export const ProjectWithProjectViewsEntitySchema = MinimalProjectSchema.extend({
-  views: z.array(ViewEntitySchema),
-}).openapi("ProjectWithProjectViewsEntity");
-
-export type ProjectWithProjectViewsEntity = z.infer<
-  typeof ProjectWithProjectViewsEntitySchema
->;
-
 export const ProjectWithProjectBookmarksEntitySchema =
   MinimalProjectSchema.extend({
     bookmarks: z.array(BookmarkEntitySchema),
@@ -343,6 +341,5 @@ export type CommentOnProjectOutput = z.infer<
 export const ProjectIdSchema = z.object({ projectId: z.cuid2() });
 export type ProjectIdInput = z.infer<typeof ProjectIdSchema>;
 
-export type ProjectViewEntity = z.infer<typeof ViewEntitySchema>;
 export type ProjectLikeEntity = z.infer<typeof LikeEntitySchema>;
 export type ProjectCommentEntity = z.infer<typeof CommentEntitySchema>;

package/src/schemas/user-strike.ts

@@ -18,4 +18,10 @@ export const UpsertUserStrikeInputSchema = z.object({
   parentType: z.enum(ACTIVITY_PARENT_TYPES).optional(),
 });
 
-export const UpsertUserStrikeOutputSchema = UserStrikeEntitySchema;
+export const UpsertUserStrikeOutputSchema = UserStrikeEntitySchema;
+
+export type UserStrikeEntity = z.infer<typeof UserStrikeEntitySchema>;
+export type UpsertUserStrikeInput = z.infer<typeof UpsertUserStrikeInputSchema>;
+export type UpsertUserStrikeOutput = z.infer<
+  typeof UpsertUserStrikeOutputSchema
+>;

package/src/schemas/user.ts

@@ -22,11 +22,7 @@ import { LikeEntitySchema } from "./like";
 import { BrandEntitySchema } from "./brand";
 import { CreativeEntitySchema } from "./creative";
 import { InvestorEntitySchema } from "./investor";
-import {
-  FeedPostEntitySchema,
-  PostEntitySchema,
-  PostWithFilesEntitySchema,
-} from "./post";
+import { PostEntitySchema, PostWithFilesEntitySchema } from "./post";
 import { JobSearchDocumentSchema } from "./job";
 import { ProductEntitySchema } from "./product";
 
@@ -226,7 +222,7 @@ export const UserWithJobBookmarksInputSchema = z.object({
 export type UserAuthStatusEntity = z.infer<typeof UserAuthStatusEntitySchema>;
 export type UserWithJobBookmarksInput = z.infer<
   typeof UserWithJobBookmarksEntitySchema
->; 
+>;
 
 /**
  * --------------------------------

package/src/schemas/username.ts

@@ -1,11 +1,13 @@
 import { z } from "@hono/zod-openapi";
 
-export const UsernameSchema = z.object({
+export const UsernameSchema = z.object({
   username: z
     .string()
     .min(3, { message: "Username must be at least 3 characters" })
     .max(32, { message: "Username must be at most 32 characters" })
     .regex(/^[a-zA-Z0-9_]+$/, {
       message: "Username may only contain letters, numbers, and underscores",
-    }),
-});
+    }),
+});
+
+export type UsernameInput = z.infer<typeof UsernameSchema>;

package/src/schemas/view.ts

@@ -1,50 +0,0 @@
-import { z } from "@hono/zod-openapi";
-import { ACTIVITY_PARENT_TYPES } from "../constants";
-
-export const ViewEntitySchema = z
-  .object({
-    id: z.cuid2().openapi({
-      description: "Unique identifier of the view record.",
-      title: "View ID",
-    }),
-    userId: z.cuid2().nullable().openapi({
-      description:
-        "Identifier of the user who viewed the entity, if authenticated.",
-      title: "User ID",
-    }),
-    ipAddress: z.string().nullable().openapi({
-      description: "IP address from which the entity was viewed.",
-      title: "IP Address",
-    }),
-    userAgent: z.string().nullable().openapi({
-      description:
-        "User agent string identifying the client device or browser.",
-      title: "User Agent",
-    }),
-    parentId: z.cuid2().openapi({
-      description: "Identifier of the parent entity being viewed.",
-      title: "Parent ID",
-    }),
-    parentType: z.enum(ACTIVITY_PARENT_TYPES).openapi({
-      description: "Type of the parent entity (e.g., project, post, etc.).",
-      title: "Parent Type",
-    }),
-    sessionId: z.string().nullable().openapi({
-      description:
-        "Session identifier associated with the view event, if available.",
-      title: "Session ID",
-    }),
-    viewedAt: z.coerce.date().optional().openapi({
-      description: "Exact timestamp when the view occurred.",
-      title: "Viewed At",
-    }),
-    viewDate: z.coerce.date().optional().openapi({
-      description:
-        "Calendar date corresponding to the view event, used for aggregation.",
-      title: "View Date",
-    }),
-  })
-  .openapi({
-    description: "Represents a record of a single view event for an entity.",
-    title: "View",
-  });

package/src/types/activity.ts

@@ -1,4 +0,0 @@
-import z from "zod";
-import { ActivitySchema } from "../schemas/activity";
-
-export type ActivityEntity = z.infer<typeof ActivitySchema>;

package/src/types/auth.ts

@@ -1,5 +0,0 @@
-import z from "zod";
-import { LoginSchema, RegisterSchema } from "../schemas/auth";
-
-export type RegisterInput = z.infer<typeof RegisterSchema>;
-export type LoginInput = z.infer<typeof LoginSchema>;

package/src/types/bookmark.ts

@@ -1,4 +0,0 @@
-import { z } from "@hono/zod-openapi";
-import { BookmarkEntitySchema } from "../schemas/bookmark";
-
-export type BookmarkEntity = z.infer<typeof BookmarkEntitySchema>;

package/src/types/chat.ts

@@ -1,31 +0,0 @@
-import z from "zod";
-import {
-  AcceptMessageRequestInputSchema,
-  BaseChatEntitySchema,
-  ChatEntitySchema,
-  ChatIdSchema,
-  CreateChatInputSchema,
-  CreateChatOutputSchema,
-  GetChatsForUserOutputSchema,
-  GetChatsOutputSchema,
-} from "../schemas/chat";
-
-export type BaseChatEntity = z.infer<typeof BaseChatEntitySchema>;
-
-export type ChatEntity = z.infer<typeof ChatEntitySchema>;
-
-export type CreateChatInput = z.infer<typeof CreateChatInputSchema>;
-
-export type CreateChatOutput = z.infer<typeof CreateChatOutputSchema>;
-
-export type ChatIdInput = z.infer<typeof ChatIdSchema>;
-
-export type GetChatsOutput = z.infer<typeof GetChatsOutputSchema>;
-
-export type GetChatsForUserOutput = z.infer<typeof GetChatsForUserOutputSchema>;
-
-export type AcceptMessageRequestInput = z.infer<
-  typeof AcceptMessageRequestInputSchema
->;
-
-export type DeclineMessageRequestInput = AcceptMessageRequestInput;