@zyacreatives/shared 2.1.30 → 2.1.31

package/dist/schemas/index.d.ts

@@ -15,3 +15,4 @@ export * from "./chat";
 export * from "./job";
 export * from "./job-application";
 export * from "./user-strike";
+export * from "./notification";

package/dist/schemas/index.js

@@ -31,3 +31,4 @@ __exportStar(require("./chat"), exports);
 __exportStar(require("./job"), exports);
 __exportStar(require("./job-application"), exports);
 __exportStar(require("./user-strike"), exports);
+__exportStar(require("./notification"), exports);

package/dist/schemas/job.d.ts

@@ -1,4 +1,13 @@
 import { z } from "zod";
+export declare const MinimalJobEntitySchema: z.ZodObject<{
+    id: z.ZodCUID2;
+    title: z.ZodString;
+    brandId: z.ZodCUID2;
+    jobType: z.ZodEnum<{
+        GIG: "GIG";
+        ROLE: "ROLE";
+    }>;
+}, z.core.$strip>;
 export declare const BaseJobEntitySchema: z.ZodObject<{
     id: z.ZodCUID2;
     title: z.ZodString;

package/dist/schemas/job.js

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetJobsOutputSchema = exports.GetJobsInputSchema = exports.GetCreatedJobsOutputSchema = exports.NormalizedJobSchema = exports.UpdateJobInputSchema = exports.UpdateGigJobInputSchema = exports.UpdateRoleJobInputSchema = exports.CreateGigJobInputSchema = exports.CreateRoleJobInputSchema = exports.CreateJobInputSchema = exports.JobWithRoleDetailsEntitySchema = exports.RoleJobEntitySchema = exports.JobWithGigDetailsEntitySchema = exports.GigJobEntitySchema = exports.JobEntitySchema = exports.JobIdSchema = exports.BaseJobEntitySchema = void 0;
+exports.GetJobsOutputSchema = exports.GetJobsInputSchema = exports.GetCreatedJobsOutputSchema = exports.NormalizedJobSchema = exports.UpdateJobInputSchema = exports.UpdateGigJobInputSchema = exports.UpdateRoleJobInputSchema = exports.CreateGigJobInputSchema = exports.CreateRoleJobInputSchema = exports.CreateJobInputSchema = exports.JobWithRoleDetailsEntitySchema = exports.RoleJobEntitySchema = exports.JobWithGigDetailsEntitySchema = exports.GigJobEntitySchema = exports.JobEntitySchema = exports.JobIdSchema = exports.BaseJobEntitySchema = exports.MinimalJobEntitySchema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("../constants");
 const JobSectionEnum = zod_1.z.enum(Object.values(constants_1.JOB_SECTIONS));
+exports.MinimalJobEntitySchema = zod_1.z.object({
+    id: zod_1.z.cuid2(),
+    title: zod_1.z.string(),
+    brandId: zod_1.z.cuid2(),
+    jobType: zod_1.z.enum(Object.values(constants_1.JOB_TYPE)),
+});
 exports.BaseJobEntitySchema = zod_1.z.object({
     id: zod_1.z.cuid2(),
     title: zod_1.z.string(),
@@ -157,7 +163,9 @@ exports.CreateRoleJobInputSchema = zod_1.z
         .enum(Object.values(constants_1.WAGE_TYPES))
         .optional(),
 })
-    .refine(({ wagesMin, wagesMax }) => wagesMin === undefined || wagesMax === undefined || wagesMax > wagesMin, {
+    .refine(({ wagesMin, wagesMax }) => wagesMin === undefined ||
+    wagesMax === undefined ||
+    wagesMax > wagesMin, {
     message: "wagesMax must be greater than wagesMin",
     path: ["wagesMax"],
 });
@@ -178,7 +186,9 @@ exports.CreateGigJobInputSchema = zod_1.z
         .enum(Object.values(constants_1.WAGE_TYPES))
         .optional(),
 })
-    .refine(({ wagesMin, wagesMax }) => wagesMin === undefined || wagesMax === undefined || wagesMax > wagesMin, {
+    .refine(({ wagesMin, wagesMax }) => wagesMin === undefined ||
+    wagesMax === undefined ||
+    wagesMax > wagesMin, {
     message: "wagesMax must be greater than wagesMin",
     path: ["wagesMax"],
 });

package/dist/schemas/notification.d.ts

@@ -0,0 +1,106 @@
+import { z } from "@hono/zod-openapi";
+export declare const NotificationEntitySchema: z.ZodObject<{
+    id: z.ZodCUID2;
+    recipientId: z.ZodCUID2;
+    actorId: z.ZodCUID2;
+    type: z.ZodEnum<{
+        readonly FOLLOW: "Follow";
+        readonly LIKE: "Like";
+        readonly COMMENT: "Comment";
+        readonly REPLY: "Reply";
+        readonly MESSAGE: "Message";
+        readonly JOB_APPLICATION: "Job Application";
+        readonly APPLICATION_STATUS_CHANGE: "Application Status Change";
+        readonly SYSTEM_STRIKE: "System Strike";
+        readonly PROJECT_FEATURED: "Project Featured";
+    }>;
+    parentId: z.ZodNullable<z.ZodOptional<z.ZodCUID2>>;
+    parentType: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+        [x: string]: string;
+    }>>>;
+    isRead: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodCoercedDate<unknown>;
+    deletedAt: z.ZodNullable<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
+}, z.core.$strip>;
+export declare const MinimalNotificationEntitySchema: z.ZodObject<{
+    id: z.ZodCUID2;
+    recipientId: z.ZodCUID2;
+    actorId: z.ZodCUID2;
+}, z.core.$strip>;
+export declare const NotificationDetailsEntitySchema: z.ZodObject<{
+    id: z.ZodCUID2;
+    recipientId: z.ZodCUID2;
+    actorId: z.ZodCUID2;
+    type: z.ZodEnum<{
+        readonly FOLLOW: "Follow";
+        readonly LIKE: "Like";
+        readonly COMMENT: "Comment";
+        readonly REPLY: "Reply";
+        readonly MESSAGE: "Message";
+        readonly JOB_APPLICATION: "Job Application";
+        readonly APPLICATION_STATUS_CHANGE: "Application Status Change";
+        readonly SYSTEM_STRIKE: "System Strike";
+        readonly PROJECT_FEATURED: "Project Featured";
+    }>;
+    parentId: z.ZodNullable<z.ZodOptional<z.ZodCUID2>>;
+    parentType: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+        [x: string]: string;
+    }>>>;
+    isRead: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodCoercedDate<unknown>;
+    deletedAt: z.ZodNullable<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
+    itemTitle: z.ZodOptional<z.ZodString>;
+    itemContent: z.ZodOptional<z.ZodString>;
+    itemImgUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ListNotificationsInputSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodEnum<{
+        readonly FOLLOW: "Follow";
+        readonly LIKE: "Like";
+        readonly COMMENT: "Comment";
+        readonly REPLY: "Reply";
+        readonly MESSAGE: "Message";
+        readonly JOB_APPLICATION: "Job Application";
+        readonly APPLICATION_STATUS_CHANGE: "Application Status Change";
+        readonly SYSTEM_STRIKE: "System Strike";
+        readonly PROJECT_FEATURED: "Project Featured";
+    }>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    unreadOnly: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<boolean, unknown>, z.ZodBoolean>>>;
+}, z.core.$strip>;
+export declare const ListNotificationsOutputSchema: z.ZodObject<{
+    notifications: z.ZodArray<z.ZodObject<{
+        id: z.ZodCUID2;
+        recipientId: z.ZodCUID2;
+        actorId: z.ZodCUID2;
+        type: z.ZodEnum<{
+            readonly FOLLOW: "Follow";
+            readonly LIKE: "Like";
+            readonly COMMENT: "Comment";
+            readonly REPLY: "Reply";
+            readonly MESSAGE: "Message";
+            readonly JOB_APPLICATION: "Job Application";
+            readonly APPLICATION_STATUS_CHANGE: "Application Status Change";
+            readonly SYSTEM_STRIKE: "System Strike";
+            readonly PROJECT_FEATURED: "Project Featured";
+        }>;
+        parentId: z.ZodNullable<z.ZodOptional<z.ZodCUID2>>;
+        parentType: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+            [x: string]: string;
+        }>>>;
+        isRead: z.ZodDefault<z.ZodBoolean>;
+        createdAt: z.ZodCoercedDate<unknown>;
+        deletedAt: z.ZodNullable<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
+        itemTitle: z.ZodOptional<z.ZodString>;
+        itemContent: z.ZodOptional<z.ZodString>;
+        itemImgUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    unreadCount: z.ZodNumber;
+}, z.core.$strip>;
+export declare const MarkReadInputSchema: z.ZodObject<{
+    notificationIds: z.ZodArray<z.ZodCUID2>;
+}, z.core.$strip>;
+export declare const NotificationCountOutputSchema: z.ZodObject<{
+    unreadCount: z.ZodNumber;
+}, z.core.$strip>;

package/dist/schemas/notification.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationCountOutputSchema = exports.MarkReadInputSchema = exports.ListNotificationsOutputSchema = exports.ListNotificationsInputSchema = exports.NotificationDetailsEntitySchema = exports.MinimalNotificationEntitySchema = exports.NotificationEntitySchema = void 0;
+const zod_openapi_1 = require("@hono/zod-openapi");
+const constants_1 = require("../constants");
+exports.NotificationEntitySchema = zod_openapi_1.z
+    .object({
+    id: zod_openapi_1.z.cuid2().openapi({ example: "not_cksd0v6q0000s9a5y8z7p3x9" }),
+    recipientId: zod_openapi_1.z.cuid2().openapi({ example: "user_recipient_123" }),
+    actorId: zod_openapi_1.z.cuid2().openapi({ example: "user_actor_456" }),
+    type: zod_openapi_1.z.enum(constants_1.NOTIFICATION_TYPES).openapi({ example: "LIKE" }),
+    parentId: zod_openapi_1.z.cuid2().optional().nullable(),
+    parentType: zod_openapi_1.z
+        .enum(Object.values(constants_1.ACTIVITY_PARENT_TYPES))
+        .optional()
+        .nullable(),
+    isRead: zod_openapi_1.z.boolean().default(false).openapi({ example: false }),
+    createdAt: zod_openapi_1.z.coerce
+        .date()
+        .openapi({ example: "2025-10-13T09:00:00.000Z" }),
+    deletedAt: zod_openapi_1.z.coerce.date().optional().nullable(),
+})
+    .openapi("NotificationEntity");
+exports.MinimalNotificationEntitySchema = zod_openapi_1.z.object({
+    id: zod_openapi_1.z.cuid2(),
+    recipientId: zod_openapi_1.z.cuid2(),
+    actorId: zod_openapi_1.z.cuid2(),
+});
+exports.NotificationDetailsEntitySchema = exports.NotificationEntitySchema.extend({
+    itemTitle: zod_openapi_1.z.string().optional(),
+    itemContent: zod_openapi_1.z.string().optional(),
+    itemImgUrl: zod_openapi_1.z.string().optional(),
+});
+exports.ListNotificationsInputSchema = zod_openapi_1.z
+    .object({
+    type: zod_openapi_1.z
+        .enum(constants_1.NOTIFICATION_TYPES)
+        .openapi({ example: "LIKE" })
+        .optional(),
+    cursor: zod_openapi_1.z.string().optional(),
+    unreadOnly: zod_openapi_1.z
+        .preprocess((val) => val === "true" || val === true, zod_openapi_1.z.boolean())
+        .optional()
+        .default(false),
+})
+    .openapi("ListNotificationsInput");
+exports.ListNotificationsOutputSchema = zod_openapi_1.z.object({
+    notifications: zod_openapi_1.z.array(exports.NotificationDetailsEntitySchema),
+    nextCursor: zod_openapi_1.z.string().optional().nullable(),
+    unreadCount: zod_openapi_1.z.number().int().openapi({ example: 5 }),
+});
+exports.MarkReadInputSchema = zod_openapi_1.z.object({
+    notificationIds: zod_openapi_1.z.array(zod_openapi_1.z.cuid2()).min(1),
+});
+exports.NotificationCountOutputSchema = zod_openapi_1.z.object({
+    unreadCount: zod_openapi_1.z.number().int().openapi({ example: 12 }),
+});

package/dist/types/index.d.ts

@@ -16,3 +16,4 @@ export * from "./message";
 export * from "./chat";
 export * from "./job";
 export * from "./user-strike";
+export * from "./notification";

package/dist/types/index.js

@@ -32,3 +32,4 @@ __exportStar(require("./message"), exports);
 __exportStar(require("./chat"), exports);
 __exportStar(require("./job"), exports);
 __exportStar(require("./user-strike"), exports);
+__exportStar(require("./notification"), exports);

package/dist/types/notification.d.ts

@@ -0,0 +1,9 @@
+import { z } from "@hono/zod-openapi";
+import type { NotificationEntitySchema, MinimalNotificationEntitySchema, NotificationDetailsEntitySchema, ListNotificationsInputSchema, ListNotificationsOutputSchema, MarkReadInputSchema, NotificationCountOutputSchema } from "../schemas/notification";
+export type NotificationEntity = z.infer<typeof NotificationEntitySchema>;
+export type MinimalNotificationEntity = z.infer<typeof MinimalNotificationEntitySchema>;
+export type NotificationDetailsEntity = z.infer<typeof NotificationDetailsEntitySchema>;
+export type ListNotificationsInput = z.infer<typeof ListNotificationsInputSchema>;
+export type ListNotificationsOutput = z.infer<typeof ListNotificationsOutputSchema>;
+export type MarkReadInput = z.infer<typeof MarkReadInputSchema>;
+export type NotificationCountOutput = z.infer<typeof NotificationCountOutputSchema>;

package/dist/types/notification.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zyacreatives/shared",
-  "version": "2.1.30",
+  "version": "2.1.31",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/schemas/index.ts

@@ -15,3 +15,4 @@ export * from "./chat";
 export * from "./job";
 export * from "./job-application";
 export * from "./user-strike";
+export * from "./notification";

package/src/schemas/job.ts

@@ -1,322 +1,364 @@
 import { z } from "zod";
 import {
-  EMPLOYMENT_TYPE,
-  EmploymentType,
-  EXPERIENCE_LEVELS,
-  ExperienceLevel,
-  GIG_TYPE,
-  GigType,
-  JOB_LOCATIONS,
-  JOB_SECTIONS,
-  JOB_STATUS,
-  JOB_TYPE,
-  JobLocation,
-  JobStatus,
-  JobType,
-  WAGE_TYPES,
-  WAGES_CURRENCY,
-  WagesCurrency,
-  WageTypes,
-  WORK_MODE,
-  WorkMode,
+    EMPLOYMENT_TYPE,
+    EmploymentType,
+    EXPERIENCE_LEVELS,
+    ExperienceLevel,
+    GIG_TYPE,
+    GigType,
+    JOB_LOCATIONS,
+    JOB_SECTIONS,
+    JOB_STATUS,
+    JOB_TYPE,
+    JobLocation,
+    JobStatus,
+    JobType,
+    WAGE_TYPES,
+    WAGES_CURRENCY,
+    WagesCurrency,
+    WageTypes,
+    WORK_MODE,
+    WorkMode,
 } from "../constants";
 
 const JobSectionEnum = z.enum(
-  Object.values(JOB_SECTIONS) as [string, ...string[]]
+    Object.values(JOB_SECTIONS) as [string, ...string[]],
 );
 
+export const MinimalJobEntitySchema = z.object({
+    id: z.cuid2(),
+    title: z.string(),
+    brandId: z.cuid2(),
+    jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
+});
+
 export const BaseJobEntitySchema = z.object({
-  id: z.cuid2(),
-  title: z.string(),
-  brandId: z.cuid2(),
-  jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
-  employmentType: z
-    .enum(
-      Object.values(EMPLOYMENT_TYPE) as [EmploymentType, ...EmploymentType[]]
-    )
-    .optional(),
-  workMode: z.enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]]),
-  status: z.enum(Object.values(JOB_STATUS) as [JobStatus, ...JobStatus[]]),
-  gigType: z
-    .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
-    .optional(),
-  location: z.enum(
-    Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]]
-  ),
-  jobSections: z
-    .array(JobSectionEnum)
-    .default([
-      JOB_SECTIONS.PERSONAL_INFORMATION,
-      JOB_SECTIONS.PROFESSIONAL_INFORMATION,
-      JOB_SECTIONS.RESUME,
-      JOB_SECTIONS.COVER_LETTER,
-    ]),
-  createdAt: z.date(),
-  updatedAt: z.date(),
+    id: z.cuid2(),
+    title: z.string(),
+    brandId: z.cuid2(),
+    jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
+    employmentType: z
+        .enum(
+            Object.values(EMPLOYMENT_TYPE) as [
+                EmploymentType,
+                ...EmploymentType[],
+            ],
+        )
+        .optional(),
+    workMode: z.enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]]),
+    status: z.enum(Object.values(JOB_STATUS) as [JobStatus, ...JobStatus[]]),
+    gigType: z
+        .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
+        .optional(),
+    location: z.enum(
+        Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]],
+    ),
+    jobSections: z
+        .array(JobSectionEnum)
+        .default([
+            JOB_SECTIONS.PERSONAL_INFORMATION,
+            JOB_SECTIONS.PROFESSIONAL_INFORMATION,
+            JOB_SECTIONS.RESUME,
+            JOB_SECTIONS.COVER_LETTER,
+        ]),
+    createdAt: z.date(),
+    updatedAt: z.date(),
 });
 
 export const JobIdSchema = z.object({
-  jobId: z.cuid2(),
+    jobId: z.cuid2(),
 });
 
 export const JobEntitySchema = z.object({
-  id: z.cuid2(),
-  title: z.string(),
-  brandId: z.cuid2(),
-  brandName: z.cuid2(),
-  brandImgUrl: z.cuid2().optional(),
-  jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
-  status: z.enum(Object.values(JOB_STATUS) as [JobStatus, ...JobStatus[]]),
-  employmentType: z
-    .enum(
-      Object.values(EMPLOYMENT_TYPE) as [EmploymentType, ...EmploymentType[]]
-    )
-    .optional(),
-  workMode: z.enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]]),
-  gigType: z
-    .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
-    .optional(),
-  location: z.enum(
-    Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]]
-  ),
-  jobSections: z
-    .array(JobSectionEnum)
-    .default([
-      JOB_SECTIONS.PERSONAL_INFORMATION,
-      JOB_SECTIONS.PROFESSIONAL_INFORMATION,
-      JOB_SECTIONS.RESUME,
-      JOB_SECTIONS.COVER_LETTER,
-    ]),
-  isBookmarked: z.boolean(),
-  createdAt: z.date(),
-  updatedAt: z.date(),
+    id: z.cuid2(),
+    title: z.string(),
+    brandId: z.cuid2(),
+    brandName: z.cuid2(),
+    brandImgUrl: z.cuid2().optional(),
+    jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
+    status: z.enum(Object.values(JOB_STATUS) as [JobStatus, ...JobStatus[]]),
+    employmentType: z
+        .enum(
+            Object.values(EMPLOYMENT_TYPE) as [
+                EmploymentType,
+                ...EmploymentType[],
+            ],
+        )
+        .optional(),
+    workMode: z.enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]]),
+    gigType: z
+        .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
+        .optional(),
+    location: z.enum(
+        Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]],
+    ),
+    jobSections: z
+        .array(JobSectionEnum)
+        .default([
+            JOB_SECTIONS.PERSONAL_INFORMATION,
+            JOB_SECTIONS.PROFESSIONAL_INFORMATION,
+            JOB_SECTIONS.RESUME,
+            JOB_SECTIONS.COVER_LETTER,
+        ]),
+    isBookmarked: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
 });
 
 export const GigJobEntitySchema = z.object({
-  id: z.cuid2(),
-  jobType: z.literal(JOB_TYPE.GIG),
-  overview: z.string(),
-  deliverables: z.string(),
-  employeeRequirements: z.string().optional(),
-  aboutCompany: z.string().optional(),
-  requiredSkills: z.array(z.string()),
-  wagesMin: z.number().optional(),
-  wagesMax: z.number().optional(),
-  wagesCurrency: z
-    .enum(Object.values(WAGES_CURRENCY) as [WagesCurrency, ...WagesCurrency[]])
-    .optional(),
-  wagesType: z
-    .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
-    .optional(),
+    id: z.cuid2(),
+    jobType: z.literal(JOB_TYPE.GIG),
+    overview: z.string(),
+    deliverables: z.string(),
+    employeeRequirements: z.string().optional(),
+    aboutCompany: z.string().optional(),
+    requiredSkills: z.array(z.string()),
+    wagesMin: z.number().optional(),
+    wagesMax: z.number().optional(),
+    wagesCurrency: z
+        .enum(
+            Object.values(WAGES_CURRENCY) as [
+                WagesCurrency,
+                ...WagesCurrency[],
+            ],
+        )
+        .optional(),
+    wagesType: z
+        .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
+        .optional(),
 });
 
 export const JobWithGigDetailsEntitySchema = JobEntitySchema.extend(
-  GigJobEntitySchema.shape
+    GigJobEntitySchema.shape,
 );
 
 export const RoleJobEntitySchema = z.object({
-  id: z.cuid2(),
-  jobType: z.literal(JOB_TYPE.ROLE),
-  experienceLevel: z.enum(
-    Object.values(EXPERIENCE_LEVELS) as [ExperienceLevel, ...ExperienceLevel[]]
-  ),
-  overview: z.string(),
-  keyResponsibilities: z.string(),
-  requiredSkills: z.array(z.string()),
-  employeeRequirements: z.string().optional(),
-  companyBenefits: z.string().optional(),
-  wagesMin: z.number().optional(),
-  wagesMax: z.number().optional(),
-  wagesCurrency: z
-    .enum(Object.values(WAGES_CURRENCY) as [WagesCurrency, ...WagesCurrency[]])
-    .optional(),
-  wagesType: z
-    .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
-    .optional(),
+    id: z.cuid2(),
+    jobType: z.literal(JOB_TYPE.ROLE),
+    experienceLevel: z.enum(
+        Object.values(EXPERIENCE_LEVELS) as [
+            ExperienceLevel,
+            ...ExperienceLevel[],
+        ],
+    ),
+    overview: z.string(),
+    keyResponsibilities: z.string(),
+    requiredSkills: z.array(z.string()),
+    employeeRequirements: z.string().optional(),
+    companyBenefits: z.string().optional(),
+    wagesMin: z.number().optional(),
+    wagesMax: z.number().optional(),
+    wagesCurrency: z
+        .enum(
+            Object.values(WAGES_CURRENCY) as [
+                WagesCurrency,
+                ...WagesCurrency[],
+            ],
+        )
+        .optional(),
+    wagesType: z
+        .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
+        .optional(),
 });
 
 export const JobWithRoleDetailsEntitySchema = JobEntitySchema.extend(
-  RoleJobEntitySchema.shape
+    RoleJobEntitySchema.shape,
 );
 
 const CreateJobInputBaseSchema = z.object({
-  title: z.string(),
-  brandId: z.cuid2(),
-  jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
+    title: z.string(),
+    brandId: z.cuid2(),
+    jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
 
-  employmentType: z
-    .enum(
-      Object.values(EMPLOYMENT_TYPE) as [EmploymentType, ...EmploymentType[]]
-    )
-    .optional(),
+    employmentType: z
+        .enum(
+            Object.values(EMPLOYMENT_TYPE) as [
+                EmploymentType,
+                ...EmploymentType[],
+            ],
+        )
+        .optional(),
 
-  workMode: z.enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]]),
+    workMode: z.enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]]),
 
