@mohasinac/appkit 2.2.0 → 2.3.0

package/dist/features/events/hooks/useBulkEvent.js

@@ -1,36 +0,0 @@
-"use client";
-import { RealtimeEventType, useRealtimeEvent, } from "../../../react";
-const BULK_EVENT_TIMEOUT_MS = 10 * 60 * 1000;
-function extractBulkResult(raw) {
-    if (typeof raw.action !== "string" || !raw.summary)
-        return null;
-    const result = {
-        action: raw.action,
-        summary: raw.summary,
-        succeeded: raw.succeeded ?? [],
-        skipped: raw.skipped ?? [],
-        failed: raw.failed ?? [],
-    };
-    if (raw.data !== undefined) {
-        result.data = raw.data;
-    }
-    return result;
-}
-export function useBulkEvent(options) {
-    const { status, error, data: result, subscribe, reset, } = useRealtimeEvent({
-        type: RealtimeEventType.BULK,
-        rtdbPath: options.rtdbPath,
-        realtimeProvider: options.realtimeProvider,
-        timeoutMs: options.timeoutMs ?? BULK_EVENT_TIMEOUT_MS,
-        onLogError: options.onLogError,
-        extractData: (options.extractData ?? extractBulkResult),
-        messages: {
-            tokenFailure: "Failed to initialise bulk operation tracking. Please try again.",
-            connectionLost: "Bulk operation tracking connection lost. Please check if the changes were applied.",
-            timedOut: "Bulk operation timed out. Please check if the changes were applied.",
-            failure: "The bulk operation did not complete. Please try again.",
-            ...(options.messages ?? {}),
-        },
-    });
-    return { status, error, result, subscribe, reset };
-}

package/dist/features/events/hooks/useEvent.d.ts

@@ -1,43 +0,0 @@
-import type { EventItem, EventEntryListResponse, LeaderboardEntry } from "../types";
-interface UseEventOptions<T extends EventItem = EventItem> {
-    enabled?: boolean;
-    initialData?: EventItem;
-    endpoint?: string;
-    /**
-     * Map the API item to a richer app-level type without forking the package.
-     * @example
-     * const { event } = useEvent<EventDocument>(id, {
-     *   transform: (raw) => ({ ...raw, registrationCount: 0 }),
-     * });
-     */
-    transform?: (item: EventItem) => T;
-}
-export declare function useEvent<T extends EventItem = EventItem>(id: string, opts?: UseEventOptions<T>): {
-    event: T | null;
-    isLoading: boolean;
-    error: string | null;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<EventItem | null, Error>>;
-};
-export declare function useEventEntries(eventId: string, params?: {
-    page?: number;
-    pageSize?: number;
-    reviewStatus?: string;
-}, opts?: {
-    enabled?: boolean;
-    endpoint?: string;
-}): {
-    entries: import("..").EventEntryItem[];
-    total: number;
-    isLoading: boolean;
-    error: string | null;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<EventEntryListResponse, Error>>;
-};
-export declare function useEventLeaderboard(eventId: string, limit?: number, opts?: {
-    enabled?: boolean;
-    endpoint?: string;
-}): {
-    leaderboard: LeaderboardEntry[];
-    isLoading: boolean;
-    error: string | null;
-};
-export {};

package/dist/features/events/hooks/useEvent.js

