@mac777/project-pinecone-schema 1.0.1 → 1.0.3

package/src/orders/payments.type.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import {
+  paymentSchema,
+  paymentStatusSchema,
+  paymentMethodSchema,
+  cardBrandSchema,
+  failureCodeSchema,
+  createPaymentSchema,
+  updatePaymentStatusSchema,
+  refundPaymentSchema,
+  paymentResponseSchema,
+  paymentsListResponseSchema
+} from './payments.schema';
+
+// =============================================================================
+// TYPE EXPORTS
+// =============================================================================
+
+// Enum types
+export type PaymentStatus = z.infer<typeof paymentStatusSchema>;
+export type PaymentMethod = z.infer<typeof paymentMethodSchema>;
+export type CardBrand = z.infer<typeof cardBrandSchema>;
+export type FailureCode = z.infer<typeof failureCodeSchema>;
+
+// Main payment type
+export type Payment = z.infer<typeof paymentSchema>;
+
+// API request/response types
+export type CreatePaymentRequest = z.infer<typeof createPaymentSchema>;
+export type UpdatePaymentStatusRequest = z.infer<typeof updatePaymentStatusSchema>;
+export type RefundPaymentRequest = z.infer<typeof refundPaymentSchema>;
+
+export type PaymentResponse = z.infer<typeof paymentResponseSchema>;
+export type PaymentsListResponse = z.infer<typeof paymentsListResponseSchema>;
+
+// Service method parameter types
+export interface CreatePaymentData {
+  orderId: string;
+  userId: string;
+  paymentId: string;
+  amount: number;
+  currency?: string;
+  paymentMethod: PaymentMethod;
+  last4?: string;
+  brand?: CardBrand;
+}
+
+export interface UpdatePaymentData {
+  paymentId: string;
+  status: PaymentStatus;
+  failureCode?: FailureCode;
+  failureMessage?: string;
+}
+
+export interface RefundPaymentData {
+  paymentId: string;
+  refundAmount: number;
+  refundId: string;
+  reason: string;
+}
+
+// Utility types for frontend
+export interface PaymentWithOrder extends Omit<Payment, 'orderId'> {
+  orderId: {
+    _id: string;
+    orderNumber: string;
+    eventId: {
+      _id: string;
+      title: string;
+      schedule: {
+        startDate: string;
+        venue: {
+          name: string;
+        };
+      };
+    };
+  };
+}
+
+export interface PaymentSummary {
+  totalPayments: number;
+  successfulPayments: number;
+  failedPayments: number;
+  refundedPayments: number;
+  totalAmount: number;
+  totalRefunded: number;
+}

package/src/orders/ticket.schema.ts

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+
+// Ticket status enum
+export const ticketStatusSchema = z.enum(['valid', 'used', 'cancelled', 'refunded', 'transferred']);
+
+// Check-in status enum
+export const checkInStatusSchema = z.enum(['not_checked_in', 'checked_in']);
+
+// Main ticket schema
+export const ticketSchema = z.object({
+  _id: z.string().optional(), // MongoDB ObjectId
+  ticketNumber: z.string().regex(/^TKT-[A-Z0-9]{6}-[A-Z0-9]{4}-\d{2}$/), // TKT-EVT123-A3K9-01
+
+  // BELONGS TO
+  orderId: z.string(), // Parent order
+  eventId: z.string(), // Which event
+  userId: z.string(), // Owner
+  ticketVariantId: z.string(), // Which type (VIP, GA, etc)
+
+  // DETAILS (denormalized for speed)
+  eventTitle: z.string(),
+  eventDate: z.date(),
+  eventVenue: z.string(),
+  ticketType: z.string(), // "VIP Pass"
+  price: z.number().min(0),
+
+  // QR CODE
+  qrCode: z.string(), // SHA256 hash
+  qrCodeUrl: z.string(), // ImageKit/S3 URL
+
+  // STATUS
+  status: ticketStatusSchema,
+
+  // CHECK-IN
+  checkInStatus: checkInStatusSchema,
+  checkedInAt: z.date().optional(),
+  checkedInBy: z.string().optional(), // Staff user ID
+
+  // TRANSFER
+  transferredTo: z.string().optional(), // New owner user ID
+  transferredAt: z.date().optional(),
+
+  // LIFECYCLE
+  issuedAt: z.date().default(() => new Date()),
+  validUntil: z.date(), // Event end date
+
+  // SECURITY
+  secretHash: z.string(), // Internal validation hash
+});
+
+// API request/response schemas
+export const createTicketSchema = z.object({
+  orderId: z.string(),
+  eventId: z.string(),
+  userId: z.string(),
+  ticketVariantId: z.string(),
+  eventTitle: z.string(),
+  eventDate: z.date(),
+  eventVenue: z.string(),
+  ticketType: z.string(),
+  price: z.number().min(0),
+});
+
+export const updateTicketStatusSchema = z.object({
+  status: ticketStatusSchema,
+});
+
+export const checkInTicketSchema = z.object({
+  staffUserId: z.string(),
+});
+
+export const transferTicketSchema = z.object({
+  newOwnerId: z.string(),
+});
+
+// Response schemas
+export const ticketResponseSchema = ticketSchema;
+export const ticketsListResponseSchema = z.array(ticketResponseSchema);

