@openinc/parse-server-opendash 4.0.28 → 4.0.30

package/dist/features/openservice/schedules/calendarSync/service/CalendarSyncPoller.js

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarSyncPoller = void 0;
+const node_1 = __importDefault(require("parse/node"));
+const eventToSchedule_js_1 = require("../functions/eventToSchedule.js");
+const calendarMetaHelper_js_1 = require("./calendarMetaHelper.js");
+const CalendarManager_js_1 = require("./CalendarManager.js");
+const index_js_1 = require("../../../../../types/index.js");
+class CalendarSyncPoller {
+    timer = null;
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    get manager() {
+        const configValues = JSON.parse(this.config.get("value"));
+        return new CalendarManager_js_1.CalendarManager({
+            tenantId: configValues.tenant_id,
+            clientID: configValues.client_id,
+            clientSecret: configValues.client_secret,
+            userMail: configValues.user_email,
+        });
+    }
+    /**
+     * Start polling the Microsoft Calendar delta feed.
+     * @param intervalMs polling interval in milliseconds (default: 5 minutes)
+     */
+    start(intervalMs = 5 * 60 * 1000) {
+        if (this.manager?.isValid !== true) {
+            console.error(`[CalendarSyncPoller] Not started — invalid configuration: ${this.manager?.isValid}`);
+            return;
+        }
+        this.poll().catch(console.error);
+        this.timer = setInterval(() => this.poll().catch(console.error), intervalMs);
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+    }
+    async poll() {
+        const deltaLink = await this.loadDeltaLink();
+        const result = await this.manager?.fetchDelta(deltaLink);
+        if (!result) {
+            console.error("[CalendarSyncPoller] Failed to fetch calendar delta.");
+            return;
+        }
+        for (const event of result.events) {
+            try {
+                await this.processEvent(event);
+            }
+            catch (err) {
+                console.error("[CalendarSyncPoller] Error processing event:", event.id, err);
+            }
+        }
+        await this.saveDeltaLink(result.deltaLink);
+    }
+    async processEvent(event) {
+        if (event["@removed"]) {
+            await this.handleDeleted(event.id);
+            return;
+        }
+        // Exception events are individual moved/edited occurrences of a series.
+        // The series master handles the recurrence as a whole; exceptions are noise.
+        if (event.type === "exception")
+            return;
+        const metaEntry = await (0, calendarMetaHelper_js_1.findCalendarMetaByEventId)(event.id);
+        if (metaEntry) {
+            const storedChangeKey = metaEntry.get("values")?.microsoftCalendarChangeKey;
+            // Skip if we caused this change (our write already stored this changeKey)
+            if (event.changeKey && storedChangeKey === event.changeKey)
+                return;
+            await this.updateScheduleFromEvent(metaEntry, event);
+        }
+        else {
+            // Delta responses omit most properties; fetch the full event before creating a schedule
+            const fullEvent = await this.manager?.fetchEvent(event.id);
+            if (!fullEvent)
+                return;
+            await this.createScheduleFromEvent(fullEvent);
+        }
+    }
+    async updateScheduleFromEvent(metaEntry, event) {
+        const scheduleId = metaEntry.get("entryObjectId");
+        if (!scheduleId)
+            return;
+        // Delta responses omit most fields; fetch the full event for title/body/cron
+        const fullEvent = (await this.manager?.fetchEvent(event.id)) ?? event;
+        const schedule = await new node_1.default.Query(index_js_1.Maintenance_Schedule).get(scheduleId, { useMasterKey: true });
+        if (fullEvent.subject)
+            schedule.set("title", fullEvent.subject);
+        if (fullEvent.bodyPreview)
+            schedule.set("description", fullEvent.bodyPreview);
+        const cronData = (0, eventToSchedule_js_1.eventToSchedule)(fullEvent);
+        if (cronData) {
+            const { notifyBeforeDue, ...cron } = cronData;
+            schedule.set("cron", cron);
+            if (notifyBeforeDue != null)
+                schedule.set("notifyBeforeDue", notifyBeforeDue);
+        }
+        // useMasterKey prevents afterSaveHook from re-syncing back to calendar
+        await schedule.save(null, { useMasterKey: true });
+        if (event.changeKey) {
+            await (0, calendarMetaHelper_js_1.updateCalendarChangeKey)(metaEntry, event.changeKey, fullEvent);
+        }
+    }
+    async createScheduleFromEvent(event) {
+        const parsed = parseEventSubject(event.subject);
+        let source;
+        const tenant = this.config.get("tenant");
+        if (parsed) {
+            source = await new node_1.default.Query(index_js_1.Source)
+                .equalTo("name", parsed.sourceName)
+                .equalTo("tenant", tenant)
+                .first({ useMasterKey: true });
+        }
+        if (!source) {
+            const configValues = JSON.parse(this.config.get("value"));
+            if (!configValues.default_source_id) {
+                console.error(`[CalendarSyncPoller] Skipping event ${event.id} — no source name in subject and no default_source_id configured.`);
+                return;
+            }
+            source = await new node_1.default.Query(index_js_1.Source)
+                .equalTo("objectId", configValues.default_source_id)
+                .first({ useMasterKey: true });
+            if (!source) {
+                console.error(`[CalendarSyncPoller] Skipping event ${event.id} — default source "${configValues.default_source_id}" not found.`);
+                return;
+            }
+        }
+        const schedule = new index_js_1.Maintenance_Schedule();
+        schedule.set("title", event.subject);
+        schedule.set("source", source);
+        schedule.set("enabled", true);
+        schedule.set("tenant", tenant);
+        if (event.bodyPreview)
+            schedule.set("description", event.bodyPreview);
+        const cronData = (0, eventToSchedule_js_1.eventToSchedule)(event);
+        if (cronData) {
+            const { notifyBeforeDue, ...cron } = cronData;
+            schedule.set("cron", cron);
+            if (notifyBeforeDue != null)
+                schedule.set("notifyBeforeDue", notifyBeforeDue);
+        }
+        // useMasterKey prevents afterSaveHook from syncing back to calendar
+        await schedule.save(null, { useMasterKey: true });
+        await (0, calendarMetaHelper_js_1.saveCalendarMeta)(schedule.id, event.id, event.changeKey, tenant, event);
+    }
+    async handleDeleted(eventId) {
+        const metaEntry = await (0, calendarMetaHelper_js_1.findCalendarMetaByEventId)(eventId);
+        if (!metaEntry)
+            return;
+        const scheduleId = metaEntry.get("entryObjectId");
+        if (scheduleId) {
+            try {
+                const schedule = await new node_1.default.Query(index_js_1.Maintenance_Schedule).get(scheduleId, { useMasterKey: true });
+                // Disable rather than delete to preserve execution history
+                schedule.set("enabled", false);
+                await schedule.save(null, { useMasterKey: true });
+            }
+            catch (err) {
+                console.error("[CalendarSyncPoller] Could not disable schedule for deleted event:", scheduleId, err);
+            }
+        }
+        await metaEntry.destroy({ useMasterKey: true });
+    }
+    async loadDeltaLink() {
+        this.config = await this.config.fetch({ useMasterKey: true });
+        const values = JSON.parse(this.config.get("value"));
+        return values.delta_link;
+    }
+    async saveDeltaLink(link) {
+        this.config = await this.config.fetch({ useMasterKey: true });
+        const values = JSON.parse(this.config.get("value"));
+        values.delta_link = link;
+        this.config.set("value", JSON.stringify(values));
+        await this.config.save(null, { useMasterKey: true });
+    }
+}
+exports.CalendarSyncPoller = CalendarSyncPoller;
+// Parses the source name out of an Outlook-originated event subject.
+// Expected format for externally-created events: "<source.name>" - <anything>
+// Quotes around the source name are optional.
+function parseEventSubject(subject) {
+    if (!subject)
+        return null;
+    const separatorIdx = subject.indexOf(" - ");
+    if (separatorIdx === -1)
+        return null;
+    const rawSource = subject.slice(0, separatorIdx).trim();
+    if (!rawSource)
+        return null;
+    const sourceName = rawSource.replace(/^"(.*)"$/, "$1");
+    return { sourceName };
+}

