@mac777/project-pinecone-schema 1.0.0

package/dist/auth/auth.constants.d.ts

@@ -0,0 +1,8 @@
+export declare const MIN_PASSWORD_LENGTH = 8;
+export declare const MAX_PASSWORD_LENGTH = 128;
+export declare const MIN_FIRST_NAME_LENGTH = 3;
+export declare const MAX_FIRST_NAME_LENGTH = 20;
+export declare const MIN_LAST_NAME_LENGTH = 3;
+export declare const MAX_LAST_NAME_LENGTH = 20;
+export declare const MIN_ORGANIZATION_NAME_LENGTH = 3;
+export declare const MAX_ORGANIZATION_NAME_LENGTH = 20;

package/dist/auth/auth.constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_ORGANIZATION_NAME_LENGTH = exports.MIN_ORGANIZATION_NAME_LENGTH = exports.MAX_LAST_NAME_LENGTH = exports.MIN_LAST_NAME_LENGTH = exports.MAX_FIRST_NAME_LENGTH = exports.MIN_FIRST_NAME_LENGTH = exports.MAX_PASSWORD_LENGTH = exports.MIN_PASSWORD_LENGTH = void 0;
+// Password strength requirements
+exports.MIN_PASSWORD_LENGTH = 8;
+exports.MAX_PASSWORD_LENGTH = 128;
+exports.MIN_FIRST_NAME_LENGTH = 3;
+exports.MAX_FIRST_NAME_LENGTH = 20;
+exports.MIN_LAST_NAME_LENGTH = 3;
+exports.MAX_LAST_NAME_LENGTH = 20;
+exports.MIN_ORGANIZATION_NAME_LENGTH = 3;
+exports.MAX_ORGANIZATION_NAME_LENGTH = 20;

package/dist/auth/auth.schema.d.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+export declare const loginSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+}, {
+    email: string;
+    password: string;
+}>;
+export declare const registerSchema: z.ZodEffects<z.ZodObject<{
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    email: z.ZodString;
+    password: z.ZodEffects<z.ZodString, string, string>;
+    confirmPassword: z.ZodString;
+} & {
+    organizationName: z.ZodOptional<z.ZodString>;
+    organizationType: z.ZodOptional<z.ZodEnum<["Venue", "Promoter", "Festival Organizer"]>>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    confirmPassword: string;
+    organizationName?: string | undefined;
+    organizationType?: "Venue" | "Promoter" | "Festival Organizer" | undefined;
+}, {
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    confirmPassword: string;
+    organizationName?: string | undefined;
+    organizationType?: "Venue" | "Promoter" | "Festival Organizer" | undefined;
+}>, {
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    confirmPassword: string;
+    organizationName?: string | undefined;
+    organizationType?: "Venue" | "Promoter" | "Festival Organizer" | undefined;
+}, {
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    confirmPassword: string;
+    organizationName?: string | undefined;
+    organizationType?: "Venue" | "Promoter" | "Festival Organizer" | undefined;
+}>;
+export declare const registerHostSchema: z.ZodEffects<z.ZodObject<{
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    email: z.ZodString;
+    password: z.ZodEffects<z.ZodString, string, string>;
+    confirmPassword: z.ZodString;
+} & {
+    organizationName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    confirmPassword: string;
+    organizationName: string;
+}, {
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    confirmPassword: string;
+    organizationName: string;
+}>, {
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    confirmPassword: string;
+    organizationName: string;
+}, {
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    confirmPassword: string;
+    organizationName: string;
+}>;
+export declare const updateGoogleUserOrganizationSchema: z.ZodObject<{
+    organization: z.ZodString;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    organization: string;
+    id: string;
+}, {
+    organization: string;
+    id: string;
+}>;

package/dist/auth/auth.schema.js

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

package/dist/auth/auth.type.d.ts

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

package/dist/auth/auth.type.js

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

package/dist/auth/index.d.ts

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

package/dist/auth/index.js

@@ -0,0 +1,19 @@
+"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("./auth.schema"), exports);
+__exportStar(require("./auth.type"), exports);
+__exportStar(require("./auth.constants"), exports);

package/dist/auth/utils/password.schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export declare const passwordSchema: z.ZodString;
+export declare const confirmPasswordSchema: z.ZodString;
+export declare const strongPasswordSchema: z.ZodEffects<z.ZodString, string, string>;

package/dist/auth/utils/password.schema.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strongPasswordSchema = exports.confirmPasswordSchema = exports.passwordSchema = void 0;
+const zod_1 = require("zod");
+const zxcvbn_1 = __importDefault(require("zxcvbn"));
+exports.passwordSchema = zod_1.z.string()
+    .min(8, 'Password must be at least 8 characters long')
+    .max(128, 'Password must be at most 128 characters long');
+exports.confirmPasswordSchema = zod_1.z.string()
+    .min(8, 'Confirm password must be at least 8 characters long')
+    .max(128, 'Confirm password must be at most 128 characters long');
+// Password strength validation
+exports.strongPasswordSchema = exports.passwordSchema.refine((password) => (0, zxcvbn_1.default)(password).score >= 2, {
+    message: 'Password must be strong (include uppercase, lowercase, numbers, and special characters)',
+});

package/dist/auth.d.ts

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

package/dist/auth.js

@@ -0,0 +1,18 @@
+"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

@@ -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/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/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/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/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?: "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

@@ -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/event.schema.js

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

package/dist/events/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/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/events.constant.d.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,12 @@
+"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'];