@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/hygiene/tasks/cleanup/empty-folders.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCleanupEmptyFolders = void 0;
+const errors_1 = require("../../../shared/errors");
+const shared_1 = require("../shared");
+/**
+ * Well-known Sitecore folder-template IDs. Normalised to lowercase /
+ * dashes-stripped / no-curlies form so callers can compare cheaply
+ * against the same shape returned by `getChildren`. Sourced from the
+ * Sitecore platform constants:
+ *
+ *   - `{A87A00B1-E6DB-45AB-8B54-636FEC3B5523}` Common/Folder
+ *   - `{0437FEE2-44C9-46A6-ABE9-28858D9FEE8C}` System/Templates/Template folder
+ *   - `{FE5DD826-48C6-436D-B87A-7C4210C7413B}` System/Media/Media folder
+ *   - `{75CC5CB0-92CB-4ABD-BA7F-23A9B20D684D}` Common/Node
+ *
+ * Add new ids via `--folder-template-ids` rather than expanding this
+ * set — different installs may have different conventions and we want
+ * the default to err on safety.
+ */
+const WELL_KNOWN_FOLDER_TEMPLATE_IDS = [
+    "a87a00b1e6db45ab8b54636fec3b5523",
+    "0437fee244c946a6abe928858d9fee8c",
+    "fe5dd82648c6436db87a7c4210c7413b",
+    "75cc5cb092cb4abdba7f23a9b20d684d",
+];
+const PROTECTED_ROOTS = ["/sitecore/system", "/sitecore/templates", "/sitecore/layout"];
+/**
+ * Delete folder-like items that have no children, recursively
+ * bottom-up under `--root`.
+ *
+ * Strategy:
+ *   1. Walk the tree depth-first via `getChildren`.
+ *   2. At each node, recurse; if every child reports as "empty after
+ *      cleanup" (i.e. itself got deleted), and the node itself has
+ *      no remaining children, delete the node.
+ *   3. Continue bubbling up — parent may become empty after its
+ *      children are deleted.
+ *
+ * Safety rails:
+ *   - `--root` required; no tenant-wide form.
+ *   - `/sitecore/system`, `/sitecore/templates`, `/sitecore/layout`
+ *     refused without `--force`.
+ *   - `--allow-write` (or env `allowWrite`) required outside
+ *     `--what-if`.
+ *   - `--max-deletions` caps total folder removals.
+ *   - Items that have content (non-folder template, fields with
+ *     values) are NOT touched — we ONLY delete items with zero
+ *     children, regardless of their template. If a "Page" item has
+ *     no children, the operator should clean it via `cleanup
+ *     duplicates` or similar, not here.
+ */
+const runCleanupEmptyFolders = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    if (!options.root) {
+        throw (0, errors_1.createScaiError)("--root is required.", "INPUT_INVALID");
+    }
+    if (!options.force && PROTECTED_ROOTS.some((p) => options.root.startsWith(p))) {
+        throw (0, errors_1.createScaiError)(`Refusing to operate under protected root '${options.root}' without --force.`, "INPUT_INVALID");
+    }
+    const { envName, root: rootConfig, client } = (0, shared_1.resolveTenant)(options);
+    if (!options.whatIf) {
+        (0, shared_1.ensureAllowWriteForCleanup)(rootConfig, envName, options.allowWrite);
+    }
+    else if (!logger.isJson()) {
+        logger.info("What-if mode active — no folders will be deleted.", "yellow");
+    }
+    const maxDeletions = options.maxDeletions ?? 500;
+    const folderTemplateIds = new Set([
+        ...WELL_KNOWN_FOLDER_TEMPLATE_IDS,
+        ...(options.folderTemplateIds ?? []).map((id) => (0, shared_1.normalizeItemId)(id)),
+    ]);
+    const templateNamePattern = options.templateNamePattern
+        ? new RegExp(options.templateNamePattern, "i")
+        : null;
+    const anyTemplate = Boolean(options.anyTemplate);
+    if (anyTemplate) {
+        logger.warn("--any-template is set — every leaf item with zero children will be deleted, regardless of template. Combine with --what-if and a tight --root.");
+    }
+    const isFolderLike = (child) => {
+        if (anyTemplate)
+            return true;
+        if (child.templateId && folderTemplateIds.has((0, shared_1.normalizeItemId)(child.templateId)))
+            return true;
+        if (templateNamePattern && child.templateName && templateNamePattern.test(child.templateName))
+            return true;
+        return false;
+    };
+    const actions = [];
+    let skippedNonFolder = 0;
+    const walk = async (path) => {
+        if (actions.length >= maxDeletions)
+            return false;
+        let children;
+        try {
+            children = await client.getChildren({ path });
+        }
+        catch {
+            return false;
+        }
+        if (children.length === 0)
+            return true;
+        const childResults = await Promise.all(children.map(async (child) => {
+            const childEmpty = await walk(child.path);
+            if (!childEmpty)
+                return false;
+            if (actions.length >= maxDeletions)
+                return false;
+            // The original behaviour deleted any leaf item with zero
+            // children — a Page item whose children had just been removed
+            // would silently disappear next run. Restrict deletions to the
+            // folder-template allowlist (with an opt-in name pattern and a
+            // hard escape via --any-template).
+            if (!isFolderLike(child)) {
+                skippedNonFolder += 1;
+                logger.verbose(`Skipping ${child.path}: template ${child.templateName ?? child.templateId ?? "<unknown>"} is not in the folder allowlist.`);
+                return false;
+            }
+            const action = {
+                itemId: child.itemId,
+                path: child.path,
+                status: options.whatIf ? "what-if" : "deleted",
+            };
+            if (!options.whatIf) {
+                try {
+                    await client.deleteItem({ itemId: child.itemId, permanently: true });
+                }
+                catch (error) {
+                    action.status = "failed";
+                    action.error = error instanceof Error ? error.message : String(error);
+                }
+            }
+            actions.push(action);
+            return action.status !== "failed";
+        }));
+        return childResults.every((r) => r === true);
+    };
+    await walk(options.root);
+    const deleted = actions.filter((a) => a.status === "deleted").length;
+    const failed = actions.filter((a) => a.status === "failed").length;
+    const summary = options.whatIf
+        ? `Plan: would delete ${actions.length} empty folder${actions.length === 1 ? "" : "s"}.`
+        : `Deleted ${deleted} empty folder${deleted === 1 ? "" : "s"}${failed > 0 ? ` (${failed} failed)` : ""}.`;
+    (0, shared_1.printReport)({
+        logger,
+        command: "cleanup.empty-folders",
+        envName,
+        results: actions,
+        summary,
+        formatLine: (a) => `${a.status === "what-if" ? "[would delete] " : a.status === "failed" ? "[failed] " : ""}${a.path}${a.error ? ` — ${a.error}` : ""}`,
+        extra: {
+            root: options.root,
+            whatIf: Boolean(options.whatIf),
+            maxDeletions,
+            deletedCount: deleted,
+            failedCount: failed,
+            skippedNonFolderCount: skippedNonFolder,
+            folderTemplateIds: [...folderTemplateIds],
+            anyTemplate,
+        },
+        options,
+    });
+    return actions;
+};
+exports.runCleanupEmptyFolders = runCleanupEmptyFolders;