package/dist/features/openservice/schedules/calendarSync/service/calendarMetaHelper.d.ts

@@ -0,0 +1,36 @@
+import { Meta_Entry, Tenant } from "../../../../../types/index.js";
+import { MetaConfig } from "../../../../../types/custom/MetaField.js";
+import { GraphEventResponse } from "../types/Event.js";
+export declare const CALENDAR_SYNC_CONTEXT: string;
+export interface CalendarEventSnapshot {
+    id: string;
+    subject?: string;
+    start: {
+        dateTime: string;
+        timeZone: string;
+    };
+    end: {
+        dateTime: string;
+        timeZone: string;
+    };
+    isAllDay?: boolean;
+    isCancelled?: boolean;
+    body?: {
+        contentType?: string;
+        content?: string;
+    };
+    recurrence?: GraphEventResponse["recurrence"];
+    location?: {
+        displayName?: string;
+    };
+}
+export interface CalendarMetaValues {
+    microsoftCalendarEventId: string;
+    microsoftCalendarChangeKey?: string;
+    microsoftCalendarEvent?: CalendarEventSnapshot;
+}
+export declare const CalendarMetaConfig: MetaConfig;
+export declare function findCalendarMetaForSchedule(scheduleId: string): Promise<Meta_Entry | null>;
+export declare function findCalendarMetaByEventId(eventId: string): Promise<Meta_Entry | null>;
+export declare function saveCalendarMeta(scheduleId: string, eventId: string, changeKey?: string, tenant?: Tenant, event?: GraphEventResponse): Promise<Meta_Entry>;
+export declare function updateCalendarChangeKey(entry: Meta_Entry, changeKey: string, event?: GraphEventResponse): Promise<void>;