@@ -1,55 +0,0 @@
-"use client";
-import { useQuery } from "@tanstack/react-query";
-import { apiClient } from "../../../http";
-import { EVENT_ENDPOINTS } from "../../../constants/api-endpoints";
-export function useEvent(id, opts) {
-    const endpoint = opts?.endpoint ?? EVENT_ENDPOINTS.BY_ID(id);
-    const { data, isLoading, error, refetch } = useQuery({
-        queryKey: ["event", id],
-        queryFn: () => apiClient.get(endpoint),
-        enabled: (opts?.enabled ?? true) && !!id,
-        initialData: opts?.initialData,
-    });
-    const event = data && opts?.transform ? opts.transform(data) : data;
-    return {
-        event: event ?? null,
-        isLoading,
-        error: error instanceof Error ? error.message : null,
-        refetch,
-    };
-}
-export function useEventEntries(eventId, params = {}, opts) {
-    const sp = new URLSearchParams();
-    if (params.page)
-        sp.set("page", String(params.page));
-    if (params.pageSize)
-        sp.set("pageSize", String(params.pageSize));
-    if (params.reviewStatus)
-        sp.set("reviewStatus", params.reviewStatus);
-    const qs = sp.toString();
-    const endpoint = opts?.endpoint ?? `${EVENT_ENDPOINTS.ENTRIES(eventId)}${qs ? `?${qs}` : ""}`;
-    const { data, isLoading, error, refetch } = useQuery({
-        queryKey: ["event-entries", eventId, qs],
-        queryFn: () => apiClient.get(endpoint),
-        enabled: (opts?.enabled ?? true) && !!eventId,
-    });
-    return {
-        entries: data?.items ?? [],
-        total: data?.total ?? 0,
-        isLoading,
-        error: error instanceof Error ? error.message : null,
-        refetch,
-    };
-}
-export function useEventLeaderboard(eventId, limit = 10, opts) {
-    const { data, isLoading, error } = useQuery({
-        queryKey: ["event-leaderboard", eventId, limit],
-        queryFn: () => apiClient.get(EVENT_ENDPOINTS.LEADERBOARD(eventId, limit)),
-        enabled: (opts?.enabled ?? true) && !!eventId,
-    });
-    return {
-        leaderboard: data ?? [],
-        isLoading,
-        error: error instanceof Error ? error.message : null,
-    };
-}

package/dist/features/events/hooks/useEvents.d.ts

@@ -1,27 +0,0 @@
-import type { EventItem, EventListResponse, EventListParams } from "../types";
-interface UseEventsOptions<T extends EventItem = EventItem> {
-    enabled?: boolean;
-    initialData?: EventListResponse;
-    endpoint?: string;
-    /**
-     * Map each API item to a richer app-level type.
-     * The API always returns `EventItem`; use this to project it to your own
-     * extended type without forking the package.
-     *
-     * @example
-     * const { events } = useEvents<EventDocument>(params, {
-     *   transform: (raw) => ({ ...raw, localizedTitle: t(raw.title) }),
-     * });
-     */
-    transform?: (item: EventItem) => T;
-}
-export declare function useEvents<T extends EventItem = EventItem>(params?: EventListParams, opts?: UseEventsOptions<T>): {
-    events: T[];
-    total: number;
-    totalPages: number;
-    hasMore: boolean;
-    isLoading: boolean;
-    error: string | null;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<EventListResponse, Error>>;
-};
-export {};

package/dist/features/events/hooks/useEvents.js

@@ -1,38 +0,0 @@
-"use client";
-import { useQuery } from "@tanstack/react-query";
-import { apiClient } from "../../../http";
-import { EVENT_ENDPOINTS } from "../../../constants/api-endpoints";
-export function useEvents(params = {}, opts) {
-    const sp = new URLSearchParams();
-    if (params.status)
-        sp.set("status", params.status);
-    if (params.type)
-        sp.set("type", params.type);
-    if (params.page)
-        sp.set("page", String(params.page));
-    if (params.pageSize)
-        sp.set("pageSize", String(params.pageSize));
-    if (params.sort)
-        sp.set("sorts", params.sort);
-    if (params.filters)
-        sp.set("filters", params.filters);
-    const qs = sp.toString();
-    const endpoint = opts?.endpoint ?? `${EVENT_ENDPOINTS.LIST}${qs ? `?${qs}` : ""}`;
-    const { data, isLoading, error, refetch } = useQuery({
-        queryKey: ["events", qs],
-        queryFn: () => apiClient.get(endpoint),
-        enabled: opts?.enabled ?? true,
-        initialData: opts?.initialData,
-    });
-    const rawItems = data?.items ?? [];
-    const events = (opts?.transform ? rawItems.map(opts.transform) : rawItems);
-    return {
-        events,
-        total: data?.total ?? 0,
-        totalPages: data?.totalPages ?? 0,
-        hasMore: data?.hasMore ?? false,
-        isLoading,
-        error: error instanceof Error ? error.message : null,
-        refetch,
-    };
-}

