payload-live-preview 1.8.0 → 2.0.0-beta.0

package/dist/plugins.d.cts

@@ -0,0 +1,509 @@
+/** Payload's `DocumentEvent` shape (admin `providers/DocumentEvents`). */
+interface PayloadDocumentEventDetail {
+    readonly entitySlug: string;
+    readonly operation?: 'create' | 'update';
+    readonly id?: string | number;
+    readonly updatedAt?: string;
+    readonly [extra: string]: unknown;
+}
+/** A validated update as events expose it. */
+interface PayloadLivePreviewData {
+    readonly fields: Record<string, unknown>;
+    readonly schema?: readonly PayloadFieldSchema[];
+    readonly globalSlug?: string;
+    readonly collectionSlug?: string;
+    readonly locale?: string;
+}
+/** The subset of Payload's field schema the runtime reads; extra properties are kept opaquely. */
+interface PayloadFieldSchema {
+    readonly name: string;
+    readonly type: PayloadFieldType;
+    readonly label?: string;
+    readonly required?: boolean;
+    readonly localized?: boolean;
+    readonly fields?: readonly PayloadFieldSchema[];
+    readonly blocks?: readonly PayloadBlockSchema[];
+    readonly relationTo?: string | readonly string[];
+    readonly hasMany?: boolean;
+    readonly admin?: {
+        readonly condition?: PayloadFieldCondition;
+    };
+    readonly [extra: string]: unknown;
+}
+interface PayloadBlockSchema {
+    readonly slug: string;
+    readonly fields: readonly PayloadFieldSchema[];
+    readonly [extra: string]: unknown;
+}
+/** Payload's core field types. `tabs` is a structural container; `group` flattens. */
+type PayloadFieldType = 'text' | 'textarea' | 'richText' | 'email' | 'number' | 'checkbox' | 'date' | 'select' | 'radio' | 'array' | 'blocks' | 'group' | 'tabs' | 'row' | 'collapsible' | 'relationship' | 'upload' | 'point' | 'json' | 'code' | 'ui';
+/** `admin.condition` is a function in source and cannot cross `postMessage`; modelled, not consumed. */
+type PayloadFieldCondition = (data: unknown, siblingData: unknown) => boolean;
+
+/**
+ * Every diagnostic code the runtime and tools emit, so a consumer can branch
+ * on `e.code` instead of matching message text. A code is never reused for a
+ * different meaning; a retired one stays reserved.
+ *
+ * Browser-side reporting sites write the literal (`code: 'LP0603'`) rather than
+ * reading it from this record: the frozen table would then ship in the inline
+ * runtime for the sake of six characters. Server-side tools may import it.
+ */
+/**
+ * Every diagnostic code the runtime can report, by name.
+ *
+ * ```ts
+ * client.events.on('error', (e) => {
+ *   if (e.code === DIAGNOSTIC_CODES.TransformThrew) reportToSentry(e.error);
+ * });
+ * ```
+ */
+declare const DIAGNOSTIC_CODES: Readonly<{
+    /** No trusted origin configured in production; nothing will be accepted. */
+    readonly NoTrustedOrigin: "LP0101";
+    /** Origin trust rests on `document.referrer`, so any framing site is trusted. */
+    readonly ReferrerOnlyTrust: "LP0102";
+    /** A plugin declares a runtime range this runtime does not satisfy; it was refused. */
+    readonly PluginIncompatible: "LP0103";
+    /** An update named a field with no binding anchor on the page. */
+    readonly OrphanField: "LP0201";
+    /** Owner scoping is on and the update names no document it could belong to. */
+    readonly UnattributableUpdate: "LP0202";
+    /** The visibility gate held offscreen writes back until they scroll into view. */
+    readonly VisibilityGateDeferred: "LP0301";
+    /** A value was refused because the attribute or the value itself is unsafe. */
+    readonly UnsafeAttributeWrite: "LP0401";
+    /** A text element has structured children, so replacing its text was skipped. */
+    readonly TextTargetHasChildren: "LP0402";
+    /** A structural container has no array template, so the update was skipped. */
+    readonly MissingArrayTemplate: "LP0403";
+    /** A structural item has no `id`; it pairs positionally, so an insert re-renders every row after it. */
+    readonly StructuralItemUnkeyed: "LP0404";
+    /** Two structural items share a key; later ones pair positionally. */
+    readonly StructuralDuplicateKey: "LP0405";
+    /** Every structural key changed while the length did not; the source generates keys per message. */
+    readonly StructuralUnstableKeys: "LP0406";
+    /** A binding asks for a delivery strategy this release does not have; it is left unchanged. */
+    readonly UnsupportedStrategy: "LP0407";
+    /** A message was rejected before it reached the update pipeline. */
+    readonly MessageRejected: "LP0501";
+    /** A preview token was rejected. */
+    readonly TokenRejected: "LP0502";
+    /** A consumer event handler threw. */
+    readonly HandlerThrew: "LP0601";
+    /** A consumer transform threw; the original value was kept. */
+    readonly TransformThrew: "LP0602";
+    /** A renderer threw while writing a value. */
+    readonly RendererThrew: "LP0603";
+    /** Runtime startup failed. */
+    readonly StartupFailed: "LP0605";
+    /** Sending the ready handshake failed. */
+    readonly ReadyFailed: "LP0606";
+    /** The audit found no runtime in a response that carried preview intent. */
+    readonly AuditRuntimeMissing: "LP0701";
+    /** The preview response declares no `frame-ancestors`. */
+    readonly AuditNoFrameAncestors: "LP0702";
+    /** `X-Frame-Options` forbids framing, which no CSP can undo. */
+    readonly AuditFrameOptionsBlocks: "LP0703";
+    /** Binding attributes are served to anonymous visitors. */
+    readonly AuditBindingsExposed: "LP0704";
+    /** More bindings than the default visibility gate will write eagerly. */
+    readonly AuditGateThresholdExceeded: "LP0705";
+    /** Owner markers exist, but some bindings are outside all of them. */
+    readonly AuditUnownedBindings: "LP0706";
+    /** The preview response carries no bindings at all. */
+    readonly AuditNoBindings: "LP0707";
+    /** The URL did not return an HTML page, so nothing else can be judged. */
+    readonly AuditNotAPage: "LP0708";
+    /** A fragment request failed (network, timeout, server error); the boundary was patched instead. */
+    readonly FragmentRequestFailed: "LP0801";
+    /** The fragment response had the wrong content type or shape; the boundary was patched instead. */
+    readonly FragmentResponseInvalid: "LP0802";
+    /** The fragment endpoint refused the preview (not authorized); the boundary was patched instead. */
+    readonly FragmentUnauthorized: "LP0803";
+    /** A fragment response arrived for a revision that was already superseded and was discarded. */
+    readonly FragmentSuperseded: "LP0804";
+    /** A route refresh was requested again for the same revision; the loop guard stopped it. */
+    readonly RouteRefreshLoop: "LP0805";
+    /** A boundary asks for the fragment strategy but no fragment handler is configured; it is patched. */
+    readonly FragmentStrategyUnavailable: "LP0806";
+    /** A readiness row is not yet at its 2.0 value; `pll doctor --v2` reports it. */
+    readonly V2ReadinessGap: "LP0709";
+    /** The preview runtime is served to anonymous visitors, not only inside the admin frame. */
+    readonly RuntimeOnPublicPage: "LP0710";
+}>;
+/** A diagnostic code, as it appears in log output and on the `error` event. */
+type DiagnosticCode = (typeof DIAGNOSTIC_CODES)[keyof typeof DIAGNOSTIC_CODES];
+
+/**
+ * How a bound region is brought up to date: the runtime patches it, a server
+ * renders a `data-payload-fragment` boundary from the unsaved form state, or
+ * the whole route refreshes. Core carries only the seam — which boundaries a
+ * strategy owns and what it may do — so a patch-only page pays for nothing
+ * more; the orchestration lives in `payload-live-preview/fragment`.
+ */
+
+/** What produced an update: the runtime's DOM patching, a server-rendered fragment, or a route refresh. */
+type UpdateSource = 'patch' | 'fragment' | 'route';
+
+/** Types shared by the runtime primitives. */
+
+/** Payload's field set plus the DOM-binding categories `html`, `url`, `image` and `structural-array`. */
+type FieldType = PayloadFieldType | 'html' | 'url' | 'image' | 'structural-array';
+/** A namespaced project renderer key, so a typo of a built-in type can never become one. */
+type CustomRendererKey = `${string}:${string}`;
+/** What a renderer may be registered under and an element may ask for. */
+type RendererKey = FieldType | CustomRendererKey;
+/**
+ * A project rich-text renderer, shared by SSR and preview. Its output goes
+ * through the sanitizer; call the same `sanitizeHtml()` server-side for byte equality.
+ */
+type RichTextRenderer = (value: unknown, context: {
+    readonly fieldName: string;
+    readonly element: Element;
+    readonly locale: string | undefined;
+}) => string;
+/** One registered binding. Several may share a field name when it renders in several places. */
+interface CachedElement {
+    /** The bound DOM element. */
+    readonly element: Element;
+    /** Payload field path, e.g., `title` or `hero.subtitle`. */
+    readonly fieldName: string;
+    /** Resolved from attributes and tag heuristics; the schema may override it unless explicit. */
+    readonly fieldType: RendererKey;
+    /** Whether `data-payload-type` set the type, in which case the schema must not override it. */
+    readonly explicitFieldType?: boolean;
+    /** Fields this binding depends on (`data-payload-depends`); a change in any re-applies it under `skipUnchanged`. */
+    readonly dependsOn?: readonly string[];
+    /** Raw `data-payload-strategy` value. */
+    readonly strategy?: string;
+    /** How the runtime brings this binding up to date; `'unknown'` for an unrecognised strategy. Resolved by the cache. */
+    readonly strategyKind?: UpdateSource | 'unknown';
+    /** Nearest enclosing `data-payload-fragment` boundary. Resolved by the cache. */
+    readonly fragmentBoundary?: Element;
+    /** `data-payload-boundary`: an anchor that hides itself while its field is empty. */
+    readonly boundary?: boolean;
+    /** Write the value into this attribute instead of the content; policed writes. */
+    readonly targetAttribute?: string;
+    /** Optional sibling-field path bound to the element's `href` attribute. */
+    readonly hrefField?: string;
+    /** Optional sibling-field path bound to the element's `src` attribute. */
+    readonly srcField?: string;
+    /** Optional sibling-field path bound to the element's `alt` attribute. */
+    readonly altField?: string;
+    /** Optional inline template for array/blocks rendering. */
+    readonly arrayTemplate?: string;
+    /** Optional separator for primitive-array stringification. */
+    readonly arraySeparator?: string;
+    /** Optional locale code locked onto this element (overrides the global locale). */
+    readonly locale?: string;
+    /** The document this binding belongs to, from the nearest `data-payload-owner`. */
+    readonly owner?: string;
+}
+/** What a renderer is given; `allFields` lets it resolve a sibling field. */
+interface RenderContext {
+    /** Full field map for the current update — used for sibling lookups. */
+    readonly allFields: Record<string, unknown>;
+    /** Active locale, or `undefined` when none is established. */
+    readonly locale: string | undefined;
+    /** Optional schema descriptor for the field, when available. */
+    readonly schema: PayloadFieldSchema | undefined;
+    /** The project's rich-text renderer, when the client was configured with one. */
+    readonly renderRichText?: RichTextRenderer;
+}
+/**
+ * A renderer writes one value into its element. It must not throw: one bad
+ * field may not stop an update. The result stays `void` — the internal
+ * no-write sentinel is not part of the contract.
+ */
+interface FieldRenderer {
+    readonly name: RendererKey;
+    render(target: CachedElement, value: unknown, context: RenderContext): void;
+}
+
+/**
+ * Shape of the `inspect()` snapshot. It only re-reads what the page already
+ * shows — origins from the injected script, field names from the DOM,
+ * counters derived from both — so it stays available in production, where a
+ * misbehaving preview is exactly the case worth diagnosing. Reading one
+ * performs no I/O and transmits nothing.
+ */
+
+/** One plugin as `inspect().plugins` reports it. */
+interface PluginInspection {
+    readonly name: string;
+    readonly version: string | undefined;
+    /** `initializing` while `init` runs, `active` afterwards, `tearing-down` while `destroy` runs. */
+    readonly state: 'initializing' | 'active' | 'tearing-down';
+    /** Live registrations owned by the plugin's scope, by kind. */
+    readonly registrations: {
+        readonly transforms: number;
+        readonly renderers: number;
+        readonly subscriptions: number;
+        readonly cleanups: number;
+    };
+}
+
+/** Public event payloads. The map keys are the valid event names; `EventEmitter` is generic over it. */
+
+interface LivePreviewEventMap {
+    /** Once per startup attempt, after observers, cache and message listening are active. A rolled-back attempt emits it again on retry. */
+    readonly init: {
+        readonly timestamp: number;
+    };
+    /** The first accepted data-bearing update from a trusted origin. */
+    readonly connect: {
+        readonly origin: string;
+        readonly timestamp: number;
+    };
+    /** The heartbeat timed out, the runtime was destroyed, or the page was suspended for navigation (`'unload'`). */
+    readonly disconnect: {
+        readonly reason: 'timeout' | 'destroy' | 'unload';
+        readonly timestamp: number;
+    };
+    /** Before the DOM is mutated for an update; `cancel()` skips exactly this revision. */
+    readonly beforeUpdate: {
+        readonly data: PayloadLivePreviewData;
+        readonly revision?: number;
+        /** When the runtime accepted the message, Unix milliseconds. */
+        readonly receivedAt?: number;
+        /** The strategy that produced the update. */
+        readonly source?: UpdateSource;
+        readonly cancel: () => void;
+    };
+    /** After each applied, still-current batch. Visibility replay may emit another for the same revision; cancelled, obsolete and deferred-only batches emit none. */
+    readonly afterUpdate: {
+        readonly data: PayloadLivePreviewData;
+        readonly updatedCount: number;
+        readonly durationMs: number;
+        readonly revision?: number;
+        readonly receivedAt?: number;
+        readonly source?: UpdateSource;
+    };
+    /** Each successful, still-current element write. */
+    readonly elementUpdate: {
+        readonly element: Element;
+        readonly fieldName: string;
+        readonly previousValue: unknown;
+        readonly nextValue: unknown;
+        readonly revision?: number;
+        readonly receivedAt?: number;
+        readonly source?: UpdateSource;
+    };
+    /** The element cache was rebuilt (initial scan or mutation). */
+    readonly cacheRefresh: {
+        readonly elementCount: number;
+        readonly fieldCount: number;
+        readonly durationMs: number;
+    };
+    /** Once per fragment boundary and revision: rendered by the server, or failed (with the LP08xx code) and patched instead. */
+    readonly fragmentRender: {
+        readonly element: Element;
+        readonly id: string;
+        readonly key: string | undefined;
+        readonly status: 'rendered' | 'failed';
+        readonly code?: DiagnosticCode;
+        readonly revision: number;
+        readonly receivedAt: number;
+    };
+    /** A `payload-document-event` message arrived (document save). */
+    readonly documentSave: {
+        readonly timestamp: number;
+    };
+    /** A data update carried `externallyUpdatedRelationship`: a related document changed in an admin drawer, so the update re-renders unconditionally. */
+    readonly relationshipUpdate: {
+        readonly detail: PayloadDocumentEventDetail;
+        readonly timestamp: number;
+    };
+    /** An error the runtime caught but cannot fully recover from. Branch on `code`; `context` is the human-readable origin. */
+    readonly error: {
+        readonly error: Error;
+        readonly context: string;
+        readonly code: DiagnosticCode;
+    };
+    /** During destroy, after observers and the message listener are removed; listeners are released by the owning client afterwards. */
+    readonly destroy: {
+        readonly timestamp: number;
+    };
+}
+/** Handlers may return a promise; they are awaited in registration order, which `beforeUpdate.cancel()` relies on. */
+type EventHandler<TPayload> = (payload: TPayload) => void | Promise<void>;
+type Unsubscribe = () => void;
+
+/**
+ * Per-instance typed emitter: handlers run sequentially in registration order,
+ * may be async, and a throwing one is logged and isolated. See ADR 0002.
+ */
+
+declare class EventEmitter<TMap extends object = LivePreviewEventMap> {
+    #private;
+    on<E extends keyof TMap>(event: E, handler: EventHandler<TMap[E]>): Unsubscribe;
+    once<E extends keyof TMap>(event: E, handler: EventHandler<TMap[E]>): Unsubscribe;
+    off<E extends keyof TMap>(event: E, handler: EventHandler<TMap[E]>): void;
+    /** Dispatch to every handler: regular ones first, then `once` handlers. */
+    emit<E extends keyof TMap>(event: E, payload: TMap[E]): Promise<void>;
+    /**
+     * Dispatch while `shouldContinue()` holds — checked around every handler, so
+     * an obsolete transaction cannot resume across an await.
+     * @internal
+     */
+    emitWhile<E extends keyof TMap>(event: E, payload: TMap[E], shouldContinue: () => boolean): Promise<boolean>;
+    /** Registered handlers for `event`, `on` and `once` together. */
+    listenerCount(event: keyof TMap): number;
+    /** Remove every handler, or only those of `event`. */
+    removeAllListeners(event?: keyof TMap): void;
+    /** Event names with at least one handler. */
+    eventNames(): (keyof TMap)[];
+}
+
+/**
+ * Plugin compatibility claims. The range grammar is the subset a plugin
+ * author writes (`*`, `1.2.3`, `^`, `~`, `>=`, `>`, `<`, `<=`, space-joined
+ * conjunctions, `||` alternatives); prerelease tags are ignored.
+ */
+interface PluginCompatibility {
+    /** A semver range the runtime's `VERSION` must satisfy, e.g. `>=2.0.0`. */
+    readonly runtime?: string;
+    /** The highest postMessage protocol version the plugin understands. */
+    readonly protocol?: number;
+}
+
+/** Plugin contract: a scoped, per-instance context for renderers, transforms and events. */
+
+/** Idempotent handle that releases one plugin-owned resource. */
+type PluginDisposer = () => void;
+/** The client's event surface scoped to one registration: bulk removal and introspection see only this plugin's listeners. */
+interface PluginEvents {
+    readonly on: <E extends keyof LivePreviewEventMap>(event: E, handler: EventHandler<LivePreviewEventMap[E]>) => Unsubscribe;
+    readonly once: <E extends keyof LivePreviewEventMap>(event: E, handler: EventHandler<LivePreviewEventMap[E]>) => Unsubscribe;
+    readonly off: <E extends keyof LivePreviewEventMap>(event: E, handler: EventHandler<LivePreviewEventMap[E]>) => void;
+    /** Emit through the owning client's event channel. */
+    readonly emit: <E extends keyof LivePreviewEventMap>(event: E, payload: LivePreviewEventMap[E]) => Promise<void>;
+    /** Guarded emit; dispatch stops when the predicate turns false or this registration is removed. */
+    readonly emitWhile: <E extends keyof LivePreviewEventMap>(event: E, payload: LivePreviewEventMap[E], shouldContinue: () => boolean) => Promise<boolean>;
+    readonly listenerCount: (event: keyof LivePreviewEventMap) => number;
+    readonly removeAllListeners: (event?: keyof LivePreviewEventMap) => void;
+    readonly eventNames: () => (keyof LivePreviewEventMap)[];
+}
+/**
+ * Synchronous value transform run in registration order; returning a thenable
+ * is a contract error (`LP0602`) that dispatches the untransformed value.
+ */
+type FieldTransform = (value: unknown, context: {
+    readonly fieldName: string;
+    readonly element: Element;
+    readonly allFields: Record<string, unknown>;
+}) => unknown;
+interface PluginContext {
+    readonly events: PluginEvents;
+    /** Register a renderer layer owned by this registration. */
+    readonly registerFieldRenderer: (renderer: FieldRenderer) => void;
+    /** Register an ordered transform owned by this registration. */
+    readonly registerTransform: (fieldName: string, transform: FieldTransform) => void;
+    /** Register a synchronous cleanup run on rollback, `unuse()` and client destruction. */
+    readonly registerCleanup?: (cleanup: PluginDisposer) => void;
+    readonly getConfig: () => Readonly<Record<string, unknown>>;
+    readonly log: (...args: unknown[]) => void;
+}
+/** `init` runs once per registration, `destroy` on removal; both may return a promise. */
+interface LivePreviewPlugin {
+    readonly name: string;
+    readonly version?: string;
+    /** Checked at registration; a plugin this runtime does not fit is refused (`LP0103`). */
+    readonly compat?: PluginCompatibility;
+    readonly init: (context: PluginContext) => void | Promise<void>;
+    readonly destroy?: () => void | Promise<void>;
+}
+
+/**
+ * Per-instance plugin manager. Mutations run through one call-order queue;
+ * while a queue-held hook is pending, a requested mutation takes the direct
+ * path because that hook may be awaiting it. See ADR 0005.
+ */
+
+interface PluginManagerOptions {
+    readonly events: EventEmitter;
+    readonly config: Readonly<Record<string, unknown>>;
+    /** Add one renderer layer to the host; may return the layer's disposer. */
+    readonly registerFieldRenderer: (renderer: FieldRenderer) => void;
+    /** Receives transform contract failures for the runtime's `error` event. */
+    readonly onTransformError?: (error: Error) => unknown;
+    readonly log: (...args: unknown[]) => void;
+}
+declare class PluginManager {
+    #private;
+    constructor(options: PluginManagerOptions);
+    /** Register a plugin transactionally; concurrent mutations run in call order. */
+    register(plugin: LivePreviewPlugin): Promise<void>;
+    /** Remove one plugin and every resource its registration created. */
+    unregister(name: string): Promise<void>;
+    /** Destroy every registration; one failure never strands another. */
+    destroyAll(): Promise<void>;
+    /** Apply active transforms in registration order; a failure returns the original value. */
+    applyTransforms(fieldName: string, value: unknown, context: {
+        readonly element: Element;
+        readonly allFields: Record<string, unknown>;
+    }, isCurrent?: () => boolean): unknown;
+    list(): readonly string[];
+    /** Every plugin with its state and live registrations (`inspect().plugins`). */
+    snapshot(): readonly PluginInspection[];
+    get size(): number;
+}
+
+/**
+ * `highlight` plugin: flashes an outline on updated elements. Respects
+ * `prefers-reduced-motion`; the stylesheet is shared per document across
+ * clients through a lease (ADR 0002).
+ */
+
+declare const highlightPlugin: LivePreviewPlugin;
+
+/** `debug` plugin: logs every lifecycle event through the plugin context. */
+
+declare const debugPlugin: LivePreviewPlugin;
+
+/** `analytics` plugin: running totals over the update stream, read through `getStats()`. */
+
+interface AnalyticsSnapshot {
+    readonly updateCount: number;
+    readonly totalElements: number;
+    readonly totalDurationMs: number;
+    readonly averageDurationMs: number;
+}
+declare function createAnalyticsPlugin(): LivePreviewPlugin & {
+    readonly getStats: () => AnalyticsSnapshot;
+};
+
+/**
+ * `documentSave` plugin: what to do when Payload saves the document.
+ * `'silent'` (default) emits only; `'reload'` reloads and restores the scroll
+ * position; `'revalidate'` POSTs to a revalidation endpoint; `'fetch'` runs
+ * a custom handler.
+ */
+
+type DocumentSaveStrategy = 'silent' | 'reload' | 'revalidate' | 'fetch';
+/** Handler for the `fetch` strategy; the signal aborts when the plugin is removed. */
+type DocumentSaveHandler = {
+    bivarianceHack(signal?: AbortSignal): void | Promise<void>;
+}['bivarianceHack'];
+interface DocumentSavePluginOptions {
+    /** Default `'silent'`. */
+    readonly strategy?: DocumentSaveStrategy;
+    /**
+     * `'revalidate'` endpoint, default `/api/revalidate`; the body is
+     * `{ source: 'payload-live-preview' }`. The request is a plain `fetch` from
+     * the preview page: cookies travel with it, there is no CSRF token, and a
+     * bearer secret in `revalidateHeaders` would sit in page JavaScript. The
+     * endpoint must authorise on its own (session cookie, same-origin check).
+     */
+    readonly revalidateUrl?: string;
+    /** Extra request headers for `'revalidate'`; `Content-Type` is set already. */
+    readonly revalidateHeaders?: Readonly<Record<string, string>>;
+    /** `'fetch'` handler; rejections are logged, never thrown. */
+    readonly handler?: DocumentSaveHandler;
+    /** `'reload'` hard-refreshes when the revalidate request fails or returns non-2xx. */
+    readonly onRevalidateFailure?: 'silent' | 'reload';
+}
+declare function documentSavePlugin(options?: DocumentSavePluginOptions): LivePreviewPlugin;
+
+export { type AnalyticsSnapshot, type CachedElement, type CustomRendererKey, DIAGNOSTIC_CODES, type DiagnosticCode, type DocumentSaveHandler, type DocumentSavePluginOptions, type DocumentSaveStrategy, EventEmitter, type EventHandler, type FieldRenderer, type FieldTransform, type FieldType, type LivePreviewEventMap, type LivePreviewPlugin, type PayloadBlockSchema, type PayloadDocumentEventDetail, type PayloadFieldCondition, type PayloadFieldSchema, type PayloadFieldType, type PayloadLivePreviewData, type PluginCompatibility, type PluginContext, type PluginDisposer, type PluginEvents, type PluginInspection, PluginManager, type PluginManagerOptions, type RenderContext, type RendererKey, type RichTextRenderer, type Unsubscribe, type UpdateSource, createAnalyticsPlugin, debugPlugin, documentSavePlugin, highlightPlugin };