@mvriu5/payload-ai 0.5.8 → 0.5.10

package/dist/payload/schemaContext.d.ts

@@ -1,19 +1,28 @@
 import type { PayloadHandler } from "payload";
-import { type ResolvedAICollectionPermissionMap } from "./collectionPermissions.js";
-export type AIChatMention = {
+import { type ResolvedCollectionPermissionMap } from "./collectionPermissions.js";
+export type ChatMention = {
     collection?: string;
     id?: string;
     label?: string;
     parent?: string;
     slug?: string;
-    type?: "block" | "collection" | "doc" | "global";
+    type?: "block" | "collection" | "doc" | "global" | "locale";
 };
 export type FieldConfig = {
+    admin?: {
+        condition?: unknown;
+    };
     blocks?: BlockConfig[];
+    defaultValue?: unknown;
     fields?: FieldConfig[];
     hasMany?: boolean;
     label?: unknown;
+    localized?: boolean;
     name?: string;
+    options?: (string | {
+        label?: unknown;
+        value?: string;
+    })[];
     relationTo?: unknown;
     required?: boolean;
     type?: string;
@@ -26,27 +35,88 @@ type BlockConfig = {
     };
     slug: string;
 };
+type VersionConfig = boolean | {
+    drafts?: boolean | Record<string, unknown>;
+};
+type CollectionLikeConfig = {
+    admin?: {
+        useAsTitle?: string;
+    };
+    access?: Record<string, unknown>;
+    auth?: unknown;
+    fields?: FieldConfig[];
+    label?: unknown;
+    labels?: {
+        plural?: unknown;
+        singular?: unknown;
+    };
+    slug: string;
+    versions?: VersionConfig;
+};
 type MentionContext = {
     blockContexts: (Record<string, unknown> & {
         parent: string;
         slug: string;
     })[];
     collectionSlugs: string[];
+    collections?: ResolvedCollectionPermissionMap;
     globalSlugs: string[];
-    mentions?: AIChatMention[];
+    mentions?: ChatMention[];
     req: Parameters<PayloadHandler>[0];
 };
-export declare const describeField: (field: FieldConfig) => Record<string, unknown>;
-export declare const collectBlocks: ({ fields, parent, }: {
+export declare const describeCollectionLikeSummary: ({ config, permissions, type, }: {
+    config: CollectionLikeConfig;
+    permissions?: ResolvedCollectionPermissionMap;
+    type: "collection" | "global";
+}) => {
+    access: {
+        aiPermissions: Record<import("./collectionPermissions.js").CollectionAction, boolean> | {
+            read: boolean;
+            update: boolean;
+        };
+        hasPayloadAccessControl: boolean;
+    };
+    hasAuth: boolean | undefined;
+    hasDrafts: boolean | undefined;
+    hasLocalizedFields: boolean | undefined;
+    label: unknown;
+    localizedFieldNames: string[] | undefined;
+    slug: string;
+    type: "collection" | "global";
+    useAsTitle: string | undefined;
+};
+export declare const describeCollectionLikeConfig: ({ config, permissions, type, }: {
+    config: CollectionLikeConfig;
+    permissions?: ResolvedCollectionPermissionMap;
+    type: "collection" | "global";
+}) => {
+    fields: Record<string, unknown>[];
+    access: {
+        aiPermissions: Record<import("./collectionPermissions.js").CollectionAction, boolean> | {
+            read: boolean;
+            update: boolean;
+        };
+        hasPayloadAccessControl: boolean;
+    };
+    hasAuth: boolean | undefined;
+    hasDrafts: boolean | undefined;
+    hasLocalizedFields: boolean | undefined;
+    label: unknown;
+    localizedFieldNames: string[] | undefined;
+    slug: string;
+    type: "collection" | "global";
+    useAsTitle: string | undefined;
+};
+export declare const collectBlocks: ({ fields, parent }: {
     fields: FieldConfig[];
     parent: string;
 }) => (Record<string, unknown> & {
     parent: string;
     slug: string;
 })[];
-export declare const getAllowedCollectionSlugs: (req: Parameters<PayloadHandler>[0], collections?: ResolvedAICollectionPermissionMap) => string[];
-export declare const getMentionContext: ({ blockContexts, collectionSlugs, globalSlugs, mentions, req, }: MentionContext) => Promise<Record<string, unknown>[]>;
-export declare const buildPromptWithMentionContext: ({ mentionContext, prompt, }: {
+export declare const getAllowedCollectionSlugs: (req: Parameters<PayloadHandler>[0], collections?: ResolvedCollectionPermissionMap) => string[];
+export declare const getMentionContext: ({ blockContexts, collectionSlugs, collections, globalSlugs, mentions, req }: MentionContext) => Promise<Record<string, unknown>[]>;
+export declare const buildPromptWithMentionContext: ({ mentionContext, prompt }: {
     mentionContext: Record<string, unknown>[];
     prompt: string;
 }) => string;

package/dist/payload/schemaContext.js

@@ -1,18 +1,172 @@
-import { getCollectionSlugsForAction } from "./collectionPermissions.js";
-import { getSerializableLabel, isInternalCollection } from "./shared.js";
+import { getCollectionPermissions, getCollectionSlugsForAction } from "./collectionPermissions.js";
+import { getCollectionFields, isAuthCollection } from "./normalizeData.js";
+import { getSerializableLabel, isInternalCollection, isRecord } from "./shared.js";
 const getSerializableRelationTo = (relationTo)=>{
-    if (typeof relationTo === "string") {
-        return relationTo;
-    }
+    if (typeof relationTo === "string") return relationTo;
     if (Array.isArray(relationTo) && relationTo.every((item)=>typeof item === "string")) {
         return relationTo;
     }
     return undefined;
 };
-export const describeField = (field)=>{
+const fieldDescriptionCache = new WeakMap();
+const blockDescriptionCache = new WeakMap();
+const collectionDescriptionCache = new WeakMap();
+const getLocaleConfigs = (req)=>{
+    const localization = req.payload.config.localization;
+    const defaultLocale = localization?.defaultLocale;
+    const locales = localization?.locales || [];
+    return locales.flatMap((locale)=>{
+        if (typeof locale === "string") {
+            return [
+                {
+                    code: locale,
+                    ...locale === defaultLocale ? {
+                        isDefault: true
+                    } : {},
+                    label: locale
+                }
+            ];
+        }
+        if (!isRecord(locale)) return [];
+        const code = "code" in locale && typeof locale.code === "string" ? locale.code : "label" in locale && typeof locale.label === "string" ? locale.label : undefined;
+        if (!code) return [];
+        const label = "label" in locale ? getSerializableLabel(locale.label, code) : code;
+        return [
+            {
+                code,
+                ...code === defaultLocale ? {
+                    isDefault: true
+                } : {},
+                label
+            }
+        ];
+    });
+};
+const getSerializableOptions = (options)=>{
+    if (!Array.isArray(options)) return undefined;
+    const serializedOptions = options.map((option)=>{
+        if (typeof option === "string") {
+            return {
+                label: option,
+                value: option
+            };
+        }
+        if (!isRecord(option)) return null;
+        const label = "label" in option ? getSerializableLabel(option.label) : undefined;
+        const value = "value" in option && typeof option.value === "string" ? option.value : undefined;
+        if (!label && !value) return null;
+        return {
+            ...label ? {
+                label
+            } : {},
+            ...value ? {
+                value
+            } : {}
+        };
+    }).filter(Boolean);
+    return serializedOptions.length > 0 ? serializedOptions : undefined;
+};
+const hasDrafts = (config)=>{
+    const versions = config?.versions;
+    if (!versions || versions === true) return false;
+    if (!isRecord(versions)) return false;
+    return Boolean(versions.drafts);
+};
+const toNormalizeCollectionConfig = (config)=>{
+    if (!config) return undefined;
+    return {
+        auth: config.auth,
+        fields: config.fields || [],
+        slug: config.slug
+    };
+};
+const getSchemaFields = (config)=>{
+    const normalizedConfig = toNormalizeCollectionConfig(config);
+    const fields = isAuthCollection(normalizedConfig) ? getCollectionFields(normalizedConfig) : [
+        ...config?.fields || []
+    ];
+    if (hasDrafts(config)) {
+        fields.push({
+            label: "Status",
+            name: "_status",
+            options: [
+                "draft",
+                "published"
+            ],
+            required: true,
+            type: "select"
+        });
+    }
+    return fields;
+};
+const getLocalizedFieldNames = (fields, path = "")=>{
+    return fields.flatMap((field)=>{
+        const fieldPath = field.name ? path ? `${path}.${field.name}` : field.name : path;
+        const nestedFields = field.fields ? getLocalizedFieldNames(field.fields, fieldPath) : [];
+        const nestedBlocks = field.blocks ? field.blocks.flatMap((block)=>getLocalizedFieldNames(block.fields || [], `${fieldPath}.${block.slug}`)) : [];
+        return [
+            ...field.localized && fieldPath ? [
+                fieldPath
+            ] : [],
+            ...nestedFields,
+            ...nestedBlocks
+        ];
+    });
+};
+const getCachedCollectionDescription = (config, type)=>{
+    const cached = collectionDescriptionCache.get(config);
+    if (cached) return cached;
+    const slug = config.slug;
+    const fields = getSchemaFields(config);
+    const localizedFieldNames = getLocalizedFieldNames(fields);
+    const description = {
+        fields: fields.map(describeField),
+        hasAuth: isAuthCollection(toNormalizeCollectionConfig(config)) || undefined,
+        hasDrafts: hasDrafts(config) || undefined,
+        hasLocalizedFields: localizedFieldNames.length > 0 || undefined,
+        label: type === "collection" ? config.labels?.plural || config.labels?.singular || slug : getSerializableLabel(config.label) || slug,
+        ...localizedFieldNames.length > 0 ? {
+            localizedFieldNames
+        } : {},
+        ...type === "collection" && config.admin?.useAsTitle ? {
+            useAsTitle: config.admin.useAsTitle
+        } : {},
+        slug
+    };
+    collectionDescriptionCache.set(config, description);
+    return description;
+};
+export const describeCollectionLikeSummary = ({ config, permissions, type })=>{
+    const description = getCachedCollectionDescription(config, type);
+    const slug = description.slug;
+    return {
+        access: {
+            aiPermissions: type === "collection" ? getCollectionPermissions({
+                permissions,
+                slug
+            }) : {
+                read: true,
+                update: true
+            },
+            hasPayloadAccessControl: Boolean(config.access)
+        },
+        hasAuth: description.hasAuth,
+        hasDrafts: description.hasDrafts,
+        hasLocalizedFields: description.hasLocalizedFields,
+        label: description.label,
+        localizedFieldNames: description.localizedFieldNames,
+        slug,
+        type,
+        useAsTitle: description.useAsTitle
+    };
+};
+const describeField = (field)=>{
+    const cached = fieldDescriptionCache.get(field);
+    if (cached) return cached;
     const label = getSerializableLabel(field.label);
     const relationTo = getSerializableRelationTo(field.relationTo);
-    return {
+    const options = getSerializableOptions(field.options);
+    const description = {
         ...label ? {
             label
         } : {},
@@ -28,9 +182,18 @@ export const describeField = (field)=>{
         ...field.hasMany ? {
             hasMany: field.hasMany
         } : {},
+        ...field.localized ? {
+            localized: field.localized
+        } : {},
         ...relationTo ? {
             relationTo
         } : {},
+        ...options ? {
+            options
+        } : {},
+        ...field.admin?.condition ? {
+            hasCondition: true
+        } : {},
         ...field.fields ? {
             fields: field.fields.map(describeField)
         } : {},
@@ -38,13 +201,29 @@ export const describeField = (field)=>{
             blocks: field.blocks.map(describeBlock)
         } : {}
     };
+    fieldDescriptionCache.set(field, description);
+    return description;
 };
 const describeBlock = (block)=>{
-    return {
+    const cached = blockDescriptionCache.get(block);
+    if (cached) return cached;
+    const description = {
         fields: (block.fields || []).map(describeField),
         label: getSerializableLabel(block.labels?.singular) || block.slug,
         slug: block.slug
     };
+    blockDescriptionCache.set(block, description);
+    return description;
+};
+export const describeCollectionLikeConfig = ({ config, permissions, type })=>{
+    return {
+        ...describeCollectionLikeSummary({
+            config,
+            permissions,
+            type
+        }),
+        fields: getCachedCollectionDescription(config, type).fields
+    };
 };
 export const collectBlocks = ({ fields, parent })=>{
     const blocks = [];
@@ -78,11 +257,34 @@ export const getAllowedCollectionSlugs = (req, collections)=>{
         req
     });
 };
-export const getMentionContext = async ({ blockContexts, collectionSlugs, globalSlugs, mentions, req })=>{
+export const getMentionContext = async ({ blockContexts, collectionSlugs, collections, globalSlugs, mentions, req })=>{
     if (!mentions || mentions.length === 0) return [];
     const context = [];
     const seen = new Set();
+    const localeConfigs = getLocaleConfigs(req);
+    const selectedLocales = (mentions.filter((mention)=>mention.type === "locale" && mention.slug).map((mention)=>mention.slug) || []).filter((locale, index, array)=>array.indexOf(locale) === index);
+    const activeLocale = selectedLocales.at(-1);
+    if (localeConfigs.length > 0) {
+        context.push({
+            activeLocale,
+            defaultLocale: localeConfigs.find((locale)=>locale.isDefault)?.code,
+            locales: localeConfigs,
+            selectedLocales,
+            type: "locales"
+        });
+    }
     for (const mention of mentions.slice(0, 8)){
+        if (mention.type === "locale" && mention.slug) {
+            const locale = localeConfigs.find((item)=>item.code === mention.slug);
+            if (!locale) continue;
+            const key = `locale:${locale.code}`;
+            if (seen.has(key)) continue;
+            seen.add(key);
+            context.push({
+                ...locale,
+                type: "locale"
+            });
+        }
         if (mention.type === "collection" && mention.slug) {
             const slug = mention.slug;
             const key = `collection:${slug}`;
@@ -90,12 +292,11 @@ export const getMentionContext = async ({ blockContexts, collectionSlugs, global
             const collectionConfig = req.payload.config.collections.find((collection)=>collection.slug === slug);
             if (!collectionConfig) continue;
             seen.add(key);
-            context.push({
-                fields: collectionConfig.fields.map(describeField),
-                label: collectionConfig.labels?.plural || collectionConfig.labels?.singular || slug,
-                slug,
+            context.push(describeCollectionLikeConfig({
+                config: collectionConfig,
+                permissions: collections,
                 type: "collection"
-            });
+            }));
         }
         if (mention.type === "global" && mention.slug) {
             const slug = mention.slug;
@@ -105,17 +306,20 @@ export const getMentionContext = async ({ blockContexts, collectionSlugs, global
             if (!globalConfig) continue;
             const globalDoc = await req.payload.findGlobal({
                 depth: 2,
+                ...activeLocale ? {
+                    locale: activeLocale
+                } : {},
                 overrideAccess: false,
                 req,
                 slug: slug
             }).catch(()=>null);
             seen.add(key);
             context.push({
-                doc: globalDoc,
-                fields: globalConfig.fields.map(describeField),
-                label: globalConfig.label || slug,
-                slug,
-                type: "global"
+                ...describeCollectionLikeConfig({
+                    config: globalConfig,
+                    type: "global"
+                }),
+                doc: globalDoc
             });
         }
         if (mention.type === "block" && mention.slug) {
@@ -138,6 +342,9 @@ export const getMentionContext = async ({ blockContexts, collectionSlugs, global
                 collection: slug,
                 depth: 2,
                 id: mention.id,
+                ...activeLocale ? {
+                    locale: activeLocale
+                } : {},
                 overrideAccess: false,
                 req
             }).catch(()=>null);
@@ -148,6 +355,9 @@ export const getMentionContext = async ({ blockContexts, collectionSlugs, global
                 doc,
                 id: mention.id,
                 label: mention.label || mention.id,
+                ...activeLocale ? {
+                    locale: activeLocale
+                } : {},
                 type: "doc"
             });
         }
@@ -157,9 +367,8 @@ export const getMentionContext = async ({ blockContexts, collectionSlugs, global
 export const buildPromptWithMentionContext = ({ mentionContext, prompt })=>{
     if (mentionContext.length === 0) return prompt;
     return [
-        "The user selected the following Payload CMS references in the input. Treat inline text like `collection: Name` or `document: Name` as references to this context, not as literal content.",
-        JSON.stringify(mentionContext, null, 2),
-        "User request:",
+        "Selected Payload references JSON. Treat inline reference labels as these entities:",
+        JSON.stringify(mentionContext),
         prompt
     ].join("\n\n");
 };

package/dist/payload/shared.d.ts

@@ -1,2 +1,35 @@
+import type { PayloadHandler } from "payload";
+export type LocalizedDataInput = Record<string, Record<string, unknown>>;
+export type AIActionProposalLike = {
+    action: "create" | "delete" | "update" | "updateGlobal";
+    collection?: string;
+    data?: Record<string, unknown>;
+    id?: string;
+    label: string;
+    locale?: string;
+    localizedData?: LocalizedDataInput;
+    slug?: string;
+};
 export declare const getSerializableLabel: (label: unknown, fallback?: string) => string;
 export declare const isInternalCollection: (slug: string) => boolean;
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const mergeData: (current: Record<string, unknown>, next: Record<string, unknown>) => Record<string, unknown>;
+export declare const isKnownGlobal: (req: Parameters<PayloadHandler>[0], slug: string) => boolean;
+export declare const hasLocalizedData: <Value>(value: Value) => value is Value & {
+    localizedData: LocalizedDataInput;
+};
+export declare const getDefaultLocale: (req: Parameters<PayloadHandler>[0]) => string | null;
+export declare const getJSONLineKey: (line: string) => string | null;
+export declare const isActionProposal: (proposal: unknown) => proposal is AIActionProposalLike;
+export declare const getOptionalNumber: (value: unknown) => number | undefined;
+export declare const getNumber: (value: unknown) => number;
+export declare const getString: (value: unknown) => string | null;
+export declare const getDocLabel: (doc: Record<string, unknown>, useAsTitle?: string) => string;
+export declare const getOptionValue: (option?: string | {
+    label?: unknown;
+    value?: string;
+}) => string | undefined;
+export declare const hasValueAtPath: (data: Record<string, unknown>, path: string) => boolean;
+export declare const getSafeProposalLabel: (label: string) => string;
+export declare const setValueAtPath: (data: Record<string, unknown>, path: string, value: unknown) => void;
+export declare const isAbortError: (err: unknown) => boolean;

package/dist/payload/shared.js

@@ -1,3 +1,4 @@
+const maxProposalLabelLength = 90;
 export const getSerializableLabel = (label, fallback = "")=>{
     if (typeof label === "string") return label;
     if (label && typeof label === "object") {
@@ -9,3 +10,116 @@ export const getSerializableLabel = (label, fallback = "")=>{
 export const isInternalCollection = (slug)=>{
     return slug.startsWith("payload-") || slug === "plugin-collection";
 };
+export const isRecord = (value)=>{
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+};
+export const mergeData = (current, next)=>{
+    return Object.fromEntries(Object.entries({
+        ...current,
+        ...next
+    }).map(([key, value])=>{
+        const currentValue = current[key];
+        if (isRecord(currentValue) && isRecord(value)) {
+            return [
+                key,
+                mergeData(currentValue, value)
+            ];
+        }
+        return [
+            key,
+            value
+        ];
+    }));
+};
+export const isKnownGlobal = (req, slug)=>{
+    return req.payload.config.globals?.some((item)=>item.slug === slug) || false;
+};
+export const hasLocalizedData = (value)=>{
+    return isRecord(value) && isRecord(value.localizedData);
+};
+export const getDefaultLocale = (req)=>{
+    const localization = req.payload.config.localization;
+    if (!localization) return null;
+    return localization.defaultLocale || null;
+};
+export const getJSONLineKey = (line)=>{
+    const match = /^(\s*)"([^"]+)":/.exec(line);
+    return match ? `${match[1]}${match[2]}` : null;
+};
+const isNonEmptyString = (value)=>{
+    return typeof value === "string" && value.trim().length > 0;
+};
+const hasWriteData = (proposal)=>{
+    const hasData = isRecord(proposal.data);
+    const hasLocalizedProposalData = hasLocalizedData(proposal);
+    return hasData !== hasLocalizedProposalData;
+};
+export const isActionProposal = (proposal)=>{
+    if (!isRecord(proposal) || !isNonEmptyString(proposal.label)) return false;
+    if (proposal.action === "create") {
+        return isNonEmptyString(proposal.collection) && hasWriteData(proposal);
+    }
+    if (proposal.action === "update") {
+        return isNonEmptyString(proposal.collection) && isNonEmptyString(proposal.id) && hasWriteData(proposal);
+    }
+    if (proposal.action === "delete") {
+        return isNonEmptyString(proposal.collection) && isNonEmptyString(proposal.id);
+    }
+    if (proposal.action === "updateGlobal") {
+        return isNonEmptyString(proposal.slug) && hasWriteData(proposal);
+    }
+    return false;
+};
+export const getOptionalNumber = (value)=>{
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+};
+export const getNumber = (value)=>{
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+};
+export const getString = (value)=>{
+    return typeof value === "string" ? value : null;
+};
+export const getDocLabel = (doc, useAsTitle)=>{
+    const titleField = useAsTitle ? getSerializableLabel(doc[useAsTitle]) : "";
+    const title = getSerializableLabel(doc.title);
+    const name = getSerializableLabel(doc.name);
+    const email = getSerializableLabel(doc.email);
+    return titleField || title || name || email || doc.id?.toString() || "Untitled";
+};
+export const getOptionValue = (option)=>{
+    if (!option) return undefined;
+    if (typeof option === "string") return option;
+    return typeof option.value === "string" ? option.value : undefined;
+};
+export const hasValueAtPath = (data, path)=>{
+    const segments = path.split(".");
+    let current = data;
+    for (const segment of segments){
+        if (!isRecord(current) || current[segment] === undefined) {
+            return false;
+        }
+        current = current[segment];
+    }
+    return true;
+};
+export const getSafeProposalLabel = (label)=>{
+    const firstLine = label.replace(/[*_`>#-]/g, "").split("\n").map((line)=>line.trim()).find(Boolean);
+    if (!firstLine) return "Review proposed CMS change";
+    if (firstLine.length <= maxProposalLabelLength) return firstLine;
+    return `${firstLine.slice(0, maxProposalLabelLength - 3).trim()}...`;
+};
+export const setValueAtPath = (data, path, value)=>{
+    const segments = path.split(".");
+    let current = data;
+    for (const segment of segments.slice(0, -1)){
+        const next = current[segment];
+        if (!isRecord(next)) {
+            current[segment] = {};
+        }
+        current = current[segment];
+    }
+    current[segments[segments.length - 1]] = value;
+};
+export const isAbortError = (err)=>{
+    return err instanceof DOMException && err.name === "AbortError";
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mvriu5/payload-ai",
-    "version": "0.5.8",
+    "version": "0.5.10",
     "description": "AI assistant plugin for Payload CMS with provider selection, CMS mentions, and signed action proposals.",
     "keywords": [
         "payload",
@@ -75,7 +75,7 @@
         "payload": "3.84.1",
         "prettier": "^3.8.4",
         "react": "19.2.7",
-        "react-dom": "19.2.6",
+        "react-dom": "19.2.7",
         "rimraf": "6.1.3",
         "sharp": "0.35.1",
         "typescript": "5.9.3",
@@ -94,6 +94,7 @@
     },
     "knip": {
         "entry": [
+            "src/exports/client.ts",
             "dev/payload.config.ts",
             "dev/next.config.mjs",
             "dev/app/**/*.{ts,tsx}"
@@ -101,6 +102,9 @@
         "ignore": [
             "dev/payload-types.ts"
         ],
+        "ignoreDependencies": [
+            "prettier"
+        ],
         "project": [
             "src/**/*.{ts,tsx}",
             "dev/**/*.{ts,tsx,mjs}"
@@ -111,6 +115,7 @@
         "@ai-sdk/google": "^3.0.80",
         "@ai-sdk/mistral": "^3.0.37",
         "@ai-sdk/openai": "^3.0.67",
+        "@openrouter/ai-sdk-provider": "^2.9.1",
         "ai": "^6.0.193",
         "zod": "^4.4.3"
     }

package/dist/components/AIActionProposalList.d.ts

@@ -1,25 +0,0 @@
-export type AIActionProposal = {
-    _aiSignature?: {
-        expiresAt: string;
-        value: string;
-    };
-    action: "create" | "delete" | "update" | "updateGlobal";
-    collection?: string;
-    data?: Record<string, unknown>;
-    id?: string;
-    label: string;
-    slug?: string;
-};
-type AIActionProposalListProps = {
-    appliedProposalIndexes: number[];
-    description?: string;
-    error?: string;
-    getViewURL?: (proposal: AIActionProposal) => string | null;
-    isApplying: boolean;
-    onDismiss?: () => void;
-    onDismissError?: () => void;
-    onApply: (proposal: AIActionProposal, index: number) => void;
-    proposals: AIActionProposal[];
-};
-export declare const AIActionProposalList: ({ appliedProposalIndexes, description, error, getViewURL, isApplying, onDismiss, onDismissError, onApply, proposals, }: AIActionProposalListProps) => import("react").JSX.Element | null;
-export {};