package/dist/features/events/index.d.ts

@@ -1,8 +0,0 @@
-export * from "./hooks/useEvents";
-export * from "./hooks/useEvent";
-export * from "./hooks/useBulkEvent";
-export * from "./components";
-export * from "./schemas";
-export * from "./columns";
-export * from "./types";
-export { manifest } from "./manifest";

package/dist/features/events/index.js

@@ -1,8 +0,0 @@
-export * from "./hooks/useEvents";
-export * from "./hooks/useEvent";
-export * from "./hooks/useBulkEvent";
-export * from "./components";
-export * from "./schemas";
-export * from "./columns";
-export * from "./types";
-export { manifest } from "./manifest";

package/dist/features/events/manifest.d.ts

@@ -1,2 +0,0 @@
-import type { FeatureManifest } from "../../contracts";
-export declare const manifest: FeatureManifest;

package/dist/features/events/manifest.js

@@ -1,24 +0,0 @@
-export const manifest = {
-    name: "events",
-    i18nNamespace: "events",
-    envKeys: [],
-    routes: [
-        { segment: "[locale]/events", exports: { default: "EventsListView" } },
-        {
-            segment: "[locale]/events/[id]",
-            exports: { default: "EventDetailView" },
-        },
-        {
-            segment: "[locale]/events/[id]/participate",
-            exports: { default: "EventParticipateView" },
-        },
-    ],
-    apiRoutes: [
-        { segment: "api/events", methods: ["GET"] },
-        { segment: "api/events/[id]", methods: ["GET"] },
-        { segment: "api/events/[id]/entries", methods: ["GET", "POST"] },
-        { segment: "api/admin/events", methods: ["GET", "POST"] },
-        { segment: "api/admin/events/[id]", methods: ["GET", "PATCH", "DELETE"] },
-        { segment: "api/admin/events/[id]/entries", methods: ["GET", "PATCH"] },
-    ],
-};

package/dist/features/events/messages/en.json

@@ -1,28 +0,0 @@
-{
-  "eventStatus": {
-    "draft": "Draft",
-    "active": "Active",
-    "paused": "Paused",
-    "ended": "Ended"
-  },
-  "eventType": {
-    "sale": "Sale",
-    "offer": "Offer",
-    "poll": "Poll",
-    "survey": "Survey",
-    "feedback": "Feedback"
-  },
-  "card": {
-    "participate": "Participate",
-    "viewResults": "View Results",
-    "entries": "entries",
-    "daysRemaining": "{count}d remaining"
-  },
-  "leaderboard": {
-    "title": "Leaderboard",
-    "rank": "Rank",
-    "participant": "Participant",
-    "points": "Points"
-  },
-  "empty": "No events available right now."
-}

package/dist/features/events/repository/event-entry.repository.d.ts

@@ -1,17 +0,0 @@
-import type { FirebaseSieveFields, FirebaseSieveResult, SieveModel } from "../../../providers/db-firebase";
-import { BaseRepository } from "../../../providers/db-firebase";
-import { type EventEntryCreateInput, type EventEntryDocument } from "../schemas";
-declare class EventEntryRepository extends BaseRepository<EventEntryDocument> {
-    static readonly SIEVE_FIELDS: FirebaseSieveFields;
-    constructor();
-    protected mapDoc<D = EventEntryDocument>(snap: import("../../../providers/db-firebase").DocumentSnapshot): D;
-    listForEvent(eventId: string, model: SieveModel): Promise<FirebaseSieveResult<EventEntryDocument>>;
-    hasUserEntered(eventId: string, userId: string): Promise<boolean>;
-    countUserEntries(eventId: string, userId: string): Promise<number>;
-    getLeaderboard(eventId: string, limit?: number): Promise<EventEntryDocument[]>;
-    createEntry(input: EventEntryCreateInput): Promise<EventEntryDocument>;
-    reviewEntry(id: string, reviewStatus: EventEntryDocument["reviewStatus"], reviewedBy: string, reviewNote?: string): Promise<EventEntryDocument>;
-}
-declare const eventEntryRepository: EventEntryRepository;
-export { EventEntryRepository, eventEntryRepository };
-export { EventEntryRepository as EventEntriesRepository };