-  gigType: z
-    .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
-    .optional(),
+    gigType: z
+        .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
+        .optional(),
 
-  location: z
-    .enum(Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]])
-    .default(JOB_LOCATIONS.REMOTE),
+    location: z
+        .enum(Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]])
+        .default(JOB_LOCATIONS.REMOTE),
 
-  jobSections: z
-    .array(JobSectionEnum)
-    .min(1, { message: "At least one job section must be provided." }),
+    jobSections: z
+        .array(JobSectionEnum)
+        .min(1, { message: "At least one job section must be provided." }),
 });
 
 export const CreateJobInputSchema = CreateJobInputBaseSchema.superRefine(
-  (data, ctx) => {
-    if (data.jobType === JOB_TYPE.ROLE && !data.employmentType) {
-      ctx.addIssue({
-        path: ["employmentType"],
-        code: "custom",
-        message: "employmentType is required for ROLE jobs",
-      });
-    }
+    (data, ctx) => {
+        if (data.jobType === JOB_TYPE.ROLE && !data.employmentType) {
+            ctx.addIssue({
+                path: ["employmentType"],
+                code: "custom",
+                message: "employmentType is required for ROLE jobs",
+            });
+        }
 
-    if (data.jobType === JOB_TYPE.GIG && !data.gigType) {
-      ctx.addIssue({
-        path: ["gigType"],
-        code: "custom",
-        message: "gigType is required for GIG jobs",
-      });
-    }
-  }
+        if (data.jobType === JOB_TYPE.GIG && !data.gigType) {
+            ctx.addIssue({
+                path: ["gigType"],
+                code: "custom",
+                message: "gigType is required for GIG jobs",
+            });
+        }
+    },
 ).transform((data) => {
-  if (data.jobType === JOB_TYPE.ROLE) {
-    return { ...data, gigType: undefined };
-  }
+    if (data.jobType === JOB_TYPE.ROLE) {
+        return { ...data, gigType: undefined };
+    }
 
-  if (data.jobType === JOB_TYPE.GIG) {
-    return { ...data, employmentType: undefined };
-  }
+    if (data.jobType === JOB_TYPE.GIG) {
+        return { ...data, employmentType: undefined };
+    }
 
-  return data;
+    return data;
 });
 
 export const CreateRoleJobInputSchema = z
