@zyacreatives/shared 2.1.28 → 2.1.31

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (22) hide show
  1. package/dist/constants.d.ts +12 -4
  2. package/dist/constants.js +16 -6
  3. package/dist/schemas/index.d.ts +1 -0
  4. package/dist/schemas/index.js +1 -0
  5. package/dist/schemas/job.d.ts +9 -0
  6. package/dist/schemas/job.js +13 -3
  7. package/dist/schemas/notification.d.ts +106 -0
  8. package/dist/schemas/notification.js +57 -0
  9. package/dist/schemas/user.d.ts +0 -16
  10. package/dist/types/index.d.ts +1 -0
  11. package/dist/types/index.js +1 -0
  12. package/dist/types/notification.d.ts +9 -0
  13. package/dist/types/notification.js +2 -0
  14. package/package.json +1 -1
  15. package/src/constants.ts +330 -316
  16. package/src/schemas/index.ts +1 -0
  17. package/src/schemas/job.ts +298 -256
  18. package/src/schemas/notification.ts +61 -0
  19. package/src/types/index.ts +1 -0
  20. package/src/types/notification.ts +34 -0
  21. package/dist/types/enums.d.ts +0 -97
  22. package/dist/types/enums.js +0 -110
package/src/schemas/index.ts CHANGED
@@ -15,3 +15,4 @@ export * from "./chat";
15
15
  export * from "./job";
16
16
  export * from "./job-application";
17
17
  export * from "./user-strike";
18
+ export * from "./notification";
package/src/schemas/job.ts CHANGED
@@ -1,322 +1,364 @@
1
1
  import { z } from "zod";
2
2
  import {
3
- EMPLOYMENT_TYPE,
4
- EmploymentType,
5
- EXPERIENCE_LEVELS,
6
- ExperienceLevel,
7
- GIG_TYPE,
8
- GigType,
9
- JOB_LOCATIONS,
10
- JOB_SECTIONS,
11
- JOB_STATUS,
12
- JOB_TYPE,
13
- JobLocation,
14
- JobStatus,
15
- JobType,
16
- WAGE_TYPES,
17
- WAGES_CURRENCY,
18
- WagesCurrency,
19
- WageTypes,
20
- WORK_MODE,
21
- WorkMode,
3
+ EMPLOYMENT_TYPE,
4
+ EmploymentType,
5
+ EXPERIENCE_LEVELS,
6
+ ExperienceLevel,
7
+ GIG_TYPE,
8
+ GigType,
9
+ JOB_LOCATIONS,
10
+ JOB_SECTIONS,
11
+ JOB_STATUS,
12
+ JOB_TYPE,
13
+ JobLocation,
14
+ JobStatus,
15
+ JobType,
16
+ WAGE_TYPES,
17
+ WAGES_CURRENCY,
18
+ WagesCurrency,
19
+ WageTypes,
20
+ WORK_MODE,
21
+ WorkMode,
22
22
  } from "../constants";
23
23
 
24
24
  const JobSectionEnum = z.enum(
25
- Object.values(JOB_SECTIONS) as [string, ...string[]]
25
+ Object.values(JOB_SECTIONS) as [string, ...string[]],
26
26
  );
27
27
 