package/dist/features/openservice/schedules/calendarSync/service/calendarMetaHelper.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarMetaConfig = exports.CALENDAR_SYNC_CONTEXT = void 0;
+exports.findCalendarMetaForSchedule = findCalendarMetaForSchedule;
+exports.findCalendarMetaByEventId = findCalendarMetaByEventId;
+exports.saveCalendarMeta = saveCalendarMeta;
+exports.updateCalendarChangeKey = updateCalendarChangeKey;
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../../../../../types/index.js");
+exports.CALENDAR_SYNC_CONTEXT = JSON.stringify([
+    "schedule",
+    "sync",
+    "microsoft",
+]);
+function toEventSnapshot(event) {
+    return {
+        id: event.id,
+        subject: event.subject,
+        start: event.start,
+        end: event.end,
+        isAllDay: event.isAllDay,
+        isCancelled: event.isCancelled,
+        body: event.body
+            ? { contentType: event.body.contentType, content: event.body.content }
+            : undefined,
+        recurrence: event.recurrence ?? undefined,
+        location: event.location?.displayName
+            ? { displayName: event.location.displayName }
+            : undefined,
+    };
+}
+exports.CalendarMetaConfig = {
+    fields: [
+        {
+            name: "microsoftCalendarEventId",
+            type: "string",
+            label: "Microsoft Calendar Event ID",
+        },
+        {
+            name: "microsoftCalendarChangeKey",
+            type: "string",
+            label: "Microsoft Calendar Change Key",
+        },
+    ],
+};
+async function findCalendarMetaForSchedule(scheduleId) {
+    return ((await new node_1.default.Query(index_js_1.Meta_Entry)
+        .equalTo("context", exports.CALENDAR_SYNC_CONTEXT)
+        .equalTo("entryClassName", index_js_1.Maintenance_Schedule.className)
+        .equalTo("entryObjectId", scheduleId)
+        .first({ useMasterKey: true })) ?? null);
+}
+async function findCalendarMetaByEventId(eventId) {
+    return ((await new node_1.default.Query(index_js_1.Meta_Entry)
+        .equalTo("context", exports.CALENDAR_SYNC_CONTEXT)
+        .equalTo("entryClassName", index_js_1.Maintenance_Schedule.className)
+        // @ts-expect-error
+        .equalTo("values.microsoftCalendarEventId", eventId)
+        .first({ useMasterKey: true })) ?? null);
+}
+async function saveCalendarMeta(scheduleId, eventId, changeKey, tenant, event) {
+    let entry = await findCalendarMetaForSchedule(scheduleId);
+    if (!entry) {
+        entry = new index_js_1.Meta_Entry();
+        entry.set("context", exports.CALENDAR_SYNC_CONTEXT);
+        entry.set("entryClassName", index_js_1.Maintenance_Schedule.className);
+        entry.set("entryObjectId", scheduleId);
+        entry.set("tenant", tenant);
+        entry.set("config", {});
+    }
+    const values = { microsoftCalendarEventId: eventId };
+    if (changeKey)
+        values.microsoftCalendarChangeKey = changeKey;
+    if (event)
+        values.microsoftCalendarEvent = toEventSnapshot(event);
+    entry.set("values", values);
+    return entry.save(null, { useMasterKey: true });
+}
+async function updateCalendarChangeKey(entry, changeKey, event) {
+    entry.set("values", {
+        ...entry.get("values"),
+        microsoftCalendarChangeKey: changeKey,
+        ...(event ? { microsoftCalendarEvent: toEventSnapshot(event) } : {}),
+    });
+    await entry.save(null, { useMasterKey: true });
+}

