@mac777/project-pinecone-schema 1.0.0 → 1.0.2

package/src/events/events.constants.ts

@@ -0,0 +1,182 @@
+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 TICKET_PRESETS: Array<{
+    id: string;
+    label: string;
+    tier: DisplayTicket['tier'];
+    styleKey: DisplayTicket['id'];
+    desc: string;
+}> = [
+  { id: 'regular', label: 'Regular', tier: 'regular', styleKey: "regular", desc: 'General admission ticket' },
+  { id: 'vip', label: 'VIP', tier: 'vip', styleKey: "vip", desc: 'Premium perks & seating' },
+  { id: 'early_bird', label: 'Early Bird', tier: 'early_bird', styleKey: "early_bird", desc: 'Discounted ticket for early purchase' },
+] 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,59 @@
+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 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>;
+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';

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

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+
+// Metrics schema
+export const metricsSchema = z.object({
+  views: z.number({ required_error: 'Views must be a number' }).int('Views must be an integer').min(0, 'Views cannot be negative').default(0),
+  ticketsSold: z.number({ required_error: 'Tickets sold must be a number' }).int('Tickets sold must be an integer').min(0, 'Tickets sold cannot be negative').default(0),
+  revenue: z.number({ required_error: 'Revenue must be a number' }).min(0, 'Revenue cannot be negative').default(0),
+  checkIns: z.number({ required_error: 'Check-ins must be a number' }).int('Check-ins must be an integer').min(0, 'Check-ins cannot be negative').default(0),
+  averageRating: z.number().min(0, 'Rating must be at least 0').max(5, 'Rating cannot exceed 5').optional(),
+  reviewCount: z.number({ required_error: 'Review count must be a number' }).int('Review count must be an integer').min(0, 'Review count cannot be negative').default(0),
+});
+
+// Business schemas
+export const pricingSchema = z.object({
+  platformFee: z.number({ required_error: 'Platform fee must be a number' }).min(0, 'Platform fee cannot be negative').default(5),
+  paymentProcessingFee: z.number().min(0, 'Payment processing fee cannot be negative').optional(),
+  currency: z.string().optional(),
+});
+
+export const payoutSchema = z.object({
+  status: z.enum(['pending', 'scheduled', 'completed'], { required_error: 'Payout status must be pending, scheduled, or completed' }).optional(),
+  amount: z.number().min(0, 'Payout amount cannot be negative').optional(),
+  scheduledDate: z.string().datetime('Payout scheduled date must be a valid ISO datetime string').optional(),
+  paidAt: z.string().datetime('Payout paid date must be a valid ISO datetime string').optional(),
+  stripePayoutId: z.string().optional(),
+});
+
+// Policies schemas
+export const cancellationSchema = z.object({
+  allowed: z.boolean({ required_error: 'Cancellation allowed must be true or false' }).default(true),
+  refundPercentage: z.number({ required_error: 'Refund percentage must be a number' }).min(0, 'Refund percentage cannot be less than 0').max(100, 'Refund percentage cannot exceed 100').default(100),
+  deadlineHours: z.number().min(0, 'Deadline hours cannot be negative').optional(),
+});
+
+export const policiesSchema = z.object({
+  cancellation: cancellationSchema.optional(),
+  transferable: z.boolean({ required_error: 'Transferable must be true or false' }).default(false),
+});
+
+// Moderation schemas
+export const flagSchema = z.object({
+  reportedBy: z.string({ required_error: 'Reported by user ID is required' }), // ObjectId as string
+  reason: z.string({ required_error: 'Report reason is required' }),
+  description: z.string({ required_error: 'Report description is required' }),
+  createdAt: z.string().datetime('Report created date must be a valid ISO datetime string').optional(),
+  status: z.enum(['pending', 'resolved', 'dismissed'], { required_error: 'Report status must be pending, resolved, or dismissed' }).default('pending'),
+});
+
+export const moderationSchema = z.object({
+  isFlagged: z.boolean({ required_error: 'Is flagged must be true or false' }).default(false),
+  flags: z.array(flagSchema, { required_error: 'Flags must be an array' }).optional(),
+  suspendedUntil: z.string().datetime('Suspension date must be a valid ISO datetime string').optional(),
+  banReason: z.string().optional(),
+});
+
+// SEO schema
+export const seoSchema = z.object({
+  metaTitle: z.string().optional(),
+  metaDescription: z.string().optional(),
+  keywords: z.array(z.string(), { required_error: 'SEO keywords must be an array of strings' }).optional(),
+  ogImage: z.string().optional(),
+});
+
+// Features schema
+export const featuresSchema = z.object({
+  isFeatured: z.boolean({ required_error: 'Is featured must be true or false' }).default(false),
+  isPremium: z.boolean({ required_error: 'Is premium must be true or false' }).default(false),
+  badges: z.array(z.string(), { required_error: 'Badges must be an array of strings' }).optional(),
+});
+
+// History schema
+export const historySchema = z.object({
+  action: z.string({ required_error: 'History action is required' }),
+  performedBy: z.string({ required_error: 'Performed by user ID is required' }), // ObjectId as string
+  timestamp: z.string().datetime('History timestamp must be a valid ISO datetime string').optional(),
+  changes: z.record(z.any()).optional(),
+});

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

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+
+export const ageRestrictionSchema = z.enum(['all_ages', '18+', '21+'], {required_error: "Age restriction is required"}).default('all_ages');

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+export const documentSchema = z.object({
+  type: z.enum(['venue_booking', 'permit', 'insurance', 'license', 'portfolio', 'other'], { required_error: 'Document type is required' }).optional(),
+  url: z.string({ required_error: 'Document URL is required' }).url('Document URL must be valid').optional(),
+  filename: z.string({ required_error: 'Document filename is required' }),
+  objectKey: z.string({ required_error: 'Document object key is required' }),
+});

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

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+
+export const eventTypeSchema = z.enum(['concert', 'festival', 'conference', 'theater', 'sports', 'other'], {required_error: "Event type is required"}).default('concert');

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+
+export const coverImageSchema = z.object({
+  alt: z.string({
+    required_error: 'Alt text is required',
+    invalid_type_error: 'Alt text must be a string'
+  }),
+  thumbnailUrl: z.string({
+    required_error: 'Thumbnail URL is required',
+    invalid_type_error: 'Thumbnail URL must be a string'
+  }),
+  url: z.string({
+    required_error: 'URL is required',
+    invalid_type_error: 'URL must be a string'
+  })
+});
+
+export const gallerySchema = z.array(z.object({
+  alt: z.string({
+    required_error: 'Alt text is required',
+    invalid_type_error: 'Alt text must be a string'
+  }),
+  thumbnailUrl: z.string({
+    required_error: 'Thumbnail URL is required',
+    invalid_type_error: 'Thumbnail URL must be a string'
+  }),
+  url: z.string({
+    required_error: 'URL is required',
+    invalid_type_error: 'URL must be a string'
+  })
+}));
+
+export const mediaSchema = z.object({
+  coverImage: coverImageSchema,
+  gallery: gallerySchema.optional()
+});

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

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export const contactPersonSchema = z.object({
+  name: z.string({ required_error: 'Contact person name is required' }),
+  phone: z.string({ required_error: 'Contact person phone is required' }).min(11, 'Phone number must be 11 digits 11 digits'),
+  email: z.string({ required_error: 'Contact person email is required' }).email('Contact person email must be valid'),
+  designation: z.string().optional(),
+});
+
+export const organizerSchema = z.object({
+  role: z.enum(['event_organizer', 'venue_owner', 'authorized_rep', 'artist'], { required_error: 'Organizer role must be event_organizer, venue_owner, authorized_rep, or artist' }).optional(),
+  companyName: z.string().optional(),
+  contactPerson: contactPersonSchema,
+});

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

