@mac777/project-pinecone-schema 1.0.1 → 1.0.3

package/dist/events/events.type.d.ts

@@ -32,14 +32,6 @@ export type StepTicketsData = z.infer<typeof stepTicketsSchema>;
 export type StepReviewData = z.infer<typeof stepReviewSchema>;
 export type SubmitEventData = z.infer<typeof submitEventSchema>;
 export type DraftEventData = z.infer<typeof draftEventSchema>;
-export interface Event {
-    id: string;
-    title: string;
-    location: string;
-    category: string;
-    date: string;
-    image?: string;
-}
 export type GetEventData = z.infer<typeof getEventSchema>;
 export type ProtectedEventData = z.infer<typeof protectedEventSchema>;
 export type ClientGetEventData = z.infer<typeof clientGetEventSchema>;

package/dist/events/utils/ticket.schema.d.ts

@@ -30,7 +30,7 @@ export declare const limitsSchema: z.ZodObject<{
     maxPerOrder?: number | undefined;
 }>;
 export declare const displayTicketSchema: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
+    _id: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     price: z.ZodObject<{
@@ -66,6 +66,7 @@ export declare const displayTicketSchema: z.ZodObject<{
     }>>;
     remaining: z.ZodOptional<z.ZodNumber>;
     sold: z.ZodOptional<z.ZodNumber>;
+    reserved: z.ZodOptional<z.ZodNumber>;
     visibility: z.ZodOptional<z.ZodDefault<z.ZodEnum<["public", "hidden", "invite_only"]>>>;
     status: z.ZodOptional<z.ZodDefault<z.ZodEnum<["active", "inactive"]>>>;
     benefits: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -79,7 +80,7 @@ export declare const displayTicketSchema: z.ZodObject<{
     quantity: number;
     tier: "early_bird" | "regular" | "vip";
     status?: "active" | "inactive" | undefined;
-    id?: string | undefined;
+    _id?: string | undefined;
     description?: string | undefined;
     salesWindow?: {
         startDate?: string | undefined;
@@ -91,6 +92,7 @@ export declare const displayTicketSchema: z.ZodObject<{
     } | undefined;
     remaining?: number | undefined;
     sold?: number | undefined;
+    reserved?: number | undefined;
     visibility?: "public" | "hidden" | "invite_only" | undefined;
     benefits?: string[] | undefined;
 }, {
@@ -101,7 +103,7 @@ export declare const displayTicketSchema: z.ZodObject<{
     };
     quantity: number;
     status?: "active" | "inactive" | undefined;
-    id?: string | undefined;
+    _id?: string | undefined;
     description?: string | undefined;
     salesWindow?: {
         startDate?: string | undefined;
@@ -113,6 +115,7 @@ export declare const displayTicketSchema: z.ZodObject<{
     } | undefined;
     remaining?: number | undefined;
     sold?: number | undefined;
+    reserved?: number | undefined;
     visibility?: "public" | "hidden" | "invite_only" | undefined;
     benefits?: string[] | undefined;
     tier?: "early_bird" | "regular" | "vip" | undefined;

package/dist/events/utils/ticket.schema.js

@@ -15,7 +15,7 @@ exports.limitsSchema = zod_1.z.object({
     maxPerOrder: zod_1.z.number({ required_error: 'Max per order must be a number' }).int('Max per order must be an integer').min(1, 'Max per order must be at least 1').default(10),
 });
 exports.displayTicketSchema = zod_1.z.object({
-    id: zod_1.z.string().optional(),
+    _id: zod_1.z.string().optional(),
     name: zod_1.z.string({ required_error: 'Ticket name is required' }),
     description: zod_1.z.string().optional(),
     price: exports.priceSchema,
@@ -24,6 +24,7 @@ exports.displayTicketSchema = zod_1.z.object({
     limits: exports.limitsSchema.optional(),
     remaining: zod_1.z.number().optional(),
     sold: zod_1.z.number().optional(),
+    reserved: zod_1.z.number().optional(),
     visibility: zod_1.z.enum(['public', 'hidden', 'invite_only'], { required_error: 'Ticket visibility must be public, hidden, or invite_only' }).default('public').optional(),
     status: zod_1.z.enum(['active', 'inactive'], { required_error: 'Ticket status must be active or inactive' }).default('active').optional(),
     benefits: zod_1.z.array(zod_1.z.string(), { required_error: 'Benefits must be an array of strings' }).optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mac777/project-pinecone-schema",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -11,11 +11,8 @@
     "zod": "^3.22.4",
     "zxcvbn": "^4.4.2"
   },
-  "files": ["dist"],
-  "publishConfig": {
-    "access": "public"
-  },
   "devDependencies": {
+    "@types/zxcvbn": "^4.4.5",
     "typescript": "^5.0.0"
   }
 }

package/src/auth/auth.constants.ts

@@ -0,0 +1,9 @@
+// Password strength requirements
+export const MIN_PASSWORD_LENGTH = 8;
+export const MAX_PASSWORD_LENGTH = 128;
+export const MIN_FIRST_NAME_LENGTH = 3;
+export const MAX_FIRST_NAME_LENGTH = 20;
+export const MIN_LAST_NAME_LENGTH = 3;
+export const MAX_LAST_NAME_LENGTH = 20;
+export const MIN_ORGANIZATION_NAME_LENGTH = 3;
+export const MAX_ORGANIZATION_NAME_LENGTH = 20;

package/src/auth/auth.schema.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { passwordSchema, confirmPasswordSchema, strongPasswordSchema } from './utils/password.schema';
+import {
+  MIN_FIRST_NAME_LENGTH,
+  MAX_FIRST_NAME_LENGTH,
+  MIN_LAST_NAME_LENGTH,
+  MAX_LAST_NAME_LENGTH,
+  MIN_ORGANIZATION_NAME_LENGTH,
+  MAX_ORGANIZATION_NAME_LENGTH
+} from './auth.constants';
+
+// =============================================================================
+// AUTH SCHEMAS
+// =============================================================================
+
+// Login schema
+export const loginSchema = z.object({
+  email: z.string().email('Please enter a valid email address'),
+  password: z.string().min(1, 'Password is required'),
+});
+
+// Base user schema
+const baseUserSchema = z.object({
+  firstName: z.string()
+    .trim()
+    .min(MIN_FIRST_NAME_LENGTH, `First name must be at least ${MIN_FIRST_NAME_LENGTH} characters long`)
+    .max(MAX_FIRST_NAME_LENGTH, `First name must be at most ${MAX_FIRST_NAME_LENGTH} characters long`),
+  lastName: z.string()
+    .trim()
+    .min(MIN_LAST_NAME_LENGTH, `Last name must be at least ${MIN_LAST_NAME_LENGTH} characters long`)
+    .max(MAX_LAST_NAME_LENGTH, `Last name must be at most ${MAX_LAST_NAME_LENGTH} characters long`),
+  email: z.string().trim().email(),
+  password: strongPasswordSchema,
+  confirmPassword: confirmPasswordSchema,
+});
+
+// Register schema for regular users
+export const registerSchema = baseUserSchema.extend({
+  organizationName: z.string().optional(),
+  organizationType: z.enum(['Venue', 'Promoter', 'Festival Organizer']).optional(),
+}).refine((data) => data.password === data.confirmPassword, {
+  message: "Passwords don't match",
+  path: ["confirmPassword"],
+});
+
+// Register schema for host users
+export const registerHostSchema = baseUserSchema.extend({
+  organizationName: z.string()
+    .trim()
+    .min(MIN_ORGANIZATION_NAME_LENGTH, `Organization name must be at least ${MIN_ORGANIZATION_NAME_LENGTH} characters long`)
+    .max(MAX_ORGANIZATION_NAME_LENGTH, `Organization name must be at most ${MAX_ORGANIZATION_NAME_LENGTH} characters long`),
+}).refine((data) => data.password === data.confirmPassword, {
+  message: 'Passwords do not match',
+  path: ['confirmPassword'],
+});
+
+
+export const updateGoogleUserOrganizationSchema = z.object({
+  organization: z.string()
+    .trim()
+    .min(MIN_ORGANIZATION_NAME_LENGTH, `Organization name must be at least ${MIN_ORGANIZATION_NAME_LENGTH} characters long`)
+    .max(MAX_ORGANIZATION_NAME_LENGTH, `Organization name must be at most ${MAX_ORGANIZATION_NAME_LENGTH} characters long`),
+  id: z.string({ required_error: 'Unauthorized' }).regex(/^[0-9a-fA-F]{24}$/, 'Unauthorized'),
+});
+

package/src/auth/auth.type.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { loginSchema, registerSchema, registerHostSchema, updateGoogleUserOrganizationSchema } from './auth.schema';
+
+// =============================================================================
+// TYPE EXPORTS
+// =============================================================================
+
+export type LoginData = z.infer<typeof loginSchema>;
+export type RegisterData = z.infer<typeof registerSchema>;
+export type RegisterHostData = z.infer<typeof registerHostSchema>;
+export type UpdateGoogleUserOrganizationData = z.infer<typeof updateGoogleUserOrganizationSchema>;
+
+// Payload interfaces for API
+export interface LoginPayload {
+  email: string;
+  password: string;
+}
+
+export interface RegisterPayload {
+  firstName: string;
+  lastName: string;
+  email: string;
+  password: string;
+  confirmPassword: string;
+  organizationName?: string;
+}
+
+export interface RegisterHostPayload extends RegisterPayload {
+  organizationName: string;
+}
+
+export interface JwtTokenPayload {
+  sub: string;
+  email: string;
+  role: string;
+  firstName?: string;
+  lastName?: string;
+  organization?: string;
+  phone?: string;
+}
+
+export type Role = 'user' | 'host' | 'admin';

package/src/auth/index.ts

@@ -0,0 +1,3 @@
+export * from './auth.schema';
+export * from './auth.type';
+export * from './auth.constants';

package/src/auth/utils/password.schema.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import zxcvbn from 'zxcvbn';
+
+export const passwordSchema = z.string()
+  .min(8, 'Password must be at least 8 characters long')
+  .max(128, 'Password must be at most 128 characters long');
+
+export const confirmPasswordSchema = z.string()
+  .min(8, 'Confirm password must be at least 8 characters long')
+  .max(128, 'Confirm password must be at most 128 characters long');
+
+// Password strength validation
+export const strongPasswordSchema = passwordSchema.refine(
+  (password) => zxcvbn(password).score >= 2,
+  {
+    message: 'Password must be strong (include uppercase, lowercase, numbers, and special characters)',
+  }
+);

package/src/events/events.constants.ts

@@ -0,0 +1,170 @@
+import { EventType, DraftEventData, AgeRestriction, VenueType, DisplayTicket } from "./events.type";
+
+export const MAX_TAGLINE_LENGTH = 150;
+export const MAX_CATEGORIES = 3;
+export const MAX_DESCRIPTION_LENGTH = 2000;
+export const MAX_DOCUMENTS = 5;
+export const SUPPORTED_IMAGE_TYPES = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/webp'];
+export const MAX_FILE_SIZE_MB = 10;
+export const MAX_FILE_SIZE_BYTES = MAX_FILE_SIZE_MB * 1024 * 1024;
+export const ALLOWED_FILE_TYPES = ['image/jpeg', 'image/png', 'application/pdf'];
+export const ALLOWED_FILE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.pdf'];
+
+export const CATEGORIES_BY_TYPE: Record<string, string[]> = {
+  concert: ['Rock', 'Pop', 'Jazz', 'Electronic', 'Indie', 'Metal', 'Acoustic', 'Classical'],
+  festival: ['Music', 'Food & Drink', 'Arts', 'Film', 'Culture', 'Tech', 'Family'],
+  conference: ['Technology', 'Business', 'Design', 'Marketing', 'Leadership', 'Startup', 'AI'],
+  theater: ['Drama', 'Comedy', 'Musical', 'Dance', 'Improv', 'Classical', 'Opera'],
+  sports: ['Football', 'Basketball', 'Tennis', 'Yoga', 'Fitness', 'Running', 'eSports'],
+  other: ['Community', 'Networking', 'Workshop', 'Meetup', 'Charity', 'Social', 'Party']
+} as const;
+
+export const EVENT_TYPES: Array<{
+  type: EventType;
+  icon: string;
+  label: string;
+}> = [
+  { type: 'concert', icon: 'Music', label: 'Concert' },
+  { type: 'festival', icon: 'Tent', label: 'Festival' },
+  { type: 'conference', icon: 'Mic2', label: 'Seminar' },
+  { type: 'theater', icon: 'Theater', label: 'Performance' },
+  { type: 'sports', icon: 'Trophy', label: 'Gala' },
+  { type: 'other', icon: 'MoreHorizontal', label: 'Other' }
+] as const;
+
+
+export const SUPPORTED_LANGUAGES = [
+  'English',
+  'Bangla'
+] as const;
+
+// Age restriction options with value (for form state) and label (for display)
+export const AGE_RESTRICTIONS: Array<{
+  value: AgeRestriction;
+  label: string;
+}> = [
+  { value: 'all_ages', label: 'All Ages' },
+  { value: '18+', label: '18+' },
+  { value: '21+', label: '21+' },
+] as const;
+
+
+
+export const IMAGE_PLACEHOLDER_TEXT = {
+  dropzone: 'Drop your image here',
+  formats: 'Supports JPG, PNG, GIF (Max 5MB)',
+  change: 'Change Image'
+} as const;
+
+
+
+
+export const HOURS = Array.from({ length: 12 }, (_, i) => i + 1);
+export const MINUTES = Array.from({ length: 60 }, (_, i) => i.toString().padStart(2, '0'));
+export const AMPM = ['AM', 'PM'] as const;
+export const TIME_PRESETS = [
+  { label: '9 am', h: 9, m: '00', p: 'AM' },
+  { label: '12 pm', h: 12, m: '00', p: 'PM' },
+  { label: '4 pm', h: 4, m: '00', p: 'PM' },
+  { label: '6 pm', h: 6, m: '00', p: 'PM' }
+] as const;
+
+export const VENUE_TYPES: Array<{ 
+  value: VenueType; 
+  label: string; 
+  icon: string; 
+}> = [
+  { value: 'indoor', label: 'Indoor', icon: 'Building' },
+  { value: 'outdoor', label: 'Outdoor', icon: 'Mountain' },
+  { value: 'hybrid', label: 'Hybrid', icon: 'Building2' }
+] as const;
+
+export const STEPS = [
+  { id: 1, label: 'Basics', description: 'Event Basics' },
+  { id: 2, label: 'Details', description: 'Event Details' },
+  { id: 3, label: 'Logistics', description: 'Date & Venue' },
+  { id: 4, label: 'Verify', description: 'Verification' },
+  { id: 5, label: 'Tickets', description: 'Ticket Setup' },
+  { id: 6, label: 'Review', description: 'Review & Publish' },
+];
+
+export const PREDEFINED_BENEFITS = [
+  'Early entry',
+  'Access to general area',
+  'VIP seating',
+  'Meet & greet',
+  'Backstage access',
+  'Complimentary drink',
+  'Priority parking',
+  'Exclusive merchandise'
+] as const;
+
+// Helper function to get tomorrow's date in ISO format
+const getTomorrowISOString = (): string => {
+  const tomorrow = new Date();
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  tomorrow.setHours(18, 0, 0, 0); // Default to 6 PM tomorrow
+  return tomorrow.toISOString();
+};
+
+const getDayAfterTomorrowISOString = (): string => {
+  const dayAfterTomorrow = new Date();
+  dayAfterTomorrow.setDate(dayAfterTomorrow.getDate() + 2);
+  dayAfterTomorrow.setHours(18, 0, 0, 0); // Default to 6 PM day after tomorrow
+  return dayAfterTomorrow.toISOString();
+};
+
+export const INITIAL_DATA: DraftEventData = {
+  title: '',
+  tagline: '',
+  type: 'concert',
+  categories: [],
+  description: '',
+  media: {
+    coverImage: {
+      url: '',
+      thumbnailUrl: '',
+      alt: ''
+    },
+    gallery: []
+  },
+  language: 'English',
+  ageRestriction: 'all_ages',
+  dressCode: 'casual',
+  schedule: {
+    startDate: getTomorrowISOString(),
+    endDate: getDayAfterTomorrowISOString(),
+  },
+  venue: {
+    name: '',
+    type: 'indoor',
+    address: {
+      street: '',
+      city: '',
+      country: '',
+    },
+    coordinates: {
+      type: 'Point',
+      coordinates: [0, 0],
+    },
+    capacity: 100,
+    parking: false,
+    publicTransit: ''
+  },
+  organizer: {
+    role: 'event_organizer',
+    contactPerson: {
+      name: '',
+      email: '',
+      phone: '',
+    },
+    companyName: ''
+  },
+  verification: {
+    documents: [],
+  },
+  tickets: [],
+  termsAccepted: false,
+  legalPermissionAccepted: false,
+  platformTermsAccepted: false,
+};

package/src/events/events.schema.ts

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+import { eventTypeSchema } from './utils/event.type.schema';
+import { mediaSchema } from './utils/media.schema';
+import { scheduleSchema } from './utils/schedule.schema';
+import { venueSchema } from './utils/venue.schema';
+import { organizerSchema } from './utils/organizer.schema';
+import { documentSchema } from './utils/document.schema';
+import { displayTicketSchema } from './utils/ticket.schema';
+import { MAX_TAGLINE_LENGTH, MAX_CATEGORIES, MAX_DESCRIPTION_LENGTH, MAX_DOCUMENTS } from './events.constants';
+import { ageRestrictionSchema } from './utils/age.restriction.schema';
+
+
+// =============================================================================
+// STEP SCHEMAS
+// =============================================================================
+
+// Step 1: Basics
+export const stepBasicsSchema = z.object({
+  title: z.string({ required_error: 'Event title is required' }).min(10, 'Event title must be at least 10 characters').max(100, 'Title must be less than 100 characters'),
+  tagline: z.string().min(5, 'Tagline must be at least 5 characters').max(MAX_TAGLINE_LENGTH, `Tagline cannot exceed ${MAX_TAGLINE_LENGTH} characters`).optional(),
+  type: eventTypeSchema,
+  categories: z.array(z.string()).max(MAX_CATEGORIES, `Maximum ${MAX_CATEGORIES} categories allowed`).optional(),
+}).passthrough();
+
+// Step 2: Details
+export const stepDetailsSchema = z.object({
+  media: mediaSchema,
+  description: z.string({ required_error: 'Event description is required' }).min(50, 'Description must be at least 50 characters').max(MAX_DESCRIPTION_LENGTH, `Description cannot exceed ${MAX_DESCRIPTION_LENGTH} characters`),
+  highlights: z.array(z.string().max(100, 'Each highlight cannot exceed 100 characters'), { required_error: 'Highlights must be an array of strings' }).max(10, 'Cannot have more than 10 highlights').optional(),
+  language: z.string({ required_error: 'Language is required' }),
+  ageRestriction: ageRestrictionSchema,
+  dressCode: z.enum(['casual', 'formal', 'semi-formal', 'other'], {required_error: "Dress code is required"}).optional(),
+}).passthrough();
+
+// Step 3: Logistics
+export const stepLogisticsSchema = z.object({
+  schedule: scheduleSchema,
+  venue: venueSchema
+}).passthrough().refine((data) => {
+  if (data.schedule.startDate && data.schedule.endDate) {
+    return new Date(data.schedule.endDate) > new Date(data.schedule.startDate);
+  }
+  return true;
+}, {
+  message: "End date and time must be after start date and time",
+  path: ["schedule", "endDate"]
+});
+
+// Step 4: Verification
+export const stepVerifySchema = z.object({
+  organizer: organizerSchema,
+  verification: z.object({
+    documents: z.array(documentSchema).min(1, 'At least one document is required').max(MAX_DOCUMENTS, `Maximum ${MAX_DOCUMENTS} documents allowed`)
+  })
+}).passthrough();
+
+// Step 5: Tickets
+export const stepTicketsSchema = z.object({
+  tickets: z.array(displayTicketSchema).min(1, 'At least one ticket type is required')
+}).passthrough().refine((data) => {
+  return data.tickets.length >= 1;
+}, {
+  message: "At least one ticket type is required",
+  path: ["tickets"]
+}).refine(data=> {
+  for (const ticket of data.tickets) {
+    if (ticket.salesWindow?.startDate && ticket.salesWindow?.endDate) {
+      if (new Date(ticket.salesWindow.endDate) <= new Date(ticket.salesWindow.startDate)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}, {
+  message: "End date and time must be after start date and time",
+  path: ["tickets", "salesWindow", "endDate"]
+});
+
+// Step 6: Review
+export const stepReviewSchema = z.object({
+  termsAccepted: z.boolean().refine(val => val === true, {
+    message: 'You must accept all terms and conditions to publish this event'
+  }),
+  legalPermissionAccepted: z.boolean().refine(val => val === true, {
+    message: 'Legal permission confirmation is required'
+  }),
+  platformTermsAccepted: z.boolean().refine(val => val === true, {
+    message: 'Platform terms acceptance is required'
+  })
+}).passthrough();
+
+export const getEventSchema = z.object({
+  eventId: z.string().regex(/^[0-9a-fA-F]{24}$/, 'Event not found').optional(),
+});
+
+export const protectedEventSchema = z.object({
+  eventId: z.string().regex(/^[0-9a-fA-F]{24}$/, 'Event not found'),
+  hostId: z.string().regex(/^[0-9a-fA-F]{24}$/, 'Unauthorized'),
+});
+
+export const pendingApprovalEditSchema = z.object({
+  eventId: z.string({ required_error: 'Event not found' }).regex(/^[0-9a-fA-F]{24}$/, 'Event not found'),
+  hostId: z.string({ required_error: 'Unauthorized' }).regex(/^[0-9a-fA-F]{24}$/, 'Unauthorized'),
+  media: mediaSchema,
+  description: z.string({ required_error: 'Event description is required' }).min(50, 'Description must be at least 50 characters').max(MAX_DESCRIPTION_LENGTH, `Description cannot exceed ${MAX_DESCRIPTION_LENGTH} characters`),
+})
+
+export const approvedEventEditSchema = z.object({
+  eventId: z.string({ required_error: 'Event not found' }).regex(/^[0-9a-fA-F]{24}$/, 'Event not found'),
+  hostId: z.string({ required_error: 'Unauthorized' }).regex(/^[0-9a-fA-F]{24}$/, 'Unauthorized'),
+  media: mediaSchema,
+  description: z.string({ required_error: 'Event description is required' }).min(50, 'Description must be at least 50 characters').max(MAX_DESCRIPTION_LENGTH, `Description cannot exceed ${MAX_DESCRIPTION_LENGTH} characters`),
+  tickets: z.array(displayTicketSchema).min(1, 'At least one ticket type is required'),
+}).refine(data=> {
+  for (const ticket of data.tickets) {
+    if (ticket.salesWindow?.startDate && ticket.salesWindow?.endDate) {
+      if (new Date(ticket.salesWindow.endDate) <= new Date(ticket.salesWindow.startDate)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}, {
+  message: "End date and time must be after start date and time",
+  path: ["tickets", "salesWindow", "endDate"]
+})
+
+// =============================================================================
+// COMPOSITE SCHEMAS
+// =============================================================================
+
+export const submitEventSchema = stepBasicsSchema
+  .merge(stepDetailsSchema)
+  .merge(stepLogisticsSchema._def.schema)
+  .merge(stepVerifySchema)
+  .merge(stepTicketsSchema._def.schema._def.schema)
+  .merge(stepReviewSchema)
+  .extend({
+    eventId: z.string().regex(/^[0-9a-fA-F]{24}$/, 'Event not found').optional(),
+    hostId: z.string().regex(/^[0-9a-fA-F]{24}$/, 'Unauthorized').optional(),
+  });
+
+export const clientGetEventSchema =  stepBasicsSchema
+  .merge(stepDetailsSchema)
+  .merge(stepLogisticsSchema._def.schema)
+  .merge(stepVerifySchema)
+  .merge(stepTicketsSchema._def.schema._def.schema)
+  .merge(stepReviewSchema)
+  .extend({
+    _id: z.string().regex(/^[0-9a-fA-F]{24}$/, 'Event not found'),
+    status: z.enum(['draft', 'pending_approval', 'approved', 'rejected', 'published', 'live', 'ended', 'cancelled'], { required_error: 'Event status is required' }).default('draft'),
+  });
+
+export const draftEventSchema = submitEventSchema
+  .partial()
+  .extend({
+    title: stepBasicsSchema.shape.title,
+  });

package/src/events/events.type.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { mediaSchema } from './utils/media.schema';
+import { scheduleSchema } from './utils/schedule.schema';
+import { venueSchema } from './utils/venue.schema';
+import { organizerSchema } from './utils/organizer.schema';
+import { documentSchema } from './utils/document.schema';
+import { displayTicketSchema } from './utils/ticket.schema';
+import { eventTypeSchema } from './utils/event.type.schema';
+import { ageRestrictionSchema } from './utils/age.restriction.schema';
+import { stepBasicsSchema, getEventSchema, protectedEventSchema, clientGetEventSchema, stepDetailsSchema, stepLogisticsSchema, stepVerifySchema, stepTicketsSchema, stepReviewSchema, submitEventSchema, draftEventSchema, pendingApprovalEditSchema, approvedEventEditSchema } from './events.schema';
+
+// =============================================================================
+// TYPE EXPORTS
+// =============================================================================
+
+// Document type is now imported from media module
+export type Media = z.infer<typeof mediaSchema>;
+export type CoverImage = z.infer<typeof mediaSchema.shape.coverImage>;
+export type Gallery = z.infer<typeof mediaSchema.shape.gallery>;
+export type Organizer = z.infer<typeof organizerSchema>;
+export type ContactPerson = z.infer<typeof organizerSchema.shape.contactPerson>;
+export type Schedule = z.infer<typeof scheduleSchema>;
+export type DisplayTicket = z.infer<typeof displayTicketSchema>;
+export type Price = z.infer<typeof displayTicketSchema.shape.price>;
+export type SalesWindow = z.infer<typeof displayTicketSchema.shape.salesWindow>;
+export type Limits = z.infer<typeof displayTicketSchema.shape.limits>;
+export type Venue = z.infer<typeof venueSchema>;
+export type VenueType = z.infer<typeof venueSchema.shape.type>;
+export type Address = z.infer<typeof venueSchema.shape.address>;
+export type Document = z.infer<typeof documentSchema>;
+
+// Shared enum types
+export type EventType = z.infer<typeof eventTypeSchema>;
+export type AgeRestriction = z.infer<typeof ageRestrictionSchema>;
+
+// Step data types
+export type StepBasicsData = z.infer<typeof stepBasicsSchema>;
+export type StepDetailsData = z.infer<typeof stepDetailsSchema>;
+export type StepLogisticsData = z.infer<typeof stepLogisticsSchema>;
+export type StepVerifyData = z.infer<typeof stepVerifySchema>;
+export type StepTicketsData = z.infer<typeof stepTicketsSchema>;
+export type StepReviewData = z.infer<typeof stepReviewSchema>;
+
+// Composite types
+export type SubmitEventData = z.infer<typeof submitEventSchema>;
+export type DraftEventData = z.infer<typeof draftEventSchema>;
+export type GetEventData = z.infer<typeof getEventSchema>;
+export type ProtectedEventData = z.infer<typeof protectedEventSchema>;
+export type ClientGetEventData = z.infer<typeof clientGetEventSchema>;
+export type PendingApprovalEditData = z.infer<typeof pendingApprovalEditSchema>;
+export type ApprovedEventEditData = z.infer<typeof approvedEventEditSchema>;

package/src/events/events.utils.schema.ts

@@ -0,0 +1,5 @@
+export * from './utils/admin.schema';
+export * from './utils/media.schema';
+export * from './utils/ticket.schema';
+export * from './utils/organizer.schema';
+export * from './utils/venue.schema';

package/{dist/events/events.d.ts → src/events/index.ts}

@@ -1,3 +1,4 @@
-export * from './events.schema';
-export * from './events.type';
-export * from './events.utils.schema';
+export * from './events.schema';
+export * from './events.type';
+export * from './events.utils.schema';
+export * from './events.constants';