@dotcms/vue 1.5.5-next.2350

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/client/dotcms-client.plugin.d.ts

@@ -0,0 +1,79 @@
+import { App, InjectionKey } from 'vue';
+import { createDotCMSClient } from '@dotcms/client';
+import { DotCMSClientConfig } from '@dotcms/types';
+/**
+ * The dotCMS client instance created by {@link createDotCMSClient}. Use this
+ * type to annotate variables that hold the injected client.
+ */
+export type DotCMSClient = ReturnType<typeof createDotCMSClient>;
+/**
+ * Injection key for the dotCMS client.
+ *
+ * Advanced: exported so a consumer can `inject(DOTCMS_CLIENT)` directly (e.g.
+ * outside a `setup()` where {@link useDotCMSClient} would throw), but prefer
+ * {@link useDotCMSClient}.
+ */
+export declare const DOTCMS_CLIENT: InjectionKey<DotCMSClient>;
+/**
+ * A Vue plugin returned by {@link createDotCMSVue}. Install it with `app.use`.
+ */
+export interface DotCMSVuePlugin {
+    install(app: App): void;
+    /** The client instance the plugin provides. Handy for use outside components. */
+    client: DotCMSClient;
+}
+/**
+ * Creates the dotCMS Vue plugin.
+ *
+ * Builds a single dotCMS client from `config` and provides it to the whole app
+ * so components can retrieve it with {@link useDotCMSClient} — no module-level
+ * singleton to import. This is the Vue analog of Angular's `provideDotCMSClient`.
+ *
+ * The created client is also exposed on the returned object as `.client`, so
+ * non-component code (route loaders, plain modules) can share the same instance.
+ *
+ * @param config - the same configuration accepted by `createDotCMSClient`
+ * @returns a Vue plugin to pass to `app.use()`
+ *
+ * @example
+ * ```ts
+ * import { createApp } from 'vue';
+ * import { createDotCMSVue } from '@dotcms/vue';
+ * import App from './App.vue';
+ *
+ * const app = createApp(App);
+ *
+ * app.use(
+ *   createDotCMSVue({
+ *     dotcmsUrl: 'https://demo.dotcms.com',
+ *     authToken: 'your-auth-token',
+ *     siteId: 'your-site-id',
+ *     requestOptions: {
+ *       // UVE needs fresh data so in-context edits are reflected immediately.
+ *       cache: 'no-cache'
+ *     }
+ *   })
+ * );
+ *
+ * app.mount('#app');
+ * ```
+ */
+export declare function createDotCMSVue(config: DotCMSClientConfig): DotCMSVuePlugin;
+/**
+ * Retrieves the dotCMS client provided by {@link createDotCMSVue}.
+ *
+ * Must be called from a component `setup` (or another composable). Throws if the
+ * plugin was not installed with `app.use(createDotCMSVue(...))`, so a missing
+ * provider fails loudly instead of returning `undefined`.
+ *
+ * @returns the dotCMS client instance
+ *
+ * @example
+ * ```ts
+ * import { useDotCMSClient } from '@dotcms/vue';
+ *
+ * const client = useDotCMSClient();
+ * const { pageAsset } = await client.page.get({ path: '/' });
+ * ```
+ */
+export declare function useDotCMSClient(): DotCMSClient;

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,25 @@
+import { DotCMSPageAsset, DotCMSPageRendererMode } from '@dotcms/types';
+import { Component } from 'vue';
+/**
+ * Prefix for the per-contentlet named slots of {@link DotCMSLayoutBody}. A slot
+ * named `contentlet-<identifier>` overrides the mapped component for the
+ * contentlet with that identifier.
+ *
+ * @example `<template #contentlet-abc123>…</template>` targets identifier `abc123`.
+ */
+export declare const CONTENTLET_SLOT_PREFIX = "contentlet-";
+/**
+ * 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,20 @@
+import { ComputedRef, MaybeRefOrGetter } 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. The `when` argument may be a
+ * plain value, a `ref`, or a getter — a reactive value is re-evaluated when it
+ * changes.
+ *
+ * @example
+ * ```ts
+ * const showInEditMode = useDotCMSShowWhen(UVE_MODE.EDIT);
+ * ```
+ *
+ * @param when the UVE mode to check against
+ * @returns a readonly computed that is `true` when the current UVE mode matches
+ */
+export declare function useDotCMSShowWhen(when: MaybeRefOrGetter<UVE_MODE>): Readonly<ComputedRef<boolean>>;