@mac777/project-pinecone-schema 1.0.0

package/dist/events/events.schema.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.draftEventSchema = exports.clientGetEventSchema = exports.submitEventSchema = exports.approvedEventEditSchema = exports.pendingApprovalEditSchema = exports.protectedEventSchema = exports.getEventSchema = exports.stepReviewSchema = exports.stepTicketsSchema = exports.stepVerifySchema = exports.stepLogisticsSchema = exports.stepDetailsSchema = exports.stepBasicsSchema = void 0;
+const zod_1 = require("zod");
+const event_type_schema_1 = require("./utils/event.type.schema");
+const media_schema_1 = require("./utils/media.schema");
+const schedule_schema_1 = require("./utils/schedule.schema");
+const venue_schema_1 = require("./utils/venue.schema");
+const organizer_schema_1 = require("./utils/organizer.schema");
+const document_schema_1 = require("./utils/document.schema");
+const ticket_schema_1 = require("./utils/ticket.schema");
+const events_constants_1 = require("./events.constants");
+const age_restriction_schema_1 = require("./utils/age.restriction.schema");
+// =============================================================================
+// STEP SCHEMAS
+// =============================================================================
+// Step 1: Basics
+exports.stepBasicsSchema = zod_1.z.object({
+    title: zod_1.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: zod_1.z.string().min(5, 'Tagline must be at least 5 characters').max(events_constants_1.MAX_TAGLINE_LENGTH, `Tagline cannot exceed ${events_constants_1.MAX_TAGLINE_LENGTH} characters`).optional(),
+    type: event_type_schema_1.eventTypeSchema,
+    categories: zod_1.z.array(zod_1.z.string()).max(events_constants_1.MAX_CATEGORIES, `Maximum ${events_constants_1.MAX_CATEGORIES} categories allowed`).optional(),
+}).passthrough();
+// Step 2: Details
+exports.stepDetailsSchema = zod_1.z.object({
+    media: media_schema_1.mediaSchema,
+    description: zod_1.z.string({ required_error: 'Event description is required' }).min(50, 'Description must be at least 50 characters').max(events_constants_1.MAX_DESCRIPTION_LENGTH, `Description cannot exceed ${events_constants_1.MAX_DESCRIPTION_LENGTH} characters`),
+    highlights: zod_1.z.array(zod_1.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: zod_1.z.string({ required_error: 'Language is required' }),
+    ageRestriction: age_restriction_schema_1.ageRestrictionSchema,
+    dressCode: zod_1.z.enum(['casual', 'formal', 'semi-formal', 'other'], { required_error: "Dress code is required" }).optional(),
+}).passthrough();
+// Step 3: Logistics
+exports.stepLogisticsSchema = zod_1.z.object({
+    schedule: schedule_schema_1.scheduleSchema,
+    venue: venue_schema_1.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
+exports.stepVerifySchema = zod_1.z.object({
+    organizer: organizer_schema_1.organizerSchema,
+    verification: zod_1.z.object({
+        documents: zod_1.z.array(document_schema_1.documentSchema).min(1, 'At least one document is required').max(events_constants_1.MAX_DOCUMENTS, `Maximum ${events_constants_1.MAX_DOCUMENTS} documents allowed`)
+    })
+}).passthrough();
+// Step 5: Tickets
+exports.stepTicketsSchema = zod_1.z.object({
+    tickets: zod_1.z.array(ticket_schema_1.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
+exports.stepReviewSchema = zod_1.z.object({
+    termsAccepted: zod_1.z.boolean().refine(val => val === true, {
+        message: 'You must accept all terms and conditions to publish this event'
+    }),
+    legalPermissionAccepted: zod_1.z.boolean().refine(val => val === true, {
+        message: 'Legal permission confirmation is required'
+    }),
+    platformTermsAccepted: zod_1.z.boolean().refine(val => val === true, {
+        message: 'Platform terms acceptance is required'
+    })
+}).passthrough();
+exports.getEventSchema = zod_1.z.object({
+    eventId: zod_1.z.string().regex(/^[0-9a-fA-F]{24}$/, 'Event not found').optional(),
+});
+exports.protectedEventSchema = zod_1.z.object({
+    eventId: zod_1.z.string().regex(/^[0-9a-fA-F]{24}$/, 'Event not found'),
+    hostId: zod_1.z.string().regex(/^[0-9a-fA-F]{24}$/, 'Unauthorized'),
+});
+exports.pendingApprovalEditSchema = zod_1.z.object({
+    eventId: zod_1.z.string({ required_error: 'Event not found' }).regex(/^[0-9a-fA-F]{24}$/, 'Event not found'),
+    hostId: zod_1.z.string({ required_error: 'Unauthorized' }).regex(/^[0-9a-fA-F]{24}$/, 'Unauthorized'),
+    media: media_schema_1.mediaSchema,
+    description: zod_1.z.string({ required_error: 'Event description is required' }).min(50, 'Description must be at least 50 characters').max(events_constants_1.MAX_DESCRIPTION_LENGTH, `Description cannot exceed ${events_constants_1.MAX_DESCRIPTION_LENGTH} characters`),
+});
+exports.approvedEventEditSchema = zod_1.z.object({
+    eventId: zod_1.z.string({ required_error: 'Event not found' }).regex(/^[0-9a-fA-F]{24}$/, 'Event not found'),
+    hostId: zod_1.z.string({ required_error: 'Unauthorized' }).regex(/^[0-9a-fA-F]{24}$/, 'Unauthorized'),
+    media: media_schema_1.mediaSchema,
+    description: zod_1.z.string({ required_error: 'Event description is required' }).min(50, 'Description must be at least 50 characters').max(events_constants_1.MAX_DESCRIPTION_LENGTH, `Description cannot exceed ${events_constants_1.MAX_DESCRIPTION_LENGTH} characters`),
+    tickets: zod_1.z.array(ticket_schema_1.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
+// =============================================================================
+exports.submitEventSchema = exports.stepBasicsSchema
+    .merge(exports.stepDetailsSchema)
+    .merge(exports.stepLogisticsSchema._def.schema)
+    .merge(exports.stepVerifySchema)
+    .merge(exports.stepTicketsSchema._def.schema._def.schema)
+    .merge(exports.stepReviewSchema)
+    .extend({
+    eventId: zod_1.z.string().regex(/^[0-9a-fA-F]{24}$/, 'Event not found').optional(),
+    hostId: zod_1.z.string().regex(/^[0-9a-fA-F]{24}$/, 'Unauthorized').optional(),
+});
+exports.clientGetEventSchema = exports.stepBasicsSchema
+    .merge(exports.stepDetailsSchema)
+    .merge(exports.stepLogisticsSchema._def.schema)
+    .merge(exports.stepVerifySchema)
+    .merge(exports.stepTicketsSchema._def.schema._def.schema)
+    .merge(exports.stepReviewSchema)
+    .extend({
+    _id: zod_1.z.string().regex(/^[0-9a-fA-F]{24}$/, 'Event not found'),
+    status: zod_1.z.enum(['draft', 'pending_approval', 'approved', 'rejected', 'published', 'live', 'ended', 'cancelled'], { required_error: 'Event status is required' }).default('draft'),
+});
+exports.draftEventSchema = exports.submitEventSchema
+    .partial()
+    .extend({
+    title: exports.stepBasicsSchema.shape.title,
+});

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

@@ -0,0 +1,47 @@
+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';
+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>;
+export type EventType = z.infer<typeof eventTypeSchema>;
+export type AgeRestriction = z.infer<typeof ageRestrictionSchema>;
+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>;
+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/dist/events/events.type.js

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

package/dist/events/events.utils.schema.d.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.utils.schema.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils/admin.schema"), exports);
+__exportStar(require("./utils/media.schema"), exports);
+__exportStar(require("./utils/ticket.schema"), exports);
+__exportStar(require("./utils/organizer.schema"), exports);
+__exportStar(require("./utils/venue.schema"), exports);

package/dist/events/index.d.ts

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

package/dist/events/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./events.schema"), exports);
+__exportStar(require("./events.type"), exports);
+__exportStar(require("./events.utils.schema"), exports);
+__exportStar(require("./events.constants"), exports);

package/dist/events/media.schema.d.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+export declare const coverImageSchema: z.ZodObject<{
+    alt: z.ZodString;
+    thumbnailUrl: z.ZodString;
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    alt: string;
+    thumbnailUrl: string;
+    url: string;
+}, {
+    alt: string;
+    thumbnailUrl: string;
+    url: string;
+}>;
+export declare const gallerySchema: z.ZodArray<z.ZodObject<{
+    alt: z.ZodString;
+    thumbnailUrl: z.ZodString;
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    alt: string;
+    thumbnailUrl: string;
+    url: string;
+}, {
+    alt: string;
+    thumbnailUrl: string;
+    url: string;
+}>, "many">;
+export declare const mediaSchema: z.ZodObject<{
+    coverImage: z.ZodObject<{
+        alt: z.ZodString;
+        thumbnailUrl: z.ZodString;
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        alt: string;
+        thumbnailUrl: string;
+        url: string;
+    }, {
+        alt: string;
+        thumbnailUrl: string;
+        url: string;
+    }>;
+    gallery: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        alt: z.ZodString;
+        thumbnailUrl: z.ZodString;
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        alt: string;
+        thumbnailUrl: string;
+        url: string;
+    }, {
+        alt: string;
+        thumbnailUrl: string;
+        url: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    coverImage: {
+        alt: string;
+        thumbnailUrl: string;
+        url: string;
+    };
+    gallery?: {
+        alt: string;
+        thumbnailUrl: string;
+        url: string;
+    }[] | undefined;
+}, {
+    coverImage: {
+        alt: string;
+        thumbnailUrl: string;
+        url: string;
+    };
+    gallery?: {
+        alt: string;
+        thumbnailUrl: string;
+        url: string;
+    }[] | undefined;
+}>;

package/dist/events/media.schema.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mediaSchema = exports.gallerySchema = exports.coverImageSchema = void 0;
+const zod_1 = require("zod");
+exports.coverImageSchema = zod_1.z.object({
+    alt: zod_1.z.string({
+        required_error: 'Alt text is required',
+        invalid_type_error: 'Alt text must be a string'
+    }),
+    thumbnailUrl: zod_1.z.string({
+        required_error: 'Thumbnail URL is required',
+        invalid_type_error: 'Thumbnail URL must be a string'
+    }),
+    url: zod_1.z.string({
+        required_error: 'URL is required',
+        invalid_type_error: 'URL must be a string'
+    })
+});
+exports.gallerySchema = zod_1.z.array(zod_1.z.object({
+    alt: zod_1.z.string({
+        required_error: 'Alt text is required',
+        invalid_type_error: 'Alt text must be a string'
+    }),
+    thumbnailUrl: zod_1.z.string({
+        required_error: 'Thumbnail URL is required',
+        invalid_type_error: 'Thumbnail URL must be a string'
+    }),
+    url: zod_1.z.string({
+        required_error: 'URL is required',
+        invalid_type_error: 'URL must be a string'
+    })
+}));
+exports.mediaSchema = zod_1.z.object({
+    coverImage: exports.coverImageSchema,
+    gallery: exports.gallerySchema.optional()
+});

package/dist/events/organizer.schema.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+export declare const contactPersonSchema: z.ZodObject<{
+    name: z.ZodString;
+    phone: z.ZodString;
+    email: z.ZodString;
+    designation: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    name: string;
+    phone: string;
+    designation?: string | undefined;
+}, {
+    email: string;
+    name: string;
+    phone: string;
+    designation?: string | undefined;
+}>;
+export declare const organizerSchema: z.ZodObject<{
+    role: z.ZodOptional<z.ZodEnum<["event_organizer", "venue_owner", "authorized_rep", "artist"]>>;
+    companyName: z.ZodOptional<z.ZodString>;
+    contactPerson: z.ZodObject<{
+        name: z.ZodString;
+        phone: z.ZodString;
+        email: z.ZodString;
+        designation: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        email: string;
+        name: string;
+        phone: string;
+        designation?: string | undefined;
+    }, {
+        email: string;
+        name: string;
+        phone: string;
+        designation?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    contactPerson: {
+        email: string;
+        name: string;
+        phone: string;
+        designation?: string | undefined;
+    };
+    role?: "event_organizer" | "venue_owner" | "authorized_rep" | "artist" | undefined;
+    companyName?: string | undefined;
+}, {
+    contactPerson: {
+        email: string;
+        name: string;
+        phone: string;
+        designation?: string | undefined;
+    };
+    role?: "event_organizer" | "venue_owner" | "authorized_rep" | "artist" | undefined;
+    companyName?: string | undefined;
+}>;

package/dist/events/organizer.schema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.organizerSchema = exports.contactPersonSchema = void 0;
+const zod_1 = require("zod");
+exports.contactPersonSchema = zod_1.z.object({
+    name: zod_1.z.string({ required_error: 'Contact person name is required' }),
+    phone: zod_1.z.string({ required_error: 'Contact person phone is required' }).min(11, 'Phone number must be 11 digits 11 digits'),
+    email: zod_1.z.string({ required_error: 'Contact person email is required' }).email('Contact person email must be valid'),
+    designation: zod_1.z.string().optional(),
+});
+exports.organizerSchema = zod_1.z.object({
+    role: zod_1.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: zod_1.z.string().optional(),
+    contactPerson: exports.contactPersonSchema,
+});

package/dist/events/schedule.schema.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const scheduleSchema: z.ZodObject<{
+    startDate: z.ZodString;
+    endDate: z.ZodString;
+    timezone: z.ZodOptional<z.ZodString>;
+    isMultiDay: z.ZodOptional<z.ZodBoolean>;
+    doors: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    startDate: string;
+    endDate: string;
+    timezone?: string | undefined;
+    isMultiDay?: boolean | undefined;
+    doors?: string | undefined;
+}, {
+    startDate: string;
+    endDate: string;
+    timezone?: string | undefined;
+    isMultiDay?: boolean | undefined;
+    doors?: string | undefined;
+}>;

package/dist/events/schedule.schema.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduleSchema = void 0;
+const zod_1 = require("zod");
+exports.scheduleSchema = zod_1.z.object({
+    startDate: zod_1.z.string({ required_error: 'Event start date is required' }).datetime('Start date must be a valid ISO datetime string'),
+    endDate: zod_1.z.string({ required_error: 'Event end date is required' }).datetime('End date must be a valid ISO datetime string'),
+    timezone: zod_1.z.string().optional(),
+    isMultiDay: zod_1.z.boolean().optional(),
+    doors: zod_1.z.string().optional(),
+});

package/dist/events/step.schema.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+export declare const priceSchema: z.ZodObject<{
+    amount: z.ZodNumber;
+    currency: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    amount: number;
+    currency: string;
+}, {
+    amount: number;
+    currency?: string | undefined;
+}>;
+export declare const salesWindowSchema: z.ZodObject<{
+    startDate: z.ZodOptional<z.ZodString>;
+    endDate: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    startDate?: string | undefined;
+    endDate?: string | undefined;
+}, {
+    startDate?: string | undefined;
+    endDate?: string | undefined;
+}>;
+export declare const limitsSchema: z.ZodObject<{
+    minPerOrder: z.ZodDefault<z.ZodNumber>;
+    maxPerOrder: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    minPerOrder: number;
+    maxPerOrder: number;
+}, {
+    minPerOrder?: number | undefined;
+    maxPerOrder?: number | undefined;
+}>;
+export declare const ticketSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    price: z.ZodObject<{
+        amount: z.ZodNumber;
+        currency: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        amount: number;
+        currency: string;
+    }, {
+        amount: number;
+        currency?: string | undefined;
+    }>;
+    quantity: z.ZodNumber;
+    salesWindow: z.ZodOptional<z.ZodObject<{
+        startDate: z.ZodOptional<z.ZodString>;
+        endDate: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        startDate?: string | undefined;
+        endDate?: string | undefined;
+    }, {
+        startDate?: string | undefined;
+        endDate?: string | undefined;
+    }>>;
+    limits: z.ZodOptional<z.ZodObject<{
+        minPerOrder: z.ZodDefault<z.ZodNumber>;
+        maxPerOrder: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        minPerOrder: number;
+        maxPerOrder: number;
+    }, {
+        minPerOrder?: number | undefined;
+        maxPerOrder?: number | undefined;
+    }>>;
+    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">>;
+    tier: z.ZodDefault<z.ZodEnum<["early_bird", "regular", "vip"]>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    price: {
+        amount: number;
+        currency: string;
+    };
+    quantity: number;
+    tier: "early_bird" | "regular" | "vip";
+    status?: "active" | "inactive" | undefined;
+    id?: string | undefined;
+    description?: string | undefined;
+    salesWindow?: {
+        startDate?: string | undefined;
+        endDate?: string | undefined;
+    } | undefined;
+    limits?: {
+        minPerOrder: number;
+        maxPerOrder: number;
+    } | undefined;
+    visibility?: "public" | "hidden" | "invite_only" | undefined;
+    benefits?: string[] | undefined;
+}, {
+    name: string;
+    price: {
+        amount: number;
+        currency?: string | undefined;
+    };
+    quantity: number;
+    status?: "active" | "inactive" | undefined;
+    id?: string | undefined;
+    description?: string | undefined;
+    salesWindow?: {
+        startDate?: string | undefined;
+        endDate?: string | undefined;
+    } | undefined;
+    limits?: {
+        minPerOrder?: number | undefined;
+        maxPerOrder?: number | undefined;
+    } | undefined;
+    visibility?: "public" | "hidden" | "invite_only" | undefined;
+    benefits?: string[] | undefined;
+    tier?: "early_bird" | "regular" | "vip" | undefined;
+}>;

package/dist/events/ticket.schema.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ticketSchema = exports.limitsSchema = exports.salesWindowSchema = exports.priceSchema = void 0;
+const zod_1 = require("zod");
+exports.priceSchema = zod_1.z.object({
+    amount: zod_1.z.number({ required_error: 'Ticket price amount is required' }).positive('Ticket price must be positive'),
+    currency: zod_1.z.string({ required_error: 'Ticket currency is required' }).default('BDT'),
+});
+exports.salesWindowSchema = zod_1.z.object({
+    startDate: zod_1.z.string().datetime('Sales start date must be a valid ISO datetime string').optional(),
+    endDate: zod_1.z.string().datetime('Sales end date must be a valid ISO datetime string').optional(),
+});
+exports.limitsSchema = zod_1.z.object({
+    minPerOrder: zod_1.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: 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.ticketSchema = zod_1.z.object({
+    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,
+    quantity: zod_1.z.number({ required_error: 'Ticket quantity is required' }).int('Quantity must be an integer').positive('Quantity must be positive'),
+    salesWindow: exports.salesWindowSchema.optional(),
+    limits: exports.limitsSchema.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(),
+    tier: zod_1.z.enum(['early_bird', 'regular', 'vip'], { required_error: 'Ticket tier must be early_bird, regular or vip' }).default('regular')
+});