-  .object({
-    id: z.cuid2(),
-    experienceLevel: z.enum(
-      Object.values(EXPERIENCE_LEVELS) as [
-        ExperienceLevel,
-        ...ExperienceLevel[]
-      ]
-    ),
-    overview: z.string(),
-    keyResponsibilities: z.string(),
-    requiredSkills: z.array(z.string()),
-    employeeRequirements: z.string().optional(),
-    companyBenefits: z.string().optional(),
-    wagesMin: z.number().optional(),
-    wagesMax: z.number().optional(),
-    wagesCurrency: z
-      .enum(
-        Object.values(WAGES_CURRENCY) as [WagesCurrency, ...WagesCurrency[]]
-      )
-      .optional(),
-    wagesType: z
-      .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
-      .optional(),
-  })
-  .refine(
-    ({ wagesMin, wagesMax }) =>
-      wagesMin === undefined || wagesMax === undefined || wagesMax > wagesMin,
-    {
-      message: "wagesMax must be greater than wagesMin",
-      path: ["wagesMax"],
-    }
-  );
+    .object({
+        id: z.cuid2(),
+        experienceLevel: z.enum(
+            Object.values(EXPERIENCE_LEVELS) as [
+                ExperienceLevel,
+                ...ExperienceLevel[],
+            ],
+        ),
+        overview: z.string(),
+        keyResponsibilities: z.string(),
+        requiredSkills: z.array(z.string()),
+        employeeRequirements: z.string().optional(),
+        companyBenefits: z.string().optional(),
+        wagesMin: z.number().optional(),
+        wagesMax: z.number().optional(),
+        wagesCurrency: z
+            .enum(
+                Object.values(WAGES_CURRENCY) as [
+                    WagesCurrency,
+                    ...WagesCurrency[],
+                ],
+            )
+            .optional(),
+        wagesType: z
+            .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
+            .optional(),
+    })
+    .refine(
+        ({ wagesMin, wagesMax }) =>
+            wagesMin === undefined ||
+            wagesMax === undefined ||
+            wagesMax > wagesMin,
+        {
+            message: "wagesMax must be greater than wagesMin",
+            path: ["wagesMax"],
+        },
+    );
 
 export const CreateGigJobInputSchema = z