package/dist/hygiene/tasks/cleanup/field-set.d.ts

@@ -0,0 +1,108 @@
+import { type HygieneCommonOptions } from "../shared";
+export type FieldSetMode = "replace" | "add" | "remove" | "clear";
+export interface CleanupFieldSetOptions extends HygieneCommonOptions {
+    /**
+     * Required. Field name to write (case-insensitive against the item's
+     * template). Single field per run — the verb is intentionally narrow
+     * so the audit trail stays clear.
+     */
+    field: string;
+    /**
+     * Required for `replace` and `add`/`remove`. The value to write:
+     *   - `replace`: written verbatim (any Sitecore wire shape — raw
+     *     string, `{guid}`, pipe-delimited list, `<link/>` XML, ISO date).
+     *   - `add` / `remove`: one or more GUIDs (with or without braces),
+     *     comma- or pipe-separated. Each is treated as a multilist
+     *     member to union with / subtract from the current value.
+     *   - `clear`: ignored; the field is wiped.
+     */
+    value?: string;
+    /**
+     * How to combine `value` with the existing field state.
+     * Default `replace`.
+     *
+     * - `replace`: overwrite the field with `value` verbatim. Works for
+     *   any field type — caller owns the wire shape.
+     * - `add`: union the supplied GUIDs into a pipe-delimited list.
+     *   Reads the current value first; refuses if the existing value is
+     *   non-empty and isn't a pipe-delimited GUID list (avoids corrupting
+     *   Single-Line Text or RichText fields by accident).
+     * - `remove`: subtract the supplied GUIDs from a pipe-delimited list.
+     *   Same shape guard as `add`.
+     * - `clear`: write the empty string.
+     *
+     * The `add` / `remove` modes are the answer to "bulk tag-add" /
+     * "bulk tag-remove" — Sitecore tags are TreelistEx fields whose
+     * underlying wire format is `{guid1}|{guid2}|…`, so set-union and
+     * set-difference are the right primitives.
+     */
+    mode?: FieldSetMode;
+    /** Restrict to descendants of this content-tree path. Default `/sitecore/content`. */
+    root?: string;
+    /** Restrict by template name pattern. Strongly recommended. */
+    templatePattern?: string;
+    /** Only update items whose current value of `field` matches this regex. */
+    whereCurrentMatches?: string;
+    /** Restrict by language. Default: every language version of each item. */
+    language?: string;
+    index?: string;
+    limit?: number;
+    includeSystem?: boolean;
+    /** Allow writing to `__`-prefixed system fields. Off by default. */
+    includeSystemFields?: boolean;
+    batchSize?: number;
+    concurrency?: number;
+    pageParallelism?: number;
+    cache?: boolean;
+    exclude?: string[];
+    since?: string;
+    owner?: string;
+    whatIf?: boolean;
+    allowWrite?: boolean;
+    baseline?: boolean;
+    output?: string;
+    format?: "json" | "csv" | "markdown";
+    /**
+     * Maximum number of items mutated per run. Default 100 — defends
+     * against an unintentionally-broad `--template-pattern` matching
+     * thousands of items.
+     */
+    maxMutations?: number;
+}
+export interface FieldSetAction {
+    itemId: string;
+    path: string;
+    templateName: string | null;
+    language: string | null;
+    fieldName: string;
+    mode: FieldSetMode;
+    oldValue: string;
+    newValue: string;
+    status: "applied" | "what-if" | "failed" | "skipped-cap" | "skipped-no-change" | "skipped-shape";
+    error?: string;
+}
+/**
+ * Bulk-edit a single field across a content scope.
+ *
+ * One verb, four modes — `replace`, `add`, `remove`, `clear`. Field
+ * "type" is not part of the verb's contract; Sitecore resolves the
+ * field name against the item's template and accepts the resulting
+ * value string. The cleanup task validates the *shape* of the existing
+ * value before `add` / `remove` (pipe-delimited GUID list) so a stray
+ * `mode: add` against a Single-Line Text field can't silently corrupt
+ * it.
+ *
+ * Safety rails:
+ *   - `--what-if` reports the plan without writing.
+ *   - `--allow-write` required outside what-if.
+ *   - `--max-mutations` caps the blast radius (default 100).
+ *   - `--template-pattern` is strongly recommended — without it the
+ *     verb operates on every item in the content tree, which is
+ *     rarely what's intended.
+ *   - `__`-prefixed system fields rejected unless `--include-system-fields`.
+ *   - `--where-current-matches` lets the operator restrict to items
+ *     whose current value of the field matches a regex (useful for
+ *     idempotent re-runs: "set Field X to V on every item where X is
+ *     currently empty").
+ */
+export declare const runCleanupFieldSet: (options: CleanupFieldSetOptions) => Promise<FieldSetAction[]>;