package/dist/features/events/repository/event-entry.repository.js

@@ -1,115 +0,0 @@
-import { DatabaseError } from "../../../errors";
-import { serverLogger } from "../../../monitoring";
-import { BaseRepository, prepareForFirestore, } from "../../../providers/db-firebase";
-import { decryptPiiFields, encryptPiiFields, EVENT_ENTRY_PII_FIELDS, } from "../../../security";
-import { EVENT_ENTRIES_COLLECTION, EVENT_ENTRY_FIELDS, } from "../schemas";
-class EventEntryRepository extends BaseRepository {
-    constructor() {
-        super(EVENT_ENTRIES_COLLECTION);
-    }
-    mapDoc(snap) {
-        const raw = super.mapDoc(snap);
-        return decryptPiiFields(raw, [
-            ...EVENT_ENTRY_PII_FIELDS,
-        ]);
-    }
-    async listForEvent(eventId, model) {
-        return this.sieveQuery(model, EventEntryRepository.SIEVE_FIELDS, {
-            baseQuery: this.getCollection().where(EVENT_ENTRY_FIELDS.EVENT_ID, "==", eventId),
-        });
-    }
-    async hasUserEntered(eventId, userId) {
-        try {
-            const snapshot = await this.getCollection()
-                .where(EVENT_ENTRY_FIELDS.EVENT_ID, "==", eventId)
-                .where(EVENT_ENTRY_FIELDS.USER_ID, "==", userId)
-                .limit(1)
-                .get();
-            return !snapshot.empty;
-        }
-        catch (error) {
-            throw new DatabaseError(`Failed to check user entry for event ${eventId}`, error);
-        }
-    }
-    async countUserEntries(eventId, userId) {
-        try {
-            const snapshot = await this.getCollection()
-                .where(EVENT_ENTRY_FIELDS.EVENT_ID, "==", eventId)
-                .where(EVENT_ENTRY_FIELDS.USER_ID, "==", userId)
-                .get();
-            return snapshot.size;
-        }
-        catch (error) {
-            throw new DatabaseError(`Failed to count user entries for event ${eventId}`, error);
-        }
-    }
-    async getLeaderboard(eventId, limit = 50) {
-        try {
-            const snapshot = await this.getCollection()
-                .where(EVENT_ENTRY_FIELDS.EVENT_ID, "==", eventId)
-                .where(EVENT_ENTRY_FIELDS.REVIEW_STATUS, "==", EVENT_ENTRY_FIELDS.REVIEW_STATUS_VALUES.APPROVED)
-                .orderBy(EVENT_ENTRY_FIELDS.POINTS, "desc")
-                .limit(limit)
-                .get();
-            return snapshot.docs.map((doc) => decryptPiiFields({
-                id: doc.id,
-                ...doc.data(),
-            }, [...EVENT_ENTRY_PII_FIELDS]));
-        }
-        catch (error) {
-            throw new DatabaseError(`Failed to get leaderboard for event ${eventId}`, error);
-        }
-    }
-    async createEntry(input) {
-        try {
-            const now = new Date();
-            const encrypted = encryptPiiFields(input, [
-                ...EVENT_ENTRY_PII_FIELDS,
-            ]);
-            const data = prepareForFirestore({
-                ...encrypted,
-                submittedAt: now,
-            });
-            const ref = await this.getCollection().add(data);
-            const created = await ref.get();
-            serverLogger.info("Event entry created", {
-                entryId: ref.id,
-                eventId: input.eventId,
-                userId: input.userId,
-            });
-            return { id: ref.id, ...created.data() };
-        }
-        catch (error) {
-            throw new DatabaseError("Failed to create event entry", error);
-        }
-    }
-    async reviewEntry(id, reviewStatus, reviewedBy, reviewNote) {
-        try {
-            const now = new Date();
-            await this.getCollection()
-                .doc(id)
-                .update(prepareForFirestore({
-                [EVENT_ENTRY_FIELDS.REVIEW_STATUS]: reviewStatus,
-                [EVENT_ENTRY_FIELDS.REVIEWED_BY]: reviewedBy,
-                [EVENT_ENTRY_FIELDS.REVIEWED_AT]: now,
-                ...(reviewNote !== undefined ? { reviewNote } : {}),
-            }));
-            serverLogger.info("Event entry reviewed", { entryId: id, reviewStatus });
-            return this.findByIdOrFail(id);
-        }
-        catch (error) {
-            throw new DatabaseError(`Failed to review event entry ${id}`, error);
-        }
-    }
-}
-EventEntryRepository.SIEVE_FIELDS = {
-    eventId: { canFilter: true, canSort: false },
-    userId: { canFilter: true, canSort: false },
-    userDisplayName: { canFilter: false, canSort: false },
-    reviewStatus: { canFilter: true, canSort: false },
-    submittedAt: { canFilter: true, canSort: true },
-    points: { canFilter: true, canSort: true },
-};
-const eventEntryRepository = new EventEntryRepository();
-export { EventEntryRepository, eventEntryRepository };
-export { EventEntryRepository as EventEntriesRepository };