-  .object({
-    id: z.cuid2(),
-    overview: z.string(),
-    deliverables: z.string(),
-    employeeRequirements: z.string().optional(),
-    aboutCompany: z.string().optional(),
-    requiredSkills: z.array(z.string()),
-    wagesMin: z.number().optional(),
-    wagesMax: z.number().optional(),
-    wagesCurrency: z
-      .enum(
-        Object.values(WAGES_CURRENCY) as [WagesCurrency, ...WagesCurrency[]]
-      )
-      .optional(),
-    wagesType: z
-      .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
-      .optional(),
-  })
-  .refine(
-    ({ wagesMin, wagesMax }) =>
-      wagesMin === undefined || wagesMax === undefined || wagesMax > wagesMin,
-    {
-      message: "wagesMax must be greater than wagesMin",
-      path: ["wagesMax"],
-    }
-  );
+    .object({
+        id: z.cuid2(),
+        overview: z.string(),
+        deliverables: z.string(),
+        employeeRequirements: z.string().optional(),
+        aboutCompany: z.string().optional(),
+        requiredSkills: z.array(z.string()),
+        wagesMin: z.number().optional(),
+        wagesMax: z.number().optional(),
+        wagesCurrency: z
+            .enum(
+                Object.values(WAGES_CURRENCY) as [
+                    WagesCurrency,
+                    ...WagesCurrency[],
+                ],
+            )
+            .optional(),
+        wagesType: z
+            .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
+            .optional(),
+    })
+    .refine(
+        ({ wagesMin, wagesMax }) =>
+            wagesMin === undefined ||
+            wagesMax === undefined ||
+            wagesMax > wagesMin,
+        {
+            message: "wagesMax must be greater than wagesMin",
+            path: ["wagesMax"],
+        },
+    );
 
 export const UpdateRoleJobInputSchema =