package/src/orders/ticket.type.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import {
+  ticketSchema,
+  ticketStatusSchema,
+  checkInStatusSchema,
+  createTicketSchema,
+  updateTicketStatusSchema,
+  checkInTicketSchema,
+  transferTicketSchema,
+  ticketResponseSchema,
+  ticketsListResponseSchema
+} from './ticket.schema';
+
+// =============================================================================
+// TYPE EXPORTS
+// =============================================================================
+
+// Enum types
+export type TicketStatus = z.infer<typeof ticketStatusSchema>;
+export type CheckInStatus = z.infer<typeof checkInStatusSchema>;
+
+// Main ticket type
+export type Ticket = z.infer<typeof ticketSchema>;
+
+// API request/response types
+export type CreateTicketRequest = z.infer<typeof createTicketSchema>;
+export type UpdateTicketStatusRequest = z.infer<typeof updateTicketStatusSchema>;
+export type CheckInTicketRequest = z.infer<typeof checkInTicketSchema>;
+export type TransferTicketRequest = z.infer<typeof transferTicketSchema>;
+
+export type TicketResponse = z.infer<typeof ticketResponseSchema>;
+export type TicketsListResponse = z.infer<typeof ticketsListResponseSchema>;
+
+// Service method parameter types
+export interface CreateTicketData {
+  orderId: string;
+  eventId: string;
+  userId: string;
+  ticketVariantId: string;
+  eventTitle: string;
+  eventDate: Date;
+  eventVenue: string;
+  ticketType: string;
+  price: number;
+  quantity: number; // For creating multiple tickets
+}
+
+export interface UpdateTicketData {
+  ticketId: string;
+  status: TicketStatus;
+}
+
+export interface CheckInTicketData {
+  ticketId: string;
+  staffUserId: string;
+}
+
+export interface TransferTicketData {
+  ticketId: string;
+  newOwnerId: string;
+}
+
+// Utility types for frontend
+export interface TicketWithOrder extends Omit<Ticket, 'orderId'> {
+  orderId: {
+    _id: string;
+    orderNumber: string;
+    status: string;
+    createdAt: string;
+  };
+}
+
+export interface TicketWithEvent extends Omit<Ticket, 'eventId'> {
+  eventId: {
+    _id: string;
+    title: string;
+    schedule: {
+      startDate: string;
+      venue: {
+        name: string;
+      };
+    };
+  };
+}
+
+export interface TicketSummary {
+  totalTickets: number;
+  validTickets: number;
+  usedTickets: number;
+  checkedInTickets: number;
+  cancelledTickets: number;
+  refundedTickets: number;
+}
+
+// QR Code generation types
+export interface QRCodeData {
+  ticketId: string;
+  ticketNumber: string;
+  eventTitle: string;
+  eventDate: string;
+  userId: string;
+  secretHash: string;
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}

package/dist/auth.d.ts

@@ -1 +0,0 @@
-export * from './auth/index';

package/dist/auth.js

@@ -1,18 +0,0 @@
-"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 });
-// Re-export from the modular auth structure
-__exportStar(require("./auth/index"), exports);

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

@@ -1,208 +0,0 @@
-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/admin.schema.js

@@ -1,70 +0,0 @@
-"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/age.restriction.schema.d.ts

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

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

@@ -1,5 +0,0 @@
-"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/document.schema.d.ts

@@ -1,17 +0,0 @@
-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?: "venue_booking" | "permit" | "insurance" | "license" | "portfolio" | "other" | undefined;
-    url?: string | undefined;
-}, {
-    filename: string;
-    objectKey: string;
-    type?: "venue_booking" | "permit" | "insurance" | "license" | "portfolio" | "other" | undefined;
-    url?: string | undefined;
-}>;

package/dist/events/document.schema.js

@@ -1,10 +0,0 @@
-"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/event.schema.js

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

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

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

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

@@ -1,5 +0,0 @@
-"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/events.constant.d.ts

@@ -1,9 +0,0 @@
-export declare const MAX_TAGLINE_LENGTH = 150;
-export declare const MAX_CATEGORIES = 3;
-export declare const MAX_DESCRIPTION_LENGTH = 2000;
-export declare const MAX_DOCUMENTS = 5;
-export declare const SUPPORTED_IMAGE_TYPES: string[];
-export declare const MAX_FILE_SIZE_MB = 10;
-export declare const MAX_FILE_SIZE_BYTES: number;
-export declare const ALLOWED_FILE_TYPES: string[];
-export declare const ALLOWED_FILE_EXTENSIONS: string[];

package/dist/events/events.constant.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALLOWED_FILE_EXTENSIONS = exports.ALLOWED_FILE_TYPES = exports.MAX_FILE_SIZE_BYTES = exports.MAX_FILE_SIZE_MB = exports.SUPPORTED_IMAGE_TYPES = exports.MAX_DOCUMENTS = exports.MAX_DESCRIPTION_LENGTH = exports.MAX_CATEGORIES = exports.MAX_TAGLINE_LENGTH = void 0;
-exports.MAX_TAGLINE_LENGTH = 150;
-exports.MAX_CATEGORIES = 3;
-exports.MAX_DESCRIPTION_LENGTH = 2000;
-exports.MAX_DOCUMENTS = 5;
-exports.SUPPORTED_IMAGE_TYPES = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/webp'];
-exports.MAX_FILE_SIZE_MB = 10;
-exports.MAX_FILE_SIZE_BYTES = exports.MAX_FILE_SIZE_MB * 1024 * 1024;
-exports.ALLOWED_FILE_TYPES = ['image/jpeg', 'image/png', 'application/pdf'];
-exports.ALLOWED_FILE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.pdf'];