28
+ export const MinimalJobEntitySchema = z.object({
29
+ id: z.cuid2(),
30
+ title: z.string(),
31
+ brandId: z.cuid2(),
32
+ jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
33
+ });
34
+
28
35
  export const BaseJobEntitySchema = z.object({
29
- id: z.cuid2(),
30
- title: z.string(),
31
- brandId: z.cuid2(),
32
- jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
33
- employmentType: z
34
- .enum(
35
- Object.values(EMPLOYMENT_TYPE) as [EmploymentType, ...EmploymentType[]]
36
- )
37
- .optional(),
38
- workMode: z.enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]]),
39
- status: z.enum(Object.values(JOB_STATUS) as [JobStatus, ...JobStatus[]]),
40
- gigType: z
41
- .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
42
- .optional(),
43
- location: z.enum(
44
- Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]]
45
- ),
46
- jobSections: z
47
- .array(JobSectionEnum)
48
- .default([
49
- JOB_SECTIONS.PERSONAL_INFORMATION,
50
- JOB_SECTIONS.PROFESSIONAL_INFORMATION,
51
- JOB_SECTIONS.RESUME,
52
- JOB_SECTIONS.COVER_LETTER,
53
- ]),
54
- createdAt: z.date(),
55
- updatedAt: z.date(),
36
+ id: z.cuid2(),
37
+ title: z.string(),
38
+ brandId: z.cuid2(),
39
+ jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
40
+ employmentType: z
41
+ .enum(
42
+ Object.values(EMPLOYMENT_TYPE) as [
43
+ EmploymentType,
44
+ ...EmploymentType[],
45
+ ],
46
+ )
47
+ .optional(),
48
+ workMode: z.enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]]),
49
+ status: z.enum(Object.values(JOB_STATUS) as [JobStatus, ...JobStatus[]]),
50
+ gigType: z
51
+ .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
52
+ .optional(),
53
+ location: z.enum(
54
+ Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]],
55
+ ),
56
+ jobSections: z
57
+ .array(JobSectionEnum)
58
+ .default([
59
+ JOB_SECTIONS.PERSONAL_INFORMATION,
60
+ JOB_SECTIONS.PROFESSIONAL_INFORMATION,
61
+ JOB_SECTIONS.RESUME,
62
+ JOB_SECTIONS.COVER_LETTER,
63
+ ]),
64
+ createdAt: z.date(),
65
+ updatedAt: z.date(),
56
66
  });
57
67
 
58
68
  export const JobIdSchema = z.object({
59
- jobId: z.cuid2(),
69
+ jobId: z.cuid2(),
60
70
  });
61
71
 
62
72
  export const JobEntitySchema = z.object({
63
- id: z.cuid2(),
64
- title: z.string(),
65
- brandId: z.cuid2(),
66
- brandName: z.cuid2(),
67
- brandImgUrl: z.cuid2().optional(),
68
- jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
69
- status: z.enum(Object.values(JOB_STATUS) as [JobStatus, ...JobStatus[]]),
70
- employmentType: z
71
- .enum(
72
- Object.values(EMPLOYMENT_TYPE) as [EmploymentType, ...EmploymentType[]]
73
- )
74
- .optional(),
75
- workMode: z.enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]]),
76
- gigType: z
77
- .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
78
- .optional(),
79
- location: z.enum(
80
- Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]]
81
- ),
82
- jobSections: z
83
- .array(JobSectionEnum)
84
- .default([
85
- JOB_SECTIONS.PERSONAL_INFORMATION,
86
- JOB_SECTIONS.PROFESSIONAL_INFORMATION,
87
- JOB_SECTIONS.RESUME,
88
- JOB_SECTIONS.COVER_LETTER,
89
- ]),
90
- isBookmarked: z.boolean(),
91
- createdAt: z.date(),
92
- updatedAt: z.date(),
73
+ id: z.cuid2(),
74
+ title: z.string(),
75
+ brandId: z.cuid2(),
76
+ brandName: z.cuid2(),
77
+ brandImgUrl: z.cuid2().optional(),
78
+ jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
79
+ status: z.enum(Object.values(JOB_STATUS) as [JobStatus, ...JobStatus[]]),
80
+ employmentType: z
81
+ .enum(
82
+ Object.values(EMPLOYMENT_TYPE) as [
83
+ EmploymentType,
84
+ ...EmploymentType[],
85
+ ],
86
+ )
87
+ .optional(),
88
+ workMode: z.enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]]),
89
+ gigType: z
90
+ .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
91
+ .optional(),
92
+ location: z.enum(
93
+ Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]],
94
+ ),
95
+ jobSections: z
96
+ .array(JobSectionEnum)
97
+ .default([
98
+ JOB_SECTIONS.PERSONAL_INFORMATION,
99
+ JOB_SECTIONS.PROFESSIONAL_INFORMATION,
100
+ JOB_SECTIONS.RESUME,
101
+ JOB_SECTIONS.COVER_LETTER,
102
+ ]),
103
+ isBookmarked: z.boolean(),
104
+ createdAt: z.date(),
105
+ updatedAt: z.date(),
93
106
  });