package/dist/features/events/repository/events.repository.d.ts

@@ -1,18 +0,0 @@
-import type { FirebaseSieveFields, FirebaseSieveResult, SieveModel } from "../../../providers/db-firebase";
-import { BaseRepository } from "../../../providers/db-firebase";
-import { type EventCreateInput, type EventDocument, type EventUpdateInput } from "../schemas";
-declare class EventRepository extends BaseRepository<EventDocument> {
-    static readonly SIEVE_FIELDS: FirebaseSieveFields;
-    constructor();
-    list(model: SieveModel): Promise<FirebaseSieveResult<EventDocument>>;
-    listActive(): Promise<EventDocument[]>;
-    createEvent(input: EventCreateInput): Promise<EventDocument>;
-    updateEvent(id: string, input: EventUpdateInput): Promise<EventDocument>;
-    changeStatus(id: string, status: EventDocument["status"]): Promise<EventDocument>;
-    incrementTotalEntries(id: string): Promise<void>;
-    incrementApprovedEntries(id: string): Promise<void>;
-    incrementFlaggedEntries(id: string): Promise<void>;
-}
-declare const eventRepository: EventRepository;
-export { EventRepository, eventRepository };
-export { EventRepository as EventsRepository };

package/dist/features/events/repository/events.repository.js

