@vicacha-devs/strapi-plugin-events 0.0.0-stage → 1.0.0

package/dist/server/src/services/index.d.ts

@@ -0,0 +1,110 @@
+declare const _default: {
+    settings: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => {
+        ensureInitialized(): Promise<import('..').EventsPluginSettings>;
+        getSettings(): Promise<import('..').EventsPluginSettings>;
+        updateSettings(patch: Partial<import('..').EventsPluginSettings>): Promise<import('..').EventsPluginSettings>;
+    };
+    occurrence: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => {
+        registerCalendarFormatter(calendarId: string, formatter: import('../../../shared/types').CalendarSystemFormatterFn): void;
+        unregisterCalendarFormatter(calendarId: string): void;
+        formatDateInCalendarSystem(isoOrDateKey: string, system: import('../../../shared/types').CalendarSystemConfig, locale?: string, options?: {
+            compact?: boolean;
+        }): string;
+        getOccurrences(params: import('./occurrencePayloadHelpers').GetOccurrencesParams): Promise<import('..').ExpandedOccurrence[]>;
+        getActiveSpotlights(params?: {
+            date?: string;
+            locale?: string;
+            sourceId?: string;
+            category?: string;
+            includeDrafts?: boolean;
+        } & import('../types').PaginationParams): Promise<import('..').ExpandedOccurrence[]>;
+        rescheduleOccurrence(params: {
+            sourceId?: string;
+            uid?: string;
+            documentId: string;
+            occurrenceDate: string;
+            newStartDate: string;
+            newEndDate?: string;
+            applyToSeries?: boolean;
+            cancelOccurrence?: boolean;
+        }): Promise<Record<string, unknown>>;
+        quickCreateEvent(params: {
+            sourceId?: string;
+            title: string;
+            startDate: string;
+            endDate?: string;
+            location?: string;
+            category?: string;
+            summary?: string;
+            rrule?: string;
+            rsvpEnabled?: boolean;
+            capacity?: number;
+        }): Promise<Record<string, unknown>>;
+    };
+    rsvp: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => {
+        getEventStats(params: {
+            eventUid?: string;
+            eventDocumentId: string;
+            occurrenceDate?: string | null;
+            capacityOverride?: number | null;
+            waitlistOverride?: boolean;
+            rsvpEnabledOverride?: boolean;
+            includeDrafts?: boolean;
+        }): Promise<import('..').RsvpStats>;
+        registerAttendee(eventDocumentId: string, input: import('..').RsvpRegistrationInput): Promise<import('..').RsvpRegistrationRecord & {
+            cancellationToken: string;
+        }>;
+        promoteFromWaitlist(params: {
+            eventUid: string;
+            eventDocumentId: string;
+            occurrenceDate: string;
+        }): Promise<import('..').RsvpRegistrationRecord[]>;
+        cancelByToken(token: string): Promise<{
+            cancelled: import('..').RsvpRegistrationRecord;
+            promotedCount: number;
+        }>;
+        updateRegistrationStatus(registrationDocumentId: string, newStatus: import('..').RsvpStatus): Promise<{
+            registration: import('..').RsvpRegistrationRecord;
+            promotedCount: number;
+        }>;
+        checkInAttendee(identifier: {
+            documentId?: string;
+            token?: string;
+        }): Promise<import('..').RsvpRegistrationRecord>;
+        listRegistrations(filters?: {
+            eventDocumentId?: string;
+            occurrenceDate?: string;
+            status?: import('..').RsvpStatus;
+            search?: string;
+        } & import('../types').PaginationParams): Promise<import('..').RsvpRegistrationRecord[]>;
+        exportRegistrationsCsv(filters?: {
+            eventDocumentId?: string;
+            occurrenceDate?: string;
+            status?: import('..').RsvpStatus;
+        }): Promise<string>;
+        formatRegistrationRecord: typeof import('./rsvpHelpers').formatRegistrationRecord;
+    };
+    ical: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => {
+        generateFeedIcs(params?: {
+            from?: string;
+            to?: string;
+            category?: string;
+            sourceId?: string;
+            locale?: string;
+        }): Promise<string>;
+        generateEventInviteIcs(params: {
+            documentId: string;
+            occurrenceDate?: string;
+            locale?: string;
+        }): Promise<string>;
+    };
+};
+export default _default;