94
107
 
95
108
  export const GigJobEntitySchema = z.object({
96
- id: z.cuid2(),
97
- jobType: z.literal(JOB_TYPE.GIG),
98
- overview: z.string(),
99
- deliverables: z.string(),
100
- employeeRequirements: z.string().optional(),
101
- aboutCompany: z.string().optional(),
102
- requiredSkills: z.array(z.string()),
103
- wagesMin: z.number().optional(),
104
- wagesMax: z.number().optional(),
105
- wagesCurrency: z
106
- .enum(Object.values(WAGES_CURRENCY) as [WagesCurrency, ...WagesCurrency[]])
107
- .optional(),
108
- wagesType: z
109
- .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
110
- .optional(),
109
+ id: z.cuid2(),
110
+ jobType: z.literal(JOB_TYPE.GIG),
111
+ overview: z.string(),
112
+ deliverables: z.string(),
113
+ employeeRequirements: z.string().optional(),
114
+ aboutCompany: z.string().optional(),
115
+ requiredSkills: z.array(z.string()),
116
+ wagesMin: z.number().optional(),
117
+ wagesMax: z.number().optional(),
118
+ wagesCurrency: z
119
+ .enum(
120
+ Object.values(WAGES_CURRENCY) as [
121
+ WagesCurrency,
122
+ ...WagesCurrency[],
123
+ ],
124
+ )
125
+ .optional(),
126
+ wagesType: z
127
+ .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
128
+ .optional(),
111
129
  });
112
130
 
113
131
  export const JobWithGigDetailsEntitySchema = JobEntitySchema.extend(
114
- GigJobEntitySchema.shape
132
+ GigJobEntitySchema.shape,
115
133
  );
116
134
 
117
135
  export const RoleJobEntitySchema = z.object({
118
- id: z.cuid2(),
119
- jobType: z.literal(JOB_TYPE.ROLE),
120
- experienceLevel: z.enum(
121
- Object.values(EXPERIENCE_LEVELS) as [ExperienceLevel, ...ExperienceLevel[]]
122
- ),
123
- overview: z.string(),
124
- keyResponsibilities: z.string(),
125
- requiredSkills: z.array(z.string()),
126
- employeeRequirements: z.string().optional(),
127
- companyBenefits: z.string().optional(),
128
- wagesMin: z.number().optional(),
129
- wagesMax: z.number().optional(),
130
- wagesCurrency: z
131
- .enum(Object.values(WAGES_CURRENCY) as [WagesCurrency, ...WagesCurrency[]])
132
- .optional(),
133
- wagesType: z
134
- .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
135
- .optional(),
136
+ id: z.cuid2(),
137
+ jobType: z.literal(JOB_TYPE.ROLE),
138
+ experienceLevel: z.enum(
139
+ Object.values(EXPERIENCE_LEVELS) as [
140
+ ExperienceLevel,
141
+ ...ExperienceLevel[],
142
+ ],
143
+ ),
144
+ overview: z.string(),
145
+ keyResponsibilities: z.string(),
146
+ requiredSkills: z.array(z.string()),
147
+ employeeRequirements: z.string().optional(),
148
+ companyBenefits: z.string().optional(),
149
+ wagesMin: z.number().optional(),
150
+ wagesMax: z.number().optional(),
151
+ wagesCurrency: z
152
+ .enum(
153
+ Object.values(WAGES_CURRENCY) as [
154
+ WagesCurrency,
155
+ ...WagesCurrency[],
156
+ ],
157
+ )
158
+ .optional(),
159
+ wagesType: z
160
+ .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
161
+ .optional(),
136
162
  });
137
163
 
138
164
  export const JobWithRoleDetailsEntitySchema = JobEntitySchema.extend(
139
- RoleJobEntitySchema.shape
165
+ RoleJobEntitySchema.shape,
140
166
  );