@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+export const scheduleSchema = z.object({
+  startDate: z.string({ required_error: 'Event start date is required' }).datetime('Start date must be a valid ISO datetime string'),
+  endDate: z.string({ required_error: 'Event end date is required' }).datetime('End date must be a valid ISO datetime string'),
+  timezone: z.string().optional(),
+  isMultiDay: z.boolean().optional(),
+  doors: z.string().optional(),
+});
+

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+
+export const priceSchema = z.object({
+  amount: z.number({ required_error: 'Ticket price amount is required' }).min(0, 'Ticket price cannot be negative'),
+  currency: z.string({ required_error: 'Ticket currency is required' }).default('BDT'),
+});
+
+export const salesWindowSchema = z.object({
+  startDate: z.string().datetime('Sales start date must be a valid ISO datetime string').optional(),
+  endDate: z.string().datetime('Sales end date must be a valid ISO datetime string').optional(),
+});
+
+export const limitsSchema = z.object({
+  minPerOrder: z.number({ required_error: 'Min per order must be a number' }).int('Min per order must be an integer').min(1, 'Min per order must be at least 1').default(1),
+  maxPerOrder: 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),
+});
+
+export const displayTicketSchema = z.object({
+  id: z.string().optional(),
+  name: z.string({ required_error: 'Ticket name is required' }),
+  description: z.string().optional(),
+  price: priceSchema,
+  quantity: z.number({ required_error: 'Ticket quantity is required' }).int('Quantity must be an integer').positive('Quantity must be positive'),
+  salesWindow: salesWindowSchema.optional(),
+  limits: limitsSchema.optional(),
+  remaining: z.number().optional(),
+  sold: z.number().optional(),
+  reserved: z.number().optional(),
+  visibility: z.enum(['public', 'hidden', 'invite_only'], { required_error: 'Ticket visibility must be public, hidden, or invite_only' }).default('public').optional(),
+  status: z.enum(['active', 'inactive'], { required_error: 'Ticket status must be active or inactive' }).default('active').optional(),
+  benefits: z.array(z.string(), { required_error: 'Benefits must be an array of strings' }).optional(),
+  tier: z.enum(['early_bird', 'regular', 'vip'], { required_error: 'Ticket tier must be early_bird, regular or vip' }).default('regular')
+});

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+
+export const venueTypeSchema = z.enum(['indoor', 'outdoor', 'hybrid'], { required_error: 'Venue type must be indoor, outdoor, or hybrid' }).optional();
+
+export const addressSchema = z.object({
+  street: z.string({ required_error: 'Street is required' }).min(1, 'Street is required'),
+  city: z.string({ required_error: 'City is required' }).min(1, 'City is required'),
+  country: z.string({ required_error: 'Country is required' }).min(1, 'Country is required'),
+});
+
+export const venueSchema = z.object({
+  name: z.string({ required_error: 'Venue name is required' }).min(1, 'Venue name is required'),
+  address: addressSchema,
+  coordinates: z.object({
+    type: z.literal('Point', { required_error: 'Coordinates type must be Point' }),
+    coordinates: z.tuple([z.number({ required_error: 'Longitude is required' }), z.number({ required_error: 'Latitude is required' })], { required_error: 'Coordinates array [lng, lat] is required' }), // [lng, lat]
+  }).optional(),
+  capacity: z.number({ required_error: 'Venue capacity is required' }).int('Capacity must be an integer').positive('Capacity must be positive').min(10, 'Capacity must be at least 10'),
+  type: venueTypeSchema,
+  parking: z.boolean().optional(),
+  publicTransit: z.string().optional(),
+});

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './auth/index';
+export * from './events/index';
+export * from './media/index';
+export * from './orders/index';
+

package/src/media/index.ts

@@ -0,0 +1,2 @@
+export * from './media.schema';
+export * from './media.type';