package/dist/hygiene/tasks/cleanup/field-set.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCleanupFieldSet = void 0;
+const cli_tasks_1 = require("../../../shared/cli-tasks");
+const errors_1 = require("../../../shared/errors");
+const shared_1 = require("../shared");
+const GUID_PATTERN = /^\{?[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}\}?$/i;
+const PIPE_GUID_LIST_PATTERN = /^(\{?[0-9a-f-]{32,38}\}?)(\|\{?[0-9a-f-]{32,38}\}?)*$/i;
+/**
+ * Normalize a GUID to the lower-case braced form `{xxxxxxxx-...-xxxxxxxxxxxx}`
+ * that Sitecore Multilist/Treelist field values use.
+ */
+const normalizeGuid = (raw) => {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    if (!GUID_PATTERN.test(trimmed))
+        return null;
+    const bare = trimmed.replace(/[{}]/g, "").toLowerCase();
+    // Insert hyphens at the standard 8-4-4-4-12 positions if absent.
+    const hyphenated = bare.length === 32
+        ? `${bare.slice(0, 8)}-${bare.slice(8, 12)}-${bare.slice(12, 16)}-${bare.slice(16, 20)}-${bare.slice(20)}`
+        : bare;
+    return `{${hyphenated}}`;
+};
+/** Parse a "comma-or-pipe-separated GUID list" input into normalized braced GUIDs. */
+const parseGuidList = (value) => {
+    const guids = value
+        .split(/[,|]/)
+        .map((part) => normalizeGuid(part))
+        .filter((g) => g !== null);
+    if (!guids.length) {
+        throw (0, errors_1.createScaiError)("`value` for mode='add'/'remove' must contain at least one GUID.", "INPUT_INVALID");
+    }
+    return guids;
+};
+const splitMultilistValue = (current) => {
+    if (!current || !current.trim())
+        return [];
+    return current
+        .split("|")
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+};
+const joinMultilistValue = (guids) => guids
+    .map((g) => normalizeGuid(g) ?? g)
+    .filter((g) => g.length > 0)
+    .join("|");
+const isPipeDelimitedGuidShape = (value) => {
+    if (!value || !value.trim())
+        return true; // empty is compatible with multilist
+    return PIPE_GUID_LIST_PATTERN.test(value.trim());
+};
+/**
+ * Bulk-edit a single field across a content scope.
+ *
+ * One verb, four modes — `replace`, `add`, `remove`, `clear`. Field
+ * "type" is not part of the verb's contract; Sitecore resolves the
+ * field name against the item's template and accepts the resulting
+ * value string. The cleanup task validates the *shape* of the existing
+ * value before `add` / `remove` (pipe-delimited GUID list) so a stray
+ * `mode: add` against a Single-Line Text field can't silently corrupt
+ * it.
+ *
+ * Safety rails:
+ *   - `--what-if` reports the plan without writing.
+ *   - `--allow-write` required outside what-if.
+ *   - `--max-mutations` caps the blast radius (default 100).
+ *   - `--template-pattern` is strongly recommended — without it the
+ *     verb operates on every item in the content tree, which is
+ *     rarely what's intended.
+ *   - `__`-prefixed system fields rejected unless `--include-system-fields`.
+ *   - `--where-current-matches` lets the operator restrict to items
+ *     whose current value of the field matches a regex (useful for
+ *     idempotent re-runs: "set Field X to V on every item where X is
+ *     currently empty").
+ */
+const runCleanupFieldSet = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    if (!options.field || !options.field.trim()) {
+        throw (0, errors_1.createScaiError)("--field is required.", "INPUT_INVALID");
+    }
+    const mode = options.mode ?? "replace";
+    if (mode !== "clear" && (options.value === undefined || options.value === null)) {
+        throw (0, errors_1.createScaiError)(`--value is required for mode='${mode}'.`, "INPUT_INVALID");
+    }
+    const maxMutations = options.maxMutations ?? 100;
+    const templateRegex = options.templatePattern ? new RegExp(options.templatePattern, "i") : null;
+    const currentRegex = options.whereCurrentMatches ? new RegExp(options.whereCurrentMatches) : null;
+    const fieldNameLc = options.field.toLowerCase();
+    const includeSystemFields = Boolean(options.includeSystemFields);
+    if (fieldNameLc.startsWith("__") && !includeSystemFields) {
+        throw (0, errors_1.createScaiError)("Refusing to write a `__`-prefixed system field without --include-system-fields.", "INPUT_INVALID");
+    }
+    // For add/remove, parse the GUID list up-front so a bad input fails
+    // before the search crawl.
+    const guidList = mode === "add" || mode === "remove" ? parseGuidList(options.value) : null;
+    const { envName, root: rootConfig, client } = (0, shared_1.resolveTenant)(options);
+    if (!options.whatIf) {
+        (0, shared_1.ensureAllowWriteForCleanup)(rootConfig, envName, options.allowWrite);
+    }
+    else if (!logger.isJson()) {
+        logger.info("What-if mode active — no items will be modified.", "yellow");
+    }
+    const { scanned, fieldsByItemId, cache, knobs } = await (0, shared_1.scanItemsAndFields)({
+        client,
+        envName,
+        root: options.root ?? "/sitecore/content",
+        logger,
+        options,
+    });
+    const plans = [];
+    for (const item of scanned) {
+        if (templateRegex && !templateRegex.test(item.templateName ?? ""))
+            continue;
+        const fields = fieldsByItemId.get(item.itemId);
+        if (!fields || !Array.isArray(fields))
+            continue;
+        const matchingField = fields.find((f) => f.name.toLowerCase() === fieldNameLc);
+        if (!matchingField)
+            continue; // Field not on this item's template; not our problem.
+        const oldValue = matchingField.value ?? "";
+        if (currentRegex && !currentRegex.test(oldValue))
+            continue;
+        let newValue = oldValue;
+        let skip;
+        switch (mode) {
+            case "replace":
+                newValue = options.value;
+                break;
+            case "clear":
+                newValue = "";
+                break;
+            case "add": {
+                if (!isPipeDelimitedGuidShape(oldValue)) {
+                    skip = "skipped-shape";
+                    break;
+                }
+                const existing = splitMultilistValue(oldValue);
+                const merged = new Set(existing.map((g) => normalizeGuid(g) ?? g.toLowerCase()).filter(Boolean));
+                for (const g of guidList)
+                    merged.add(g);
+                newValue = joinMultilistValue([...merged]);
+                break;
+            }
+            case "remove": {
+                if (!isPipeDelimitedGuidShape(oldValue)) {
+                    skip = "skipped-shape";
+                    break;
+                }
+                const existing = splitMultilistValue(oldValue);
+                const toRemove = new Set(guidList);
+                const filtered = existing.map((g) => normalizeGuid(g) ?? g).filter((g) => !toRemove.has(g));
+                newValue = joinMultilistValue(filtered);
+                break;
+            }
+        }
+        if (!skip && newValue === oldValue) {
+            skip = "skipped-no-change";
+        }
+        plans.push({
+            item,
+            field: { name: matchingField.name, oldValue },
+            newValue,
+            ...(skip && { skip }),
+        });
+        if (plans.filter((p) => !p.skip).length >= maxMutations) {
+            logger.warn(`Hit --max-mutations cap (${maxMutations}); ${scanned.length - plans.length} item(s) skipped. Re-run with a higher cap to widen.`);
+            break;
+        }
+    }
+    logger.verbose(`${plans.length} item(s) considered; ${plans.filter((p) => !p.skip).length} will mutate.`);
+    const actions = await (0, cli_tasks_1.mapWithConcurrency)(plans, async (plan) => {
+        const base = {
+            itemId: plan.item.itemId,
+            path: plan.item.path,
+            templateName: plan.item.templateName,
+            language: plan.item.language,
+            fieldName: plan.field.name,
+            mode,
+            oldValue: plan.field.oldValue,
+            newValue: plan.newValue,
+        };
+        if (plan.skip)
+            return { ...base, status: plan.skip };
+        if (options.whatIf)
+            return { ...base, status: "what-if" };
+        try {
+            await client.updateItemFields({
+                itemId: (0, shared_1.dashifyItemId)(plan.item.itemId),
+                fields: [{ name: plan.field.name, value: plan.newValue }],
+            });
+            return { ...base, status: "applied" };
+        }
+        catch (error) {
+            return {
+                ...base,
+                status: "failed",
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }, knobs.concurrency);
+    await cache?.flush();
+    const applied = actions.filter((a) => a.status === "applied").length;
+    const failed = actions.filter((a) => a.status === "failed").length;
+    const skippedShape = actions.filter((a) => a.status === "skipped-shape").length;
+    const summary = options.whatIf
+        ? `Plan: would update ${actions.filter((a) => a.status === "what-if").length} item(s) [mode=${mode}].`
+        : `Applied ${applied} update(s) [mode=${mode}]${failed > 0 ? `; ${failed} failed` : ""}${skippedShape > 0 ? `; ${skippedShape} skipped (incompatible shape)` : ""}.`;
+    (0, shared_1.printReport)({
+        logger,
+        command: "cleanup.field-set",
+        envName,
+        results: actions,
+        summary,
+        formatLine: (a) => `${a.status === "applied" ? "" : `[${a.status}] `}${a.path} — ${a.fieldName}: ${a.oldValue.slice(0, 30) || "(empty)"} → ${a.newValue.slice(0, 30) || "(empty)"}${a.error ? ` — ${a.error}` : ""}`,
+        extra: {
+            field: options.field,
+            mode,
+            whatIf: Boolean(options.whatIf),
+            maxMutations,
+            appliedCount: applied,
+            failedCount: failed,
+            skippedShapeCount: skippedShape,
+        },
+        options,
+    });
+    return actions;
+};
+exports.runCleanupFieldSet = runCleanupFieldSet;

package/dist/hygiene/tasks/cleanup/find-replace.d.ts

@@ -0,0 +1,77 @@
+import { type HygieneCommonOptions } from "../shared";
+export interface CleanupFindReplaceOptions extends HygieneCommonOptions {
+    /** Required. Pattern to find. */
+    pattern: string;
+    /** Required. Replacement string. Supports regex backreferences (`$1`, `$&`). */
+    replacement: string;
+    literal?: boolean;
+    ignoreCase?: boolean;
+    flags?: string;
+    /** Field-name filter. */
+    fields?: string[];
+    includeSystemFields?: boolean;
+    /** Content root. Default `/sitecore/content`. */
+    root?: string;
+    index?: string;
+    limit?: number;
+    includeSystem?: boolean;
+    language?: string;
+    batchSize?: number;
+    concurrency?: number;
+    pageParallelism?: number;
+    cache?: boolean;
+    whatIf?: boolean;
+    allowWrite?: boolean;
+    /**
+     * Maximum number of items to mutate per run. Default 100 — defends
+     * against runaway pattern matches. Set higher when you've validated
+     * the audit output and want to apply at scale.
+     */
+    maxMutations?: number;
+}
+export interface FindReplaceAction {
+    itemId: string;
+    path: string;
+    templateName: string | null;
+    language: string | null;
+    fieldsChanged: Array<{
+        fieldName: string;
+        matchCount: number;
+        /** Up to 3 before/after pairs for the report. */
+        samples: Array<{
+            before: string;
+            after: string;
+        }>;
+    }>;
+    status: "applied" | "what-if" | "failed" | "skipped-cap";
+    error?: string;
+}
+/**
+ * Apply a find-replace operation across content fields.
+ *
+ * Strategy:
+ *   1. Use `scanItemsAndFields` to crawl items and load fields.
+ *   2. Compile the pattern once; for each field, run `.replace` to
+ *      compute the new value and count matches.
+ *   3. Apply via `updateItemFields(itemId, [{name, value}])` per item.
+ *   4. Stop when `--max-mutations` items have been touched.
+ *
+ * Safety rails:
+ *   - `--what-if` reports the planned changes without calling the API.
+ *   - `--allow-write` (or env `allowWrite`) required outside `--what-if`.
+ *   - `--max-mutations` caps the change blast-radius. Default 100.
+ *   - `__`-prefixed system fields are excluded by default. Operators
+ *     who want to touch them must pass `--include-system-fields` AND
+ *     know what they're doing — replacing a `__Renderings` value via
+ *     regex will mangle the XML.
+ *
+ * Notes:
+ *   - The `replacement` string supports JS RegExp backreferences
+ *     (`$1`, `$&`, `$<name>`), same as `String.replace()`. Operators
+ *     who want literal `$` use `$$$$`.
+ *   - Each item is mutated in a single `updateItem` call regardless
+ *     of how many fields change on it. Per-language updates aren't
+ *     supported in this round — the Authoring API treats the update
+ *     as latest-version on the item's primary language.
+ */
+export declare const runCleanupFindReplace: (options: CleanupFindReplaceOptions) => Promise<FindReplaceAction[]>;