@mvriu5/payload-ai 1.1.1 → 1.3.2

package/dist/handlers/mediaUploadHandler.d.ts

@@ -0,0 +1,7 @@
+import { type PayloadHandler } from "payload";
+export type MediaUploadOptions = {
+    acceptedMimeTypes?: string[];
+    collectionSlug: string;
+    maxFileSize?: number;
+};
+export declare const createMediaUploadHandler: ({ acceptedMimeTypes, collectionSlug, maxFileSize }: MediaUploadOptions) => PayloadHandler;

package/dist/handlers/mediaUploadHandler.js

@@ -0,0 +1,99 @@
+import { addDataAndFileToRequest } from "payload";
+import { getNumber, getString, isRecord } from "../payload/shared.js";
+const mimeTypeMatches = (mimeType, acceptedMimeType)=>{
+    if (acceptedMimeType === mimeType) return true;
+    if (!acceptedMimeType.endsWith("/*")) return false;
+    return mimeType.startsWith(`${acceptedMimeType.slice(0, -2)}/`);
+};
+const isAcceptedMimeType = (mimeType, acceptedMimeTypes)=>{
+    if (!acceptedMimeTypes || acceptedMimeTypes.length === 0) return true;
+    return acceptedMimeTypes.some((acceptedMimeType)=>mimeTypeMatches(mimeType, acceptedMimeType));
+};
+const getUploadData = (data)=>{
+    if (!isRecord(data)) return {};
+    const { collection: _collection, file: _file, ...uploadData } = data;
+    return uploadData;
+};
+const getMediaAttachment = ({ collectionSlug, doc, file })=>{
+    const record = isRecord(doc) ? doc : {};
+    const id = record.id;
+    return {
+        collection: collectionSlug,
+        filename: getString(record.filename) || file.name || "",
+        filesize: getNumber(record.filesize) || file.size || 0,
+        id: typeof id === "string" || typeof id === "number" ? String(id) : "",
+        mimeType: getString(record.mimeType) || file.mimetype || "",
+        type: "media",
+        url: getString(record.url)
+    };
+};
+export const createMediaUploadHandler = ({ acceptedMimeTypes, collectionSlug, maxFileSize })=>async (req)=>{
+        const uploadReq = req;
+        try {
+            await addDataAndFileToRequest(uploadReq);
+            const collectionConfig = uploadReq.payload.config.collections.find((collection)=>collection.slug === collectionSlug);
+            if (!collectionConfig) {
+                return Response.json({
+                    error: `Upload collection not found: ${collectionSlug}`
+                }, {
+                    status: 400
+                });
+            }
+            if (!collectionConfig.upload) {
+                return Response.json({
+                    error: `Collection is not upload-enabled: ${collectionSlug}`
+                }, {
+                    status: 400
+                });
+            }
+            const file = uploadReq.file;
+            if (!file) {
+                return Response.json({
+                    error: "File is required"
+                }, {
+                    status: 400
+                });
+            }
+            const fileSize = typeof file.size === "number" && Number.isFinite(file.size) ? file.size : 0;
+            if (maxFileSize && fileSize > maxFileSize) {
+                return Response.json({
+                    error: `File exceeds max size of ${maxFileSize} bytes`
+                }, {
+                    status: 413
+                });
+            }
+            const mimeType = file.mimetype || "";
+            if (mimeType && !isAcceptedMimeType(mimeType, acceptedMimeTypes)) {
+                return Response.json({
+                    error: `File type is not accepted: ${mimeType}`
+                }, {
+                    status: 415
+                });
+            }
+            const doc = await uploadReq.payload.create({
+                collection: collectionSlug,
+                data: getUploadData(uploadReq.data),
+                file: file,
+                overrideAccess: false,
+                req: uploadReq
+            });
+            return Response.json({
+                attachment: getMediaAttachment({
+                    collectionSlug,
+                    doc,
+                    file
+                }),
+                doc
+            });
+        } catch (err) {
+            uploadReq.payload.logger.error({
+                err,
+                msg: "AI media upload failed"
+            });
+            return Response.json({
+                error: "Media upload failed."
+            }, {
+                status: 500
+            });
+        }
+    };

package/dist/handlers/mentionSuggestionHandler.js

@@ -61,16 +61,13 @@ export const createMentionSuggestionHandler = (options = {})=>async (req)=>{
                 type: "doc"
             });
         };