package/dist/server/src/services/occurrence.d.ts

@@ -0,0 +1,44 @@
+import { Core } from '@strapi/strapi';
+import { CalendarSystemConfig, CalendarSystemFormatterFn, ExpandedOccurrence } from '../../../shared/types';
+import { PaginationParams } from '../types';
+import { GetOccurrencesParams } from './occurrenceHelpers';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    registerCalendarFormatter(calendarId: string, formatter: CalendarSystemFormatterFn): void;
+    unregisterCalendarFormatter(calendarId: string): void;
+    formatDateInCalendarSystem(isoOrDateKey: string, system: CalendarSystemConfig, locale?: string, options?: {
+        compact?: boolean;
+    }): string;
+    getOccurrences(params: GetOccurrencesParams): Promise<ExpandedOccurrence[]>;
+    getActiveSpotlights(params?: {
+        date?: string;
+        locale?: string;
+        sourceId?: string;
+        category?: string;
+        includeDrafts?: boolean;
+    } & PaginationParams): Promise<ExpandedOccurrence[]>;
+    rescheduleOccurrence(params: {
+        sourceId?: string;
+        uid?: string;
+        documentId: string;
+        occurrenceDate: string;
+        newStartDate: string;
+        newEndDate?: string;
+        applyToSeries?: boolean;
+        cancelOccurrence?: boolean;
+    }): Promise<Record<string, unknown>>;
+    quickCreateEvent(params: {
+        sourceId?: string;
+        title: string;
+        startDate: string;
+        endDate?: string;
+        location?: string;
+        category?: string;
+        summary?: string;
+        rrule?: string;
+        rsvpEnabled?: boolean;
+        capacity?: number;
+    }): Promise<Record<string, unknown>>;
+};
+export default _default;

package/dist/server/src/services/occurrenceHelpers.d.ts

@@ -0,0 +1,16 @@
+import { Core } from '@strapi/strapi';
+import { EventSourceMapping, EventsPluginSettings, ExpandedOccurrence } from '../../../shared/types';
+import { GetOccurrencesParams, assertValidIsoDateTime, buildQuickCreatePayload, resolveOccurrenceWindow, resolveQuickCreateSource } from './occurrencePayloadHelpers';
+import { PendingOccurrenceRsvpMeta } from './occurrenceRsvpBatch';
+export { type GetOccurrencesParams, assertValidIsoDateTime, buildQuickCreatePayload, resolveOccurrenceWindow, resolveQuickCreateSource, };
+export declare function fetchDocumentsForSource(strapi: Core.Strapi, source: EventSourceMapping, params: GetOccurrencesParams, settings: EventsPluginSettings): Promise<Array<Record<string, unknown>>>;
+export declare function expandDocumentOccurrencesSync(args: {
+    strapi: Core.Strapi;
+    doc: Record<string, unknown>;
+    source: EventSourceMapping;
+    params: GetOccurrencesParams;
+    settings: EventsPluginSettings;
+    windowStart: string;
+    windowEnd: string;
+    pendingRsvpMap: Map<string, PendingOccurrenceRsvpMeta>;
+}): ExpandedOccurrence[];

package/dist/server/src/services/occurrencePayloadHelpers.d.ts

