@mac777/project-pinecone-schema 1.0.0

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

@@ -0,0 +1,208 @@
+import { z } from 'zod';
+export declare const metricsSchema: z.ZodObject<{
+    views: z.ZodDefault<z.ZodNumber>;
+    ticketsSold: z.ZodDefault<z.ZodNumber>;
+    revenue: z.ZodDefault<z.ZodNumber>;
+    checkIns: z.ZodDefault<z.ZodNumber>;
+    averageRating: z.ZodOptional<z.ZodNumber>;
+    reviewCount: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    views: number;
+    ticketsSold: number;
+    revenue: number;
+    checkIns: number;
+    reviewCount: number;
+    averageRating?: number | undefined;
+}, {
+    views?: number | undefined;
+    ticketsSold?: number | undefined;
+    revenue?: number | undefined;
+    checkIns?: number | undefined;
+    averageRating?: number | undefined;
+    reviewCount?: number | undefined;
+}>;
+export declare const pricingSchema: z.ZodObject<{
+    platformFee: z.ZodDefault<z.ZodNumber>;
+    paymentProcessingFee: z.ZodOptional<z.ZodNumber>;
+    currency: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    platformFee: number;
+    currency?: string | undefined;
+    paymentProcessingFee?: number | undefined;
+}, {
+    currency?: string | undefined;
+    platformFee?: number | undefined;
+    paymentProcessingFee?: number | undefined;
+}>;
+export declare const payoutSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<["pending", "scheduled", "completed"]>>;
+    amount: z.ZodOptional<z.ZodNumber>;
+    scheduledDate: z.ZodOptional<z.ZodString>;
+    paidAt: z.ZodOptional<z.ZodString>;
+    stripePayoutId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status?: "pending" | "scheduled" | "completed" | undefined;
+    amount?: number | undefined;
+    scheduledDate?: string | undefined;
+    paidAt?: string | undefined;
+    stripePayoutId?: string | undefined;
+}, {
+    status?: "pending" | "scheduled" | "completed" | undefined;
+    amount?: number | undefined;
+    scheduledDate?: string | undefined;
+    paidAt?: string | undefined;
+    stripePayoutId?: string | undefined;
+}>;
+export declare const cancellationSchema: z.ZodObject<{
+    allowed: z.ZodDefault<z.ZodBoolean>;
+    refundPercentage: z.ZodDefault<z.ZodNumber>;
+    deadlineHours: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    allowed: boolean;
+    refundPercentage: number;
+    deadlineHours?: number | undefined;
+}, {
+    allowed?: boolean | undefined;
+    refundPercentage?: number | undefined;
+    deadlineHours?: number | undefined;
+}>;
+export declare const policiesSchema: z.ZodObject<{
+    cancellation: z.ZodOptional<z.ZodObject<{
+        allowed: z.ZodDefault<z.ZodBoolean>;
+        refundPercentage: z.ZodDefault<z.ZodNumber>;
+        deadlineHours: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        allowed: boolean;
+        refundPercentage: number;
+        deadlineHours?: number | undefined;
+    }, {
+        allowed?: boolean | undefined;
+        refundPercentage?: number | undefined;
+        deadlineHours?: number | undefined;
+    }>>;
+    transferable: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    transferable: boolean;
+    cancellation?: {
+        allowed: boolean;
+        refundPercentage: number;
+        deadlineHours?: number | undefined;
+    } | undefined;
+}, {
+    cancellation?: {
+        allowed?: boolean | undefined;
+        refundPercentage?: number | undefined;
+        deadlineHours?: number | undefined;
+    } | undefined;
+    transferable?: boolean | undefined;
+}>;
+export declare const flagSchema: z.ZodObject<{
+    reportedBy: z.ZodString;
+    reason: z.ZodString;
+    description: z.ZodString;
+    createdAt: z.ZodOptional<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<["pending", "resolved", "dismissed"]>>;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "resolved" | "dismissed";
+    description: string;
+    reportedBy: string;
+    reason: string;
+    createdAt?: string | undefined;
+}, {
+    description: string;
+    reportedBy: string;
+    reason: string;
+    status?: "pending" | "resolved" | "dismissed" | undefined;
+    createdAt?: string | undefined;
+}>;
+export declare const moderationSchema: z.ZodObject<{
+    isFlagged: z.ZodDefault<z.ZodBoolean>;
+    flags: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        reportedBy: z.ZodString;
+        reason: z.ZodString;
+        description: z.ZodString;
+        createdAt: z.ZodOptional<z.ZodString>;
+        status: z.ZodDefault<z.ZodEnum<["pending", "resolved", "dismissed"]>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "pending" | "resolved" | "dismissed";
+        description: string;
+        reportedBy: string;
+        reason: string;
+        createdAt?: string | undefined;
+    }, {
+        description: string;
+        reportedBy: string;
+        reason: string;
+        status?: "pending" | "resolved" | "dismissed" | undefined;
+        createdAt?: string | undefined;
+    }>, "many">>;
+    suspendedUntil: z.ZodOptional<z.ZodString>;
+    banReason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    isFlagged: boolean;
+    flags?: {
+        status: "pending" | "resolved" | "dismissed";
+        description: string;
+        reportedBy: string;
+        reason: string;
+        createdAt?: string | undefined;
+    }[] | undefined;
+    suspendedUntil?: string | undefined;
+    banReason?: string | undefined;
+}, {
+    isFlagged?: boolean | undefined;
+    flags?: {
+        description: string;
+        reportedBy: string;
+        reason: string;
+        status?: "pending" | "resolved" | "dismissed" | undefined;
+        createdAt?: string | undefined;
+    }[] | undefined;
+    suspendedUntil?: string | undefined;
+    banReason?: string | undefined;
+}>;
+export declare const seoSchema: z.ZodObject<{
+    metaTitle: z.ZodOptional<z.ZodString>;
+    metaDescription: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ogImage: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    metaTitle?: string | undefined;
+    metaDescription?: string | undefined;
+    keywords?: string[] | undefined;
+    ogImage?: string | undefined;
+}, {
+    metaTitle?: string | undefined;
+    metaDescription?: string | undefined;
+    keywords?: string[] | undefined;
+    ogImage?: string | undefined;
+}>;
+export declare const featuresSchema: z.ZodObject<{
+    isFeatured: z.ZodDefault<z.ZodBoolean>;
+    isPremium: z.ZodDefault<z.ZodBoolean>;
+    badges: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    isFeatured: boolean;
+    isPremium: boolean;
+    badges?: string[] | undefined;
+}, {
+    isFeatured?: boolean | undefined;
+    isPremium?: boolean | undefined;
+    badges?: string[] | undefined;
+}>;
+export declare const historySchema: z.ZodObject<{
+    action: z.ZodString;
+    performedBy: z.ZodString;
+    timestamp: z.ZodOptional<z.ZodString>;
+    changes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    action: string;
+    performedBy: string;
+    timestamp?: string | undefined;
+    changes?: Record<string, any> | undefined;
+}, {
+    action: string;
+    performedBy: string;
+    timestamp?: string | undefined;
+    changes?: Record<string, any> | undefined;
+}>;

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.historySchema = exports.featuresSchema = exports.seoSchema = exports.moderationSchema = exports.flagSchema = exports.policiesSchema = exports.cancellationSchema = exports.payoutSchema = exports.pricingSchema = exports.metricsSchema = void 0;
+const zod_1 = require("zod");
+// Metrics schema
+exports.metricsSchema = zod_1.z.object({
+    views: zod_1.z.number({ required_error: 'Views must be a number' }).int('Views must be an integer').min(0, 'Views cannot be negative').default(0),
+    ticketsSold: zod_1.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: zod_1.z.number({ required_error: 'Revenue must be a number' }).min(0, 'Revenue cannot be negative').default(0),
+    checkIns: zod_1.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: zod_1.z.number().min(0, 'Rating must be at least 0').max(5, 'Rating cannot exceed 5').optional(),
+    reviewCount: zod_1.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
+exports.pricingSchema = zod_1.z.object({
+    platformFee: zod_1.z.number({ required_error: 'Platform fee must be a number' }).min(0, 'Platform fee cannot be negative').default(5),
+    paymentProcessingFee: zod_1.z.number().min(0, 'Payment processing fee cannot be negative').optional(),
+    currency: zod_1.z.string().optional(),
+});
+exports.payoutSchema = zod_1.z.object({
+    status: zod_1.z.enum(['pending', 'scheduled', 'completed'], { required_error: 'Payout status must be pending, scheduled, or completed' }).optional(),
+    amount: zod_1.z.number().min(0, 'Payout amount cannot be negative').optional(),
+    scheduledDate: zod_1.z.string().datetime('Payout scheduled date must be a valid ISO datetime string').optional(),
+    paidAt: zod_1.z.string().datetime('Payout paid date must be a valid ISO datetime string').optional(),
+    stripePayoutId: zod_1.z.string().optional(),
+});
+// Policies schemas
+exports.cancellationSchema = zod_1.z.object({
+    allowed: zod_1.z.boolean({ required_error: 'Cancellation allowed must be true or false' }).default(true),
+    refundPercentage: zod_1.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: zod_1.z.number().min(0, 'Deadline hours cannot be negative').optional(),
+});
+exports.policiesSchema = zod_1.z.object({
+    cancellation: exports.cancellationSchema.optional(),
+    transferable: zod_1.z.boolean({ required_error: 'Transferable must be true or false' }).default(false),
+});
+// Moderation schemas
+exports.flagSchema = zod_1.z.object({
+    reportedBy: zod_1.z.string({ required_error: 'Reported by user ID is required' }), // ObjectId as string
+    reason: zod_1.z.string({ required_error: 'Report reason is required' }),
+    description: zod_1.z.string({ required_error: 'Report description is required' }),
+    createdAt: zod_1.z.string().datetime('Report created date must be a valid ISO datetime string').optional(),
+    status: zod_1.z.enum(['pending', 'resolved', 'dismissed'], { required_error: 'Report status must be pending, resolved, or dismissed' }).default('pending'),
+});
+exports.moderationSchema = zod_1.z.object({
+    isFlagged: zod_1.z.boolean({ required_error: 'Is flagged must be true or false' }).default(false),
+    flags: zod_1.z.array(exports.flagSchema, { required_error: 'Flags must be an array' }).optional(),
+    suspendedUntil: zod_1.z.string().datetime('Suspension date must be a valid ISO datetime string').optional(),
+    banReason: zod_1.z.string().optional(),
+});
+// SEO schema
+exports.seoSchema = zod_1.z.object({
+    metaTitle: zod_1.z.string().optional(),
+    metaDescription: zod_1.z.string().optional(),
+    keywords: zod_1.z.array(zod_1.z.string(), { required_error: 'SEO keywords must be an array of strings' }).optional(),
+    ogImage: zod_1.z.string().optional(),
+});
+// Features schema
+exports.featuresSchema = zod_1.z.object({
+    isFeatured: zod_1.z.boolean({ required_error: 'Is featured must be true or false' }).default(false),
+    isPremium: zod_1.z.boolean({ required_error: 'Is premium must be true or false' }).default(false),
+    badges: zod_1.z.array(zod_1.z.string(), { required_error: 'Badges must be an array of strings' }).optional(),
+});
+// History schema
+exports.historySchema = zod_1.z.object({
+    action: zod_1.z.string({ required_error: 'History action is required' }),
+    performedBy: zod_1.z.string({ required_error: 'Performed by user ID is required' }), // ObjectId as string
+    timestamp: zod_1.z.string().datetime('History timestamp must be a valid ISO datetime string').optional(),
+    changes: zod_1.z.record(zod_1.z.any()).optional(),
+});

package/dist/events/utils/age.restriction.schema.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare const ageRestrictionSchema: z.ZodDefault<z.ZodEnum<["all_ages", "18+", "21+"]>>;

package/dist/events/utils/age.restriction.schema.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ageRestrictionSchema = void 0;
+const zod_1 = require("zod");
+exports.ageRestrictionSchema = zod_1.z.enum(['all_ages', '18+', '21+'], { required_error: "Age restriction is required" }).default('all_ages');

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const documentSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodEnum<["venue_booking", "permit", "insurance", "license", "portfolio", "other"]>>;
+    url: z.ZodOptional<z.ZodString>;
+    filename: z.ZodString;
+    objectKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    filename: string;
+    objectKey: string;
+    type?: "other" | "venue_booking" | "permit" | "insurance" | "license" | "portfolio" | undefined;
+    url?: string | undefined;
+}, {
+    filename: string;
+    objectKey: string;
+    type?: "other" | "venue_booking" | "permit" | "insurance" | "license" | "portfolio" | undefined;
+    url?: string | undefined;
+}>;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.documentSchema = void 0;
+const zod_1 = require("zod");
+exports.documentSchema = zod_1.z.object({
+    type: zod_1.z.enum(['venue_booking', 'permit', 'insurance', 'license', 'portfolio', 'other'], { required_error: 'Document type is required' }).optional(),
+    url: zod_1.z.string({ required_error: 'Document URL is required' }).url('Document URL must be valid').optional(),
+    filename: zod_1.z.string({ required_error: 'Document filename is required' }),
+    objectKey: zod_1.z.string({ required_error: 'Document object key is required' }),
+});

package/dist/events/utils/event.type.schema.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare const eventTypeSchema: z.ZodDefault<z.ZodEnum<["concert", "festival", "conference", "theater", "sports", "other"]>>;

package/dist/events/utils/event.type.schema.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventTypeSchema = void 0;
+const zod_1 = require("zod");
+exports.eventTypeSchema = zod_1.z.enum(['concert', 'festival', 'conference', 'theater', 'sports', 'other'], { required_error: "Event type is required" }).default('concert');

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

@@ -0,0 +1,119 @@
+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 displayTicketSchema: 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;
+    }>>;
+    remaining: z.ZodOptional<z.ZodNumber>;
+    sold: 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">>;
+    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;
+    remaining?: number | undefined;
+    sold?: 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;
+    remaining?: number | undefined;
+    sold?: number | undefined;
+    visibility?: "public" | "hidden" | "invite_only" | undefined;
+    benefits?: string[] | undefined;
+    tier?: "early_bird" | "regular" | "vip" | undefined;
+}>;