@dotcms/vue 1.5.5

package/lib/__test__/mocks.d.ts

@@ -0,0 +1,6 @@
+import { DotCMSBasicContentlet, DotCMSColumnContainer, DotCMSPageAsset, DotPageAssetLayoutColumn } from '@dotcms/types';
+export declare const MOCK_COLUMN: DotPageAssetLayoutColumn;
+export declare const MOCK_CONTAINER: DotCMSColumnContainer;
+export declare const MOCK_CONTENTLET: DotCMSBasicContentlet;
+export declare const MOCK_PAGE_ASSET: DotCMSPageAsset;
+export declare const PAGE_ASSET_NO_BODY: DotCMSPageAsset;

package/lib/components/Column/Column.vue.d.ts

@@ -0,0 +1,12 @@
+import { DotPageAssetLayoutColumn } from '@dotcms/types';
+/**
+ * @internal
+ * Renders a single column of the 12-column grid. Position is derived from the
+ * column's `leftOffset`/`width` — the same values the React SDK turns into
+ * `col-start-*`/`col-end-*` classes, applied here as inline grid styles.
+ */
+type __VLS_Props = {
+    column: DotPageAssetLayoutColumn;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/lib/components/Container/Container.vue.d.ts

@@ -0,0 +1,11 @@
+import { DotCMSColumnContainer } from '@dotcms/types';
+/**
+ * @internal
+ * Renders a dotCMS container and the contentlets placed inside it. Container
+ * metadata (`data-dot-*`) is editor-only and stripped from live output.
+ */
+type __VLS_Props = {
+    container: DotCMSColumnContainer;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/components/Container/ContainerNotFound.vue.d.ts

@@ -0,0 +1,6 @@
+/** @internal Dev-only message shown when a container cannot be found on the page. */
+type __VLS_Props = {
+    identifier: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/components/Container/EmptyContainer.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/lib/components/Contentlet/Contentlet.vue.d.ts

@@ -0,0 +1,14 @@
+import { DotCMSBasicContentlet } from '@dotcms/types';
+/**
+ * @internal
+ * Renders a single contentlet: resolves the user component for its content type
+ * (falling back to a dev-only placeholder) and emits the editor `data-dot-*`
+ * metadata only when in development/edit mode.
+ */
+type __VLS_Props = {
+    contentlet: DotCMSBasicContentlet;
+    /** JSON-serialized container data the contentlet belongs to. */
+    container: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/lib/components/Contentlet/constants.d.ts

@@ -0,0 +1,2 @@
+/** CSS class applied to every contentlet wrapper. */
+export declare const CONTENTLET_CLASS = "dotcms-contentlet";

package/lib/components/DotCMSBlockEditorRenderer/DotCMSBlockEditorRenderer.vue.d.ts

@@ -0,0 +1,5 @@
+import { BlockEditorRendererProps } from './types';
+declare const _default: import('vue').DefineComponent<BlockEditorRendererProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BlockEditorRendererProps> & Readonly<{}>, {
+    isDevMode: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/components/DotCMSBlockEditorRenderer/components/BlockEditorBlock.vue.d.ts

@@ -0,0 +1,13 @@
+import { BlockEditorNode } from '@dotcms/types';
+import { CustomRenderer } from '../types';
+/**
+ * Recursive dispatcher: renders a list of block-editor nodes, delegating each to
+ * a custom renderer (if provided) or the matching built-in block component.
+ */
+type __VLS_Props = {
+    content?: BlockEditorNode[];
+    customRenderers?: CustomRenderer;
+    isDevMode?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/BulletList.vue.d.ts

@@ -0,0 +1,17 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLUListElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLUListElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/CodeBlock.vue.d.ts

@@ -0,0 +1,22 @@
+import { BlockEditorNode } from '@dotcms/types';
+/** Renders a code block, exposing the language via `data-language`. */
+type __VLS_Props = {
+    node: BlockEditorNode;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLPreElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLPreElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/DotContent.vue.d.ts

@@ -0,0 +1,10 @@
+import { BlockEditorNode } from '@dotcms/types';
+import { CustomRenderer } from '../../types';
+/** Renders an embedded contentlet block via a custom renderer keyed by content type. */
+type __VLS_Props = {
+    node: BlockEditorNode;
+    customRenderers?: CustomRenderer;
+    isDevMode?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/DotImage.vue.d.ts

@@ -0,0 +1,7 @@
+import { BlockEditorNode } from '@dotcms/types';
+/** Renders a dotCMS image block with optional text-wrap / alignment. */
+type __VLS_Props = {
+    node: BlockEditorNode;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/DotVideo.vue.d.ts

@@ -0,0 +1,7 @@
+import { BlockEditorNode } from '@dotcms/types';
+/** Renders a dotCMS video block. */
+type __VLS_Props = {
+    node: BlockEditorNode;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLVideoElement>;
+export default _default;

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/GridBlock.vue.d.ts

@@ -0,0 +1,10 @@
+import { BlockEditorNode } from '@dotcms/types';
+import { CustomRenderer } from '../../types';
+/** Renders a two-column grid block over a 12-column grid. */
+type __VLS_Props = {
+    node: BlockEditorNode;
+    customRenderers?: CustomRenderer;
+    isDevMode?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/Heading.vue.d.ts

@@ -0,0 +1,22 @@
+import { BlockEditorNode } from '@dotcms/types';
+/** Renders a heading block as h1..h6 based on `node.attrs.level` (default 1). */
+type __VLS_Props = {
+    node: BlockEditorNode;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/ListItem.vue.d.ts

@@ -0,0 +1,17 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLLIElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLLIElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/NoComponentProvided.vue.d.ts

@@ -0,0 +1,6 @@
+/** Dev-only warning shown when a contentlet block has no matching custom renderer. */
+type __VLS_Props = {
+    contentType?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/OrderedList.vue.d.ts

@@ -0,0 +1,17 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLOListElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLOListElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/Paragraph.vue.d.ts

@@ -0,0 +1,22 @@
+import { BlockEditorNode } from '@dotcms/types';
+/** Renders a paragraph block, applying any node attrs as inline styles. */
+type __VLS_Props = {
+    node: BlockEditorNode;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLParagraphElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLParagraphElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/Quote.vue.d.ts

@@ -0,0 +1,17 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLQuoteElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLQuoteElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/TableRenderer.vue.d.ts

@@ -0,0 +1,15 @@
+import { BlockEditorNode } from '@dotcms/types';
+import { CustomRenderer } from '../../types';
+/**
+ * Renders a table block. Cell type — not row position — decides `<th>` vs `<td>`
+ * (`node.type === 'tableHeader'`), matching the VTL renderer, so column headers
+ * in any row keep their semantic wrapper and `scope`.
+ */
+type __VLS_Props = {
+    content: BlockEditorNode[];
+    attrs?: BlockEditorNode['attrs'];
+    customRenderers?: CustomRenderer;
+    isDevMode?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLTableElement>;
+export default _default;

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/TextBlock.vue.d.ts

@@ -0,0 +1,13 @@
+import { BlockEditorMark } from '@dotcms/types';
+/**
+ * Renders a text node, applying its marks (bold, italic, link, ...) recursively.
+ *
+ * Each mark wraps a `TextBlock` of the remaining marks, so nested formatting is
+ * preserved. When no marks remain the raw text is emitted.
+ */
+type __VLS_Props = {
+    text?: string;
+    marks?: BlockEditorMark[];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/components/DotCMSBlockEditorRenderer/components/blocks/UnknownBlock.vue.d.ts

@@ -0,0 +1,10 @@
+import { BlockEditorNode } from '@dotcms/types';
+/**
+ * Renders an unknown block. Shows a visible warning only inside the UVE; in the
+ * live site it renders nothing to avoid leaking editor scaffolding.
+ */
+type __VLS_Props = {
+    node: BlockEditorNode;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/components/DotCMSBlockEditorRenderer/types.d.ts

@@ -0,0 +1,44 @@
+import { BlockEditorNode } from '@dotcms/types';
+import { Component, CSSProperties } from 'vue';
+/**
+ * Props that every custom block renderer receives.
+ *
+ * A custom renderer is a Vue component that gets the full {@link BlockEditorNode}
+ * as its `node` prop and the already-rendered children in its default slot.
+ *
+ * @template TData the type of data stored in `node.attrs.data` (contentlet blocks)
+ */
+export interface CustomRendererProps<TData = unknown> {
+    /** The full BlockEditorNode with attrs, marks, content, etc. */
+    node: BlockEditorNode & {
+        attrs?: {
+            data?: TData;
+            [key: string]: unknown;
+        };
+    };
+}
+/**
+ * A custom renderer component — a Vue component whose props include the `node`
+ * (typed via {@link CustomRendererProps}) plus a default slot with the rendered
+ * children.
+ */
+export type CustomRendererComponent = Component<CustomRendererProps>;
+/**
+ * Map of block type name to the custom renderer component that should render it.
+ */
+export type CustomRenderer = Record<string, CustomRendererComponent>;
+/**
+ * Props for {@link DotCMSBlockEditorRenderer}.
+ */
+export interface BlockEditorRendererProps {
+    /** The block editor field value (a root node with `content`). */
+    blocks: BlockEditorNode;
+    /** Inline styles for the container element. */
+    style?: CSSProperties;
+    /** CSS class for the container element. */
+    className?: string;
+    /** Custom renderers keyed by block type (or content type for contentlet blocks). */
+    customRenderers?: CustomRenderer;
+    /** When true, renders helpful dev-only messages for invalid/unknown blocks. */
+    isDevMode?: boolean;
+}

package/lib/components/DotCMSEditableText/DotCMSEditableText.vue.d.ts

@@ -0,0 +1,15 @@
+import { DotCMSBasicContentlet } from '@dotcms/types';
+import { DotCMSEditableTextProps } from './utils';
+declare const _default: <T extends DotCMSBasicContentlet>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & DotCMSEditableTextProps<T> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/lib/components/DotCMSEditableText/utils.d.ts

@@ -0,0 +1,22 @@
+import { DotCMSBasicContentlet } from '@dotcms/types';
+export type DOT_EDITABLE_TEXT_FORMAT = 'html' | 'text';
+export type DOT_EDITABLE_TEXT_MODE = 'minimal' | 'full' | 'plain';
+/**
+ * Props for {@link DotCMSEditableText}.
+ */
+export interface DotCMSEditableTextProps<T extends DotCMSBasicContentlet = DotCMSBasicContentlet> {
+    /** The contentlet whose field is edited. */
+    contentlet: T;
+    /** The field of the contentlet to edit. */
+    fieldName: keyof T;
+    /** The editor format — `text` or `html`. Defaults to `text`. */
+    format?: DOT_EDITABLE_TEXT_FORMAT;
+    /** The editor toolbar preset — `plain`, `minimal` or `full`. Defaults to `plain`. */
+    mode?: DOT_EDITABLE_TEXT_MODE;
+}
+type TinyMCEInit = Record<string, unknown>;
+/**
+ * TinyMCE init config per editor mode, composed from the shared dotCMS presets.
+ */
+export declare const TINYMCE_CONFIG: Record<DOT_EDITABLE_TEXT_MODE, TinyMCEInit>;
+export {};

package/lib/components/DotCMSLayoutBody/DotCMSLayoutBody.vue.d.ts

@@ -0,0 +1,5 @@
+import { DotCMSLayoutBodyProps } from './types';
+declare const _default: import('vue').DefineComponent<DotCMSLayoutBodyProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DotCMSLayoutBodyProps> & Readonly<{}>, {
+    mode: import('@dotcms/types').DotCMSPageRendererMode;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/components/DotCMSLayoutBody/components/ErrorMessage.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/lib/components/DotCMSLayoutBody/types.d.ts

@@ -0,0 +1,17 @@
+import { DotCMSPageAsset, DotCMSPageRendererMode } from '@dotcms/types';
+import { Component } from 'vue';
+/**
+ * Props for {@link DotCMSLayoutBody}.
+ */
+export interface DotCMSLayoutBodyProps {
+    /** The dotCMS page asset containing the layout information. */
+    page: DotCMSPageAsset;
+    /**
+     * Map of content-type variable name to the Vue component that renders it.
+     * The special `CustomNoComponent` key is used as the fallback for unmatched
+     * content types.
+     */
+    components: Record<string, Component>;
+    /** Renderer mode; defaults to `production`. */
+    mode?: DotCMSPageRendererMode;
+}

package/lib/components/DotCMSShow/DotCMSShow.vue.d.ts

@@ -0,0 +1,35 @@
+import { UVE_MODE } from '@dotcms/types';
+/**
+ * `DotCMSShow` conditionally renders its slot content based on the current
+ * Universal Visual Editor (UVE) mode.
+ *
+ * @example
+ * ```vue
+ * <DotCMSShow :when="UVE_MODE.EDIT">
+ *   <button @click="editContentlet(contentlet)">Edit</button>
+ * </DotCMSShow>
+ * ```
+ */
+type __VLS_Props = {
+    /** The UVE mode in which the slot content should be rendered. */
+    when?: UVE_MODE;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    when: UVE_MODE;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/FallbackComponent/FallbackComponent.vue.d.ts

@@ -0,0 +1,13 @@
+import { Component } from 'vue';
+import { DotCMSBasicContentlet } from '@dotcms/types';
+/**
+ * @internal
+ * Fallback rendered when no component is mapped for a contentlet's content type.
+ * Only visible in development mode.
+ */
+type __VLS_Props = {
+    contentlet: DotCMSBasicContentlet;
+    userNoComponent?: Component;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/components/Row/Row.vue.d.ts

@@ -0,0 +1,13 @@
+import { DotPageAssetLayoutRow } from '@dotcms/types';
+/**
+ * @internal
+ * Renders a layout row and its columns. The `id` is the section anchor the
+ * editor scrolls to; the inner grid spans 12 columns.
+ */
+type __VLS_Props = {
+    row: DotPageAssetLayoutRow;
+    /** 1-based section index used as the scroll-to-section anchor id. */
+    index: number;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/lib/composables/useCheckVisibleContent.d.ts

@@ -0,0 +1,16 @@
+import { Ref } from 'vue';
+/**
+ * @internal
+ *
+ * Composable that reports whether an element rendered visible content (measured
+ * height greater than zero). Used in development mode to give empty contentlets
+ * a minimum height so the editor can still target them.
+ *
+ * Takes a getter for the element (rather than a template ref) so the caller can
+ * resolve it from the component instance's root element and avoid attaching a
+ * template ref to a wrapper vnode — which Vue may hoist, triggering a warning.
+ *
+ * @param getElement returns the element to measure (called on mount)
+ * @returns a ref that is `true` when the element has a measurable height
+ */
+export declare function useCheckVisibleContent(getElement: () => Element | null | undefined): Ref<boolean>;

package/lib/composables/useDotCMSShowWhen.d.ts

@@ -0,0 +1,18 @@
+import { Ref } from 'vue';
+import { UVE_MODE } from '@dotcms/types';
+/**
+ * Composable that reports whether the current UVE mode matches the given mode.
+ *
+ * Useful for conditionally rendering content based on the editor mode (EDIT,
+ * PREVIEW, LIVE). It resolves after mount (returns `false` during SSR), matching
+ * the React SDK's `useDotCMSShowWhen` behavior.
+ *
+ * @example
+ * ```ts
+ * const showInEditMode = useDotCMSShowWhen(UVE_MODE.EDIT);
+ * ```
+ *
+ * @param when the UVE mode to check against
+ * @returns a readonly ref that is `true` when the current UVE mode matches
+ */
+export declare function useDotCMSShowWhen(when: UVE_MODE): Readonly<Ref<boolean>>;

package/lib/composables/useEditableDotCMSPage.d.ts

@@ -0,0 +1,34 @@
+import { Ref } from 'vue';
+import { DotCMSComposedPageResponse, DotCMSExtendedPageResponse } from '@dotcms/types';
+/**
+ * Composable to manage the editable state of a dotCMS page inside the Universal
+ * Visual Editor (UVE).
+ *
+ * It initializes the UVE, keeps the navigation in sync, and subscribes to
+ * content changes so the returned page response updates live while an editor is
+ * working. Outside of the UVE it is a pass-through: the returned ref simply
+ * holds the initial response.
+ *
+ * This is the Vue analog of the React SDK's `useEditableDotCMSPage` hook and the
+ * Angular SDK's `DotCMSEditablePageService.listen()`.
+ *
+ * @example
+ * ```ts
+ * import { useEditableDotCMSPage } from '@dotcms/vue';
+ * import { createDotCMSClient } from '@dotcms/client';
+ *
+ * const client = createDotCMSClient({
+ *   dotcmsUrl: 'https://your-dotcms-instance.com',
+ *   authToken: 'your-auth-token'
+ * });
+ *
+ * const pageResponse = await client.page.get('/');
+ * const page = useEditableDotCMSPage(pageResponse);
+ *
+ * // page.value.pageAsset — reactive; re-renders on UVE content changes.
+ * ```
+ *
+ * @param pageResponse the initial page response from `client.page.get()`
+ * @returns a reactive ref holding the (possibly live-updating) page response
+ */
+export declare function useEditableDotCMSPage<T extends DotCMSExtendedPageResponse>(pageResponse: DotCMSComposedPageResponse<T>): Ref<DotCMSComposedPageResponse<T>>;

package/lib/composables/useIsAnalyticsActive.d.ts

@@ -0,0 +1,14 @@
+import { Ref } from 'vue';
+/**
+ * @internal
+ *
+ * Composable that tracks whether dotCMS Analytics is active on the page.
+ *
+ * Analytics may initialize after the page renders, so in addition to reading the
+ * current state on mount we subscribe to the `dotcms:analytics:ready` window
+ * event and re-evaluate when it fires. Used in live mode to decide whether the
+ * minimal contentlet attributes Analytics needs should be kept.
+ *
+ * @returns a ref that is `true` when Analytics is active
+ */
+export declare function useIsAnalyticsActive(): Ref<boolean>;

package/lib/composables/useIsDevMode.d.ts

@@ -0,0 +1,23 @@
+import { ComputedRef, MaybeRefOrGetter } from 'vue';
+import { DotCMSPageRendererMode } from '@dotcms/types';
+/**
+ * @internal
+ *
+ * Resolve whether we are rendering in "development" mode — i.e. whether editor
+ * metadata (`data-dot-*` attributes, empty-state placeholders, fallback
+ * components) should be emitted. Inside the UVE it follows the UVE state (dev
+ * when mode is EDIT); otherwise it follows the renderer `mode`.
+ */
+export declare function resolveDevMode(mode: DotCMSPageRendererMode | undefined): boolean;
+/**
+ * @internal
+ *
+ * Computed development-mode flag. `getUVEState()` and the renderer `mode` are
+ * both available synchronously, so this resolves during setup — the editor
+ * `data-dot-*` attributes are present on the first render (which the UVE relies
+ * on to attach its tooling) with no per-instance `onMounted`.
+ *
+ * Called once at the layout root ({@link DotCMSLayoutBody}); the result is
+ * shared with the whole tree via the page context.
+ */
+export declare function useIsDevMode(mode: MaybeRefOrGetter<DotCMSPageRendererMode | undefined>): ComputedRef<boolean>;