@@ -0,0 +1,30 @@
+import { EventSourceMapping, EventsPluginSettings } from '../../../shared/types';
+import { PaginationParams } from '../types';
+export interface GetOccurrencesParams extends PaginationParams {
+    from?: string;
+    to?: string;
+    locale?: string;
+    category?: string;
+    sourceId?: string;
+    documentId?: string;
+    includeDrafts?: boolean;
+    onlySpotlights?: boolean;
+}
+export declare function assertValidIsoDateTime(raw: unknown, fieldName: string): number;
+export declare function resolveOccurrenceWindow(params: GetOccurrencesParams): {
+    windowStart: string;
+    windowEnd: string;
+    isEmptyWindow: boolean;
+};
+export declare function resolveQuickCreateSource(settings: EventsPluginSettings, sourceId?: string): EventSourceMapping;
+export declare function buildQuickCreatePayload(source: EventSourceMapping, settings: EventsPluginSettings, params: {
+    title: string;
+    startDate: string;
+    endDate?: string;
+    location?: string;
+    category?: string;
+    summary?: string;
+    rrule?: string;
+    rsvpEnabled?: boolean;
+    capacity?: number;
+}): Record<string, unknown>;

package/dist/server/src/services/occurrenceRsvpBatch.d.ts

@@ -0,0 +1,25 @@
+import { Core } from '@strapi/strapi';
+import { ExpandedOccurrence } from '../../../shared/types';
+/**
+ * Strictly restricts mapped event sources to `api::*` content types
+ * and the built-in `plugin::events.event` collection type.
+ */
+export declare function isAllowedEventSourceUid(uid: unknown): uid is string;
+/**
+ * Extracts configured custom fields while stripping `private: true` schema
+ * attributes, sensitive credential/token fields, and prototype-pollution keys.
+ */
+export declare function extractCustomFields(strapi: Core.Strapi, sourceUid: string, doc: Record<string, unknown>, customFieldKeys?: string[]): Record<string, unknown> | undefined;
+export interface PendingOccurrenceRsvpMeta {
+    eventUid: string;
+    eventDocumentId: string;
+    occurrenceDate: string;
+    capacity: number | null;
+    waitlistEnabled: boolean;
+    rsvpEnabled: boolean;
+}
+/**
+ * Populates `occ.rsvp` across all expanded occurrences using a single batched
+ * database query aggregated in memory in O(N) instead of N+1 queries.
+ */
+export declare function attachBatchedRsvpStats(strapi: Core.Strapi, occurrences: ExpandedOccurrence[], pendingByOccurrenceId: Map<string, PendingOccurrenceRsvpMeta>): Promise<void>;

package/dist/server/src/services/rsvp.d.ts

@@ -0,0 +1,51 @@
+import { Core } from '@strapi/strapi';
+import { RsvpRegistrationInput, RsvpRegistrationRecord, RsvpStats, RsvpStatus } from '../../../shared/types';
+import { PaginationParams } from '../types';
+import { formatRegistrationRecord, maskEmail } from './rsvpHelpers';
+export { maskEmail };
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getEventStats(params: {
+        eventUid?: string;
+        eventDocumentId: string;
+        occurrenceDate?: string | null;
+        capacityOverride?: number | null;
+        waitlistOverride?: boolean;
+        rsvpEnabledOverride?: boolean;
+        includeDrafts?: boolean;
+    }): Promise<RsvpStats>;
+    registerAttendee(eventDocumentId: string, input: RsvpRegistrationInput): Promise<RsvpRegistrationRecord & {
+        cancellationToken: string;
+    }>;
+    promoteFromWaitlist(params: {
+        eventUid: string;
+        eventDocumentId: string;
+        occurrenceDate: string;
+    }): Promise<RsvpRegistrationRecord[]>;
+    cancelByToken(token: string): Promise<{
+        cancelled: RsvpRegistrationRecord;
+        promotedCount: number;
+    }>;
+    updateRegistrationStatus(registrationDocumentId: string, newStatus: RsvpStatus): Promise<{
+        registration: RsvpRegistrationRecord;
+        promotedCount: number;
+    }>;
+    checkInAttendee(identifier: {
+        documentId?: string;
+        token?: string;
+    }): Promise<RsvpRegistrationRecord>;
+    listRegistrations(filters?: {
+        eventDocumentId?: string;
+        occurrenceDate?: string;
+        status?: RsvpStatus;
+        search?: string;
+    } & PaginationParams): Promise<RsvpRegistrationRecord[]>;
+    exportRegistrationsCsv(filters?: {
+        eventDocumentId?: string;
+        occurrenceDate?: string;
+        status?: RsvpStatus;
+    }): Promise<string>;
+    formatRegistrationRecord: typeof formatRegistrationRecord;
+};
+export default _default;