-  CreateRoleJobInputSchema.partial().required({ id: true });
+    CreateRoleJobInputSchema.partial().required({ id: true });
 
 export const UpdateGigJobInputSchema =
-  CreateGigJobInputSchema.partial().required({ id: true });
+    CreateGigJobInputSchema.partial().required({ id: true });
 
 export const UpdateJobInputSchema = CreateJobInputBaseSchema.partial().extend({
-  id: z.cuid2(),
-  status: z
-    .enum(Object.values(JOB_STATUS) as [JobStatus, ...JobStatus[]])
-    .optional(),
+    id: z.cuid2(),
+    status: z
+        .enum(Object.values(JOB_STATUS) as [JobStatus, ...JobStatus[]])
+        .optional(),
 });
 
 export const NormalizedJobSchema = z.union([
-  JobWithGigDetailsEntitySchema,
-  JobEntitySchema,
-  JobWithRoleDetailsEntitySchema,
+    JobWithGigDetailsEntitySchema,
+    JobEntitySchema,
+    JobWithRoleDetailsEntitySchema,
 ]);
 
 export const GetCreatedJobsOutputSchema = z.object({
-  jobs: z.array(NormalizedJobSchema),
-  noOfJobs: z.number(),
-  noOfActiveJobs: z.number(),
-  noOfArchivedJobs: z.number(),
+    jobs: z.array(NormalizedJobSchema),
+    noOfJobs: z.number(),
+    noOfActiveJobs: z.number(),
+    noOfArchivedJobs: z.number(),
 });
 
 export const GetJobsInputSchema = z.object({
-  q: z.string().optional(),
-  jobType: z
-    .enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]])
-    .optional(),
-  workMode: z
-    .enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]])
-    .optional(),
-  location: z
-    .enum(Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]])
-    .optional(),
-  employmentType: z
-    .enum(
-      Object.values(EMPLOYMENT_TYPE) as [EmploymentType, ...EmploymentType[]]
-    )
-    .optional(),
-  gigType: z
-    .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
-    .optional(),
-  requiredSkills: z
-    .string()
-    .optional()
-    .describe("Comma-separated: React,Node.js"),
+    q: z.string().optional(),
+    jobType: z
+        .enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]])
+        .optional(),
+    workMode: z
+        .enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]])
+        .optional(),
+    location: z
+        .enum(Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]])
+        .optional(),
+    employmentType: z
+        .enum(
+            Object.values(EMPLOYMENT_TYPE) as [
+                EmploymentType,
+                ...EmploymentType[],
+            ],
+        )
+        .optional(),
+    gigType: z
+        .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
+        .optional(),
+    requiredSkills: z
+        .string()
+        .optional()
+        .describe("Comma-separated: React,Node.js"),
 