141
167
 
142
168
  const CreateJobInputBaseSchema = z.object({
143
- title: z.string(),
144
- brandId: z.cuid2(),
145
- jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
169
+ title: z.string(),
170
+ brandId: z.cuid2(),
171
+ jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
146
172
 
147
- employmentType: z
148
- .enum(
149
- Object.values(EMPLOYMENT_TYPE) as [EmploymentType, ...EmploymentType[]]
150
- )
151
- .optional(),
173
+ employmentType: z
174
+ .enum(
175
+ Object.values(EMPLOYMENT_TYPE) as [
176
+ EmploymentType,
177
+ ...EmploymentType[],
178
+ ],
179
+ )
180
+ .optional(),
152
181
 
153
- workMode: z.enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]]),
182
+ workMode: z.enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]]),
154
183
 
155
- gigType: z
156
- .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
157
- .optional(),
184
+ gigType: z
185
+ .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
186
+ .optional(),
158
187
 
159
- location: z
160
- .enum(Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]])
161
- .default(JOB_LOCATIONS.REMOTE),
188
+ location: z
189
+ .enum(Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]])
190
+ .default(JOB_LOCATIONS.REMOTE),
162
191
 
163
- jobSections: z
164
- .array(JobSectionEnum)
165
- .min(1, { message: "At least one job section must be provided." }),
192
+ jobSections: z
193
+ .array(JobSectionEnum)
194
+ .min(1, { message: "At least one job section must be provided." }),
166
195
  });
167
196
 
168
197
  export const CreateJobInputSchema = CreateJobInputBaseSchema.superRefine(
169
- (data, ctx) => {
170
- if (data.jobType === JOB_TYPE.ROLE && !data.employmentType) {
171
- ctx.addIssue({
172
- path: ["employmentType"],
173
- code: "custom",
174
- message: "employmentType is required for ROLE jobs",
175
- });
176
- }
198
+ (data, ctx) => {
199
+ if (data.jobType === JOB_TYPE.ROLE && !data.employmentType) {
200
+ ctx.addIssue({
201
+ path: ["employmentType"],
202
+ code: "custom",
203
+ message: "employmentType is required for ROLE jobs",
204
+ });
205
+ }
177
206
 
178
- if (data.jobType === JOB_TYPE.GIG && !data.gigType) {
179
- ctx.addIssue({
180
- path: ["gigType"],
181
- code: "custom",
182
- message: "gigType is required for GIG jobs",
183
- });
184
- }
185
- }
207
+ if (data.jobType === JOB_TYPE.GIG && !data.gigType) {
208
+ ctx.addIssue({
209
+ path: ["gigType"],
210
+ code: "custom",
211
+ message: "gigType is required for GIG jobs",
212
+ });
213
+ }
214
+ },
186
215
  ).transform((data) => {
187
- if (data.jobType === JOB_TYPE.ROLE) {
188
- return { ...data, gigType: undefined };
189
- }
216
+ if (data.jobType === JOB_TYPE.ROLE) {
217
+ return { ...data, gigType: undefined };
218
+ }
190
219
 
191
- if (data.jobType === JOB_TYPE.GIG) {
192
- return { ...data, employmentType: undefined };
193
- }
220
+ if (data.jobType === JOB_TYPE.GIG) {
221
+ return { ...data, employmentType: undefined };
222
+ }
194
223
 
195
- return data;
224
+ return data;
196
225
  });
197
226
 
198
227
  export const CreateRoleJobInputSchema = z