package/dist/server/src/services/rsvpHelpers.d.ts

@@ -0,0 +1,52 @@
+import { Core } from '@strapi/strapi';
+import { EventLifecycleStatus, RRuleFieldValue, RsvpRegistrationInput, RsvpRegistrationRecord, RsvpStats, RsvpStatus } from '../../../shared/types';
+export interface ResolvedTargetEvent {
+    uid: string;
+    documentId: string;
+    title: string;
+    startDate: string;
+    endDate: string | null;
+    allDay: boolean;
+    recurrence: RRuleFieldValue;
+    eventStatus: EventLifecycleStatus;
+    rsvpEnabled: boolean;
+    capacity: number | null;
+    waitlistEnabled: boolean;
+    maxGuestsPerRegistration: number;
+    registrationDeadline: string | null;
+}
+export declare function maskEmail(email: string): string;
+export declare function readNullablePositiveInt(val: unknown): number | null;
+export declare function resolveTargetEvent(strapi: Core.Strapi, eventDocumentId: string, preferredUid?: string, options?: {
+    includeDrafts?: boolean;
+}): Promise<ResolvedTargetEvent | null>;
+export declare function readStoredGuestsCount(val: unknown): number;
+export declare function assertValidGuestsCount(val: unknown): number;
+export declare function formatRegistrationRecord(raw: Record<string, unknown>): RsvpRegistrationRecord;
+export declare function aggregateRsvpCounts(records: Array<Record<string, unknown>>): Pick<RsvpStats, "confirmedCount" | "confirmedSeats" | "checkedInSeats" | "waitlistedCount" | "waitlistedSeats" | "cancelledCount">;
+export declare function validateRegistrationInputAndEvent(input: RsvpRegistrationInput, targetEvent: ResolvedTargetEvent): {
+    attendeeName: string;
+    attendeeEmail: string;
+    guestsCount: number;
+};
+export declare function resolveAssignedRsvpStatus(targetEvent: ResolvedTargetEvent, confirmedSeats: number, guestsCount: number): RsvpStatus;
+export declare function trySendNotificationEmail(strapi: Core.Strapi, payload: {
+    to: string;
+    attendeeName: string;
+    eventTitle: string;
+    occurrenceDate: string;
+    guestsCount: number;
+    status: RsvpStatus;
+    promotedFromWaitlist?: boolean;
+}): Promise<void>;
+export declare function buildRegistrationCreateData(args: {
+    targetEvent: ResolvedTargetEvent;
+    eventDocumentId: string;
+    occurrenceDate: string;
+    attendeeName: string;
+    attendeeEmail: string;
+    guestsCount: number;
+    assignedStatus: RsvpStatus;
+    tokenHash: string;
+    input: RsvpRegistrationInput;
+}): Record<string, unknown>;

package/dist/server/src/services/rsvpMutations.d.ts

@@ -0,0 +1,34 @@
+import { Core } from '@strapi/strapi';
+import { RsvpRegistrationRecord, RsvpStatus } from '../../../shared/types';
+import { ResolvedTargetEvent } from './rsvpHelpers';
+export interface EmailQueueItem {
+    to: string;
+    attendeeName: string;
+    eventTitle: string;
+    occurrenceDate: string;
+    guestsCount: number;
+    status: RsvpStatus;
+    promotedFromWaitlist?: boolean;
+}
+export declare function fetchRegistrationRecordsSafe(strapi: Core.Strapi, eventDocumentId: string, occurrenceDate: string | null): Promise<Array<Record<string, unknown>>>;
+export declare function promoteFromWaitlistUnlocked(strapi: Core.Strapi, params: {
+    eventUid: string;
+    eventDocumentId: string;
+    occurrenceDate: string;
+    targetEventOverride?: ResolvedTargetEvent | null;
+}): Promise<{
+    promoted: RsvpRegistrationRecord[];
+    emails: EmailQueueItem[];
+}>;
+export declare function executeCancelByToken(strapi: Core.Strapi, token: string): Promise<{
+    cancelled: RsvpRegistrationRecord;
+    promotedCount: number;
+}>;
+export declare function executeUpdateRegistrationStatus(strapi: Core.Strapi, registrationDocumentId: string, newStatus: RsvpStatus): Promise<{
+    registration: RsvpRegistrationRecord;
+    promotedCount: number;
+}>;
+export declare function executeCheckInAttendee(strapi: Core.Strapi, identifier: {
+    documentId?: string;
+    token?: string;
+}): Promise<RsvpRegistrationRecord>;