-  status: z.string().optional(),
-  page: z.coerce.number().min(1).default(1),
-  limit: z.coerce.number().min(1).max(100).default(20),
+    status: z.string().optional(),
+    page: z.coerce.number().min(1).default(1),
+    limit: z.coerce.number().min(1).max(100).default(20),
 });
 
 export const GetJobsOutputSchema = z.object({
-  jobs: z.array(NormalizedJobSchema),
-  total: z.number(),
-  page: z.number(),
-  totalPages: z.number(),
-  hasNextPage: z.boolean(),
-  hasPrevPage: z.boolean(),
+    jobs: z.array(NormalizedJobSchema),
+    total: z.number(),
+    page: z.number(),
+    totalPages: z.number(),
+    hasNextPage: z.boolean(),
+    hasPrevPage: z.boolean(),
 });

package/src/schemas/notification.ts

@@ -0,0 +1,61 @@
+import { z } from "@hono/zod-openapi";
+import { ACTIVITY_PARENT_TYPES, NOTIFICATION_TYPES } from "../constants";
+
+export const NotificationEntitySchema = z
+    .object({
+        id: z.cuid2().openapi({ example: "not_cksd0v6q0000s9a5y8z7p3x9" }),
+        recipientId: z.cuid2().openapi({ example: "user_recipient_123" }),
+        actorId: z.cuid2().openapi({ example: "user_actor_456" }),
+        type: z.enum(NOTIFICATION_TYPES).openapi({ example: "LIKE" }),
+        parentId: z.cuid2().optional().nullable(),
+        parentType: z
+            .enum(Object.values(ACTIVITY_PARENT_TYPES) as [string, ...string[]])
+            .optional()
+            .nullable(),
+        isRead: z.boolean().default(false).openapi({ example: false }),
+        createdAt: z.coerce
+            .date()
+            .openapi({ example: "2025-10-13T09:00:00.000Z" }),
+        deletedAt: z.coerce.date().optional().nullable(),
+    })
+    .openapi("NotificationEntity");
+
+export const MinimalNotificationEntitySchema = z.object({
+    id: z.cuid2(),
+    recipientId: z.cuid2(),
+    actorId: z.cuid2(),
+});
+
+export const NotificationDetailsEntitySchema = NotificationEntitySchema.extend({
+    itemTitle: z.string().optional(),
+    itemContent: z.string().optional(),
+    itemImgUrl: z.string().optional(),
+});
+
+export const ListNotificationsInputSchema = z
+    .object({
+        type: z
+            .enum(NOTIFICATION_TYPES)
+            .openapi({ example: "LIKE" })
+            .optional(),
+        cursor: z.string().optional(),
+        unreadOnly: z
+            .preprocess((val) => val === "true" || val === true, z.boolean())
+            .optional()
+            .default(false),
+    })
+    .openapi("ListNotificationsInput");
+
+export const ListNotificationsOutputSchema = z.object({
+    notifications: z.array(NotificationDetailsEntitySchema),
+    nextCursor: z.string().optional().nullable(),
+    unreadCount: z.number().int().openapi({ example: 5 }),
+});
+
+export const MarkReadInputSchema = z.object({
+    notificationIds: z.array(z.cuid2()).min(1),
+});
+
+export const NotificationCountOutputSchema = z.object({
+    unreadCount: z.number().int().openapi({ example: 12 }),
+});