199
- .object({
200
- id: z.cuid2(),
201
- experienceLevel: z.enum(
202
- Object.values(EXPERIENCE_LEVELS) as [
203
- ExperienceLevel,
204
- ...ExperienceLevel[]
205
- ]
206
- ),
207
- overview: z.string(),
208
- keyResponsibilities: z.string(),
209
- requiredSkills: z.array(z.string()),
210
- employeeRequirements: z.string().optional(),
211
- companyBenefits: z.string().optional(),
212
- wagesMin: z.number().optional(),
213
- wagesMax: z.number().optional(),
214
- wagesCurrency: z
215
- .enum(
216
- Object.values(WAGES_CURRENCY) as [WagesCurrency, ...WagesCurrency[]]
217
- )
218
- .optional(),
219
- wagesType: z
220
- .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
221
- .optional(),
222
- })
223
- .refine(
224
- ({ wagesMin, wagesMax }) =>
225
- wagesMin === undefined || wagesMax === undefined || wagesMax > wagesMin,
226
- {
227
- message: "wagesMax must be greater than wagesMin",
228
- path: ["wagesMax"],
229
- }
230
- );
228
+ .object({
229
+ id: z.cuid2(),
230
+ experienceLevel: z.enum(
231
+ Object.values(EXPERIENCE_LEVELS) as [
232
+ ExperienceLevel,
233
+ ...ExperienceLevel[],
234
+ ],
235
+ ),
236
+ overview: z.string(),
237
+ keyResponsibilities: z.string(),
238
+ requiredSkills: z.array(z.string()),
239
+ employeeRequirements: z.string().optional(),
240
+ companyBenefits: z.string().optional(),
241
+ wagesMin: z.number().optional(),
242
+ wagesMax: z.number().optional(),
243
+ wagesCurrency: z
244
+ .enum(
245
+ Object.values(WAGES_CURRENCY) as [
246
+ WagesCurrency,
247
+ ...WagesCurrency[],
248
+ ],
249
+ )
250
+ .optional(),
251
+ wagesType: z
252
+ .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
253
+ .optional(),
254
+ })
255
+ .refine(
256
+ ({ wagesMin, wagesMax }) =>
257
+ wagesMin === undefined ||
258
+ wagesMax === undefined ||
259
+ wagesMax > wagesMin,
260
+ {
261
+ message: "wagesMax must be greater than wagesMin",
262
+ path: ["wagesMax"],
263
+ },
264
+ );
231
265
 
232
266
  export const CreateGigJobInputSchema = z
233
- .object({
234
- id: z.cuid2(),
235
- overview: z.string(),
236
- deliverables: z.string(),
237
- employeeRequirements: z.string().optional(),
238
- aboutCompany: z.string().optional(),
239
- requiredSkills: z.array(z.string()),
240
- wagesMin: z.number().optional(),
241
- wagesMax: z.number().optional(),
242
- wagesCurrency: z
243
- .enum(
244
- Object.values(WAGES_CURRENCY) as [WagesCurrency, ...WagesCurrency[]]
245
- )
246
- .optional(),
247
- wagesType: z
248
- .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
249
- .optional(),
250
- })
251
- .refine(
252
- ({ wagesMin, wagesMax }) =>
253
- wagesMin === undefined || wagesMax === undefined || wagesMax > wagesMin,
254
- {
255
- message: "wagesMax must be greater than wagesMin",
256
- path: ["wagesMax"],
257
- }
258
- );
267
+ .object({
268
+ id: z.cuid2(),
269
+ overview: z.string(),
270
+ deliverables: z.string(),
271
+ employeeRequirements: z.string().optional(),
272
+ aboutCompany: z.string().optional(),
273
+ requiredSkills: z.array(z.string()),
274
+ wagesMin: z.number().optional(),
275
+ wagesMax: z.number().optional(),
276
+ wagesCurrency: z
277
+ .enum(
278
+ Object.values(WAGES_CURRENCY) as [
279
+ WagesCurrency,
280
+ ...WagesCurrency[],
281
+ ],
282
+ )
283
+ .optional(),
284
+ wagesType: z
285
+ .enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
286
+ .optional(),
287
+ })
288
+ .refine(
289
+ ({ wagesMin, wagesMax }) =>
290
+ wagesMin === undefined ||
291
+ wagesMax === undefined ||
292
+ wagesMax > wagesMin,
293
+ {
294
+ message: "wagesMax must be greater than wagesMin",
295
+ path: ["wagesMax"],
296
+ },
297
+ );
259
298
 
260
299
  export const UpdateRoleJobInputSchema =