package/dist/server/src/services/rsvpSecurity.d.ts

@@ -0,0 +1,22 @@
+import { Core } from '@strapi/strapi';
+import { ResolvedTargetEvent } from './rsvpHelpers';
+export declare function generateRawRsvpToken(): string;
+export declare function hashRsvpToken(rawToken: string): string;
+export declare function verifyTokenHashConstantTime(candidateHash: string, storedValue: unknown): boolean;
+export declare function findRegistrationByRawToken(strapi: Core.Strapi, rawToken: string): Promise<{
+    record: Record<string, unknown>;
+    tokenHash: string;
+} | null>;
+export declare function clearOccurrenceLocks(strapi: Core.Strapi): void;
+/**
+ * Serializes mutations per `(eventDocumentId, occurrenceDate)` scoped per
+ * Strapi instance and wraps inside `strapi.db.transaction` when available.
+ */
+export declare function withOccurrenceLock<T>(strapi: Core.Strapi, eventDocumentId: string, occurrenceDate: string, fn: () => Promise<T>): Promise<T>;
+/**
+ * Verifies that `occurrenceDate` is a valid calendar YYYY-MM-DD and matches
+ * an actual scheduled (non-excluded, non-cancelled) occurrence of `targetEvent`.
+ * Returns the occurrence's effective end timestamp in ms when determinable.
+ */
+export declare function assertScheduledOccurrence(targetEvent: ResolvedTargetEvent, occurrenceDate: string): number | null;
+export declare function resolveValidatedOccurrenceDate(inputDate: string | undefined, targetEvent: ResolvedTargetEvent): string;

package/dist/server/src/services/settings.d.ts

@@ -0,0 +1,10 @@
+import { Core } from '@strapi/strapi';
+import { EventsPluginSettings } from '../../../shared/types';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    ensureInitialized(): Promise<EventsPluginSettings>;
+    getSettings(): Promise<EventsPluginSettings>;
+    updateSettings(patch: Partial<EventsPluginSettings>): Promise<EventsPluginSettings>;
+};
+export default _default;

package/dist/server/src/types.d.ts