package/dist/features/openservice/schedules/calendarSync/types/ConfigValues.d.ts

@@ -0,0 +1,8 @@
+export type ConfigValues = {
+    tenant_id: string;
+    client_id: string;
+    client_secret: string;
+    user_email: string;
+    default_source_id?: string;
+    delta_link?: string;
+};

package/dist/features/openservice/schedules/calendarSync/types/ConfigValues.js

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

package/dist/features/openservice/schedules/calendarSync/types/Event.d.ts

@@ -60,7 +60,7 @@ export type GraphEvent = {
     subject?: string;
     body?: ItemBody;
     start: DateTimeTimeZone;
-    end: DateTimeTimeZone;
+    end?: DateTimeTimeZone;
     location?: Location;
     attendees?: Attendee[];
     isAllDay?: boolean;

package/dist/features/openservice/schedules/initSchedulesFeature.js

@@ -6,8 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.initSchedulesFeature = initSchedulesFeature;
 const node_1 = __importDefault(require("parse/node"));
 const index_js_1 = require("../../../types/index.js");
+const CalendarSyncPoller_js_1 = require("./calendarSync/service/CalendarSyncPoller.js");
 async function initSchedulesFeature() {
     updateFiinishedSchedules();
+    const configs = await new node_1.default.Query(index_js_1.Config)
+        .equalTo("key", "OPENSERVICE_MICROSOFT_OUTLOOK_INTEGRATION")
+        .includeAll()
+        .findAll({ useMasterKey: true });
+    const pollers = configs.map((config) => new CalendarSyncPoller_js_1.CalendarSyncPoller(config).start(1000 * 60));
 }
 async function updateFiinishedSchedules() {
     const executionsToUpdate = await new node_1.default.Query(index_js_1.Maintenance_Schedule_Execution)

package/dist/hooks/Config_open_service.js

@@ -45,6 +45,8 @@ async function init() {
             //object.value can look like this: [{"label":"PSA","allowedValues":[],"required":false},{"label":"Typ","allowedValues":[],"required":false,"onlyOneAllowedValue":false},{"label":"Material","allowedValues":["@OD3_Maintenance_Item"],"required":false,"onlyOneAllowedValue":false},{"label":"Dienstleister","allowedValues":["@OD3_COMPANY","@OD3_CONTACT"],"required":false,"onlyOneAllowedValue":false}]
             //fields in Maintenance_Step can look like this: [{"value":"Handschuhe","metafield":{"label":"PSA","allowedValues":[],"required":false}},{"value":"Auffüllen","metafield":{"label":"Typ","allowedValues":[],"required":false,"onlyOneAllowedValue":false}}]
             const metafieldsconfig = JSON.parse(object.get("value"));
+            if (!Array.isArray(metafieldsconfig))
+                return;
             const [maintenanceStepQueryError, maintenanceStepQuery] = await (0, catchError_js_1.catchError)(new node_1.default.Query(index_js_2.Maintenance_Schedule_Step).find({
                 useMasterKey: true,
             }));

package/dist/hooks/Maintenance_Schedule.js

@@ -6,12 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = init;
 const node_1 = __importDefault(require("parse/node"));
 const scheduleToEvent_1 = require("../features/openservice/schedules/calendarSync/functions/scheduleToEvent");
+const calendarMetaHelper_1 = require("../features/openservice/schedules/calendarSync/service/calendarMetaHelper");
 const CalendarManager_1 = require("../features/openservice/schedules/calendarSync/service/CalendarManager");
 const schema_1 = require("../features/schema");
 const types_1 = require("../types");
 async function init() {
     (0, schema_1.beforeSaveHook)(types_1.Maintenance_Schedule, async (request) => {
-        const { object, original, user } = request;
         await (0, schema_1.defaultHandler)(request);
         // await defaultAclHandler(request, { allowCustomACL: true });
     });
@@ -51,8 +51,8 @@ async function init() {
         }
     });
     (0, schema_1.beforeDeleteHook)(types_1.Maintenance_Schedule, async (request) => {
-        const { object, original, user, master } = request;
-        const scheduleFetched = await object?.fetchWithInclude(["template", "source"], {
+        const { object } = request;
+        const scheduleFetched = await object?.fetchWithInclude(["template", "source", "tenant"], {
             useMasterKey: true,
         });
         const template = scheduleFetched?.get("template");
@@ -60,9 +60,16 @@ async function init() {
         if (source)
             template?.relation("sources").remove(source);
         await template?.save(null, { useMasterKey: true });
-        // Delete associated calendar event
-        if (object.get("meta")?.microsoftCalendarEventId) {
-            await new CalendarManager_1.CalendarManager().deleteEvent(object.get("meta")?.microsoftCalendarEventId);
+        const metaEntry = await (0, calendarMetaHelper_1.findCalendarMetaForSchedule)(object.id);
+        if (metaEntry) {
+            const eventId = metaEntry.get("values")?.microsoftCalendarEventId;
+            if (eventId) {
+                const calendarManager = await getScheduleCalendarManager(object);
+                if (!calendarManager)
+                    return;
+                await calendarManager.deleteEvent(eventId);
+            }
+            await metaEntry.destroy({ useMasterKey: true });
         }
     });
 }
@@ -85,15 +92,20 @@ async function addToTemplateSources(schedule) {
     await template.save(null, { useMasterKey: true });
 }
 async function updateCalendarEvent(schedule) {
-    const event = await (0, scheduleToEvent_1.scheduleToEvent)(schedule);
+    const metaEntry = await (0, calendarMetaHelper_1.findCalendarMetaForSchedule)(schedule.id);
+    const snapshot = metaEntry?.get("values")?.microsoftCalendarEvent;
+    const event = await (0, scheduleToEvent_1.scheduleToEvent)(schedule, snapshot);
     if (!event)
         return;
-    const calendarManager = new CalendarManager_1.CalendarManager();
-    const meta = schedule.get("meta") || {};
-    const microsoftCalendarEventId = meta.microsoftCalendarEventId;
-    if (microsoftCalendarEventId) {
-        console.log("Updating schedule in calendar...");
-        await calendarManager.updateEvent(microsoftCalendarEventId, event);
+    const calendarManager = await getScheduleCalendarManager(schedule);
+    if (!calendarManager)
+        return;
+    const eventId = metaEntry?.get("values")?.microsoftCalendarEventId;
+    if (eventId) {
+        const updatedEvent = await calendarManager.updateEvent(eventId, event);
+        if (updatedEvent?.changeKey && metaEntry) {
+            await (0, calendarMetaHelper_1.updateCalendarChangeKey)(metaEntry, updatedEvent.changeKey, updatedEvent);
+        }
     }
     else {
         await addToCalendar(schedule);
@@ -104,18 +116,31 @@ async function updateCalendarEvent(schedule) {
  * @param schedule
  */
 async function addToCalendar(schedule) {
-    console.log("Creating new calendar event for schedule...");
     const event = await (0, scheduleToEvent_1.scheduleToEvent)(schedule);
     if (!event)
         return;
-    const calendarManager = new CalendarManager_1.CalendarManager();
+    const calendarManager = await getScheduleCalendarManager(schedule);
+    if (!calendarManager)
+        return;
     const createdEvent = await calendarManager.createEvent(event);
-    if (createdEvent && createdEvent.id) {
-        const existingMeta = schedule.get("meta") || {};
-        schedule.set("meta", {
-            ...existingMeta,
-            microsoftCalendarEventId: createdEvent.id,
-        });
-        await schedule.save(null, { useMasterKey: true });
+    if (createdEvent?.id) {
+        await (0, calendarMetaHelper_1.saveCalendarMeta)(schedule.id, createdEvent.id, createdEvent.changeKey, schedule.get("tenant"), createdEvent);
     }
 }
+async function getScheduleCalendarManager(schedule) {
+    const config = await new node_1.default.Query(types_1.Config)
+        .equalTo("key", "OPENSERVICE_MICROSOFT_OUTLOOK_INTEGRATION")
+        .equalTo("tenant", schedule.get("tenant"))
+        .first({ useMasterKey: true });
+    if (!config) {
+        return;
+    }
+    const configValues = JSON.parse(config.get("value"));
+    const calendarManager = new CalendarManager_1.CalendarManager({
+        tenantId: configValues.tenant_id,
+        clientID: configValues.client_id,
+        clientSecret: configValues.client_secret,
+        userMail: configValues.user_email,
+    });
+    return calendarManager;
+}

package/dist/types/Meta_Config.d.ts

@@ -1,19 +1,20 @@
 import Parse from "parse/node";
 import type { Tenant } from "./Tenant";
+import { MetaConfig } from "./custom/MetaField";
 export interface Meta_ConfigAttributes {
     id: string;
     objectId: string;
     createdAt: Date;
     updatedAt: Date;
-    config: any;
+    config: MetaConfig;
     context?: string | undefined;
     tenant?: Tenant | undefined;
 }
 export declare class Meta_Config extends Parse.Object<Meta_ConfigAttributes> {
     static className: string;
     constructor(data?: Partial<Meta_ConfigAttributes>);
-    get config(): any;
-    set config(value: any);
+    get config(): MetaConfig;
+    set config(value: MetaConfig);
     get context(): string | undefined;
     set context(value: string | undefined);
     get tenant(): Tenant | undefined;

package/dist/types/Meta_Entry.d.ts

@@ -1,12 +1,13 @@
 import Parse from "parse/node";
 import type { Meta_Config } from "./Meta_Config";
 import type { Tenant } from "./Tenant";
+import { MetaConfig } from "./custom/MetaField";
 export interface Meta_EntryAttributes {
     id: string;
     objectId: string;
     createdAt: Date;
     updatedAt: Date;
-    config?: any | undefined;
+    config?: MetaConfig | undefined;
     context?: string | undefined;
     entryClassName?: string | undefined;
     entryObjectId?: string | undefined;
@@ -17,8 +18,8 @@ export interface Meta_EntryAttributes {
 export declare class Meta_Entry extends Parse.Object<Meta_EntryAttributes> {
     static className: string;
     constructor(data?: Partial<Meta_EntryAttributes>);
-    get config(): any | undefined;
-    set config(value: any | undefined);
+    get config(): MetaConfig | undefined;
+    set config(value: MetaConfig | undefined);
     get context(): string | undefined;
     set context(value: string | undefined);
     get entryClassName(): string | undefined;

package/dist/types/custom/MetaField.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Base properties shared by all meta field types
+ */
+export type MetaFieldBaseConfig = {
+    name: string;
+    label: string;
+    placeholder?: string;
+    help?: string;
+    required?: boolean;
+    /** Default value for the field */
+    defaultValue?: any;
+};
+/**
+ * String field type with optional validation
+ */
+export type MetaFieldString = MetaFieldBaseConfig & {
+    type: "string";
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    multiline?: boolean;
+};
+/**
+ * Number field type with min/max constraints
+ */
+export type MetaFieldNumber = MetaFieldBaseConfig & {
+    type: "number";
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+};
+/**
+ * Boolean field type (checkbox/switch)
+ */
+export type MetaFieldBoolean = MetaFieldBaseConfig & {
+    type: "boolean";
+    defaultValue?: boolean;
+};
+/**
+ * Date field type with optional date range constraints
+ */
+export type MetaFieldDate = MetaFieldBaseConfig & {
+    type: "date";
+    minDate?: Date;
+    maxDate?: Date;
+    includeTime?: boolean;
+};
+/**
+ * Select field type with predefined options
+ */
+export type MetaFieldSelect = MetaFieldBaseConfig & {
+    type: "select";
+    options: Array<{
+        label: string;
+        value: string;
+        disabled?: boolean;
+    }>;
+    /** Optional grouping for select options */
+    groups?: Array<{
+        label: string;
+        options: Array<{
+            label: string;
+            value: string;
+            disabled?: boolean;
+        }>;
+    }>;
+    multiple?: boolean;
+    defaultValue?: string | string[];
+};
+/**
+ * Parse select field type for selecting Parse objects
+ */
+export type MetaFieldSelectParse = MetaFieldBaseConfig & {
+    type: "select_parse";
+    className: string;
+    display?: string;
+    multiple?: boolean;
+    defaultValue?: string | string[];
+};
+/**
+ * Array of all available field types
+ */
+export declare const META_FIELD_TYPES: readonly ["string", "number", "boolean", "date", "select", "select_parse"];
+/**
+ * Literal type for field types derived from the array
+ */
+export type MetaFieldTypes = (typeof META_FIELD_TYPES)[number];
+/**
+ * Mapped type for accessing MetaField types by their string literal
+ * @example MetaFieldMap["string"] => MetaFieldString
+ */
+export type MetaFieldMap = {
+    string: MetaFieldString;
+    number: MetaFieldNumber;
+    boolean: MetaFieldBoolean;
+    date: MetaFieldDate;
+    select: MetaFieldSelect;
+    select_parse: MetaFieldSelectParse;
+};
+/**
+ * Union type of all specific meta field types
+ */
+export type MetaFieldConfig = MetaFieldString | MetaFieldNumber | MetaFieldBoolean | MetaFieldDate | MetaFieldSelect | MetaFieldSelectParse;
+/**
+ * Helper type to extract specific field type from MetaField union
+ */
+export type MetaFieldOfType<T extends MetaFieldTypes> = Extract<MetaFieldConfig, {
+    type: T;
+}>;
+/**
+ * Type guard to check if a field is of a specific type
+ */
+export declare function isMetaFieldType<T extends MetaFieldTypes>(field: MetaFieldConfig, type: T): field is MetaFieldOfType<T>;
+export type MetaConfig = {
+    fields: MetaFieldConfig[];
+};