@@ -1,128 +0,0 @@
-import { DatabaseError } from "../../../errors";
-import { serverLogger } from "../../../monitoring";
-import { BaseRepository, prepareForFirestore, } from "../../../providers/db-firebase";
-import { EVENT_FIELDS, EVENTS_COLLECTION, } from "../schemas";
-import { increment } from "../../../contracts/field-ops";
-class EventRepository extends BaseRepository {
-    constructor() {
-        super(EVENTS_COLLECTION);
-    }
-    async list(model) {
-        return this.sieveQuery(model, EventRepository.SIEVE_FIELDS);
-    }
-    async listActive() {
-        try {
-            const now = new Date();
-            const snapshot = await this.getCollection()
-                .where(EVENT_FIELDS.STATUS, "==", EVENT_FIELDS.STATUS_VALUES.ACTIVE)
-                .where(EVENT_FIELDS.ENDS_AT, ">=", now)
-                .orderBy(EVENT_FIELDS.ENDS_AT, "asc")
-                .get();
-            return snapshot.docs.map((doc) => this.mapDoc(doc));
-        }
-        catch (error) {
-            throw new DatabaseError("Failed to list active events", error);
-        }
-    }
-    async createEvent(input) {
-        try {
-            const now = new Date();
-            const data = prepareForFirestore({
-                ...input,
-                stats: { totalEntries: 0, approvedEntries: 0, flaggedEntries: 0 },
-                createdAt: now,
-                updatedAt: now,
-            });
-            const ref = await this.getCollection().add(data);
-            const created = await ref.get();
-            serverLogger.info("Event created", { eventId: ref.id, type: input.type });
-            return this.mapDoc(created);
-        }
-        catch (error) {
-            throw new DatabaseError("Failed to create event", error);
-        }
-    }
-    async updateEvent(id, input) {
-        try {
-            const now = new Date();
-            const data = prepareForFirestore({
-                ...input,
-                [EVENT_FIELDS.UPDATED_AT]: now,
-            });
-            await this.getCollection().doc(id).update(data);
-            const updated = await this.findByIdOrFail(id);
-            serverLogger.info("Event updated", { eventId: id });
-            return updated;
-        }
-        catch (error) {
-            throw new DatabaseError(`Failed to update event ${id}`, error);
-        }
-    }
-    async changeStatus(id, status) {
-        return this.updateEvent(id, { status });
-    }
-    async incrementTotalEntries(id) {
-        try {
-            await this.getCollection()
-                .doc(id)
-                .update({
-                [EVENT_FIELDS.STATS.TOTAL_ENTRIES]: increment(1),
-            });
-        }
-        catch (error) {
-            throw new DatabaseError(`Failed to increment totalEntries for event ${id}`, error);
-        }
-    }
-    async incrementApprovedEntries(id) {
-        try {
-            await this.getCollection()
-                .doc(id)
-                .update({
-                [EVENT_FIELDS.STATS.APPROVED_ENTRIES]: increment(1),
-            });
-        }
-        catch (error) {
-            throw new DatabaseError(`Failed to increment approvedEntries for event ${id}`, error);
-        }
-    }
-    async incrementFlaggedEntries(id) {
-        try {
-            await this.getCollection()
-                .doc(id)
-                .update({
-                [EVENT_FIELDS.STATS.FLAGGED_ENTRIES]: increment(1),
-            });
-        }
-        catch (error) {
-            throw new DatabaseError(`Failed to increment flaggedEntries for event ${id}`, error);
-        }
-    }
-}
-EventRepository.SIEVE_FIELDS = {
-    type: { canFilter: true, canSort: false },
-    status: { canFilter: true, canSort: true },
-    title: { canFilter: true, canSort: true },
-    createdBy: { canFilter: true, canSort: false },
-    startsAt: { canFilter: true, canSort: true },
-    endsAt: { canFilter: true, canSort: true },
-    "stats.totalEntries": {
-        path: "stats.totalEntries",
-        canFilter: true,
-        canSort: true,
-    },
-    "stats.approvedEntries": {
-        path: "stats.approvedEntries",
-        canFilter: true,
-        canSort: true,
-    },
-    "stats.flaggedEntries": {
-        path: "stats.flaggedEntries",
-        canFilter: true,
-        canSort: true,
-    },
-    id: { canFilter: true, canSort: false },
-    createdAt: { canFilter: true, canSort: true },
-};
-const eventRepository = new EventRepository();
-export { EventRepository, eventRepository };
-export { EventRepository as EventsRepository };

package/dist/features/events/schemas/firestore.d.ts