@@ -0,0 +1,171 @@
+import { Core } from '@strapi/strapi';
+import { CalendarSystemConfig, CalendarSystemFormatterFn, EventsPluginSettings, ExpandedOccurrence, RsvpRegistrationInput, RsvpRegistrationRecord, RsvpStats, RsvpStatus } from '../../shared/types';
+export declare class PluginValidationError extends Error {
+    readonly statusCode = 400;
+    constructor(message: string);
+}
+export declare class PluginNotFoundError extends Error {
+    readonly statusCode = 404;
+    constructor(message: string);
+}
+export interface StrapiKoaContext {
+    query?: Record<string, unknown>;
+    params?: Record<string, string | undefined>;
+    request?: {
+        body?: Record<string, unknown>;
+    };
+    status?: number;
+    body?: unknown;
+    set: (header: string, value: string) => void;
+    badRequest: (message: string, details?: unknown) => unknown;
+    notFound?: (message?: string, details?: unknown) => unknown;
+}
+export interface PaginationParams {
+    limit?: number;
+    page?: number;
+    pageSize?: number;
+}
+export interface StrapiDocumentQueryOptions {
+    filters?: Record<string, unknown>;
+    sort?: string | string[] | Record<string, "asc" | "desc">;
+    limit?: number;
+    locale?: string;
+    status?: "draft" | "published";
+    populate?: Record<string, unknown> | string[];
+}
+export interface StrapiDocumentServiceClient {
+    findMany: (options?: StrapiDocumentQueryOptions) => Promise<Array<Record<string, unknown>>>;
+    findOne: (options: {
+        documentId: string;
+        locale?: string;
+        status?: "draft" | "published";
+    }) => Promise<Record<string, unknown> | null>;
+    create: (options: {
+        data: Record<string, unknown>;
+        locale?: string;
+        status?: "draft" | "published";
+    }) => Promise<Record<string, unknown>>;
+    update: (options: {
+        documentId: string;
+        data: Record<string, unknown>;
+        locale?: string;
+        status?: "draft" | "published";
+    }) => Promise<Record<string, unknown>>;
+}
+export interface EventsSettingsService {
+    ensureInitialized: () => Promise<EventsPluginSettings>;
+    getSettings: () => Promise<EventsPluginSettings>;
+    updateSettings: (patch: Partial<EventsPluginSettings>) => Promise<EventsPluginSettings>;
+}
+export interface EventsOccurrenceService {
+    registerCalendarFormatter: (calendarId: string, formatter: CalendarSystemFormatterFn) => void;
+    unregisterCalendarFormatter: (calendarId: string) => void;
+    formatDateInCalendarSystem: (isoOrDateKey: string, system: CalendarSystemConfig, locale?: string, options?: {
+        compact?: boolean;
+    }) => string;
+    getOccurrences: (params: {
+        from?: string;
+        to?: string;
+        locale?: string;
+        category?: string;
+        sourceId?: string;
+        documentId?: string;
+        includeDrafts?: boolean;
+        onlySpotlights?: boolean;
+    } & PaginationParams) => Promise<ExpandedOccurrence[]>;
+    getActiveSpotlights: (params?: {
+        date?: string;
+        locale?: string;
+        sourceId?: string;
+        category?: string;
+        includeDrafts?: boolean;
+    } & PaginationParams) => Promise<ExpandedOccurrence[]>;
+    rescheduleOccurrence: (params: {
+        sourceId?: string;
+        uid?: string;
+        documentId: string;
+        occurrenceDate: string;
+        newStartDate: string;
+        newEndDate?: string;
+        applyToSeries?: boolean;
+        cancelOccurrence?: boolean;
+    }) => Promise<Record<string, unknown>>;
+    quickCreateEvent: (params: {
+        sourceId?: string;
+        title: string;
+        startDate: string;
+        endDate?: string;
+        location?: string;
+        category?: string;
+        summary?: string;
+        rrule?: string;
+        rsvpEnabled?: boolean;
+        capacity?: number;
+    }) => Promise<Record<string, unknown>>;
+}
+export interface EventsRsvpService {
+    getEventStats: (params: {
+        eventUid?: string;
+        eventDocumentId: string;
+        occurrenceDate?: string | null;
+        capacityOverride?: number | null;
+        waitlistOverride?: boolean;
+        rsvpEnabledOverride?: boolean;
+        includeDrafts?: boolean;
+    }) => Promise<RsvpStats>;
+    registerAttendee: (eventDocumentId: string, input: RsvpRegistrationInput) => Promise<RsvpRegistrationRecord & {
+        cancellationToken: string;
+    }>;
+    promoteFromWaitlist: (params: {
+        eventUid: string;
+        eventDocumentId: string;
+        occurrenceDate: string;
+    }) => Promise<RsvpRegistrationRecord[]>;
+    cancelByToken: (token: string) => Promise<{
+        cancelled: RsvpRegistrationRecord;
+        promotedCount: number;
+    }>;
+    updateRegistrationStatus: (registrationDocumentId: string, newStatus: RsvpStatus) => Promise<{
+        registration: RsvpRegistrationRecord;
+        promotedCount: number;
+    }>;
+    checkInAttendee: (identifier: {
+        documentId?: string;
+        token?: string;
+    }) => Promise<RsvpRegistrationRecord>;
+    listRegistrations: (filters?: {
+        eventDocumentId?: string;
+        occurrenceDate?: string;
+        status?: RsvpStatus;
+        search?: string;
+    } & PaginationParams) => Promise<RsvpRegistrationRecord[]>;
+    exportRegistrationsCsv: (filters?: {
+        eventDocumentId?: string;
+        occurrenceDate?: string;
+        status?: RsvpStatus;
+    }) => Promise<string>;
+}
+export interface EventsIcalService {
+    generateFeedIcs: (params?: {
+        from?: string;
+        to?: string;
+        category?: string;
+        sourceId?: string;
+        locale?: string;
+    }) => Promise<string>;
+    generateEventInviteIcs: (params: {
+        documentId: string;
+        occurrenceDate?: string;
+        locale?: string;
+    }) => Promise<string>;
+}
+export declare function getDocumentsClient(strapi: Core.Strapi, uid: string): StrapiDocumentServiceClient;
+export declare function getSettingsService(strapi: Core.Strapi): EventsSettingsService;
+export declare function getOccurrenceService(strapi: Core.Strapi): EventsOccurrenceService;
+export declare function getRsvpService(strapi: Core.Strapi): EventsRsvpService;
+export declare function getIcalService(strapi: Core.Strapi): EventsIcalService;
+export declare function clampPaginatedSlice<T>(items: T[], params?: PaginationParams & {
+    defaultLimit?: number;
+    maxLimit?: number;
+}): T[];
+export declare function handleControllerError(strapi: Core.Strapi, ctx: StrapiKoaContext, err: unknown, fallbackMessage: string): unknown;