package/src/types/index.ts

@@ -16,3 +16,4 @@ export * from "./message";
 export * from "./chat";
 export * from "./job";
 export * from "./user-strike";
+export * from "./notification";

package/src/types/notification.ts

@@ -0,0 +1,34 @@
+import { z } from "@hono/zod-openapi";
+import type {
+    NotificationEntitySchema,
+    MinimalNotificationEntitySchema,
+    NotificationDetailsEntitySchema,
+    ListNotificationsInputSchema,
+    ListNotificationsOutputSchema,
+    MarkReadInputSchema,
+    NotificationCountOutputSchema,
+} from "../schemas/notification";
+
+export type NotificationEntity = z.infer<typeof NotificationEntitySchema>;
+
+export type MinimalNotificationEntity = z.infer<
+    typeof MinimalNotificationEntitySchema
+>;
+
+export type NotificationDetailsEntity = z.infer<
+    typeof NotificationDetailsEntitySchema
+>;
+
+export type ListNotificationsInput = z.infer<
+    typeof ListNotificationsInputSchema
+>;
+
+export type ListNotificationsOutput = z.infer<
+    typeof ListNotificationsOutputSchema
+>;
+
+export type MarkReadInput = z.infer<typeof MarkReadInputSchema>;
+
+export type NotificationCountOutput = z.infer<
+    typeof NotificationCountOutputSchema
+>;