@prenta/mcp-server 0.23.0

package/dist/client.d.ts

@@ -0,0 +1,1348 @@
+/**
+ * Thin HTTP client for the Prenta CMS REST API. We deliberately don't depend
+ * on @prenta/core here — that would force the MCP server to bring
+ * in Prisma, all the server-side modules, and a Next.js runtime context. The
+ * MCP server only needs to translate MCP tool calls into HTTP requests.
+ */
+export interface PrentaClientOptions {
+    /** Base URL of the CMS, e.g. `https://maidpro.co`. The /api/cms path is appended automatically. */
+    baseUrl: string;
+    /** API key (`act_sk_...`). */
+    apiKey: string;
+    /** Optional fetch implementation override (used in tests). */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Thrown by `PrentaClient` on non-2xx responses. Carries the HTTP
+ * `status` so callers (e.g. `list_collections`'s OpenAPI fallback) can
+ * branch on the status code rather than pattern-matching the error
+ * message — pattern matching was rejected by review on PR #155 because
+ * a real 404 might omit the literal substring "not found" and an
+ * unrelated 5xx response might include it.
+ */
+export declare class PrentaClientError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+export declare class PrentaClient {
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    private readonly fetchImpl;
+    constructor(opts: PrentaClientOptions);
+    private headers;
+    private request;
+    /**
+     * POST a `multipart/form-data` body. Distinct from `request()` because:
+     *
+     *  - we MUST NOT set `Content-Type` (the fetch implementation appends the
+     *    multipart boundary; if we override it the server can't parse the body),
+     *  - we MUST NOT `JSON.stringify(form)` — a `FormData` is sent verbatim,
+     *  - the upload handler in `cms-core` rejects requests without a valid
+     *    `Content-Length` header, and Node 20+ / undici populate that header
+     *    automatically when the body is a `FormData`.
+     *
+     * Used exclusively by `uploadMedia` today. Kept as a thin private helper so
+     * the failure mode (multipart parse error vs JSON parse error vs HTTP
+     * error) stays observable to the caller.
+     */
+    private requestMultipart;
+    listDocuments(collection: string, query?: {
+        page?: number;
+        pageSize?: number;
+        status?: string;
+        search?: string;
+        slug?: string;
+    }): Promise<{
+        data: {
+            docs: any[];
+            total: number;
+            page: number;
+            pageSize: number;
+        };
+    }>;
+    getDocument(collection: string, id: string): Promise<{
+        data: any;
+    }>;
+    createDocument(collection: string, data: Record<string, unknown>): Promise<{
+        data: any;
+    }>;
+    updateDocument(collection: string, id: string, data: Record<string, unknown>): Promise<{
+        data: any;
+    }>;
+    deleteDocument(collection: string, id: string): Promise<{
+        data: {
+            deleted: boolean;
+        };
+    }>;
+    getGlobal(slug: string): Promise<{
+        data: any;
+    }>;
+    updateGlobal(slug: string, data: Record<string, unknown>): Promise<{
+        data: any;
+    }>;
+    /**
+     * List media assets. The `GET /media` endpoint returns the asset array under
+     * `items`/`data` (and pagination fields), never `docs`. We normalize it into
+     * the same `{ data: { docs, total, page, pageSize, totalPages } }` envelope
+     * as `listDocuments` so the `list_media` MCP tool output is consistent with
+     * `list_documents` and an agent can read `docs` uniformly.
+     */
+    listMedia(query?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<{
+        data: {
+            docs: any[];
+            total: number;
+            page: number;
+            pageSize: number;
+            totalPages: number;
+        };
+    }>;
+    /**
+     * Upload a binary asset to the CMS media library. Bytes are accepted as a
+     * `Uint8Array` / `Buffer` (the MCP tool wrapper handles base64 decoding
+     * from the JSON-RPC layer, but the client surface stays binary).
+     *
+     * The server enforces a 50 MB hard cap and validates magic bytes against
+     * the declared `mimeType` — uploading a `.exe` with `image/png` will be
+     * rejected with HTTP 415. SVGs are sanitised server-side. Pass
+     * `skipOptimize: true` to keep the original bytes; by default JPEG / PNG
+     * are recompressed to WebP.
+     */
+    uploadMedia(input: {
+        filename: string;
+        mimeType: string;
+        bytes: Uint8Array | Buffer;
+        skipOptimize?: boolean;
+        /**
+         * When true, skip content-hash dedupe and always create a new record
+         * even if identical bytes already exist (#718).
+         */
+        forceUpload?: boolean;
+    }): Promise<{
+        data: any;
+    }>;
+    /**
+     * Update media metadata. Only the supplied fields are touched. `alt` maps
+     * to the DB column `altText`; `focalX` / `focalY` (range 0..1) drive
+     * smart-crop on the front end. `caption`, `description`, and `focusKeyword`
+     * round out the fields `calculateMediaSeoScore` reads, so an agent can take
+     * an asset all the way to a passing media SEO grade.
+     */
+    updateMedia(id: string, body: {
+        alt?: string;
+        title?: string;
+        filename?: string;
+        caption?: string;
+        description?: string;
+        focusKeyword?: string;
+        focalX?: number;
+        focalY?: number;
+        /** WCAG decorative image — empty alt is intentional (#714). */
+        isDecorative?: boolean;
+    }): Promise<{
+        data: any;
+    }>;
+    /**
+     * Vision-backed alt text for a media library image. Requires the AI plugin,
+     * a vision-capable provider, and `ai.features.mediaAltText` enabled.
+     * Returns a suggestion — call `update_media({ alt })` to publish it.
+     */
+    generateMediaAlt(body: {
+        mediaId?: string;
+        imageUrl?: string;
+        pageTitle?: string;
+        surroundingText?: string;
+        purpose?: 'decorative' | 'informative' | 'functional';
+    }): Promise<{
+        data: {
+            alt: string;
+            title: string;
+            alternatives: string[];
+            isDecorative: boolean;
+            confidence: number;
+            usedVision: boolean;
+        };
+    }>;
+    /** Delete a media item AND its underlying blob storage object (best-effort). */
+    deleteMedia(id: string): Promise<{
+        data: {
+            success: boolean;
+        };
+    }>;
+    /**
+     * Bulk-update media metadata. Per-item patches (not a shared patch). Returns
+     * per-id success/failure so a large backfill can land partial results (#717).
+     */
+    bulkUpdateMedia(items: Array<{
+        id: string;
+        alt?: string;
+        title?: string;
+        filename?: string;
+        caption?: string;
+        description?: string;
+        focusKeyword?: string;
+        focalX?: number;
+        focalY?: number;
+        isDecorative?: boolean;
+    }>): Promise<{
+        data: {
+            updated: number;
+            failed: number;
+            results: Array<{
+                id: string;
+                ok: true;
+                data: any;
+            } | {
+                id: string;
+                ok: false;
+                error: string;
+                status?: number;
+            }>;
+        };
+    }>;
+    /**
+     * Bulk-delete media items and their blobs (best-effort). Requires
+     * `confirm: true` at the MCP tool layer; the API also requires it.
+     */
+    bulkDeleteMedia(ids: string[], confirm: true): Promise<{
+        data: {
+            deleted: number;
+            failed: number;
+            results: Array<{
+                id: string;
+                ok: true;
+            } | {
+                id: string;
+                ok: false;
+                error: string;
+                status?: number;
+            }>;
+        };
+    }>;
+    /**
+     * Recompress an existing image to WebP. Returns the updated media row plus
+     * an `optimization` summary (`{ originalSize, optimizedSize, savings, ... }`).
+     * Already-WebP files and non-images short-circuit with `alreadyOptimized: true`.
+     */
+    optimizeMedia(id: string): Promise<{
+        data: any;
+    }>;
+    /**
+     * Move a media item into a folder, or out of every folder by passing
+     * `folderId: null`. The server validates that the target folder lives in
+     * the `media` scope.
+     */
+    moveMediaToFolder(id: string, folderId: string | null): Promise<{
+        data: {
+            success: boolean;
+        };
+    }>;
+    /**
+     * List folders in a given scope as a nested tree (`{ ...folder, children: [...] }`).
+     * Scopes today: `'media'` for the media library, `'documents'` / `'collections'`
+     * for document folders. The `scope` query param is required by the server.
+     */
+    listFolders(scope: string): Promise<{
+        data: any[];
+    }>;
+    /**
+     * Create a folder. If `parentId` is supplied, it must already exist AND live
+     * in the same scope — the server refuses cross-scope reparenting.
+     */
+    createFolder(body: {
+        name: string;
+        scope: string;
+        parentId?: string | null;
+    }): Promise<{
+        data: any;
+    }>;
+    /**
+     * Update a folder: rename (`name`), reparent (`parentId`; pass `null` to
+     * promote to root), or reorder (`position`). The server prevents self-
+     * parenting and cross-scope reparenting.
+     */
+    updateFolder(id: string, body: {
+        name?: string;
+        parentId?: string | null;
+        position?: number;
+    }): Promise<{
+        data: any;
+    }>;
+    /**
+     * Delete a folder. Refuses with HTTP 409 if the folder still contains
+     * documents, media, or sub-folders — the caller must move or delete the
+     * contents first.
+     */
+    deleteFolder(id: string): Promise<{
+        data: {
+            success: boolean;
+        };
+    }>;
+    /**
+     * Move a document into a folder, or remove it from every folder by passing
+     * `folderId: null`. Server validates that the target folder is in the
+     * documents / collections scope.
+     */
+    moveDocumentToFolder(id: string, folderId: string | null): Promise<{
+        data: {
+            success: boolean;
+        };
+    }>;
+    /**
+     * List immutable snapshots of a document, newest first. Each `Version`
+     * carries the full `data` payload at the time of write plus the user who
+     * made the change (joined via `relationLoadStrategy: 'join'` server-side).
+     */
+    listVersions(collection: string, documentId: string, query?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<{
+        data: {
+            versions: any[];
+            total: number;
+            page: number;
+            pageSize: number;
+            totalPages: number;
+        };
+    }>;
+    /**
+     * Roll a document back to a prior version. The restore goes through the
+     * normal `updateDocument` path so it: (a) runs validation hooks, (b)
+     * creates a NEW version row capturing the restore (i.e. it never rewrites
+     * history), and (c) emits a `version_restored` event to `prenta_audit_logs`.
+     */
+    restoreVersion(collection: string, documentId: string, versionId: string): Promise<{
+        data: any;
+    }>;
+    /**
+     * Schedule a document to publish and/or unpublish at a future timestamp.
+     * `scheduledAt` (publish) forces `status` → `SCHEDULED` so the cron picks
+     * it up; `scheduledUnpublishAt` leaves the current status alone. The
+     * server requires at least one of the two, both must be ISO 8601 strings
+     * AND in the future, and `scheduledUnpublishAt` must be after
+     * `scheduledAt` when both are provided.
+     */
+    schedulePublish(collection: string, documentId: string, body: {
+        scheduledAt?: string | null;
+        scheduledUnpublishAt?: string | null;
+    }): Promise<{
+        data: {
+            id: string;
+            status: string;
+            scheduledAt: string | null;
+            scheduledUnpublishAt: string | null;
+        };
+    }>;
+    /**
+     * Cancel any pending publish + unpublish schedule for the document. If
+     * the document was in `SCHEDULED` (not yet published) the server drops
+     * its status back to `DRAFT`. Already-published documents stay live.
+     */
+    unschedulePublish(collection: string, documentId: string): Promise<{
+        data: {
+            id: string;
+            status: string;
+            scheduledAt: null;
+            scheduledUnpublishAt: null;
+        };
+    }>;
+    /**
+     * Read the workflow state of a document. Returns the current stage
+     * (`DRAFT` | `IN_REVIEW` | `APPROVED` | `PUBLISHED` | `ARCHIVED`), the
+     * stages the *current* user is allowed to transition to next (derived
+     * from their role), plus the reviewer ID + note if set.
+     */
+    getWorkflowState(collection: string, documentId: string): Promise<{
+        data: {
+            stage: string;
+            transitions: string[];
+            reviewerId: string | null;
+            reviewNote: string | null;
+        };
+    }>;
+    /**
+     * Move a document to a new workflow stage. The server validates that the
+     * transition is allowed from the current stage AND that the caller's
+     * role permits it; if either check fails it returns HTTP 400 with the
+     * reason in the error body.
+     */
+    transitionWorkflow(collection: string, documentId: string, body: {
+        stage: string;
+        note?: string;
+    }): Promise<{
+        data: {
+            success: boolean;
+        };
+    }>;
+    /**
+     * List the comment thread attached to a document. By default returns only
+     * unresolved, non-deleted comments. `includeResolved` widens that to
+     * include resolved threads; `includeDeleted` is admin-only and surfaces
+     * soft-deleted moderation history (returns HTTP 403 for non-admin keys).
+     */
+    listComments(documentId: string, query?: {
+        includeResolved?: boolean;
+        includeDeleted?: boolean;
+        pageSize?: number;
+    }): Promise<{
+        data: any[];
+    }>;
+    /**
+     * Create a comment on a document. `anchor` is optional and lets the
+     * caller pin the comment to a specific text range (used by the
+     * Prosemirror selection UI in the admin). `parentId` is set for thread
+     * replies. The server emits a `comment_created` event to
+     * `prenta_audit_logs` and fires a fire-and-forget notification dispatch.
+     */
+    createComment(documentId: string, body: {
+        body: string;
+        anchor?: {
+            from: string;
+            to: string;
+        } | null;
+        parentId?: string | null;
+    }): Promise<{
+        data: any;
+    }>;
+    /**
+     * Run a deterministic accessibility audit over a page-builder tree.
+     * Detects missing alt text, heading-level skips, missing form labels,
+     * missing ARIA attributes, and undersized touch targets. Returns an
+     * array of `A11yIssue` entries — each carries `autoFixable: boolean`
+     * so the caller can pair this with `fixPageA11y` for one-click cleanup.
+     *
+     * Pass the tree exactly as returned by a document's `data.tree` field;
+     * no normalisation needed.
+     */
+    auditPageA11y(tree: unknown): Promise<{
+        data: {
+            issues: Array<{
+                id: string;
+                blockId: string;
+                type: "missing-alt" | "heading-skip" | "missing-label" | "missing-aria" | "small-touch-target";
+                severity: "error" | "warning";
+                message: string;
+                autoFixable: boolean;
+            }>;
+        };
+    }>;
+    /**
+     * Auto-fix the accessibility issues marked `autoFixable: true` from
+     * `audit_page_a11y` and return the mutated tree plus a report
+     * (`fixedCount` / `remainingCount`). Non-auto-fixable issues are
+     * returned in `report.issues` for human follow-up. The handler emits a
+     * `settings_changed` audit event with the fix counts.
+     */
+    fixPageA11y(tree: unknown): Promise<{
+        data: {
+            tree: unknown;
+            report: {
+                issues: Array<{
+                    id: string;
+                    blockId: string;
+                    type: string;
+                    severity: "error" | "warning";
+                    message: string;
+                    autoFixable: boolean;
+                }>;
+                fixedCount: number;
+                remainingCount: number;
+            };
+        };
+    }>;
+    /**
+     * Edit a comment body. Only the author can edit; the server returns a
+     * `forbidden` error otherwise. Resolved threads remain editable so a
+     * moderator can append context.
+     */
+    editComment(id: string, body: string): Promise<{
+        data: any;
+    }>;
+    /** Mark a comment thread resolved. Requires write-role; emits `comment_resolved` audit event. */
+    resolveComment(id: string): Promise<{
+        data: any;
+    }>;
+    /** Re-open a previously resolved comment thread. Requires write-role. */
+    reopenComment(id: string): Promise<{
+        data: any;
+    }>;
+    /**
+     * Soft-delete a comment. Server returns `forbidden` unless the caller is
+     * the author OR an admin. Soft-deleted comments are admin-only viewable
+     * via `list_comments({ includeDeleted: true })`.
+     */
+    deleteComment(id: string): Promise<{
+        data: any;
+    }>;
+    /** List all redirects, newest first. */
+    listRedirects(): Promise<{
+        data: any[];
+    }>;
+    /**
+     * Create a redirect. Admin-only. The server enforces an open-redirect
+     * defence — absolute destinations must point at a host that's either
+     * the configured `NEXT_PUBLIC_SITE_URL` or listed in
+     * `redirects.allowedExternalHosts`. Relative destinations (`/foo`) are
+     * always allowed. `statusCode` accepts 301 / 302 / 307 / 308 only and
+     * defaults to 301 on the server.
+     */
+    createRedirect(body: {
+        source: string;
+        destination: string;
+        statusCode?: 301 | 302 | 307 | 308;
+        isRegex?: boolean;
+        notes?: string | null;
+    }): Promise<{
+        data: any;
+    }>;
+    /** Delete a redirect by ID. Admin-only. */
+    deleteRedirect(id: string): Promise<{
+        data: {
+            success: boolean;
+        };
+    }>;
+    /**
+     * List page templates. Admin-only. Optional `category` filter narrows
+     * to a single template category. `collection` reorders the result so
+     * the suggested templates for that collection bubble to the top
+     * (driven by collection presets) and annotates each row with
+     * `suggested` / `suggestionRank`. When `collection` is supplied the
+     * response also carries a top-level `suggestion` summary.
+     */
+    listPageTemplates(query?: {
+        category?: string;
+        collection?: string;
+    }): Promise<{
+        data: any[];
+        suggestion?: any;
+    }>;
+    /** Fetch a single page template by ID. Admin-only. */
+    getPageTemplate(id: string): Promise<{
+        data: any;
+    }>;
+    /** List saved page-builder sections. Admin-only. Optional `category` filter. */
+    listSavedSections(query?: {
+        category?: string;
+    }): Promise<{
+        data: any[];
+    }>;
+    /**
+     * Run a site-wide SEO scan over every published document. **Expensive**
+     * — touches every published row. Returns
+     * `{ total, pagesWithIssues, totalProblems, issues[] }` where each
+     * issue carries `{ documentId, title, slug, problems[] }`. The audit
+     * recommended gating this behind an explicit confirmation arg; the
+     * tool wrapper enforces that, the client is intentionally a thin
+     * pass-through.
+     */
+    seoScanRun(): Promise<{
+        data: any;
+    }>;
+    /**
+     * Aggregate SEO health for the dashboard — counts of missing meta
+     * descriptions / alt text plus a `topContent` array of recent
+     * published docs with light SEO scores. Cheap; safe to call on
+     * dashboard refresh.
+     */
+    seoSummary(): Promise<{
+        data: any;
+    }>;
+    /**
+     * Aggregated Overview-tab payload: site score + grade + delta, four
+     * headline metrics, open-issue summary, priority-ranked quick wins, and
+     * (gated) search-performance rows. Cheap read; derived from the last
+     * completed audit run.
+     */
+    seoOverview(): Promise<{
+        data: any;
+    }>;
+    /**
+     * Kick off a persistent SEO audit run. `scope` controls breadth:
+     * `full` (everything), `content`, `technical`, or `redirect`. Returns the
+     * created `SEOAuditRun` (status, issue counts, before/after site score).
+     * Heavier than `seoSummary` — persists issues for the Audit tab.
+     */
+    runSeoAudit(scope?: 'full' | 'content' | 'technical' | 'redirect'): Promise<{
+        data: any;
+    }>;
+    /** List persisted SEO audit runs, newest first. */
+    listSeoAuditRuns(): Promise<{
+        data: {
+            runs: any[];
+        };
+    }>;
+    /**
+     * List SEO issues with optional filters. `severity` (critical/warning/info),
+     * `category` (content/technical/redirects/...), `status`
+     * (open/ignored/resolved/recurring), and `auditRunId` narrow the result.
+     */
+    listSeoIssues(query?: {
+        severity?: string;
+        category?: string;
+        status?: string;
+        auditRunId?: string;
+    }): Promise<{
+        data: {
+            issues: any[];
+        };
+    }>;
+    /** Fetch a single SEO issue by ID. */
+    getSeoIssue(id: string): Promise<{
+        data: any;
+    }>;
+    /** Mark an SEO issue resolved / ignored / reopened. */
+    setSeoIssueStatus(id: string, action: 'resolve' | 'ignore' | 'reopen'): Promise<{
+        data: any;
+    }>;
+    /**
+     * Export a markdown SEO fix brief for dev-team handoff. Embeds cached AI
+     * content briefs and topic research when available.
+     */
+    exportSeoFixBrief(query?: {
+        severity?: string;
+        status?: string;
+        auditRunId?: string;
+        manualOnly?: boolean;
+        includeContentBriefs?: boolean;
+        includeContentResearch?: boolean;
+    }): Promise<{
+        data: {
+            markdown: string;
+            filename: string;
+            issueCount: number;
+        };
+    }>;
+    /** Preview a deterministic or AI-assisted inline metadata/schema fix. */
+    suggestSeoIssueFix(id: string): Promise<{
+        data: {
+            suggestion: any;
+        };
+    }>;
+    /** Apply a previously suggested inline fix (requires matching fingerprint). */
+    applySeoIssueFix(id: string, fingerprint: string): Promise<{
+        data: any;
+    }>;
+    /** Load a cached AI content brief for a content/heading issue. */
+    getSeoIssueContentBrief(id: string): Promise<{
+        data: {
+            supported: boolean;
+            brief: any;
+            stale: boolean;
+        };
+    }>;
+    /** Generate (or regenerate) an AI content brief for manual content fixes. */
+    generateSeoIssueContentBrief(id: string): Promise<{
+        data: {
+            brief: any;
+        };
+    }>;
+    /**
+     * Run topic research (thin-content) then generate a content brief in one step.
+     * Optional competitor URLs are fetched SSRF-safe (max 3).
+     */
+    researchAndBriefSeoIssue(id: string, competitorUrls?: string[]): Promise<{
+        data: {
+            research: any;
+            brief: any;
+        };
+    }>;
+    /** Batch-generate content briefs for open issues (skips fresh cached briefs). */
+    batchGenerateSeoContentBriefs(body?: {
+        severity?: string;
+        status?: string;
+        issueIds?: string[];
+        skipExisting?: boolean;
+        includeResearch?: boolean;
+        competitorUrls?: string[];
+    }): Promise<{
+        data: {
+            generated: number;
+            skipped: number;
+            failed: number;
+            results: Array<{
+                issueId: string;
+                status: string;
+                error?: string;
+            }>;
+        };
+    }>;
+    /** List redirect rules with hit counts + stale flags. */
+    listRedirectRules(): Promise<{
+        data: {
+            rules: any[];
+        };
+    }>;
+    /** Redirect overview counts (active / stale / 404s / chains). */
+    redirectOverview(): Promise<{
+        data: any;
+    }>;
+    /** Detected redirect chains and loops with safe-flatten suggestions. */
+    redirectChains(): Promise<{
+        data: {
+            chains: any[];
+        };
+    }>;
+    /** Flatten a redirect chain to a single hop (updates the first rule's destination). */
+    flattenRedirectChain(chainId: string): Promise<{
+        data: any;
+    }>;
+    /** AI-generated 404 recovery suggestions awaiting review. */
+    listRedirectSuggestions(): Promise<{
+        data: {
+            suggestions: any[];
+        };
+    }>;
+    getRedirectRecoverySettings(): Promise<{
+        data: any;
+    }>;
+    updateRedirectRecoverySettings(body: {
+        aiRerank?: boolean;
+        autoApply?: boolean;
+        autoApplyMinConfidence?: number;
+    }): Promise<{
+        data: any;
+    }>;
+    /** Scan tracked 404s and generate recovery redirect suggestions. */
+    generateRedirectRecoverySuggestions(): Promise<{
+        data: any;
+    }>;
+    acceptRedirectSuggestion(id: string): Promise<{
+        data: any;
+    }>;
+    dismissRedirectSuggestion(id: string): Promise<{
+        data: any;
+    }>;
+    exportRedirectsCsv(): Promise<{
+        data: {
+            csv: string;
+        };
+    }>;
+    importRedirectsCsv(csv: string): Promise<{
+        data: {
+            imported: number;
+            errors: string[];
+        };
+    }>;
+    updateRedirectRule(id: string, body: Record<string, unknown>): Promise<{
+        data: any;
+    }>;
+    /** Site-wide internal/external link graph snapshot (Links tab). */
+    seoLinkSnapshot(): Promise<{
+        data: any;
+    }>;
+    /** Broken / suspicious outbound link scan (bounded batch). */
+    seoLinkHealth(): Promise<{
+        data: any;
+    }>;
+    seoLinkSuggest(body: {
+        targetEntityId: string;
+        targetEntityType: 'page' | 'post';
+        limit?: number;
+    }): Promise<{
+        data: any;
+    }>;
+    /** Build or refresh the AI link index used for contextual suggestions. */
+    seoLinkAiIndex(): Promise<{
+        data: any;
+    }>;
+    getCrawlSettings(): Promise<{
+        data: any;
+    }>;
+    updateCrawlSettings(body: Record<string, unknown>): Promise<{
+        data: any;
+    }>;
+    getRobotsTxt(): Promise<{
+        data: any;
+    }>;
+    updateRobotsTxt(body: string): Promise<{
+        data: any;
+    }>;
+    getSitemapStatus(): Promise<{
+        data: any;
+    }>;
+    regenerateSitemap(): Promise<{
+        data: any;
+    }>;
+    listSeoContentRecords(): Promise<{
+        data: {
+            records: any[];
+        };
+    }>;
+    getSeoContentRecord(entityType: string, entityId: string): Promise<{
+        data: any;
+    }>;
+    updateSeoContentFields(entityType: string, entityId: string, body: Record<string, unknown>): Promise<{
+        data: any;
+    }>;
+    aiSeoGenerateField(body: {
+        field: string;
+        entityType: string;
+        entityId: string;
+    }): Promise<{
+        data: any;
+    }>;
+    aiSeoExplainIssue(issueId: string): Promise<{
+        data: any;
+    }>;
+    aiSeoGenerateSchema(body: {
+        entityType: string;
+        entityId: string;
+        schemaType: string;
+    }): Promise<{
+        data: any;
+    }>;
+    aiSeoSummarize(): Promise<{
+        data: any;
+    }>;
+    /**
+     * List submissions for a form. **PII-sensitive** — form submissions
+     * typically contain names, emails, free-form messages, and any other
+     * fields the form collects. Requires write-role on the API key AND
+     * an explicit `formId` (no enumeration). Paged.
+     */
+    listFormSubmissions(formId: string, query?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<{
+        data: {
+            submissions: any[];
+            total: number;
+            page: number;
+            pageSize: number;
+            totalPages: number;
+        };
+    }>;
+    /**
+     * List entries from the submissions inbox (decrypted PII, attribution,
+     * read/star/archive state). `formId` is required at the tool boundary to
+     * prevent accidental cross-form enumeration. Returns
+     * `{ data: { entries, total, page, pageSize } }`.
+     */
+    listFormEntries(query: {
+        formId: string;
+        page?: number;
+        pageSize?: number;
+        unread?: boolean;
+        starred?: boolean;
+        archived?: boolean;
+        spamStatus?: string;
+    }): Promise<{
+        data: {
+            entries: any[];
+            total: number;
+            page: number;
+            pageSize: number;
+        };
+    }>;
+    /**
+     * Read a single entry plus the schema version it was captured against.
+     * Returns `{ data: { entry, fields } }`. The server audits this read as
+     * `form.entry.viewed` because it exposes decrypted PII.
+     */
+    getFormEntry(entryId: string): Promise<{
+        data: {
+            entry: any;
+            fields: any[];
+        };
+    }>;
+    /**
+     * List form definitions (NOT submissions). Returns
+     * `{ data: Form[], total, page, pageSize }` where each form carries its
+     * field schema plus the legacy `fieldCount` / `submissions` aliases. Use
+     * this to discover form IDs before reading entries or editing a schema.
+     */
+    listForms(query?: {
+        page?: number;
+        pageSize?: number;
+        status?: string;
+        search?: string;
+        sortBy?: string;
+        sortDirection?: 'asc' | 'desc';
+    }): Promise<{
+        data: any[];
+        total: number;
+        page: number;
+        pageSize: number;
+    }>;
+    /** Fetch a single form definition by ID (metadata + field schema). */
+    getForm(id: string): Promise<{
+        data: any;
+    }>;
+    /**
+     * Create a form. Only `name` is required server-side; the slug is derived
+     * from `name` when omitted. `fields` is the initial field schema (see
+     * `saveFormSchema` for the field shape) — omit to start with an empty
+     * form and add the schema in a second call.
+     */
+    createForm(body: {
+        name: string;
+        slug?: string;
+        description?: string;
+        status?: 'active' | 'draft' | 'archived';
+        fields?: Array<Record<string, unknown>>;
+        successMessage?: string;
+        redirectUrl?: string;
+    }): Promise<{
+        data: any;
+    }>;
+    /**
+     * Update a form's metadata. Only the supplied fields change. Note the
+     * field SCHEMA is NOT editable here — use `saveFormSchema` so each schema
+     * change is versioned.
+     */
+    updateForm(id: string, body: {
+        name?: string;
+        description?: string;
+        status?: 'active' | 'draft' | 'archived';
+        successMessage?: string;
+        redirectUrl?: string;
+    }): Promise<{
+        data: any;
+    }>;
+    /**
+     * Delete a form. By default the server refuses (HTTP 409) when the form
+     * has submissions; pass `force: true` to delete it and its entries.
+     */
+    deleteForm(id: string, force?: boolean): Promise<{
+        data: {
+            success: boolean;
+        };
+    }>;
+    /** Duplicate a form (new draft copy with a fresh slug). Returns the new form. */
+    duplicateForm(id: string): Promise<{
+        data: any;
+    }>;
+    /**
+     * Read a form's field schema plus its version history:
+     * `{ fields, activeVersionId, versions }`. Call before `saveFormSchema`
+     * to avoid clobbering the live schema.
+     */
+    getFormSchema(id: string): Promise<{
+        data: {
+            fields: any[];
+            activeVersionId: string | null;
+            versions: any[];
+        };
+    }>;
+    /**
+     * Replace a form's field schema. Creates a NEW schema version (history is
+     * never rewritten) and points the form at it. `fields` is the full
+     * ordered field list — partial patches are not supported (read with
+     * `getFormSchema`, mutate, write back the whole array).
+     */
+    saveFormSchema(id: string, fields: Array<Record<string, unknown>>, notes?: string): Promise<{
+        data: {
+            form: any;
+            version: any;
+        };
+    }>;
+    /**
+     * Update inbox state on a single submission entry (mark read/unread,
+     * star, archive). Does not touch the captured field values.
+     */
+    updateFormEntry(entryId: string, patch: {
+        unread?: boolean;
+        starred?: boolean;
+        archived?: boolean;
+    }): Promise<{
+        data: any;
+    }>;
+    /** Apply the same inbox-state patch to many entries at once. Returns `{ updated }`. */
+    bulkUpdateFormEntries(ids: string[], patch: {
+        unread?: boolean;
+        starred?: boolean;
+        archived?: boolean;
+    }): Promise<{
+        data: {
+            updated: number;
+        };
+    }>;
+    /** Permanently delete a submission entry (and its decrypted PII). Destructive. */
+    deleteFormEntry(entryId: string): Promise<{
+        data: {
+            success: boolean;
+        };
+    }>;
+    /**
+     * Export every submission for a form as CSV. The endpoint returns a raw
+     * `text/csv` body (NOT a JSON envelope), so we read it as text rather
+     * than via `request()`. **Bulk PII egress** — the server records a
+     * `form.entries.exported` audit event. Returns the CSV text plus the
+     * server-suggested filename.
+     */
+    exportFormEntries(formId: string): Promise<{
+        filename: string;
+        csv: string;
+    }>;
+    /**
+     * Read the deployment health of the CMS. Unauthenticated on the server
+     * side (still safe to call — exposes only operational status, no
+     * tenant data). Returns `{ status, version, env, models,
+     * databaseConnected, secretConfigured }`.
+     *
+     * Recommended as an agent's first call: a `degraded` / `unhealthy`
+     * status surfaces operator-level config problems early instead of
+     * surfacing as cryptic errors deep in a workflow.
+     */
+    healthCheck(): Promise<{
+        data: any;
+    }>;
+    generatePage(input: {
+        prompt: string;
+        template?: string;
+        context?: string;
+        steps?: string[];
+        tone?: string;
+    }): Promise<{
+        data: {
+            tree: any;
+            steps: any[];
+            totalTokensUsed: number;
+            totalDurationMs: number;
+        };
+    }>;
+    generateBlock(input: {
+        blockType: string;
+        variant?: string;
+        pageContext?: unknown;
+        tone?: string;
+    }): Promise<{
+        data: any;
+    }>;
+    /** One-shot: generate AI page AND persist as a draft (or published) document. */
+    createPageFromPrompt(input: {
+        prompt: string;
+        template?: string;
+        context?: string;
+        steps?: string[];
+        tone?: string;
+        collection?: string;
+        title?: string;
+        slug?: string;
+        status?: 'DRAFT' | 'PUBLISHED';
+        publish?: boolean;
+    }): Promise<{
+        data: {
+            document: any;
+            generation: {
+                steps: any[];
+                totalTokensUsed: number;
+                totalDurationMs: number;
+            };
+        };
+    }>;
+    /**
+     * Generic AI content authoring for any non-page collection. Used by the
+     * per-type MCP tools (create_blog_post, create_case_study, etc.) and by the
+     * generic create_in_collection tool.
+     */
+    createDocumentFromPrompt(collection: string, input: {
+        prompt: string;
+        context?: string;
+        tone?: string;
+        targetAudience?: string;
+        title?: string;
+        slug?: string;
+        status?: 'DRAFT' | 'PUBLISHED';
+        publish?: boolean;
+    }): Promise<{
+        data: {
+            document: any;
+            generation: {
+                usage: {
+                    promptTokens: number;
+                    completionTokens: number;
+                };
+                durationMs: number;
+                seo: {
+                    metaTitle?: string;
+                    metaDescription?: string;
+                    schemaType?: string;
+                };
+            };
+        };
+    }>;
+    /**
+     * Run the composite content audit (SEO + readability + a11y + freshness)
+     * against a stored document or ad-hoc content. Deterministic — no LLM call,
+     * safe to invoke on every save.
+     */
+    auditDocument(input: {
+        collection?: string;
+        id?: string;
+        title?: string;
+        body?: string;
+        metaTitle?: string;
+        metaDescription?: string;
+        targetKeyword?: string;
+        url?: string;
+        headings?: string[];
+        images?: Array<{
+            src: string;
+            alt?: string;
+        }>;
+        internalLinks?: string[];
+        externalLinks?: string[];
+        publishedAt?: string;
+        updatedAt?: string;
+        contentType?: string;
+    }): Promise<{
+        data: any;
+    }>;
+    /**
+     * Inline AI co-author. Wraps the plugin-ai writing assistant
+     * (rewrite/expand/compress/proofread) behind a single HTTP surface.
+     */
+    coauthor(input: {
+        action: 'rewrite' | 'expand' | 'compress' | 'proofread';
+        text: string;
+        style?: string;
+        tone?: string;
+        instructions?: string;
+        targetLength?: number;
+        collectionSlug?: string;
+        targetAudience?: string;
+    }): Promise<{
+        data: {
+            action: string;
+            text: string;
+            changes?: unknown[];
+        };
+    }>;
+    /**
+     * Suggest internal links from a body of text against the published CMS
+     * documents the API key can read. Optionally scope to a single collection.
+     */
+    suggestInternalLinks(input: {
+        content: string;
+        collection?: string;
+        limit?: number;
+        excludeId?: string;
+    }): Promise<{
+        data: {
+            suggestions: any[];
+            candidatesScanned: number;
+        };
+    }>;
+    /** Fetch the auto-generated OpenAPI spec, useful for tools listing collections + fields. */
+    getOpenApi(): Promise<any>;
+    /**
+     * List configured collections via the dedicated `/collections`
+     * discovery endpoint. Returns `{ data: CollectionMeta[] }` with one
+     * entry per configured collection (`slug`, `labels`, `type`, `fields`,
+     * `fieldCount`, `hidden`). Sourced directly from `getPrentaConfig()`
+     * server-side, so it stays accurate even when OpenAPI spec generation
+     * is missing routes. Newer endpoint — older CMS servers may return
+     * 404; `list_collections` falls back to OpenAPI in that case.
+     */
+    listCollections(): Promise<{
+        data: Array<{
+            slug: string;
+            labels: {
+                singular: string;
+                plural: string;
+            };
+            type: string;
+            urlPrefix: string;
+            hidden: boolean;
+            fieldCount: number;
+            fields: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                relationTo?: string | string[];
+                hasMany?: boolean;
+                options?: Array<{
+                    label: string;
+                    value: string;
+                }>;
+            }>;
+        }>;
+    }>;
+    /**
+     * Lightweight user directory lookup used by the comment mention
+     * picker. Returns up to 10 active users whose name OR email matches
+     * `query` (case-insensitive `contains`). Empty / whitespace
+     * queries return an empty array — the endpoint deliberately won't
+     * dump the whole user table.
+     *
+     * Exposed via the `search_users` MCP tool so AI agents can resolve
+     * `@<userId>` mentions when drafting comments.
+     */
+    searchUsers(query: string): Promise<{
+        data: Array<{
+            id: string;
+            name: string;
+            email: string;
+        }>;
+    }>;
+    /** Resolve a public URL path to its document. */
+    resolveUrl(path: string): Promise<{
+        data: any;
+    }>;
+    /**
+     * Soft-check navigation item URLs against published documents + redirects.
+     * Returns warnings only — never blocks save. Requires cms-core with
+     * `POST /navigations/validate-targets`.
+     */
+    validateNavigationTargets(items: unknown[]): Promise<{
+        data: {
+            warnings: string[];
+            unresolved: Array<{
+                itemPath: string;
+                label: string;
+                url: string;
+                normalizedPath: string;
+            }>;
+        };
+    }>;
+    /** Run the deterministic SEO content analysis against a stored document. */
+    seoAnalyzeDocument(documentId: string): Promise<any>;
+    /** Compute a Flesch-Kincaid / grade-level readability score for a document body. */
+    seoReadability(documentId: string): Promise<any>;
+    /**
+     * Suggest internal-link targets for a document. Title-keyword-based (extracts
+     * up to 5 keywords > 3 chars from the doc title, matches them against
+     * other PUBLISHED documents). Returns up to 10 suggestions. Distinct from
+     * `suggestInternalLinks` above, which is content-based and freeform.
+     *
+     * `title` and `slug` are typed nullable because the underlying Prisma
+     * `Document` schema makes them optional (`String?`) — the API forwards
+     * the raw column values, so callers must handle nulls before rendering
+     * anchor text or building target URLs.
+     */
+    seoInternalLinks(documentId: string): Promise<{
+        suggestions: Array<{
+            id: string;
+            title: string | null;
+            slug: string | null;
+            collection: string;
+        }>;
+    }>;
+    /** Build the OG / Twitter / canonical meta-tag preview for a document. */
+    seoMetaPreview(documentId: string): Promise<any>;
+    /** Build the Schema.org JSON-LD graph for a document. */
+    seoSchemaGraph(documentId: string): Promise<any>;
+    /**
+     * Discover the registered section types + their content/field schemas.
+     * Each entry carries `id`, `name`, `description`, `category`, `scope`,
+     * `fields` (the inspector schema), and `defaultContent` / `defaultSettings`.
+     *
+     * Pass `scope: 'page'` or `scope: 'post'` to list only the types usable on
+     * that surface (so an agent building a post template doesn't pick a
+     * page-only type, and vice versa).
+     */
+    listSectionTypes(scope?: 'page' | 'post'): Promise<{
+        data: any[];
+    }>;
+    /**
+     * Validate section content against its type schema. Deterministic (no
+     * LLM). Returns `{ valid, errors, warnings }` where each issue is
+     * `{ sectionType, field?, message }`. An unknown `sectionType` is a hard
+     * error (no registered renderer).
+     */
+    validateSection(input: {
+        sectionType: string;
+        content: Record<string, unknown>;
+        settings?: Record<string, unknown>;
+    }): Promise<{
+        data: {
+            valid: boolean;
+            errors: Array<{
+                sectionType: string;
+                field?: string;
+                message: string;
+            }>;
+            warnings: Array<{
+                sectionType: string;
+                field?: string;
+                message: string;
+            }>;
+        };
+    }>;
+    /** List a page's ordered sections (`data.sections`). */
+    listPageSections(collection: string, id: string): Promise<{
+        data: any[];
+    }>;
+    /**
+     * Add a section to a page. The server seeds registry defaults for
+     * `sectionType`, shallow-merges the supplied `content` / `settings`,
+     * generates an id, inserts at `position` (default end), and persists.
+     * Returns `{ section, sections, validation }`.
+     */
+    addPageSection(collection: string, id: string, body: {
+        sectionType: string;
+        name?: string;
+        internalLabel?: string;
+        visible?: boolean;
+        content?: Record<string, unknown>;
+        settings?: Record<string, unknown>;
+        position?: number;
+    }): Promise<{
+        data: {
+            section: any;
+            sections: any[];
+            validation: any;
+        };
+    }>;
+    /**
+     * Update a section in place. Only supplied fields change; `content` /
+     * `settings` are shallow-merged. Returns `{ section, sections, validation }`.
+     */
+    updatePageSection(collection: string, id: string, sectionId: string, body: {
+        content?: Record<string, unknown>;
+        settings?: Record<string, unknown>;
+        name?: string;
+        internalLabel?: string;
+        visible?: boolean;
+    }): Promise<{
+        data: {
+            section: any;
+            sections: any[];
+            validation: any;
+        };
+    }>;
+    /** Reorder a page's sections to an explicit id order. Returns the new array. */
+    reorderPageSections(collection: string, id: string, orderedIds: string[]): Promise<{
+        data: any[];
+    }>;
+    /** Remove a section from a page. Returns the remaining sections. */
+    removePageSection(collection: string, id: string, sectionId: string): Promise<{
+        data: {
+            sections: any[];
+        };
+    }>;
+    /**
+     * Read a post type's template: `{ postType, docId, header, sections }`.
+     * Returns an unsaved default (centered header, empty section list) when
+     * the type has no saved template yet (`docId: null`).
+     */
+    getPostTemplate(postType: string): Promise<{
+        data: {
+            postType: string;
+            docId: string | null;
+            header: any;
+            sections: any[];
+        };
+    }>;
+    /**
+     * Create or replace a post type's template. `header` is coerced to a full
+     * header config (missing keys filled with defaults) and `sections` are
+     * coerced (unknown section types dropped) so the stored template always
+     * renders. Use only `scope: 'post'` section types in `sections`.
+     */
+    savePostTemplate(postType: string, body: {
+        header?: Record<string, unknown>;
+        sections?: any[];
+    }): Promise<{
+        data: {
+            postType: string;
+            docId: string | null;
+            header: any;
+            sections: any[];
+        };
+    }>;
+}
+//# sourceMappingURL=client.d.ts.map