package/dist/shared/calendarSystems.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Re-exports multi-calendar systems (CLDR + custom formatters) from
+ * @vicacha-devs/strapi-plugin-calendar so strapi-plugin-events shares a single
+ * calendar engine across the monorepo.
+ */
+export { SUPPORTED_INTL_CALENDARS, applyDayOffset, extractCalendarParts, formatDateInCalendarSystem, getRegisteredCalendarFormatters, registerCalendarSystemFormatter, resolveOccurrenceAlternateDates, unregisterCalendarSystemFormatter, } from '../../strapi-plugin-calendar/shared/index.ts';

package/dist/shared/icalGenerator.d.ts

@@ -0,0 +1,25 @@
+import { CalendarLinkSet, ExpandedOccurrence, RsvpRegistrationRecord } from './types';
+export declare function toIcsTimestamp(isoString: string, allDay?: boolean): string;
+export declare function escapeIcsText(value: string | undefined | null): string;
+/**
+ * Folds an iCalendar line at 75 UTF-8 octets per RFC 5545 Section 3.1,
+ * iterating over Unicode code points so surrogate pairs are never split.
+ */
+export declare function foldIcsLine(line: string): string;
+export declare function buildCalendarLinks(params: {
+    documentId: string;
+    title: string;
+    startDate: string;
+    endDate: string;
+    allDay?: boolean;
+    summary?: string;
+    location?: string;
+    occurrenceDate?: string;
+}): CalendarLinkSet;
+export declare function generateIcsCalendar(occurrences: ExpandedOccurrence[], feedTitle?: string): string;
+/**
+ * Prevents CSV Formula Injection (CWE-1236) including leading-whitespace
+ * bypasses and escapes quotes/newlines.
+ */
+export declare function sanitizeCsvCell(raw: unknown): string;
+export declare function generateRegistrationsCsv(records: RsvpRegistrationRecord[]): string;

package/dist/shared/index.d.ts

@@ -0,0 +1,6 @@
+export * from './calendarSystems';
+export * from './icalGenerator';
+export * from './pluginId';
+export * from './rruleEngine';
+export * from './spotlightHelpers';
+export * from './types';