@@ -1,115 +0,0 @@
-/**
- * Events Firestore Document Types & Constants
- */
-import type { MediaField } from "../../media/types";
-import type { EventType, EventStatus, EntryReviewStatus, SaleConfig, OfferConfig, PollConfig, SurveyConfig, FeedbackConfig } from "../types";
-export declare const EVENTS_COLLECTION: "events";
-export declare const EVENT_ENTRIES_COLLECTION: "eventEntries";
-export interface EventDocument {
-    id: string;
-    type: EventType;
-    title: string;
-    description: string;
-    status: EventStatus;
-    startsAt: Date;
-    endsAt: Date;
-    coverImage?: MediaField | null;
-    coverImageUrl?: string;
-    eventImages?: MediaField[];
-    winnerImages?: MediaField[];
-    additionalImages?: MediaField[];
-    tags?: string[];
-    saleConfig?: SaleConfig;
-    offerConfig?: OfferConfig;
-    pollConfig?: PollConfig;
-    surveyConfig?: SurveyConfig;
-    feedbackConfig?: FeedbackConfig;
-    stats: {
-        totalEntries: number;
-        approvedEntries: number;
-        flaggedEntries: number;
-    };
-    createdBy: string;
-    createdAt: Date;
-    updatedAt: Date;
-}
-export interface EventEntryDocument {
-    id: string;
-    eventId: string;
-    userId?: string;
-    userDisplayName?: string;
-    userEmail?: string;
-    pollVotes?: string[];
-    pollComment?: string;
-    formResponses?: Record<string, unknown>;
-    reviewStatus: EntryReviewStatus;
-    reviewedBy?: string;
-    reviewedAt?: Date;
-    reviewNote?: string;
-    points?: number;
-    ipAddress?: string;
-    submittedAt: Date;
-}
-export declare const EVENT_INDEXED_FIELDS: readonly ["type", "status", "startsAt", "endsAt", "createdAt"];
-export declare const EVENT_ENTRY_INDEXED_FIELDS: readonly ["eventId", "userId", "reviewStatus", "submittedAt", "points"];
-export declare const EVENT_FIELDS: {
-    readonly ID: "id";
-    readonly TYPE: "type";
-    readonly TITLE: "title";
-    readonly DESCRIPTION: "description";
-    readonly STATUS: "status";
-    readonly STARTS_AT: "startsAt";
-    readonly ENDS_AT: "endsAt";
-    readonly COVER_IMAGE_URL: "coverImageUrl";
-    readonly COVER_IMAGE: "coverImage";
-    readonly EVENT_IMAGES: "eventImages";
-    readonly WINNER_IMAGES: "winnerImages";
-    readonly ADDITIONAL_IMAGES: "additionalImages";
-    readonly TAGS: "tags";
-    readonly CREATED_BY: "createdBy";
-    readonly CREATED_AT: "createdAt";
-    readonly UPDATED_AT: "updatedAt";
-    readonly STATUS_VALUES: {
-        readonly DRAFT: EventStatus;
-        readonly ACTIVE: EventStatus;
-        readonly PAUSED: EventStatus;
-        readonly ENDED: EventStatus;
-    };
-    readonly TYPE_VALUES: {
-        readonly SALE: EventType;
-        readonly OFFER: EventType;
-        readonly POLL: EventType;
-        readonly SURVEY: EventType;
-        readonly FEEDBACK: EventType;
-    };
-    readonly STATS: {
-        readonly TOTAL_ENTRIES: "stats.totalEntries";
-        readonly APPROVED_ENTRIES: "stats.approvedEntries";
-        readonly FLAGGED_ENTRIES: "stats.flaggedEntries";
-    };
-};
-export declare const EVENT_ENTRY_FIELDS: {
-    readonly ID: "id";
-    readonly EVENT_ID: "eventId";
-    readonly USER_ID: "userId";
-    readonly REVIEW_STATUS: "reviewStatus";
-    readonly REVIEWED_BY: "reviewedBy";
-    readonly REVIEWED_AT: "reviewedAt";
-    readonly SUBMITTED_AT: "submittedAt";
-    readonly POINTS: "points";
-    readonly REVIEW_STATUS_VALUES: {
-        readonly PENDING: EntryReviewStatus;
-        readonly APPROVED: EntryReviewStatus;
-        readonly FLAGGED: EntryReviewStatus;
-    };
-};
-export type EventCreateInput = Omit<EventDocument, "id" | "createdAt" | "updatedAt" | "stats">;
-export type EventUpdateInput = Partial<Omit<EventDocument, "id" | "createdAt" | "createdBy">>;
-export type EventEntryCreateInput = Omit<EventEntryDocument, "id" | "submittedAt">;
-export declare const eventQueryHelpers: {
-    readonly active: () => readonly ["status", "==", EventStatus];
-    readonly byType: (type: EventType) => readonly ["type", "==", EventType];
-    readonly byStatus: (status: EventStatus) => readonly ["status", "==", EventStatus];
-    readonly upcoming: (date: Date) => readonly ["startsAt", ">", Date];
-    readonly past: (date: Date) => readonly ["endsAt", "<", Date];
-};