-        for (const collection of collections){
-            if (suggestions.length >= 5) break;
+        const searchResults = await Promise.all(collections.flatMap((collection)=>{
             const collectionFields = collection.fields;
             const localeCodes = query && hasLocalizedFields(collectionFields) ? getLocaleCodes(req) : [];
             const localesToSearch = localeCodes.length > 0 ? localeCodes : [
                 null
             ];
-            for (const locale of localesToSearch){
-                if (suggestions.length >= 5) break;
-                const result = await req.payload.find({
+            return localesToSearch.map((locale)=>req.payload.find({
                     collection: collection.slug,
                     depth: 0,
                     limit: query ? 100 : 10,
@@ -79,16 +76,21 @@ export const createMentionSuggestionHandler = (options = {})=>async (req)=>{
                     } : {},
                     overrideAccess: false,
                     req
+                }).then((result)=>({
+                        collection,
+                        result
+                    })));
+        }));
+        for (const { collection, result } of searchResults){
+            if (suggestions.length >= 5) break;
+            for (const doc of result.docs){
+                if (suggestions.length >= 5) break;
+                addSuggestion({
+                    collectionSlug: collection.slug,
+                    doc,
+                    requireLabelMatch: Boolean(normalizedQuery),
+                    useAsTitle: collection.admin?.useAsTitle
                 });
-                for (const doc of result.docs){
-                    if (suggestions.length >= 5) break;
-                    addSuggestion({
-                        collectionSlug: collection.slug,
-                        doc,
-                        requireLabelMatch: Boolean(normalizedQuery),
-                        useAsTitle: collection.admin?.useAsTitle
-                    });
-                }
             }
         }
         return Response.json({

package/dist/handlers/proposalDiffHandler.js

@@ -1,15 +1,9 @@
 import { verifyActionProposal } from "../ai/proposalSigning.js";
 import { redactSensitiveData } from "../ai/sensitiveData.js";
-import { getCollectionFields, getLocalizedRequiredFallbackData, normalizeAuthData, normalizeDataForFields } from "../payload/normalizeData.js";
+import { getSchemaFields } from "../payload/normalizeData.js";
+import { applyLocalizedRequiredFallbackToPreparedData, prepareProposalWriteData } from "../payload/proposalData.js";
 import { isCollectionActionAllowed } from "../payload/collectionPermissions.js";
 import { getDefaultLocale, hasLocalizedData, isActionProposal, mergeData } from "../payload/shared.js";
-const applyLocalizedRequiredFallback = ({ data, fallbackSource, fields })=>{
-    return mergeData(getLocalizedRequiredFallbackData({
-        fields,
-        source: fallbackSource,
-        target: data
-    }), data);
-};
 export const createProposalDiffHandler = (options = {})=>async (req)=>{
         if (!req.user) return Response.json({
             error: "Unauthorized"
@@ -34,6 +28,7 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
             status: 400
         });
         try {
+            const inferenceText = body?.prompt;
             const defaultLocale = getDefaultLocale(req);
             if (proposal.action === "updateGlobal") {
                 const globalConfig = req.payload.config.globals?.find((global)=>global.slug === proposal.slug);
@@ -45,7 +40,27 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                 if (hasLocalizedData(proposal)) {
                     const beforeByLocale = {};
                     const afterByLocale = {};
-                    const globalFields = globalConfig.fields || [];
+                    const globalFields = getSchemaFields({
+                        fields: globalConfig.fields || [],
+                        slug: proposal.slug
+                    });
+                    const preparedData = prepareProposalWriteData({
+                        collectionConfig: {
+                            fields: globalConfig.fields || [],
+                            slug: proposal.slug
+                        },
+                        inferenceText,
+                        label: proposal.label,
+                        localizedData: proposal.localizedData,
+                        mode: "update"
+                    });
+                    if (preparedData.issues.length > 0 || !preparedData.localizedData) {
+                        return Response.json({
+                            error: "Proposal is invalid."
+                        }, {
+                            status: 400
+                        });
+                    }
                     const defaultLocaleDoc = defaultLocale ? await req.payload.findGlobal({
                         depth: 2,
                         fallbackLocale: false,
@@ -54,8 +69,7 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                         req,
                         slug: proposal.slug
                     }) : null;
-                    for (const [locale, localeData] of Object.entries(proposal.localizedData)){
-                        const normalized = normalizeDataForFields(globalFields, localeData);
+                    const localizedResults = await Promise.all(Object.entries(preparedData.localizedData).map(async ([locale, localeData])=>{
                         const doc = await req.payload.findGlobal({
                             depth: 2,
                             fallbackLocale: false,
@@ -64,20 +78,43 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                             req,
                             slug: proposal.slug
                         });
-                        const completedData = applyLocalizedRequiredFallback({
-                            data: normalized.data,
+                        const completedData = applyLocalizedRequiredFallbackToPreparedData({
                             fallbackSource: locale === defaultLocale ? doc : defaultLocaleDoc || doc,
-                            fields: globalFields
+                            fields: globalFields,
+                            preparedData: localeData
                         });
+                        return {
+                            completedData,
+                            doc,
+                            locale
+                        };
+                    }));
+                    localizedResults.forEach(({ completedData, doc, locale })=>{
                         beforeByLocale[locale] = redactSensitiveData(doc);
                         afterByLocale[locale] = redactSensitiveData(mergeData(doc, completedData));
-                    }
+                    });
                     return Response.json({
                         after: afterByLocale,
                         before: beforeByLocale
                     });
                 }
-                const normalized = normalizeDataForFields(globalConfig.fields || [], proposal.data);
+                const preparedData = prepareProposalWriteData({
+                    collectionConfig: {
+                        fields: globalConfig.fields || [],
+                        slug: proposal.slug
+                    },
+                    data: proposal.data,
+                    inferenceText,
+                    label: proposal.label,
+                    mode: "update"
+                });
+                if (preparedData.issues.length > 0 || !preparedData.data) {
+                    return Response.json({
+                        error: "Proposal is invalid."
+                    }, {
+                        status: 400
+                    });
+                }
                 const doc = await req.payload.findGlobal({
                     depth: 2,
                     ...proposal.locale ? {
@@ -88,7 +125,7 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                     slug: proposal.slug
                 });
                 return Response.json({
-                    after: redactSensitiveData(mergeData(doc, normalized.data)),
+                    after: redactSensitiveData(mergeData(doc, preparedData.data)),
                     before: redactSensitiveData(doc)
                 });
             }
@@ -119,9 +156,22 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                 });
             }
             const collectionConfig = req.payload.config.collections.find((collection)=>collection.slug === proposal.collection);
-            const collectionFields = getCollectionFields(collectionConfig);
-            const normalizeCollectionData = (data)=>normalizeAuthData(collectionConfig, normalizeDataForFields(collectionFields, data));
+            const collectionFields = getSchemaFields(collectionConfig);
             if (hasLocalizedData(proposal)) {
+                const preparedData = prepareProposalWriteData({
+                    collectionConfig,
+                    inferenceText,
+                    label: proposal.label,
+                    localizedData: proposal.localizedData,
+                    mode: proposal.action
+                });
+                if (preparedData.issues.length > 0 || !preparedData.localizedData) {
+                    return Response.json({
+                        error: "Proposal is invalid."
+                    }, {
+                        status: 400
+                    });
+                }
                 const afterByLocale = {};
                 const beforeByLocale = {};
                 const defaultLocaleDoc = proposal.action === "update" && defaultLocale ? await req.payload.findByID({
@@ -134,49 +184,66 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                     req
                 }) : null;
                 let createFallbackSource = null;
-                for (const [locale, localeData] of Object.entries(proposal.localizedData)){
-                    const normalized = normalizeCollectionData(localeData);
-                    const fallbackSource = proposal.action === "create" ? createFallbackSource || {} : locale === defaultLocale ? await req.payload.findByID({
-                        collection: proposal.collection,
-                        depth: 2,
-                        fallbackLocale: false,
-                        id: proposal.id,
-                        locale,
-                        overrideAccess: false,
-                        req
-                    }) : defaultLocaleDoc || {};
-                    const completedData = applyLocalizedRequiredFallback({
-                        data: normalized.data,
-                        fallbackSource,
-                        fields: collectionFields
-                    });
-                    if (proposal.action === "create") {
+                if (proposal.action === "create") {
+                    for (const [locale, localeData] of Object.entries(preparedData.localizedData)){
+                        const completedData = applyLocalizedRequiredFallbackToPreparedData({
+                            fallbackSource: createFallbackSource || {},
+                            fields: collectionFields,
+                            preparedData: localeData
+                        });
                         beforeByLocale[locale] = {};
                         afterByLocale[locale] = redactSensitiveData(completedData);
                         createFallbackSource = mergeData(createFallbackSource || {}, completedData);
-                        continue;
                     }
-                    const doc = await req.payload.findByID({
-                        collection: proposal.collection,
-                        depth: 2,
-                        fallbackLocale: false,
-                        id: proposal.id,
-                        locale,
-                        overrideAccess: false,
-                        req
+                } else {
+                    const localizedResults = await Promise.all(Object.entries(preparedData.localizedData).map(async ([locale, localeData])=>{
+                        const doc = await req.payload.findByID({
+                            collection: proposal.collection,
+                            depth: 2,
+                            fallbackLocale: false,
+                            id: proposal.id,
+                            locale,
+                            overrideAccess: false,
+                            req
+                        });
+                        const completedData = applyLocalizedRequiredFallbackToPreparedData({
+                            fallbackSource: locale === defaultLocale ? doc : defaultLocaleDoc || {},
+                            fields: collectionFields,
+                            preparedData: localeData
+                        });
+                        return {
+                            completedData,
+                            doc,
+                            locale
+                        };
+                    }));
+                    localizedResults.forEach(({ completedData, doc, locale })=>{
+                        beforeByLocale[locale] = redactSensitiveData(doc);
+                        afterByLocale[locale] = redactSensitiveData(mergeData(doc, completedData));
                     });
-                    beforeByLocale[locale] = redactSensitiveData(doc);
-                    afterByLocale[locale] = redactSensitiveData(mergeData(doc, completedData));
                 }
                 return Response.json({
                     after: afterByLocale,
                     before: beforeByLocale
                 });
             }
-            const normalized = normalizeCollectionData(proposal.data);
+            const preparedData = prepareProposalWriteData({
+                collectionConfig,
+                data: proposal.data,
+                inferenceText,
+                label: proposal.label,
+                mode: proposal.action
+            });
+            if (preparedData.issues.length > 0 || !preparedData.data) {
+                return Response.json({
+                    error: "Proposal is invalid."
+                }, {
+                    status: 400
+                });
+            }
             if (proposal.action === "create") {
                 return Response.json({
-                    after: redactSensitiveData(normalized.data),
+                    after: redactSensitiveData(preparedData.data),
                     before: {}
                 });
             }
@@ -191,7 +258,7 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                 req
             });
             return Response.json({
-                after: redactSensitiveData(mergeData(doc, normalized.data)),
+                after: redactSensitiveData(mergeData(doc, preparedData.data)),
                 before: redactSensitiveData(doc)
             });
         } catch (err) {

package/dist/index.d.ts

@@ -6,6 +6,12 @@ export type PayloadAIPluginOptions = {
     collections?: CollectionPermissionMap;
     disabled?: boolean;
     maxOutputTokens?: number;
+    media?: {
+        acceptedMimeTypes?: string[];
+        collectionSlug?: string;
+        enabled?: boolean;
+        maxFileSize?: number;
+    };
     models?: AIModelConfig;
 };
 export declare const payloadAiPlugin: (pluginOptions: PayloadAIPluginOptions) => (config: Config) => Config;

package/dist/index.js

@@ -2,13 +2,25 @@ import { aiProviders, getResolvedAIModelConfig } from "./ai/providerOptions.js";
 import { createApplyActionHandler } from "./handlers/applyActionHandler.js";
 import { createChatHandler } from "./handlers/chatHandler.js";
 import { createMentionSuggestionHandler } from "./handlers/mentionSuggestionHandler.js";
+import { createMediaUploadHandler } from "./handlers/mediaUploadHandler.js";
 import { createProposalDiffHandler } from "./handlers/proposalDiffHandler.js";
 import { createAuditLogHandler } from "./handlers/auditLogHandler.js";
 import { resolveCollectionPermissions } from "./payload/collectionPermissions.js";
 import { isInternalCollection } from "./payload/shared.js";
-const auditLogCollectionSlug = "payload-ai-auditlog";
+const resolveMediaUploadOptions = (media)=>{
+    if (!media || media.enabled === false) return null;
+    return {
+        ...media.acceptedMimeTypes ? {
+            acceptedMimeTypes: media.acceptedMimeTypes
+        } : {},
+        collectionSlug: media.collectionSlug || "media",
+        ...typeof media.maxFileSize === "number" && Number.isFinite(media.maxFileSize) && media.maxFileSize > 0 ? {
+            maxFileSize: Math.floor(media.maxFileSize)
+        } : {}
+    };
+};
 const createAIChangesCollection = ()=>({
-        slug: auditLogCollectionSlug,
+        slug: "payload-ai-auditlog",
         access: {
             create: ()=>false,
             delete: ()=>false,
@@ -156,9 +168,10 @@ export const payloadAiPlugin = (pluginOptions)=>(config)=>{
         const collectionPermissions = resolveCollectionPermissions(pluginOptions.collections);
         const allowUserApiKeys = pluginOptions.allowUserApiKeys !== false;
         const modelConfig = getResolvedAIModelConfig(pluginOptions.models);
+        const mediaUploadOptions = resolveMediaUploadOptions(pluginOptions.media);
         const maxOutputTokens = typeof pluginOptions.maxOutputTokens === "number" && Number.isFinite(pluginOptions.maxOutputTokens) && pluginOptions.maxOutputTokens > 0 ? Math.floor(pluginOptions.maxOutputTokens) : undefined;
         if (!config.collections) config.collections = [];
-        if (!config.collections.some((collection)=>collection.slug === auditLogCollectionSlug)) {
+        if (!config.collections.some((collection)=>collection.slug === "payload-ai-auditlog")) {
             config.collections.push(createAIChangesCollection());
         }
         addAccountFields({
@@ -166,7 +179,13 @@ export const payloadAiPlugin = (pluginOptions)=>(config)=>{
             config
         });
         if (pluginOptions.disabled) return config;
-        const mentionCollectionSlugs = config.collections.filter((collection)=>!isInternalCollection(collection.slug)).filter((collection)=>collectionPermissions ? Boolean(collectionPermissions[collection.slug]?.read) : true).map((collection)=>collection.slug);
+        const mentionCollectionSlugs = config.collections.flatMap((collection)=>{
+            if (isInternalCollection(collection.slug)) return [];
+            if (collectionPermissions && !collectionPermissions[collection.slug]?.read) return [];
+            return [
+                collection.slug
+            ];
+        });
         if (!config.endpoints) config.endpoints = [];
         if (!config.admin) config.admin = {};
         config.admin.custom = {
@@ -175,12 +194,18 @@ export const payloadAiPlugin = (pluginOptions)=>(config)=>{
                 ...config.admin.custom?.payloadAiPlugin || {},
                 collectionSlugs: mentionCollectionSlugs,
                 allowUserApiKeys,
+                ...mediaUploadOptions ? {
+                    media: {
+                        ...mediaUploadOptions,
+                        enabled: true
+                    }
+                } : {},
                 models: modelConfig
             }
         };
         if (!config.admin.components) config.admin.components = {};
         if (!config.admin.components.beforeDashboard) config.admin.components.beforeDashboard = [];
-        config.admin.components.beforeDashboard.push(`@mvriu5/payload-ai/client#AIInput`);
+        config.admin.components.beforeDashboard.push(`@mvriu5/payload-ai/client#Dashboard`);
         config.endpoints.push({
             handler: createChatHandler({
                 allowUserApiKeys,
@@ -193,7 +218,7 @@ export const payloadAiPlugin = (pluginOptions)=>(config)=>{
         });
         config.endpoints.push({
             handler: createApplyActionHandler({
-                changeLogCollection: auditLogCollectionSlug,
+                changeLogCollection: "payload-ai-auditlog",
                 collections: collectionPermissions
             }),
             method: "post",
@@ -201,7 +226,7 @@ export const payloadAiPlugin = (pluginOptions)=>(config)=>{
         });
         config.endpoints.push({
             handler: createAuditLogHandler({
-                changeLogCollection: auditLogCollectionSlug
+                changeLogCollection: "payload-ai-auditlog"
             }),
             method: "get",
             path: "/ai-audit-log"
@@ -220,6 +245,13 @@ export const payloadAiPlugin = (pluginOptions)=>(config)=>{
             method: "post",
             path: "/ai-mention-suggestion"
         });
+        if (mediaUploadOptions) {
+            config.endpoints.push({
+                handler: createMediaUploadHandler(mediaUploadOptions),
+                method: "post",
+                path: "/ai-upload-media"
+            });
+        }
         if (incomingOnInit) {
             config.onInit = async (payload)=>{
                 await incomingOnInit(payload);

package/dist/payload/collectionPermissions.js

@@ -6,7 +6,9 @@ const allActions = [
     "update"
 ];
 const getKnownCollectionSlugs = (req)=>{
-    return req.payload.config.collections.map((collection)=>collection.slug).filter((slug)=>!isInternalCollection(slug));
+    return req.payload.config.collections.flatMap((collection)=>isInternalCollection(collection.slug) ? [] : [
+            collection.slug
+        ]);
 };
 export const resolveCollectionPermissions = (collections)=>{
     if (!collections) return undefined;

package/dist/payload/logging.d.ts

@@ -0,0 +1,9 @@
+import type { PayloadHandler } from "payload";
+type LogLevel = "error" | "info" | "warn";
+type LogEntry = {
+    [key: string]: unknown;
+    msg: string;
+};
+export declare const getLogPreview: (value?: string | null) => string | null;
+export declare const logHandlerEvent: (req: Parameters<PayloadHandler>[0], level: LogLevel, entry: LogEntry) => void;
+export {};

package/dist/payload/logging.js

@@ -0,0 +1,14 @@
+const maxPreviewLength = 180;
+export const getLogPreview = (value)=>{
+    if (!value) return null;
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    if (trimmed.length <= maxPreviewLength) return trimmed;
+    return `${trimmed.slice(0, maxPreviewLength).trim()}...`;
+};
+export const logHandlerEvent = (req, level, entry)=>{
+    const logger = req.payload?.logger;
+    const log = logger?.[level];
+    if (typeof log !== "function") return;
+    log.call(logger, entry);
+};

package/dist/payload/normalizeData.d.ts

@@ -1,24 +1,31 @@
 export type FieldConfig = {
-    blocks?: BlockConfig[];
+    admin?: Record<string, unknown>;
+    blocks?: readonly BlockConfig[];
     defaultValue?: unknown;
-    fields?: FieldConfig[];
+    fields?: readonly FieldConfig[];
+    hasMany?: boolean;
     label?: unknown;
     localized?: boolean;
     name?: string;
-    options?: (string | {
+    options?: readonly (string | {
         value?: string;
     })[];
+    relationTo?: unknown;
     required?: boolean;
     type?: string;
 };
 type BlockConfig = {
-    fields?: FieldConfig[];
+    fields?: readonly FieldConfig[];
     slug: string;
 };
 export type CollectionConfig = {
+    admin?: Record<string, unknown>;
     auth?: unknown;
-    fields: FieldConfig[];
+    fields?: readonly FieldConfig[];
     slug: string;
+    versions?: boolean | {
+        drafts?: boolean | Record<string, unknown>;
+    };
 };
 export type NormalizedData = {
     coercedFields: string[];
@@ -26,12 +33,9 @@ export type NormalizedData = {
     droppedFields: string[];
 };
 export declare const isAuthCollection: (collectionConfig?: CollectionConfig | null) => boolean;
-export declare const getCollectionFields: (collectionConfig?: CollectionConfig | null) => FieldConfig[];
+export declare const hasDrafts: (collectionConfig?: CollectionConfig | null) => boolean;
+export declare const getSchemaFields: (collectionConfig?: CollectionConfig | null) => FieldConfig[];
+export declare const createLexicalText: (value: unknown) => Record<string, unknown>;
 export declare const normalizeAuthData: (collectionConfig: CollectionConfig | undefined, normalized: NormalizedData) => NormalizedData;
-export declare const normalizeDataForFields: (fields: FieldConfig[], data: Record<string, unknown>) => NormalizedData;
-export declare const getLocalizedRequiredFallbackData: ({ fields, source, target, }: {
-    fields: FieldConfig[];
-    source: Record<string, unknown>;
-    target: Record<string, unknown>;
-}) => Record<string, unknown>;
+export declare const normalizeDataForFields: (fields: readonly FieldConfig[], data: Record<string, unknown>) => NormalizedData;
 export {};