261
- CreateRoleJobInputSchema.partial().required({ id: true });
300
+ CreateRoleJobInputSchema.partial().required({ id: true });
262
301
 
263
302
  export const UpdateGigJobInputSchema =
264
- CreateGigJobInputSchema.partial().required({ id: true });
303
+ CreateGigJobInputSchema.partial().required({ id: true });
265
304
 
266
305
  export const UpdateJobInputSchema = CreateJobInputBaseSchema.partial().extend({
267
- id: z.cuid2(),
268
- status: z
269
- .enum(Object.values(JOB_STATUS) as [JobStatus, ...JobStatus[]])
270
- .optional(),
306
+ id: z.cuid2(),
307
+ status: z
308
+ .enum(Object.values(JOB_STATUS) as [JobStatus, ...JobStatus[]])
309
+ .optional(),
271
310
  });
272
311
 
273
312
  export const NormalizedJobSchema = z.union([
274
- JobWithGigDetailsEntitySchema,
275
- JobEntitySchema,
276
- JobWithRoleDetailsEntitySchema,
313
+ JobWithGigDetailsEntitySchema,
314
+ JobEntitySchema,
315
+ JobWithRoleDetailsEntitySchema,
277
316
  ]);
278
317
 
279
318
  export const GetCreatedJobsOutputSchema = z.object({
280
- jobs: z.array(NormalizedJobSchema),
281
- noOfJobs: z.number(),
282
- noOfActiveJobs: z.number(),
283
- noOfArchivedJobs: z.number(),
319
+ jobs: z.array(NormalizedJobSchema),
320
+ noOfJobs: z.number(),
321
+ noOfActiveJobs: z.number(),
322
+ noOfArchivedJobs: z.number(),
284
323
  });
285
324
 
286
325
  export const GetJobsInputSchema = z.object({
287
- q: z.string().optional(),
288
- jobType: z
289
- .enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]])
290
- .optional(),
291
- workMode: z
292
- .enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]])
293
- .optional(),
294
- location: z
295
- .enum(Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]])
296
- .optional(),
297
- employmentType: z
298
- .enum(
299
- Object.values(EMPLOYMENT_TYPE) as [EmploymentType, ...EmploymentType[]]
300
- )
301
- .optional(),
302
- gigType: z
303
- .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
304
- .optional(),
305
- requiredSkills: z
306
- .string()
307
- .optional()
308
- .describe("Comma-separated: React,Node.js"),
326
+ q: z.string().optional(),
327
+ jobType: z
328
+ .enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]])
329
+ .optional(),
330
+ workMode: z
331
+ .enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]])
332
+ .optional(),
333
+ location: z
334
+ .enum(Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]])
335
+ .optional(),
336
+ employmentType: z
337
+ .enum(
338
+ Object.values(EMPLOYMENT_TYPE) as [
339
+ EmploymentType,
340
+ ...EmploymentType[],
341
+ ],
342
+ )
343
+ .optional(),
344
+ gigType: z
345
+ .enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
346
+ .optional(),
347
+ requiredSkills: z
348
+ .string()
349
+ .optional()
350
+ .describe("Comma-separated: React,Node.js"),
309
351
 
310
- status: z.string().optional(),
311
- page: z.coerce.number().min(1).default(1),
312
- limit: z.coerce.number().min(1).max(100).default(20),
352
+ status: z.string().optional(),
353
+ page: z.coerce.number().min(1).default(1),
354
+ limit: z.coerce.number().min(1).max(100).default(20),
313
355
  });
314
356
 
315
357
  export const GetJobsOutputSchema = z.object({
316
- jobs: z.array(NormalizedJobSchema),
317
- total: z.number(),
318
- page: z.number(),
319
- totalPages: z.number(),
320
- hasNextPage: z.boolean(),
321
- hasPrevPage: z.boolean(),
358
+ jobs: z.array(NormalizedJobSchema),
359
+ total: z.number(),
360
+ page: z.number(),
361
+ totalPages: z.number(),
362
+ hasNextPage: z.boolean(),
363
+ hasPrevPage: z.boolean(),
322
364
  });